contrib/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libbacktrace.cc

   1 //===-- sanitizer_symbolizer_libbacktrace.cc ------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is shared between AddressSanitizer and ThreadSanitizer
  11 // run-time libraries.
  12 // Libbacktrace implementation of symbolizer parts.
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "sanitizer_platform.h"
  16
  17 #include "sanitizer_internal_defs.h"
  18 #include "sanitizer_symbolizer.h"
  19 #include "sanitizer_symbolizer_libbacktrace.h"
  20
  21 #if SANITIZER_LIBBACKTRACE
  22 # include "backtrace-supported.h"
  23 # if SANITIZER_POSIX && BACKTRACE_SUPPORTED && !BACKTRACE_USES_MALLOC
  24 #  include "backtrace.h"
  25 #  if SANITIZER_CP_DEMANGLE
  26 #   undef ARRAY_SIZE
  27 #   include "demangle.h"
  28 #  endif
  29 # else
  30 #  define SANITIZER_LIBBACKTRACE 0
  31 # endif
  32 #endif
  33
  34 namespace __sanitizer {
  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   const char *module_name;
  90   uptr module_offset;
  91
  92   void append(SymbolizedStack *f) {
  93     if (last != nullptr) {
  94       last->next = f;
  95       last = f;
  96     } else {
  97       first = f;
  98       last = f;
  99     }
 100   }
 101 };
 102
 103 extern "C" {
 104 static int SymbolizeCodePCInfoCallback(void *vdata, uintptr_t addr,
 105                                        const char *filename, int lineno,
 106                                        const char *function) {
 107   SymbolizeCodeCallbackArg *cdata = (SymbolizeCodeCallbackArg *)vdata;
 108   if (function) {
 109     SymbolizedStack *cur = SymbolizedStack::New(addr);
 110     cdata->append(cur);
 111     AddressInfo *info = &cur->info;
 112     info->FillAddressAndModuleInfo(addr, cdata->module_name,
 113                                    cdata->module_offset);
 114     info->function = LibbacktraceSymbolizer::Demangle(function, true);
 115     if (filename)
 116       info->file = internal_strdup(filename);
 117     info->line = lineno;
 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     SymbolizedStack *cur = SymbolizedStack::New(addr);
 127     cdata->append(cur);
 128     AddressInfo *info = &cur->info;
 129     info->FillAddressAndModuleInfo(addr, cdata->module_name,
 130                                    cdata->module_offset);
 131     info->function = LibbacktraceSymbolizer::Demangle(symname, true);
 132   }
 133 }
 134
 135 static void SymbolizeDataCallback(void *vdata, uintptr_t, const char *symname,
 136                                   uintptr_t symval, uintptr_t symsize) {
 137   DataInfo *info = (DataInfo *)vdata;
 138   if (symname && symval) {
 139     info->name = LibbacktraceSymbolizer::Demangle(symname, true);
 140     info->start = symval;
 141     info->size = symsize;
 142   }
 143 }
 144
 145 static void ErrorCallback(void *, const char *, int) {}
 146 }  // extern "C"
 147
 148 }  // namespace
 149
 150 LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
 151   // State created in backtrace_create_state is leaked.
 152   void *state = (void *)(backtrace_create_state("/proc/self/exe", 0,
 153                                                 ErrorCallback, NULL));
 154   if (!state)
 155     return 0;
 156   return new(*alloc) LibbacktraceSymbolizer(state);
 157 }
 158
 159 SymbolizedStack *LibbacktraceSymbolizer::SymbolizeCode(uptr addr,
 160                                                        const char *module_name,
 161                                                        uptr module_offset) {
 162   SymbolizeCodeCallbackArg data;
 163   data.first = nullptr;
 164   data.last = nullptr;
 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.first)
 170     return data.first;
 171   backtrace_syminfo((backtrace_state *)state_, addr, SymbolizeCodeCallback,
 172                     ErrorCallback, &data);
 173   return data.first;
 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 #else  // SANITIZER_LIBBACKTRACE
 183
 184 LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
 185   return 0;
 186 }
 187
 188 SymbolizedStack *LibbacktraceSymbolizer::SymbolizeCode(uptr addr,
 189                                                        const char *module_name,
 190                                                        uptr module_offset) {
 191   (void)state_;
 192   return nullptr;
 193 }
 194
 195 bool LibbacktraceSymbolizer::SymbolizeData(DataInfo *info) {
 196   return false;
 197 }
 198
 199 #endif  // SANITIZER_LIBBACKTRACE
 200
 201 char *LibbacktraceSymbolizer::Demangle(const char *name, bool always_alloc) {
 202 #if SANITIZER_LIBBACKTRACE && SANITIZER_CP_DEMANGLE
 203   if (char *demangled = CplusV3Demangle(name))
 204     return demangled;
 205 #endif
 206   if (always_alloc)
 207     return internal_strdup(name);
 208   return 0;
 209 }
 210
 211 }  // namespace __sanitizer