Re: Debugging new code using debug-info from old code

[Michael Snyder <msnyder@specifix.com>]

On Wed, 2008-05-07 at 17:29 -0700, Lokesh Kumar wrote:
> Hi all,
> 
> I am trying to debug a "transformed" C code using the debugging
> information of the "original" C code. Essentially, my code goes
> through some transformations that keeps its semantic structure same
> but add some extraneous function calls distributed throughout the
> code.
> 
> I want that when a user debugs this new code, all the new additions
> are hidden away from him/her and (s)he feels as if (s)he is debugging
> the original code. What this means is that there should exists an
> underlying mapping between the transformed code and original code so
> that it could map the debugging commands for original code into
> corresponding commands for transformed code.
> 
> I started out by trying to load the symbol table of the original
> executable while debugging the transformed binary but that doesn't
> seem to help since the function addresses and everything else has
> changed. My second thoughts seem to suggest that if I can update the
> debugging information in the transformed binary as per my original
> code, I may get what I want. However, I am not sure how this will work
> if there were some compile-time optimizations in one code and not in
> another but I am not thinking about that now.
> 
> I think I can use some help here. Does anyone here have a better idea
> on how to do it ? Or perhaps, how can I update the debugging
> information from one binary to another ?

This has been done before -- for instance, this is how the 
original "cfront" c++ compiler worked.  "cfront" would pre-process
the C++ source code and generate a transformed C program file, 
which would then be compiled.

In order to make debuggers (notably gdb) display the un-preprocessed
C++ source instead of the processed C source, cfront would generate
"#line" directives in the output (C) program that referred back to
lines within the input (C++) program.

So, if your transformed output file contains some code that 
is associated with, say, line 1000 of your input source file, 
you would instrument the output file with a line directive 
that would look something like 

   #line 1000 'input.c'

Try it.  You can add some line directives by hand and 
compile the code to experiment with the debugger behavior.