Although it is possible to do a reasonable amount of debugging at
nonzero optimization levels,
the higher the level the more likely that
source-level constructs will have been eliminated by optimization.
For example, if a loop is strength-reduced, the loop
control variable may be completely eliminated and thus cannot be
displayed in the debugger.
This can only happen at
Explicit temporary variables that you code might be eliminated at
-O1 or higher.
The use of the
which is needed for source-level debugging,
affects the size of the program executable on disk,
and indeed the debugging information can be quite large.
However, it has no effect on the generated code (and thus does not
Since the compiler generates debugging tables for a compilation unit before it performs optimizations, the optimizing transformations may invalidate some of the debugging data. You therefore need to anticipate certain anomalous situations that may arise while debugging optimized code. These are the most common cases:
nextcommands show the PC bouncing back and forth in the code. This may result from any of the following optimizations:
return, or a
breakin a C
In general, when an unexpected value appears for a local variable or parameter you should first ascertain if that value was actually computed by your program, as opposed to being incorrectly reported by the debugger. Record fields or array elements in an object designated by an access value are generally less of a problem, once you have ascertained that the access value is sensible. Typically, this means checking variables in the preceding code and in the calling subprogram to verify that the value observed is explainable from other values (one must apply the procedure recursively to those other values); or re-running the code and stopping a little earlier (perhaps before the call) and stepping to better see how the variable obtained the value in question; or continuing to step `from' the point of the strange value to see if code motion had simply moved the variable’s assignments later.
In light of such anomalies, a recommended technique is to use
early in the software development cycle, when extensive debugging capabilities
are most needed, and then move to
-O1 and later
the debugger becomes less critical.
Whether to use the
-g switch in the release version is
a release management issue.
Note that if you use
-g you can then use the
on the resulting executable,
which removes both debugging information and global symbols.