G ++ und __attribute __ ((optimize)) Debugger Verhalten nicht ändern

Question

Ich versuche mit __attribute__ zu spielen, um eine Funktion im Wesentlichen mit anderen Flags aus dem Rest des Codes kompiliert zu ermöglichen. Zum Beispiel:

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

ich mit -g -O2 Gebäude bin, aber ich möchte in der Lage sein sanely MyDebugabbleFunction() zu debuggen - so habe ich die __attribute__((optimize(0))) auf seine Erklärung. Ich kann jedoch keinen wirklichen Unterschied feststellen, wenn ich diese beiden Funktionen mit einem Debugger durchtrete. Ich würde das "scheinbar unberechenbare" Verhalten erwarten, das ich normalerweise sehe, wenn ich versuche, durch optimierten Code in MyNormalFunction zu gehen, aber das Standard "-g" - nur Debugger-Verhalten in MyDebuggableFunction.

Ist es, dass ich etwas falsch gemacht habe mit __attribute__? Oder dass ich schlechten Demo-Code (d. H. Code, der nicht viel "optimiert" wird) innerhalb der beiden Funktionen verwendet habe? Oder interpretiere ich falsch, was der Unterschied im Debugger sein soll?

Ich benutze gcc 4.6.

---

EDIT basierend auf GManNickG Vorschlag

habe ich diesen Code stattdessen und mit -O2 -g gebaut:

#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

Versuchen Sie, ein Test wie dieser Stelle:

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

Es wird viel einfacher zu folgen.

---

Beachten Sie, dass in main beginnen sollten, wenn sie durch Schritt, weil es sehr wahrscheinlich reduziert werden wird:

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

Wenn Sie sich für sie, bei der Demontage der Suche macht diese Aufgabe viel einfacher.

Answer 2

Nachdem die Fehler im Code Fixierung, so dass es kompiliert:

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 

Wie Sie das Optimierungs Attribut funktionierte gut sehen kann.