Wrong line numbers from addr2line

I try to find the exact line of a call in the backtrace in C++ program. Right now I am using these lines (from the man page of backtrace) to get the trace: ``` void *bt_buffer[1000]; char **bt_strings; int bt_nptrs = backtrace(bt_buffer, 1000); bt_strings = backtrace_symbols(bt_buffer, bt_nptrs); ``` In bt_strings I find lines of the form ``` ./prog() [0x402e42] ``` Now I take the address (the hex string) and feed it to addr2line. That sometimes results in apparently wrong line numbers. Internet search led me to this post, in which it is shown that ``` readelf -wl ./prog ``` indicates where the line really is, or rather how many lines the symbol has moved to the current line. edit: This happens when I compile with `-g -O0`, i.e. explicetly without optimisations. The compiler is `gcc 4.6.3` Is there another compiler flag that I miss? My problem is the following: I need to automate this. I need my program to create a backtrace (done), extract the file (done) and the line number (fail). I could of course call `readelf` and parse the output, but that's not really suitable, as the output differs from symbol to symbol depending on what exactly happened. Sometimes The address of a symbol is in one line and the information about the line offset in the next line... To sum up: Is there an elegant way to get the exact line number of a function call in the backtrace from within the program during runtime? edit: example code: ``` #define UNW_LOCAL_ONLY #include <libunwind.h> #include <execinfo.h> #include <iostream> #include <stdlib.h> void show_backtrace() { // get current address void* p = __builtin_return_address(0); std::cout << std::hex << p << std::endl; // get callee addresses p = __builtin_return_address(1); std::cout << std::hex << p << std::endl; p = __builtin_return_address(2); std::cout << std::hex << p << std::endl; } void show_backtrace2() { void *array[10]; size_t size; char **strings; int i; size = backtrace (array, 10); strings = backtrace_symbols ((void *const *)array, size); for (i = 0; i < size; i++) { std::cout << strings[i] << std::endl; } free (strings); } void show_backtrace3 (void) { char name[256]; unw_cursor_t cursor; unw_context_t uc; unw_word_t ip, sp, offp; unw_getcontext (&uc); unw_init_local (&cursor, &uc); while (unw_step(&cursor) > 0) { char file[256]; int line = 0; name[0] = '\0'; unw_get_proc_name (&cursor, name, 256, &offp); unw_get_reg (&cursor, UNW_REG_IP, &ip); unw_get_reg (&cursor, UNW_REG_SP, &sp); std::cout << std:: hex << name << " ip = " << (long) ip << " , sp = " << (long) sp << std::endl; } } void dummy_function2() { show_backtrace(); show_backtrace2(); show_backtrace3(); } void dummy_function1() { dummy_function2 (); } // line 73 int main(int argc, char **argv) { dummy_function1 (); return 0; } ``` compile and run: ``` g++ test_unwind.cc -g -O0 -lunwind && ./a.out ``` output: ``` 0x400edb 0x400ef0 0x400f06 ./a.out() [0x400cfb] ./a.out() [0x400ee0] ./a.out() [0x400ef0] ./a.out() [0x400f06] /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xed) [0x7f2f044ae76d] ./a.out() [0x400b79] _Z15dummy_function2v ip = 400ee5 , sp = 7fffdb564580 _Z15dummy_function1v ip = 400ef0 , sp = 7fffdb564590 main ip = 400f06 , sp = 7fffdb5645a0 __libc_start_main ip = 7f2f044ae76d , sp = 7fffdb5645c0 _start ip = 400b79 , sp = 7fffdb564680 ``` testing e.g. 0x400ef0 with addr2line yields ``` /path/to/code/test_unwind.cc:73 ``` which is the correct file, but wrong line number. In real life applications the line number can differ by many lines, forward and backward. edit: compiling with `-S` shows that the relevant part is: ``` .LCFI34: .cfi_def_cfa_register 6 .loc 2 72 0 call _Z15dummy_function2v .loc 2 73 0 popq %rbp ``` What is displayed by `addr2line` and alike is the return address, as shown in the line after the `call`. I would like to get the "entry" line, i.e. what is shown before!