Mark Mitchell wrote:
Kenneth Zadeck wrote:
1) Screw the debugging. The motivation behind this option is that
not only is it easy, but the reality is that we have changed the
program so much that even if we did "fix up the types" so that the
matched the generated program, that the code is so different from
what the user expected that (s)he could not even debug if anyway.
I think this would be very disappointing to users. One of the
long-standing advantages of GCC is that you can in fact do some level
of debugging with optimized code.
It's true that if you tear apart structures, the debugger is going to
have a hard time dealing with that at present, but it's also true that
dropping all language-specific knowledge of types is going to make
life very hard for users. And it's not like you're always going to
mangle things beyond recognition; tossing out all the debug info is
throwing out the baby with the bathwater.
2) Generate the debugging for the types early, and then add an
interface that would parse and regenerate the debugging info with
the changes. It is quite likely that this would lock gcc
completely into dwarf, but that appears to only be a problem for
AIX at this point, so that may not be that much of a problem.
This is the approach I would suggest. Dump out the debug info for
types before you throw away all the information, and then leave it aside.
I am coming to the conclusion, for other reasons that this is what we
are going to have to do.
kenny
