libsanitizer/sanitizer_common/sanitizer_symbolizer_libbacktrace.cc

   1 //===-- sanitizer_symbolizer_libbacktrace.cc ------------------------------===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // This file is shared between AddressSanitizer and ThreadSanitizer
   9 // run-time libraries.
  10 // Libbacktrace implementation of symbolizer parts.
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "sanitizer_platform.h"
  14
  15 #include "sanitizer_internal_defs.h"
  16 #include "sanitizer_symbolizer.h"
  17 #include "sanitizer_symbolizer_libbacktrace.h"
  18
  19 #if SANITIZER_LIBBACKTRACE
  20 # include "backtrace-supported.h"
  21 # if SANITIZER_POSIX && BACKTRACE_SUPPORTED && !BACKTRACE_USES_MALLOC
  22 #  include "backtrace.h"
  23 #  if SANITIZER_CP_DEMANGLE
  24 #   undef ARRAY_SIZE
  25 #   include "demangle.h"
  26 #  endif
  27 # else
  28 #  define SANITIZER_LIBBACKTRACE 0
  29 # endif
  30 #endif
  31
  32 namespace __sanitizer {
  33
  34 static char *DemangleAlloc(const char *name, bool always_alloc);
  35
  36 #if SANITIZER_LIBBACKTRACE
  37
  38 namespace {
  39
  40 # if SANITIZER_CP_DEMANGLE
  41 struct CplusV3DemangleData {
  42   char *buf;
  43   uptr size, allocated;
  44 };
  45
  46 extern "C" {
  47 static void CplusV3DemangleCallback(const char *s, size_t l, void *vdata) {
  48   CplusV3DemangleData *data = (CplusV3DemangleData *)vdata;
  49   uptr needed = data->size + l + 1;
  50   if (needed > data->allocated) {
  51     data->allocated *= 2;
  52     if (needed > data->allocated)
  53       data->allocated = needed;
  54     char *buf = (char *)InternalAlloc(data->allocated);
  55     if (data->buf) {
  56       internal_memcpy(buf, data->buf, data->size);
  57       InternalFree(data->buf);
  58     }
  59     data->buf = buf;
  60   }
  61   internal_memcpy(data->buf + data->size, s, l);
  62   data->buf[data->size + l] = '\0';
  63   data->size += l;
  64 }
  65 }  // extern "C"
  66
  67 char *CplusV3Demangle(const char *name) {
  68   CplusV3DemangleData data;
  69   data.buf = 0;
  70   data.size = 0;
  71   data.allocated = 0;
  72   if (cplus_demangle_v3_callback(name, DMGL_PARAMS | DMGL_ANSI,
  73                                  CplusV3DemangleCallback, &data)) {
  74     if (data.size + 64 > data.allocated)
  75       return data.buf;
  76     char *buf = internal_strdup(data.buf);
  77     InternalFree(data.buf);
  78     return buf;
  79   }
  80   if (data.buf)
  81     InternalFree(data.buf);
  82   return 0;
  83 }
  84 # endif  // SANITIZER_CP_DEMANGLE
  85
  86 struct SymbolizeCodeCallbackArg {
  87   SymbolizedStack *first;
  88   SymbolizedStack *last;
  89   uptr frames_symbolized;
  90
  91   AddressInfo *get_new_frame(uintptr_t addr) {
  92     CHECK(last);
  93     if (frames_symbolized > 0) {
  94       SymbolizedStack *cur = SymbolizedStack::New(addr);
  95       AddressInfo *info = &cur->info;
  96       info->FillModuleInfo(first->info.module, first->info.module_offset);
  97       last->next = cur;
  98       last = cur;
  99     }
 100     CHECK_EQ(addr, first->info.address);
 101     CHECK_EQ(addr, last->info.address);
 102     return &last->info;
 103   }
 104 };
 105
 106 extern "C" {
 107 static int SymbolizeCodePCInfoCallback(void *vdata, uintptr_t addr,
 108                                        const char *filename, int lineno,
 109                                        const char *function) {
 110   SymbolizeCodeCallbackArg *cdata = (SymbolizeCodeCallbackArg *)vdata;
 111   if (function) {
 112     AddressInfo *info = cdata->get_new_frame(addr);
 113     info->function = DemangleAlloc(function, /*always_alloc*/ true);
 114     if (filename)
 115       info->file = internal_strdup(filename);
 116     info->line = lineno;
 117     cdata->frames_symbolized++;
 118   }
 119   return 0;
 120 }
 121
 122 static void SymbolizeCodeCallback(void *vdata, uintptr_t addr,
 123                                   const char *symname, uintptr_t, uintptr_t) {
 124   SymbolizeCodeCallbackArg *cdata = (SymbolizeCodeCallbackArg *)vdata;
 125   if (symname) {
 126     AddressInfo *info = cdata->get_new_frame(addr);
 127     info->function = DemangleAlloc(symname, /*always_alloc*/ true);
 128     cdata->frames_symbolized++;
 129   }
 130 }
 131
 132 static void SymbolizeDataCallback(void *vdata, uintptr_t, const char *symname,
 133                                   uintptr_t symval, uintptr_t symsize) {
 134   DataInfo *info = (DataInfo *)vdata;
 135   if (symname && symval) {
 136     info->name = DemangleAlloc(symname, /*always_alloc*/ true);
 137     info->start = symval;
 138     info->size = symsize;
 139   }
 140 }
 141
 142 static void ErrorCallback(void *, const char *, int) {}
 143 }  // extern "C"
 144
 145 }  // namespace
 146
 147 LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
 148   // State created in backtrace_create_state is leaked.
 149   void *state = (void *)(backtrace_create_state("/proc/self/exe", 0,
 150                                                 ErrorCallback, NULL));
 151   if (!state)
 152     return 0;
 153   return new(*alloc) LibbacktraceSymbolizer(state);
 154 }
 155
 156 bool LibbacktraceSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
 157   SymbolizeCodeCallbackArg data;
 158   data.first = stack;
 159   data.last = stack;
 160   data.frames_symbolized = 0;
 161   backtrace_pcinfo((backtrace_state *)state_, addr, SymbolizeCodePCInfoCallback,
 162                    ErrorCallback, &data);
 163   if (data.frames_symbolized > 0)
 164     return true;
 165   backtrace_syminfo((backtrace_state *)state_, addr, SymbolizeCodeCallback,
 166                     ErrorCallback, &data);
 167   return (data.frames_symbolized > 0);
 168 }
 169
 170 bool LibbacktraceSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
 171   backtrace_syminfo((backtrace_state *)state_, addr, SymbolizeDataCallback,
 172                     ErrorCallback, info);
 173   return true;
 174 }
 175
 176 #else  // SANITIZER_LIBBACKTRACE
 177
 178 LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
 179   return 0;
 180 }
 181
 182 bool LibbacktraceSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
 183   (void)state_;
 184   return false;
 185 }
 186
 187 bool LibbacktraceSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
 188   return false;
 189 }
 190
 191 #endif  // SANITIZER_LIBBACKTRACE
 192
 193 static char *DemangleAlloc(const char *name, bool always_alloc) {
 194 #if SANITIZER_LIBBACKTRACE && SANITIZER_CP_DEMANGLE
 195   if (char *demangled = CplusV3Demangle(name))
 196     return demangled;
 197 #endif
 198   if (always_alloc)
 199     return internal_strdup(name);
 200   return 0;
 201 }
 202
 203 const char *LibbacktraceSymbolizer::Demangle(const char *name) {
 204   return DemangleAlloc(name, /*always_alloc*/ false);
 205 }
 206
 207 }  // namespace __sanitizer