G ++ i __attribute __ ((optymalizuj)) nie zmieniają zachowania debuggera

Question

Próbuję grać z __attribute__, aby umożliwić zasadniczo kompilację funkcji za pomocą różnych flag od reszty kodu. Na przykład:

#include <iostream> 
#include <vector> 

void MyNormalFunction(); 

void MyDebugabbleFunction() __attribute__((optimize(0))); 

void MyNormalFunction() 
{ 
    std::cout << "Test" << std::endl; 

    std::vector<int> a; 

    for(unsigned int i = 0; i < 10; ++i) 
    { 
    a.push_back(i); 
    } 
} 

void MyDebugabbleFunction() 
{ 
    std::cout << "Test" << std::endl; 

    std::vector<int> a; 

    for(unsigned int i = 0; i < 10; ++i) 
    { 
    a.push_back(i); 
    } 
} 

int main() 
{ 
    MyNormalFunction(); 
    MyDebugabbleFunction(); 
    return 0; 
} 

buduję z -g -O2, ale chcę, aby móc zdrowo debugowania MyDebugabbleFunction() - więc użyłem __attribute__((optimize(0))) na swojej deklaracji. Jednak nie mogę powiedzieć żadnej różnicy podczas przechodzenia przez te dwie funkcje za pomocą debuggera. Spodziewam się "pozornie nieregularnego" zachowania, które zwykle widzę, próbując przejść przez zoptymalizowany kod w MyNormalFunction, ale standardowe "-g" - jedyne zachowanie debuggera w MyDebuggableFunction.

Czy zrobiłem coś złego z __attribute__? Albo, że użyłem złego kodu demo (tj. Kodu, który nie "zoptymalizuje się dużo") wewnątrz dwóch funkcji? Czy błędnie interpretuję, jaka różnica ma być w debugerze?

Używam gcc 4.6.

---

EDIT na podstawie sugestii GManNickG za

użyłem zamiast tego kodu, a zbudowane z -O2 -g:

#include <iostream> 
#include <vector> 

int MyNormalFunction(); 

int MyDebugabbleFunction() __attribute__((optimize(0))); 

int MyNormalFunction() 
{ 
    int val = 0; // breakpoint here - debugger does NOT stop here 
    val = 1; 
    val = 2; 
    return val; 
} // debugger stops here instead 

int MyDebugabbleFunction() 
{ 
    int val = 0; // breakpoint here - debugger stops here and steps through the next 3 lines as if it were built with only -g 
    val = 1; 
    val = 2; 
    return val; 
} 

int main() 
{ 
    int a = MyNormalFunction(); 
    std::cout << a << std::endl; 

    int b = MyDebugabbleFunction(); 
    std::cout << b << std::endl; 

    return 0; 
} 

Answer 1

Spróbuj test tak zamiast:

int MyNormalFunction() 
{ 
    int val = 0; 
    val = 1; 
    val = 2; 

    // should optimize to return 2 
    return val; 
} 

int MyDebuggableFunction() __attribute__((optimize(0))); 
{ 
    int val = 0; 
    val = 1; 
    val = 2; 

    // could optimize to return 2, but attribute blocks that 
    return val; 
} 

int main() 
{ 
    // we need to actually output the return values, 
    // or main itself could be optimized to nothing 
    std::cout << MyNormalFunction() << std::endl; 
    std::cout << MyDebuggableFunction() << std::endl; 
} 

To ułatwi obserwowanie.

---

Zauważ, że należy rozpocząć w main, przy przechodzeniu, ponieważ najprawdopodobniej zostanie zmniejszona do:

int main() 
{ 
    std::cout << 2 << std::endl; 
    std::cout << MyDebuggableFunction() << std::endl; 
} 

Jeśli się na to, patrząc na demontaż czyni to zadanie dużo łatwiej.

Answer 2

Po naprawie błędów w kodzie, więc kompiluje:

g++ -S x.c 

_Z16MyNormalFunctionv: 
.LFB1255: 
    .cfi_startproc 
    movl $2, %eax 
    ret 

_Z20MyDebuggableFunctionv: 
.LFB1256: 
    .cfi_startproc 
    movl $0, -4(%rsp) 
    movl $1, -4(%rsp) 
    movl $2, -4(%rsp) 
    movl -4(%rsp), %eax 
    ret 

Jak widać atrybut optymalizacji pracował w porządku.