|
111
|
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 static char *DemangleAlloc(const char *name, bool always_alloc);
|
|
|
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 uptr frames_symbolized;
|
|
|
90
|
|
|
91 AddressInfo *get_new_frame(uintptr_t addr) {
|
|
|
92 CHECK(last);
|
|
|
93 if (frames_symbolized > 0) {
|
|
|
94 SymbolizedStack *cur = SymbolizedStack::New(addr);
|
|
|
95 AddressInfo *info = &cur->info;
|
|
|
96 info->FillModuleInfo(first->info.module, first->info.module_offset,
|
|
|
97 first->info.module_arch);
|
|
|
98 last->next = cur;
|
|
|
99 last = cur;
|
|
|
100 }
|
|
|
101 CHECK_EQ(addr, first->info.address);
|
|
|
102 CHECK_EQ(addr, last->info.address);
|
|
|
103 return &last->info;
|
|
|
104 }
|
|
|
105 };
|
|
|
106
|
|
|
107 extern "C" {
|
|
|
108 static int SymbolizeCodePCInfoCallback(void *vdata, uintptr_t addr,
|
|
|
109 const char *filename, int lineno,
|
|
|
110 const char *function) {
|
|
|
111 SymbolizeCodeCallbackArg *cdata = (SymbolizeCodeCallbackArg *)vdata;
|
|
|
112 if (function) {
|
|
|
113 AddressInfo *info = cdata->get_new_frame(addr);
|
|
|
114 info->function = DemangleAlloc(function, /*always_alloc*/ true);
|
|
|
115 if (filename)
|
|
|
116 info->file = internal_strdup(filename);
|
|
|
117 info->line = lineno;
|
|
|
118 cdata->frames_symbolized++;
|
|
|
119 }
|
|
|
120 return 0;
|
|
|
121 }
|
|
|
122
|
|
|
123 static void SymbolizeCodeCallback(void *vdata, uintptr_t addr,
|
|
|
124 const char *symname, uintptr_t, uintptr_t) {
|
|
|
125 SymbolizeCodeCallbackArg *cdata = (SymbolizeCodeCallbackArg *)vdata;
|
|
|
126 if (symname) {
|
|
|
127 AddressInfo *info = cdata->get_new_frame(addr);
|
|
|
128 info->function = DemangleAlloc(symname, /*always_alloc*/ true);
|
|
|
129 cdata->frames_symbolized++;
|
|
|
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 = DemangleAlloc(symname, /*always_alloc*/ 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 bool LibbacktraceSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
|
|
|
158 SymbolizeCodeCallbackArg data;
|
|
|
159 data.first = stack;
|
|
|
160 data.last = stack;
|
|
|
161 data.frames_symbolized = 0;
|
|
|
162 backtrace_pcinfo((backtrace_state *)state_, addr, SymbolizeCodePCInfoCallback,
|
|
|
163 ErrorCallback, &data);
|
|
|
164 if (data.frames_symbolized > 0)
|
|
|
165 return true;
|
|
|
166 backtrace_syminfo((backtrace_state *)state_, addr, SymbolizeCodeCallback,
|
|
|
167 ErrorCallback, &data);
|
|
|
168 return (data.frames_symbolized > 0);
|
|
|
169 }
|
|
|
170
|
|
|
171 bool LibbacktraceSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
|
|
|
172 backtrace_syminfo((backtrace_state *)state_, addr, SymbolizeDataCallback,
|
|
|
173 ErrorCallback, info);
|
|
|
174 return true;
|
|
|
175 }
|
|
|
176
|
|
|
177 #else // SANITIZER_LIBBACKTRACE
|
|
|
178
|
|
|
179 LibbacktraceSymbolizer *LibbacktraceSymbolizer::get(LowLevelAllocator *alloc) {
|
|
|
180 return 0;
|
|
|
181 }
|
|
|
182
|
|
|
183 bool LibbacktraceSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
|
|
|
184 (void)state_;
|
|
|
185 return false;
|
|
|
186 }
|
|
|
187
|
|
|
188 bool LibbacktraceSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
|
|
|
189 return false;
|
|
|
190 }
|
|
|
191
|
|
|
192 #endif // SANITIZER_LIBBACKTRACE
|
|
|
193
|
|
|
194 static char *DemangleAlloc(const char *name, bool always_alloc) {
|
|
|
195 #if SANITIZER_LIBBACKTRACE && SANITIZER_CP_DEMANGLE
|
|
|
196 if (char *demangled = CplusV3Demangle(name))
|
|
|
197 return demangled;
|
|
|
198 #endif
|
|
|
199 if (always_alloc)
|
|
|
200 return internal_strdup(name);
|
|
|
201 return 0;
|
|
|
202 }
|
|
|
203
|
|
|
204 const char *LibbacktraceSymbolizer::Demangle(const char *name) {
|
|
|
205 return DemangleAlloc(name, /*always_alloc*/ false);
|
|
|
206 }
|
|
|
207
|
|
|
208 } // namespace __sanitizer
|
