libsanitizer/sanitizer_common/sanitizer_symbolizer_libbacktrace.cpp

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