This is the mail archive of the
gdb@sourceware.org
mailing list for the GDB project.
Re: [Compile] Inserting compiled code via jumps
Hi,
The idea is similar to fast breakpoints conditions, as gdb would need
to patch in a jump to the compiled code directly or via a trampoline.
Here is an example of how it could be used :
(gdb) fcompile file snippet.c test.c:8
// snippet.c is compiled via gcc. It could contain a call to an trace
collector function for instance
// The instruction corresponding to line 8 of source file test.c is
replaced by a jump to a trampoline
// In the trampoline we call _gdb_expr_(), and then execute the
instruction that we replaced, corrected for displacement
(gdb) run
// The code from snippet.c is executed every time we hit line 8 of test.c
This would directly encompass fast breakpoint conditions, using a
snippet like "if(cond) __asm__("int3");".
NB: this does not work right now because gdb does not debug the
inserted snippet, but it should when injected via a jump.
The code for patching in the jump is located in gdbserver, I think
there is no use for dyninst for this. I am currently trying to migrate
what is necessary to a common directory.
If you need any more information let me know.
Thanks,
Paul
Tom Tromey <tom@tromey.com> wrote :
"Paul" == Paul Naert <paul.naert@polymtl.ca> writes:
Paul> I am a masters student and I would like to devote my research to
Paul> improving GDB's GCC Compile and Execute by adding the possibility to
Paul> jump directly to the compiled code without having to hit a breakpoint.
Paul> The idea is to reuse the same principle that was used in fast
Paul> tracepoints to insert code in a compiled program, except that instead
Paul> of jumping to GDB's collector function we would execute the code
Paul> compiled by GCC each time we hit the selected instruction.
I am not sure I really understand the idea.
With the "compile" command, we had hopes of someday extending it to
either allow fast breakpoint conditions (by compiling the breakpoint
condition and patching the process); or to allow fix-and-continue
(recompiling a single function and inserting it).
Is your idea like one of these? If it's different, could you maybe show
an example of how a user would use it?
Paul> - Has someone already worked on this ? On the wiki page there are
Paul> mentions to future projects that seem related (fast breakpoint
Paul> conditions most notably)
As far as I know nobody is working on it.
Paul> - Do you see any reason why that would not work that I missed,
Paul> except for the limitations of the existing Compile project?
I think it's entirely possible. I think the main issues involve the
patching -- figuring out how to replace instructions. Maybe dyninst
could be used to help with the rewriting, or maybe it can be done purely
in gdb.
thanks,
Tom