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 #if SANITIZER_LIBBACKTRACE
40 # if SANITIZER_CP_DEMANGLE
41 struct CplusV3DemangleData {
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) {
52 if (needed > data->allocated)
53 data->allocated = needed;
54 char *buf = (char *)InternalAlloc(data->allocated);
56 internal_memcpy(buf, data->buf, data->size);
57 InternalFree(data->buf);
61 internal_memcpy(data->buf + data->size, s, l);
62 data->buf[data->size + l] = '\0';
67 char *CplusV3Demangle(const char *name) {
68 CplusV3DemangleData data;
72 if (cplus_demangle_v3_callback(name, DMGL_PARAMS | DMGL_ANSI,
73 CplusV3DemangleCallback, &data)) {
74 if (data.size + 64 > data.allocated)
76 char *buf = internal_strdup(data.buf);
77 InternalFree(data.buf);
81 InternalFree(data.buf);
84 # endif // SANITIZER_CP_DEMANGLE
86 struct SymbolizeCodeCallbackArg {
87 SymbolizedStack *first;
88 SymbolizedStack *last;
89 const char *module_name;
92 void append(SymbolizedStack *f) {
93 if (last != nullptr) {
104 static int SymbolizeCodePCInfoCallback(void *vdata, uintptr_t addr,
105 const char *filename, int lineno,
106 const char *function) {
107 SymbolizeCodeCallbackArg *cdata = (SymbolizeCodeCallbackArg *)vdata;
109 SymbolizedStack *cur = SymbolizedStack::New(addr);
111 AddressInfo *info = &cur->info;
112 info->FillAddressAndModuleInfo(addr, cdata->module_name,
113 cdata->module_offset);
114 info->function = LibbacktraceSymbolizer::Demangle(function, true);
116 info->file = internal_strdup(filename);
122 static void SymbolizeCodeCallback(void *vdata, uintptr_t addr,
123 const char *symname, uintptr_t, uintptr_t) {
124 SymbolizeCodeCallbackArg *cdata = (SymbolizeCodeCallbackArg *)vdata;
126 SymbolizedStack *cur = SymbolizedStack::New(addr);
128 AddressInfo *info = &cur->info;
129 info->FillAddressAndModuleInfo(addr, cdata->module_name,
130 cdata->module_offset);
131 info->function = LibbacktraceSymbolizer::Demangle(symname, true);
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;
145 static void ErrorCallback(void *, const char *, int) {}
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));
156 return new(*alloc) LibbacktraceSymbolizer(state);
159 SymbolizedStack *LibbacktraceSymbolizer::SymbolizeCode(uptr addr,
160 const char *module_name,
161 uptr module_offset) {
162 SymbolizeCodeCallbackArg data;
163 data.first = nullptr;
165 data.module_name = module_name;
166 data.module_offset = module_offset;
167 backtrace_pcinfo((backtrace_state *)state_, addr, SymbolizeCodePCInfoCallback,
168 ErrorCallback, &data);
171 backtrace_syminfo((backtrace_state *)state_, addr, SymbolizeCodeCallback,
172 ErrorCallback, &data);
176 bool LibbacktraceSymbolizer::SymbolizeData(DataInfo *info) {
177 backtrace_syminfo((backtrace_state *)state_, info->address,
178 SymbolizeDataCallback, ErrorCallback, info);
182 #else // SANITIZER_LIBBACKTRACE
184 LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
188 SymbolizedStack *LibbacktraceSymbolizer::SymbolizeCode(uptr addr,
189 const char *module_name,
190 uptr module_offset) {
195 bool LibbacktraceSymbolizer::SymbolizeData(DataInfo *info) {
199 #endif // SANITIZER_LIBBACKTRACE
201 char *LibbacktraceSymbolizer::Demangle(const char *name, bool always_alloc) {
202 #if SANITIZER_LIBBACKTRACE && SANITIZER_CP_DEMANGLE
203 if (char *demangled = CplusV3Demangle(name))
207 return internal_strdup(name);
211 } // namespace __sanitizer