ExceptionBase_stacktrace.cpp

Go to the documentation of this file.

#include "wibmod/WIB1/BUException/ExceptionBase.hh"
 
// Error string for stack string allocation error
static const char stackError[] = "Stack allocation failed.\n";
 
const char*
BUException::exBase::StackTrace() const throw()
{
  if (stackBuffer == NULL)
    return stackError;
  return stackBuffer;
}
 
void
BUException::exBase::AppendStackLine(const char* line) throw()
{
  // Check for NULL line
  if (line == NULL)
    return;
 
  // get raw line size
  size_t lineSize = strlen(line);
  if (lineSize >= (stackSize - stackUsed))
    lineSize = stackSize - stackUsed;
  // copy string
  strncpy(stackBuffer + stackUsed, line, lineSize);
  // update size
  stackUsed += lineSize;
  // Add eol
  if ((stackSize - stackUsed) > 1) {
    stackBuffer[stackUsed] = '\n';
    stackUsed++;
  }
  // add null terminator (there is always room for one(unless NULL))
  if (stackBuffer != NULL) {
    stackBuffer[stackUsed] = '\0';
  }
}
 
void
BUException::exBase::GenerateStackTrace() throw()
{
  // Get the thread/process ID for this stack trace
  PID = syscall(SYS_gettid);
 
  // Get the stack trace (void *s)
  const size_t maxStackSize = 20;
  void* functionStack[maxStackSize];
  size_t stackSize;
 
  // Fill functionStack with void * pointers to return address of the corresponding stack frame
  // filed up to maxStackSize with most recent calls
  stackSize = backtrace(functionStack, maxStackSize);
 
  // Get the stack trace strings  (we have to free this)
  char** functionNames = backtrace_symbols(functionStack, stackSize);
  if (functionNames == NULL) {
    fprintf(stderr, "Error in exBase::GenerateStackTrace(). backtrace_symbols failed\n");
    return;
  }
 
  char* demangledName = NULL;
  // Start stack trace from 3 to skip the exception class's functions
  for (size_t iFunction = 3; iFunction < stackSize; iFunction++) {
    // based off of http://panthema.net/2008/0901-stacktrace-demangled/
    // Be paranoid about these pointers and make sure they are valid
    if (functionNames[iFunction] == NULL) {
      AppendStackLine("Unknown");
      continue;
    }
 
    char* mangledStart = NULL;
    char* offsetStart = NULL;
    char* offsetEnd = NULL;
 
    // Find mangled and offset start/ends
    char* bufferEnd = functionNames[iFunction] + strlen(functionNames[iFunction]);
    for (char* buffer = functionNames[iFunction]; buffer != bufferEnd; buffer++) {
      // Look for function's opening '('
      if (*buffer == '(')
        mangledStart = buffer;
      // Look for offset in function
      else if (*buffer == '+')
        offsetStart = buffer;
      // Look for closing ')', but only if we've found an opening one
      else if ((*buffer == ')') && (offsetStart != NULL)) {
        offsetEnd = buffer;
        break;
      }
    }
 
    // if the parsing makes sense
    if ((mangledStart != NULL) && (offsetStart != NULL) && (offsetEnd != NULL) && (mangledStart < offsetStart)) {
      // Make manglesStart point to the beginning of the name
      mangledStart++;
      // put in a null terminator at offsetStart to end the mangled name
      *offsetStart = '\0';
 
      // Make offset start point to the beginning of the offset
      offsetStart++;
      // put a null terminator at the end of the offset
      *offsetEnd = '\0';
 
      // demangle
      size_t demangledSize = 0;
      int demangledRet = 0;
      char* retName = abi::__cxa_demangle(mangledStart, demangledName, &demangledSize, &demangledRet);
      // Append demangled line
      if ((demangledRet == 0) && (retName != NULL)) {
        // copy possibly reallocated c-string
        demangledName = retName;
        AppendStackLine(demangledName);
      } else // if ther was an error, append the mangled name
      {
        AppendStackLine(mangledStart);
      }
    } else // Bad parse, just print the line
    {
      AppendStackLine(functionNames[iFunction]);
    }
  }
 
  if (demangledName != NULL)
    free(demangledName);
  free(functionNames);
}