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 #if SANITIZER_LIBBACKTRACE
  35
  36 namespace {
  37
  38 #if SANITIZER_CP_DEMANGLE
  39 struct CplusV3DemangleData {
  40   char *buf;
  41   uptr size, allocated;
  42 };
  43
  44 extern "C" {
  45 static void CplusV3DemangleCallback(const char *s, size_t l, void *vdata) {
  46   CplusV3DemangleData *data = (CplusV3DemangleData *)vdata;
  47   uptr needed = data->size + l + 1;
  48   if (needed > data->allocated) {
  49     data->allocated *= 2;
  50     if (needed > data->allocated)
  51       data->allocated = needed;
  52     char *buf = (char *)InternalAlloc(data->allocated);
  53     if (data->buf) {
  54       internal_memcpy(buf, data->buf, data->size);
  55       InternalFree(data->buf);
  56     }
  57     data->buf = buf;
  58   }
  59   internal_memcpy(data->buf + data->size, s, l);
  60   data->buf[data->size + l] = '\0';
  61   data->size += l;
  62 }
  63 }  // extern "C"
  64
  65 char *CplusV3Demangle(const char *name, bool always_alloc) {
  66   CplusV3DemangleData data;
  67   data.buf = 0;
  68   data.size = 0;
  69   data.allocated = 0;
  70   if (cplus_demangle_v3_callback(name, DMGL_PARAMS | DMGL_ANSI,
  71                                  CplusV3DemangleCallback, &data)) {
  72     if (data.size + 64 > data.allocated)
  73       return data.buf;
  74     char *buf = internal_strdup(data.buf);
  75     InternalFree(data.buf);
  76     return buf;
  77   }
  78   if (data.buf)
  79     InternalFree(data.buf);
  80   if (always_alloc)
  81     return internal_strdup(name);
  82   return 0;
  83 }
  84 #else
  85 const char *CplusV3Demangle(const char *name, bool always_alloc) {
  86   if (always_alloc)
  87     return internal_strdup(name);
  88   return 0;
  89 }
  90 #endif
  91
  92 struct SymbolizeCodeData {
  93   AddressInfo *frames;
  94   uptr n_frames;
  95   uptr max_frames;
  96   const char *module_name;
  97   uptr module_offset;
  98 };
  99
 100 extern "C" {
 101 static int SymbolizeCodePCInfoCallback(void *vdata, uintptr_t addr,
 102                                        const char *filename, int lineno,
 103                                        const char *function) {
 104   SymbolizeCodeData *cdata = (SymbolizeCodeData *)vdata;
 105   if (function) {
 106     AddressInfo *info = &cdata->frames[cdata->n_frames++];
 107     info->Clear();
 108     info->FillAddressAndModuleInfo(addr, cdata->module_name,
 109                                    cdata->module_offset);
 110     info->function = CplusV3Demangle(function, true);
 111     if (filename)
 112       info->file = internal_strdup(filename);
 113     info->line = lineno;
 114     if (cdata->n_frames == cdata->max_frames)
 115       return 1;
 116   }
 117   return 0;
 118 }
 119
 120 static void SymbolizeCodeCallback(void *vdata, uintptr_t addr,
 121                                   const char *symname, uintptr_t, uintptr_t) {
 122   SymbolizeCodeData *cdata = (SymbolizeCodeData *)vdata;
 123   if (symname) {
 124     AddressInfo *info = &cdata->frames[0];
 125     info->Clear();
 126     info->FillAddressAndModuleInfo(addr, cdata->module_name,
 127                                    cdata->module_offset);
 128     info->function = CplusV3Demangle(symname, true);
 129     cdata->n_frames = 1;
 130   }
 131 }
 132
 133 static void SymbolizeDataCallback(void *vdata, uintptr_t, const char *symname,
 134                                   uintptr_t symval, uintptr_t symsize) {
 135   DataInfo *info = (DataInfo *)vdata;
 136   if (symname && symval) {
 137     info->name = CplusV3Demangle(symname, true);
 138     info->start = symval;
 139     info->size = symsize;
 140   }
 141 }
 142
 143 static void ErrorCallback(void *, const char *, int) {}
 144 }  // extern "C"
 145
 146 }  // namespace
 147
 148 LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
 149   // State created in backtrace_create_state is leaked.
 150   void *state = (void *)(backtrace_create_state("/proc/self/exe", 0,
 151                                                 ErrorCallback, NULL));
 152   if (!state)
 153     return 0;
 154   return new(*alloc) LibbacktraceSymbolizer(state);
 155 }
 156
 157 uptr LibbacktraceSymbolizer::SymbolizeCode(uptr addr, AddressInfo *frames,
 158                                            uptr max_frames,
 159                                            const char *module_name,
 160                                            uptr module_offset) {
 161   SymbolizeCodeData data;
 162   data.frames = frames;
 163   data.n_frames = 0;
 164   data.max_frames = max_frames;
 165   data.module_name = module_name;
 166   data.module_offset = module_offset;
 167   backtrace_pcinfo((backtrace_state *)state_, addr, SymbolizeCodePCInfoCallback,
 168                    ErrorCallback, &data);
 169   if (data.n_frames)
 170     return data.n_frames;
 171   backtrace_syminfo((backtrace_state *)state_, addr, SymbolizeCodeCallback,
 172                     ErrorCallback, &data);
 173   return data.n_frames;
 174 }
 175
 176 bool LibbacktraceSymbolizer::SymbolizeData(DataInfo *info) {
 177   backtrace_syminfo((backtrace_state *)state_, info->address,
 178                     SymbolizeDataCallback, ErrorCallback, info);
 179   return true;
 180 }
 181
 182 const char *LibbacktraceSymbolizer::Demangle(const char *name) {
 183 #if SANITIZER_CP_DEMANGLE
 184   const char *demangled = CplusV3Demangle(name, false);
 185   if (demangled)
 186     return demangled;
 187   return name;
 188 #else
 189   return 0;
 190 #endif
 191 }
 192
 193 #else  // SANITIZER_LIBBACKTRACE
 194
 195 LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
 196   return 0;
 197 }
 198
 199 uptr LibbacktraceSymbolizer::SymbolizeCode(uptr addr, AddressInfo *frames,
 200                                            uptr max_frames,
 201                                            const char *module_name,
 202                                            uptr module_offset) {
 203   (void)state_;
 204   return 0;
 205 }
 206
 207 bool LibbacktraceSymbolizer::SymbolizeData(DataInfo *info) {
 208   return false;
 209 }
 210
 211 const char *LibbacktraceSymbolizer::Demangle(const char *name) {
 212   return 0;
 213 }
 214
 215 #endif  // SANITIZER_LIBBACKTRACE
 216
 217 }  // namespace __sanitizer