1 //===-- sanitizer_symbolizer_libbacktrace.cc ------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file is shared between AddressSanitizer and ThreadSanitizer
11 // run-time libraries.
12 // Libbacktrace implementation of symbolizer parts.
13 //===----------------------------------------------------------------------===//
15 #include "sanitizer_platform.h"
17 #include "sanitizer_internal_defs.h"
18 #include "sanitizer_symbolizer.h"
19 #include "sanitizer_symbolizer_libbacktrace.h"
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
27 # include "demangle.h"
30 # define SANITIZER_LIBBACKTRACE 0
34 namespace __sanitizer {
36 static char *DemangleAlloc(const char *name, bool always_alloc);
38 #if SANITIZER_LIBBACKTRACE
42 # if SANITIZER_CP_DEMANGLE
43 struct CplusV3DemangleData {
49 static void CplusV3DemangleCallback(const char *s, size_t l, void *vdata) {
50 CplusV3DemangleData *data = (CplusV3DemangleData *)vdata;
51 uptr needed = data->size + l + 1;
52 if (needed > data->allocated) {
54 if (needed > data->allocated)
55 data->allocated = needed;
56 char *buf = (char *)InternalAlloc(data->allocated);
58 internal_memcpy(buf, data->buf, data->size);
59 InternalFree(data->buf);
63 internal_memcpy(data->buf + data->size, s, l);
64 data->buf[data->size + l] = '\0';
69 char *CplusV3Demangle(const char *name) {
70 CplusV3DemangleData data;
74 if (cplus_demangle_v3_callback(name, DMGL_PARAMS | DMGL_ANSI,
75 CplusV3DemangleCallback, &data)) {
76 if (data.size + 64 > data.allocated)
78 char *buf = internal_strdup(data.buf);
79 InternalFree(data.buf);
83 InternalFree(data.buf);
86 # endif // SANITIZER_CP_DEMANGLE
88 struct SymbolizeCodeCallbackArg {
89 SymbolizedStack *first;
90 SymbolizedStack *last;
91 uptr frames_symbolized;
93 AddressInfo *get_new_frame(uintptr_t addr) {
95 if (frames_symbolized > 0) {
96 SymbolizedStack *cur = SymbolizedStack::New(addr);
97 AddressInfo *info = &cur->info;
98 info->FillModuleInfo(first->info.module, first->info.module_offset);
102 CHECK_EQ(addr, first->info.address);
103 CHECK_EQ(addr, last->info.address);
109 static int SymbolizeCodePCInfoCallback(void *vdata, uintptr_t addr,
110 const char *filename, int lineno,
111 const char *function) {
112 SymbolizeCodeCallbackArg *cdata = (SymbolizeCodeCallbackArg *)vdata;
114 AddressInfo *info = cdata->get_new_frame(addr);
115 info->function = DemangleAlloc(function, /*always_alloc*/ true);
117 info->file = internal_strdup(filename);
119 cdata->frames_symbolized++;
124 static void SymbolizeCodeCallback(void *vdata, uintptr_t addr,
125 const char *symname, uintptr_t, uintptr_t) {
126 SymbolizeCodeCallbackArg *cdata = (SymbolizeCodeCallbackArg *)vdata;
128 AddressInfo *info = cdata->get_new_frame(addr);
129 info->function = DemangleAlloc(symname, /*always_alloc*/ true);
130 cdata->frames_symbolized++;
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;
144 static void ErrorCallback(void *, const char *, int) {}
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));
155 return new(*alloc) LibbacktraceSymbolizer(state);
158 bool LibbacktraceSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
159 SymbolizeCodeCallbackArg data;
162 data.frames_symbolized = 0;
163 backtrace_pcinfo((backtrace_state *)state_, addr, SymbolizeCodePCInfoCallback,
164 ErrorCallback, &data);
165 if (data.frames_symbolized > 0)
167 backtrace_syminfo((backtrace_state *)state_, addr, SymbolizeCodeCallback,
168 ErrorCallback, &data);
169 return (data.frames_symbolized > 0);
172 bool LibbacktraceSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
173 backtrace_syminfo((backtrace_state *)state_, addr, SymbolizeDataCallback,
174 ErrorCallback, info);
178 #else // SANITIZER_LIBBACKTRACE
180 LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
184 bool LibbacktraceSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
189 bool LibbacktraceSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
193 #endif // SANITIZER_LIBBACKTRACE
195 static char *DemangleAlloc(const char *name, bool always_alloc) {
196 #if SANITIZER_LIBBACKTRACE && SANITIZER_CP_DEMANGLE
197 if (char *demangled = CplusV3Demangle(name))
201 return internal_strdup(name);
205 const char *LibbacktraceSymbolizer::Demangle(const char *name) {
206 return DemangleAlloc(name, /*always_alloc*/ false);
209 } // namespace __sanitizer