DebugUtils.cpp

#include "DebugUtils.h"
 
#if defined( _WIN32 )
  #define WIN32_LEAN_AND_MEAN
  #include <Windows.h>
  #include <dbghelp.h>
#endif
 
#if defined(_WIN32)
 
bool Cogs::isBeingDebugged() {
  return IsDebuggerPresent();
}
 
std::string Cogs::getCallstack() {
  std::string callstack;
  void*       addresses[200];
  int         noofaddresses = CaptureStackBackTrace(0, 199, addresses, nullptr);
  char        buffer[1000];
 
  for(int idx = 0; idx < noofaddresses; ++idx) {
    char               local[sizeof(IMAGEHLP_SYMBOL64) + 992];
    IMAGEHLP_SYMBOL64* symbol = reinterpret_cast<IMAGEHLP_SYMBOL64*>(local);
    DWORD64            realaddr = reinterpret_cast<DWORD64>(addresses[idx]) - 1;
    DWORD64            symdisp;
 
    buffer[0] = 0;
 
    memset(local, 0, sizeof(local));
 
    symbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
    symbol->MaxNameLength = sizeof(local) - sizeof(IMAGEHLP_SYMBOL64);
 
    if(SymGetSymFromAddr64(GetCurrentProcess(), realaddr, &symdisp, symbol) || (!GetLastError() && symbol->Name[0])) {
      char            symname[4096];
      DWORD           linedisp;
      IMAGEHLP_LINE64 line;
 
      UnDecorateSymbolName(symbol->Name, symname, sizeof(symname), UNDNAME_COMPLETE);
 
      memset(&line, 0, sizeof(line));
      line.SizeOfStruct = sizeof(line);
 
      if(SymGetLineFromAddr64(GetCurrentProcess(), realaddr, &linedisp, &line)) {
        sprintf(buffer, "%p - %s (%s:%d)\n", reinterpret_cast<void*>(realaddr), symname, line.FileName, line.LineNumber);
      }
      else {
        sprintf(buffer, "%p - %s\n", reinterpret_cast<void*>(realaddr), symname);
      }
    }
    else {
      sprintf(buffer, "%p - (Unknown)\n", reinterpret_cast<void*>(realaddr));
    }
    callstack += buffer;
  }
  return callstack;
}
 
#elif defined(__linux__)
 
#include <cxxabi.h>   // Needs libc++-dev on Ubuntu.
#include <dlfcn.h>
#include <fcntl.h>
#include <unistd.h>
#include <unwind.h>
 
bool Cogs::isBeingDebugged() {
  char  buf[4096];
  int   fd = open("/proc/self/status", O_RDONLY);
 
  if (fd >= 0) {
    ssize_t   bytesread = read(fd, buf, sizeof(buf) - 1);
 
    close(fd);
 
    if (bytesread > 0) {
      buf[bytesread] = 0;
 
      constexpr char  tracerPidString[] = "TracerPid:";
      const char*     ptr = strstr(buf, tracerPidString);
 
      if (ptr) {
        ptr += sizeof(tracerPidString) - 1;
 
        for (const char* end = buf + bytesread; ptr <= end; ++ptr) {
          if (!isspace(*ptr)) {
            return ::isdigit(*ptr) != 0 && *ptr != '0';
          }
        }
      }
    }
  }
  return false;
}
 
struct BacktraceState {
  void**  current;
  void**  end;
};
 
_Unwind_Reason_Code unwindCallback(struct _Unwind_Context* context, void* arg)
{
  BacktraceState* state = static_cast<BacktraceState*>(arg);
  uintptr_t       pc = _Unwind_GetIP(context);
 
  if (pc) {
    if (state->current == state->end) {
      return _URC_END_OF_STACK;
    }
    *state->current++ = reinterpret_cast<void*>(pc);
  }
  return _URC_NO_REASON;
}
 
std::string Cogs::getCallstack() {
  std::string     callstack;
  void*           addresses[200];
  BacktraceState  state = {addresses, addresses + 200};
 
  _Unwind_Backtrace(&unwindCallback, &state);
 
  for (int idx = 0, addrCount = static_cast<int>(state.current - addresses); idx < addrCount; ++idx) {
    Dl_info   info;
    char      hexAddr[21] = { '0', 'x', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', ':', ' ', 0 };
    uint64_t  addrValue = reinterpret_cast<uint64_t>(addresses[idx]);
 
    for (int idx = 18; addrValue; addrValue >>= 4) {
      hexAddr[--idx] = "0123456789ABCDEF"[addrValue & 0x0F];
    }
 
    callstack += hexAddr;
 
    if (dladdr(addresses[idx], &info)) {
      if (info.dli_sname) {
        int   status;
        char* demangled = abi::__cxa_demangle(info.dli_sname, nullptr, nullptr, &status);
 
        if (demangled) {
          if (status == 0) {
            callstack += demangled;
          }
          free(demangled);
        }
        else {
          callstack += info.dli_sname;
        }
      }
      else if (info.dli_fname) {
        callstack += info.dli_fname;
      }
    }
    callstack += "\n";
  }
  return callstack;
}
 
#elif defined(__APPLE__)
 
#include <assert.h>
#include <stdbool.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/sysctl.h>
 
bool Cogs::isBeingDebugged() {
  int               mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid()};
  struct kinfo_proc info = {};
  size_t            size = sizeof(info);
  int               junk = sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0);
 
  assert(junk == 0);
  return info.kp_proc.p_flag & P_TRACED;
}
 
std::string Cogs::getCallstack() {
  return "Sorry, callstack retrieval not implemented for Apple platforms.";
}
 
#endif