This is the mail archive of the mailing list for the GDB project.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [LLVMdev] Connecting JITted code to gdb

I'm adding the gdb list because it appears there's currently no way to
tell gdb about newly-JITted code. That is, it's not an LLVM-specific

There appear to be two techniques in common use to debug
dynamically-generated code despite this. First, as Evan suggests
below, we can have the JIT print the address range that it's written a
function into, have gdb disassemble that, set breakpoints at
particular addresses, and print variables by knowing what register
they live in. Second, as described at,
we can write out a full object file with dwarf tables, and use
add-symbol-file to get gdb to load that on demand.

Neither of these is ideal. add-symbol-file is better, but it doesn't
allow us to set breakpoints inside the JITted code until it's
generated, and it doesn't let those breakpoints follow the code as
it's re-optimized and re-translated. It currently also requires user
interaction, but it's possible that we could write a file to
reload the debug information every time the user gets to the gdb
prompt. There may be other problems I haven't though of.

It would be better to have an interface through which a JITting
library could tell gdb about newly-generated code. This could resemble
the overlay interface
( or
the interface through which dynamic loaders tell gdb about
newly-loaded code. There are a couple considerations that are specific
to JITting, of course:
 1. A JIT compiler generates new code frequently, and having to do
lots of extra work, especially while the debugger isn't attached, may
hurt performance.
 2. Translated code gets duplicated, replaced, and freed, and gdb
needs to modify its breakpoints to keep up.

I don't really know enough about the internals of LLVM or gdb to make
any recommendations, but I think it would be useful to find some way
for them (and other debuggers and JITs) to talk to each other.


On Fri, Mar 27, 2009 at 1:48 PM, Evan Cheng <> wrote:
> Run with -debug-only=jit.
> Break on line 1148 of JITEmitter.cpp. The debugging message will tell
> you the address and size of the function that was jitted. You can then
> tell gdb to disassemble the code.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]