G ++ and __attribute __ ((optimize)) no cambia el comportamiento del depurador

Question

Estoy tratando de jugar con __attribute__ para permitir que una función se compile esencialmente con banderas diferentes del resto del código. Por ejemplo:

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

estoy construyendo con -O2 -g, pero yo quiero ser capaz de depurar con cordura MyDebugabbleFunction() - por lo que utiliza el __attribute__((optimize(0))) en su declaración. Sin embargo, realmente no puedo decir ninguna diferencia al pasar por estas dos funciones con un depurador. Esperaría el comportamiento "aparentemente errático" que suelo ver al tratar de pasar por el código optimizado en MyNormalFunction, pero el comportamiento estándar "-g" del depurador en MyDebuggableFunction.

¿Es que he hecho algo mal con __attribute__? ¿O que he usado un código de demostración malo (es decir, un código que no se "optimiza mucho") dentro de las dos funciones? ¿O estoy malinterpretando cuál se supone que es la diferencia en el depurador?

Estoy usando gcc 4.6.

---

EDITAR basado en la sugerencia de GManNickG

que utiliza este código en su lugar, y construido 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

Pruebe una prueba de esta forma:

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

Hará que sea mucho más fácil de seguir.

---

Tenga en cuenta que usted debe comenzar en main, al desplazarse por, porque muy probablemente se reducirá a:

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

Si es para ella, mirando el desmontaje hace esta tarea más fácil.

Answer 2

Después de corregir los errores en el código, por lo que 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 

Como se puede ver el atributo de optimización funcionaba bien.