PVAssert.hpp

#ifndef _pv_assert_h
#define _pv_assert_h

#include "utils/PVLog.hpp"
#include <cxxabi.h>
#include <execinfo.h>
#include <stdio.h>
#include <stdlib.h>

#ifdef NDEBUG
#define pvAssert(c)
#define pvAssertMessage(c, fmt, ...)
#else

#define pvAssert(c)                                                                                \
   if (!(c)) {                                                                                     \
      PV::pv_assert_failed(__FILE__, __LINE__, #c);                                                \
   }

#define pvAssertMessage(c, fmt, ...)                                                               \
   if (!(c)) {                                                                                     \
      PV::pv_assert_failed_message(__FILE__, __LINE__, #c, fmt, ##__VA_ARGS__);                    \
   }
#endif

namespace PV {
void pv_assert_failed(const char *file, int line, const char *condition);
void pv_assert_failed_message(
      const char *file,
      int line,
      const char *condition,
      const char *fmt,
      ...);

static inline void print_stacktrace(FILE *out = stderr, unsigned int max_frames = 63) {
   StackTrace() << "stack trace:" << std::endl;

   // 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) {
      StackTrace() << "  <empty, possibly corrupt>" << std::endl;
      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);

   // iterate over the returned symbol lines. skip the first, it is the
   // address of this function.
   for (int i = 1; i < addrlen; i++) {
      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
            StackTrace() << "  " << symbollist[i] << " : " << funcname << "+" << begin_offset
                         << std::endl;
         }
         else {
            // demangling failed. Output function name as a C function with
            // no arguments.
            StackTrace() << "  " << symbollist[i] << " : " << begin_name << "+" << begin_offset
                         << std::endl;
         }
      }
      else {
         // couldn't parse the line? print the whole line.
         StackTrace() << "  " << symbollist[i] << std::endl;
      }
   }

   free(funcname);
   free(symbollist);
}
}

#endif