GCC gOlogy: studying the impact of optimizations on debugging
fsfla.org
fsfla.org
No, it's sitting right there in a register, and I know that because I just stepped through, instruction-by-instruction, the code that computed its value. Fortunately it does not claim the register has been "optimized away" too, but the experience of debugging optimised code could definitely use a lot of improvement.
(This isn't exclusive to GCC/GDB either --- I've seen the same with MSVC and Visual Studio, but in my experience the latter tends to be somewhat better.)
Given the invariant of "debug info does not affect optimization", you end up with plenty of cases where your only possible choices are "give the user a possibly wrong value for the variable" or "say the value does not exist anymore".
Most of the time, the latter is done instead of the former.
You also unfortunately cannot just mark them so the debugger tells you "this may be wrong, it may be right, good luck".
Historically, compilers tried doing the former, users complained enough that they switched to doing the latter.
Over individual ranges, it even supports saying "this piece of the variable is in a register, this piece in memory, etc". Even at the per-bit level. You can evaluate complex turing-complete expressions to produce the value, including calling DWARF expression subroutines (the latter is fairly new)
GDB supports them all.
The underlying problem is multi-fold. 1. Computations get rewritten and rearranged in ways that do not affect the semantics of the program overall, but do of the intermediate states.
IE if you rewrite
a = b * 5
c = a * b
as
a = b * b
c = a * 5
assuming b = 3 the intermediate value of a is now 9 but in terms of the original code it was 15
A value of 45 probably would just confuse the programmer.
It is possible, with extensive enough tracking to solve the above problem for a significant set of cases
However, code movement and rearrangement make it not feasible to solve it in all (particularly around heavy loop optimization).
2. Variables also get partially coalesced/eliminated all the time in other interesting ways.
Turning applesauce back into apples is not possible in practice. I admit the theoretical possibility, but ...
[1] https://docs.microsoft.com/en-us/visualstudio/debugger/using...
It seems well informed, but it lacks any coherent structure. And throughout I couldn't deduce what the point was. Like a well educated rant.
Most of the time, nobody cared. (Which is fine, I never did this stuff for no reason, the write-up was typically beneficial for me personally, and if nobody else cared, that's OK by me.) But the odd one would prove useful and end up getting re-forwarded multiple times, and that happened often enough that I kept doing it.
(I use the past tense because I do contract work these days, and that works differently.)
Leaving aside the justification for this sort of thing in general, and moving on to why you might be interested in this particular note: suppose you'd always just built your code at one of either -O0 (shit code, but works well with any debugger), -Os (slightly less shit code, debugging probably tolerable) or -O2/-O3 (decent code, but debugging is a pain - and I always knew the assembly language for every target! The people that only knew C++ had a devil of a time).
So this works, and you're used to it, and what better argument for anything could there possibly be. But you probably wondered whether you could do better, and with this in mind you've probably looked at the gcc manual and noted that there's this huge pile of other sub-options. What if you tweaked those, you wonder? Would that make things better? Would it make them worse? If you only had the time to investigate which would impede debugging, and which you could just pop into your debug build with impunity, safe in the knowledge that it wouldn't cause you any difficulty! If only you had the sort of more in-depth knowledge of compiler internals required to make this sort of judgement by yourself, rather than just go through the 500,000 combinations of options to try each one in turn! And/or if you only you had somebody on staff who could just try this stuff out and write you a summary! But you don't, and you don't, and you don't, and you have a product to finish anyway...
So this document might at least be mildly interesting.
I spend a lot of my time optimizing code switching between,01 and 03.
I am genuinely very worried about the trade-off between optimization and pragmatism.
At the same time, I am limited. This very useful analysis would help me a lot if it providied an executive summary.
Non-linear debug builds are obviously harmful.
you should never use a debugger
because it only serves to complicate things
using the I/O subsystem to debug your program
is a far more efficient way to debug.
If you do things this way,
you orthogonalize the optimization side of your compiler
from the mess created by trying to assist the debugging process
via the rather complex and intrusive (from the compiler's perspective) component called the debugger
that reeaaallly depends. I had cases where adding a printf and recompiling would take mere seconds and a gdb startup on the order of 3 to 4 minutes because recompiling only changes one shared library while GDB has to load all of them.
A text editor and a compiler is all you need.
That simplifies your programming interface a lot.
If you're going down into registers, you're obviously debugging the wrong way.
You don't need printf's if you write directly to your screen which is easy to do.
I don't know what you mean by this. If you don't have f.ex. printf available you have to come up with something else.
>You don't need printf's if you write directly to your screen which is easy to do.
What if the hardware you're debugging doesn't have a screen?