Stack unwind might fail for a number of reasons:
If the stack has been corrupted by the user code; if so, the program might core dump, or the data collection code might core dump, depending on exactly how the stack was corrupted.
If the user code does not follow the standard ABI conventions for function calls. In particular, on the SPARC platform, if the return register, %o7, is altered before a save instruction is executed.
On any platform, hand-written assembler code might violate the conventions.
If the leaf PC is in a function after the callee’s frame is popped from the stack, but before the function returns.
If the call stack contains more than about 250 frames, the Collector does not have the space to completely unwind the call stack. In this case, PCs for functions from _start to some point in the call stack are not recorded in the experiment. The artificial function <Truncated-stack> is shown as called from <Total> to tally the topmost frames recorded.
If the Collector fails to unwind the frames of optimized functions on x86 platforms.
If you generate intermediate files using the -E or -P compiler options, the Analyzer uses the intermediate file for annotated source code, not the original source file. The #line directives generated with -E can cause problems in the assignment of metrics to source lines.
The following line appears in annotated source if there are instructions from a function that do not have line numbers referring to the source file that was compiled to generate the function:
function_name -- <instructions without line numbers>
Line numbers can be absent under the following circumstances:
You compiled without specifying the -g option.
The debugging information was stripped after compilation, or the executables or object files that contain the information are moved or deleted or subsequently modified.
The function contains code that was generated from #include files rather than from the original source file.
At high optimization, if code was inlined from a function in a different file.
The source file has #line directives referring to some other file; compiling with the -E option, and then compiling the resulting .i file is one way in which this happens. It may also happen when you compile with the -P flag.
The object file cannot be found to read line number information.
The compiler used generates incomplete line number tables.