G ++ ve __attribute __ ((optimize)) hata ayıklayıcı davranışını değiştirmiyor

Question

Bir işlevin, kodun geri kalanından farklı bayraklarla temel olarak derlenmesine izin vermek için __attribute__ ile oynamaya çalışıyorum. Örneğin:

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

Ben -g -o2 ile inşa ediyorum, ama sanely MyDebugabbleFunction() hata ayıklama yapabilmek istiyor - bu yüzden onun beyanı üzerine __attribute__((optimize(0))) kullandı. Ancak, bu iki işlevi bir hata ayıklayıcısına yönlendirirken gerçekten bir fark bile edemiyorum. Genellikle MyNormalFunction'da optimize edilmiş koddan geçmeye çalışırken gördüğüm "görünüşte düzensiz" davranışı, ancak MyDebuggableFunction'da standart "-g" -only debugger davranışını beklerim.

__attribute__ ile ilgili bir sorun mu var? Ya da iki fonksiyonun içinde kötü demo kodu (yani "çok optimize edilmiş" olmayan kod) kullandım mı? Yoksa hata ayıklayıcıda farkın ne olduğunu yanlış yorumluyor muyum?

gcc 4.6 kullanıyorum.

#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

artık şöyle bir testi deneyin:

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

GManNickG önerisine dayalı

---

DÜZENLEME

ben yerine bu kodu kullanılan ve O2 -g ile inşa

Takip etmeyi çok daha kolaylaştıracak. ilerlerken hangi büyük olasılıkla düşecektir çünkü, main, içinde başlamalıdır

---

Not:

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

bunun için yukarı iseniz, sökme bakarak bu görevi yapar daha kolay.

Answer 2

kodunda hataları düzeltmeden sonra

, bu yüzden derler:

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 

optimizasyon nitelik iyi çalıştı görebileceğiniz gibi.