G ++ e __attribute __ ((ottimizzazione)) non cambiano il comportamento del debugger

Question

Sto provando a giocare con __attribute__ per consentire a una funzione di essere essenzialmente compilata con diversi flag dal resto del codice. Per esempio:

#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; 
} 

sto costruendo con -O2 -g, ma voglio essere in grado di eseguire il debug in modo sano MyDebugabbleFunction() - così ho usato il __attribute__((optimize(0))) sulla sua dichiarazione. Tuttavia, non posso davvero dire alcuna differenza quando si passa attraverso queste due funzioni con un debugger. Mi aspetterei il comportamento "apparentemente erratico" che di solito vedo quando provo a passare attraverso il codice ottimizzato in MyNormalFunction, ma il comportamento standard del "-g" -only debugger in MyDebuggableFunction.

È che ho fatto qualcosa di sbagliato con __attribute__? O che ho usato un cattivo codice dimostrativo (cioè codice che non viene "ottimizzato molto") all'interno delle due funzioni? Oppure sto interpretando male la differenza che si suppone nel debugger?

Sto utilizzando gcc 4.6.

---

EDIT basato su suggerimento di GManNickG

ho usato questo codice, invece, e costruita con -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

Prova un test come questo, invece:

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; 
} 

Sarà molto più facile da seguire.

---

nota che si dovrebbe iniziare a main, quando si passa attraverso, perché molto probabilmente sarà ridotto a:

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

Se siete in su per esso, guardando lo smontaggio rende questo compito molto più facile.

Answer 2

Dopo aver risolto gli errori nel codice, in modo che compila:

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 

Come si può vedere l'attributo di ottimizzazione ha funzionato bene.