stacktrace.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <execinfo.h>
#include <cxxabi.h>
#include "oomph_utilities.h"

Go to the source code of this file.

Functions
static void	print_stacktrace (std::ostream &exception_stream, unsigned int max_frames=63)

Function Documentation

print_stacktrace()

static void print_stacktrace ( std::ostream &  exception_stream, unsigned int  max_frames = 63  )

inlinestatic

Print a demangled stack backtrace of the caller function

{
  exception_stream << "\nStack trace:\n";
  exception_stream << "------------\n";
 
  // storage array for stack trace address data
  void* addrlist[max_frames + 1];
 
  // retrieve current stack addresses
  int addrlen = backtrace(addrlist, sizeof(addrlist) / sizeof(void*));
 
  if (addrlen == 0)
  {
    exception_stream << "\n<empty stack trace, possibly corrupt>\n";
    return;
  }
 
  // resolve addresses into strings containing "filename(function+address)",
  // this array must be free()-ed
  char** symbollist = backtrace_symbols(addrlist, addrlen);
 
  // allocate string which will be filled with the demangled function name
  size_t funcnamesize = 256;
  char* funcname = (char*)malloc(funcnamesize);
 
  // Stream to collect information that allows retrieval of line numbers
  std::stringstream address_stream;
 
  // iterate over the returned symbol lines. skip the first, it is the
  // address of this function.
  for (int i = 1; i < addrlen; i++)
  {
    // ------------- begin  mh addition ---------------
    char *begin_absolute = 0, *end_absolute = 0;
 
    // find absolute address (in square brackets)
    // ./module(function+0x15c) [0x8048a6d]
    for (char* p = symbollist[i]; *p; ++p)
    {
      if (*p == '[') begin_absolute = p;
      else if (*p == ']' && begin_absolute)
      {
        end_absolute = p;
        break;
      }
    }
 
    if (begin_absolute)
    {
      *begin_absolute++ = '\0';
      *end_absolute = '\0';
      if (oomph::CommandLineArgs::Argc != 0)
      {
        address_stream << "addr2line -e " << oomph::CommandLineArgs::Argv[0]
                       << " " << begin_absolute << "\n";
      }
      else
      {
        address_stream << "addr2line -e [name_of_executable] " << begin_absolute
                       << "\n";
      }
    }
 
    // ------------- end mh addition ---------------
 
    char *begin_name = 0, *begin_offset = 0, *end_offset = 0;
 
    // find parentheses and +address offset surrounding the mangled name:
    // ./module(function+0x15c) [0x8048a6d]
    for (char* p = symbollist[i]; *p; ++p)
    {
      if (*p == '(') begin_name = p;
      else if (*p == '+')
        begin_offset = p;
      else if (*p == ')' && begin_offset)
      {
        end_offset = p;
        break;
      }
    }
 
    if (begin_name && begin_offset && end_offset && begin_name < begin_offset)
    {
      *begin_name++ = '\0';
      *begin_offset++ = '\0';
      *end_offset = '\0';
 
      // mangled name is now in [begin_name, begin_offset) and caller
      // offset in [begin_offset, end_offset). now apply
      // __cxa_demangle():
 
      int status;
      char* ret =
        abi::__cxa_demangle(begin_name, funcname, &funcnamesize, &status);
      if (status == 0)
      {
        funcname = ret; // use possibly realloc()-ed string
        /* fprintf(out, "  %s : %s+%s\n", */
        /*         symbollist[i], funcname, begin_offset); */
        exception_stream << symbollist[i] << " : " << funcname << "+"
                         << begin_offset << std::endl;
      }
      else
      {
        // demangling failed. Output function name as a C function with
        // no arguments.
        /* fprintf(out, "  %s : %s()+%s\n", */
        /*         symbollist[i], begin_name, begin_offset); */
 
        exception_stream << symbollist[i] << " : " << begin_name << "+"
                         << begin_offset << std::endl;
      }
    }
    else
    {
      // couldn't parse the line? print the whole line.
      // fprintf(out, "  %s\n", symbollist[i]);
      exception_stream << symbollist[i] << std::endl;
    }
  }
 
  exception_stream << "\nHere are the commmands to obtain the line numbers:\n";
 
  exception_stream << "--------------------------------------------------\n";
  exception_stream << address_stream.str() << std::endl;
 
 
  if (oomph::CommandLineArgs::Argc == 0)
  {
    exception_stream << "\nNOTE: Replace [name_of_executable] by the actual\n"
                     << "       name of the executable. I would have inserted\n"
                     << "       this for you if you had called \n\n"
                     << "          CommandLineArgs::setup(argc,argv);\n\n"
                     << "       in your driver code...\n\n";
  }
 
  free(funcname);
  free(symbollist);
}

References oomph::CommandLineArgs::Argc, oomph::CommandLineArgs::Argv, i, p, and ret.

Referenced by oomph::OomphLibException::OomphLibException().