I have installed gdb 7.7
(from GNU sources) under OS X Mavericks (10.9.2). I codesigned it, so it works fine whenever I debug a c++
file that does not contain templates. However, it is unable to step into template functions (can step into regular functions, but just fails to step into templated ones). When I type step
command in a debugging session, it just steps over the function, as if the debugging symbols are not present for the template function. My template function is not even a member function, is just a simple function defined inside the main.cpp
.
I compile my program with g++ -g -O0 main.cpp
(I use g++4.8.2
from macports
and not clang++
), even tried -fno-inline
, still same behaviour, cannot step into template functions. Is this a gdb
known problem under OS X Mavericks? Or, can anyone reproduce the bug?
my code:
#include <iostream>
template <typename T> // template
void f(T x)
{
std::cout << "In f:" << std::endl;
std::cout << x << std::endl;
}
void g() // non-template
{
std::cout << "It works here!" << std::endl;
std::cout << "Exiting g()..." << std::endl;
}
int main()
{
f<double>(12.3); // gdb does not step into f()
g(); // gdb steps into g()
}
Can not step in f
after a breakpoint at f<double>(12.3)
.
If f()
is a regular function, such as g()
in my code, then it steps into.
Thanks!
Update: gdb
works as it should under any other OS, such as linux/windows/solaris
. It seems to be a problem related to OS X.
Reading symbols from a.out...done.
(gdb) disassemble main
Dump of assembler code for function main():
0x0000000100000d62 <+0>: push %rbp
0x0000000100000d63 <+1>: mov %rsp,%rbp
0x0000000100000d66 <+4>: movabs $0x402899999999999a,%rax
0x0000000100000d70 <+14>: movq %rax,%xmm0
0x0000000100000d75 <+19>: callq 0x100000e44
0x0000000100000d7a <+24>: callq 0x100000d0c <g()>
0x0000000100000d7f <+29>: mov $0x0,%eax
0x0000000100000d84 <+34>: pop %rbp
0x0000000100000d85 <+35>: retq
End of assembler dump.
(gdb)
Now we set a breakpoint at the entry of main()
(gdb) b main
Breakpoint 1 at 0x100000d66: file src/templated_bug.cpp, line 22.
(gdb) r
Starting program: /Users/vlad/template_gdb_bug/a.out
Breakpoint 1, main () at src/templated_bug.cpp:22
22 f<double>(12.3);
(gdb) s
In f:
12.3
23 g();
(gdb) s
g () at src/templated_bug.cpp:16
16 cout<<"It works here!"<<endl;
(gdb) s
It works here!
17 cout<<"Exiting g()..."<<endl;
(gdb) s
Exiting g()...
18 }
(gdb) s
main () at src/templated_bug.cpp:24
24 }
(gdb) s
[Inferior 1 (process 50945) exited normally]
(gdb)
As you can see, it does not step inside f()
but steps inside g()
. Moreover,
(gdb) disassemble f
No symbol "f" in current context.
However, for another function g()
that is non-template, the symbols are loaded and I can disassemble it.
(gdb) disassemble g
Dump of assembler code for function g():
0x0000000100000d0c <+0>: push %rbp
0x0000000100000d0d <+1>: mov %rsp,%rbp
0x0000000100000d10 <+4>: lea 0x193(%rip),%rsi # 0x100000eaa
0x0000000100000d17 <+11>: mov 0x2ea(%rip),%rax # 0x100001008
0x0000000100000d1e <+18>: mov %rax,%rdi
0x0000000100000d21 <+21>: callq 0x100000e5c
0x0000000100000d26 <+26>: mov 0x2e3(%rip),%rdx # 0x100001010
0x0000000100000d2d <+33>: mov %rdx,%rsi
0x0000000100000d30 <+36>: mov %rax,%rdi
0x0000000100000d33 <+39>: callq 0x100000e4a
0x0000000100000d38 <+44>: lea 0x17a(%rip),%rsi # 0x100000eb9
0x0000000100000d3f <+51>: mov 0x2c2(%rip),%rax # 0x100001008
0x0000000100000d46 <+58>: mov %rax,%rdi
0x0000000100000d49 <+61>: callq 0x100000e5c
0x0000000100000d4e <+66>: mov 0x2bb(%rip),%rdx # 0x100001010
0x0000000100000d55 <+73>: mov %rdx,%rsi
0x0000000100000d58 <+76>: mov %rax,%rdi
0x0000000100000d5b <+79>: callq 0x100000e4a
0x0000000100000d60 <+84>: pop %rbp
0x0000000100000d61 <+85>: retq
End of assembler dump.