1 //===-- sanitizer_stacktrace_libcdep.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 //===----------------------------------------------------------------------===//
13
14 #include "sanitizer_common.h"
15 #include "sanitizer_placement_new.h"
16 #include "sanitizer_stacktrace.h"
17 #include "sanitizer_stacktrace_printer.h"
18 #include "sanitizer_symbolizer.h"
19
20 namespace __sanitizer {
21
Print() const22 void StackTrace::Print() const {
23 if (trace == nullptr || size == 0) {
24 Printf(" <empty stack>\n\n");
25 return;
26 }
27 InternalScopedString frame_desc(GetPageSizeCached() * 2);
28 InternalScopedString dedup_token(GetPageSizeCached());
29 int dedup_frames = common_flags()->dedup_token_length;
30 uptr frame_num = 0;
31 for (uptr i = 0; i < size && trace[i]; i++) {
32 // PCs in stack traces are actually the return addresses, that is,
33 // addresses of the next instructions after the call.
34 uptr pc = GetPreviousInstructionPc(trace[i]);
35 SymbolizedStack *frames = Symbolizer::GetOrInit()->SymbolizePC(pc);
36 CHECK(frames);
37 for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
38 frame_desc.clear();
39 RenderFrame(&frame_desc, common_flags()->stack_trace_format, frame_num++,
40 cur->info, common_flags()->symbolize_vs_style,
41 common_flags()->strip_path_prefix);
42 Printf("%s\n", frame_desc.data());
43 if (dedup_frames-- > 0) {
44 if (dedup_token.length())
45 dedup_token.append("--");
46 if (cur->info.function != nullptr)
47 dedup_token.append(cur->info.function);
48 }
49 }
50 frames->ClearAll();
51 }
52 // Always print a trailing empty line after stack trace.
53 Printf("\n");
54 if (dedup_token.length())
55 Printf("DEDUP_TOKEN: %s\n", dedup_token.data());
56 }
57
Unwind(u32 max_depth,uptr pc,uptr bp,void * context,uptr stack_top,uptr stack_bottom,bool request_fast_unwind)58 void BufferedStackTrace::Unwind(u32 max_depth, uptr pc, uptr bp, void *context,
59 uptr stack_top, uptr stack_bottom,
60 bool request_fast_unwind) {
61 top_frame_bp = (max_depth > 0) ? bp : 0;
62 // Avoid doing any work for small max_depth.
63 if (max_depth == 0) {
64 size = 0;
65 return;
66 }
67 if (max_depth == 1) {
68 size = 1;
69 trace_buffer[0] = pc;
70 return;
71 }
72 if (!WillUseFastUnwind(request_fast_unwind)) {
73 #if SANITIZER_CAN_SLOW_UNWIND
74 if (context)
75 SlowUnwindStackWithContext(pc, context, max_depth);
76 else
77 SlowUnwindStack(pc, max_depth);
78 #else
79 UNREACHABLE("slow unwind requested but not available");
80 #endif
81 } else {
82 FastUnwindStack(pc, bp, stack_top, stack_bottom, max_depth);
83 }
84 }
85
GetModuleAndOffsetForPc(uptr pc,char * module_name,uptr module_name_len,uptr * pc_offset)86 static int GetModuleAndOffsetForPc(uptr pc, char *module_name,
87 uptr module_name_len, uptr *pc_offset) {
88 const char *found_module_name = nullptr;
89 bool ok = Symbolizer::GetOrInit()->GetModuleNameAndOffsetForPC(
90 pc, &found_module_name, pc_offset);
91
92 if (!ok) return false;
93
94 if (module_name && module_name_len) {
95 internal_strncpy(module_name, found_module_name, module_name_len);
96 module_name[module_name_len - 1] = '\x00';
97 }
98 return true;
99 }
100
101 } // namespace __sanitizer
102 using namespace __sanitizer;
103
104 extern "C" {
105 SANITIZER_INTERFACE_ATTRIBUTE
__sanitizer_symbolize_pc(uptr pc,const char * fmt,char * out_buf,uptr out_buf_size)106 void __sanitizer_symbolize_pc(uptr pc, const char *fmt, char *out_buf,
107 uptr out_buf_size) {
108 if (!out_buf_size) return;
109 pc = StackTrace::GetPreviousInstructionPc(pc);
110 SymbolizedStack *frame = Symbolizer::GetOrInit()->SymbolizePC(pc);
111 if (!frame) {
112 internal_strncpy(out_buf, "<can't symbolize>", out_buf_size);
113 out_buf[out_buf_size - 1] = 0;
114 return;
115 }
116 InternalScopedString frame_desc(GetPageSizeCached());
117 uptr frame_num = 0;
118 // Reserve one byte for the final 0.
119 char *out_end = out_buf + out_buf_size - 1;
120 for (SymbolizedStack *cur = frame; cur && out_buf < out_end;
121 cur = cur->next) {
122 frame_desc.clear();
123 RenderFrame(&frame_desc, fmt, frame_num++, cur->info,
124 common_flags()->symbolize_vs_style,
125 common_flags()->strip_path_prefix);
126 if (!frame_desc.length())
127 continue;
128 // Reserve one byte for the terminating 0.
129 uptr n = out_end - out_buf - 1;
130 internal_strncpy(out_buf, frame_desc.data(), n);
131 out_buf += __sanitizer::Min<uptr>(n, frame_desc.length());
132 *out_buf++ = 0;
133 }
134 CHECK(out_buf <= out_end);
135 *out_buf = 0;
136 }
137
138 SANITIZER_INTERFACE_ATTRIBUTE
__sanitizer_symbolize_global(uptr data_addr,const char * fmt,char * out_buf,uptr out_buf_size)139 void __sanitizer_symbolize_global(uptr data_addr, const char *fmt,
140 char *out_buf, uptr out_buf_size) {
141 if (!out_buf_size) return;
142 out_buf[0] = 0;
143 DataInfo DI;
144 if (!Symbolizer::GetOrInit()->SymbolizeData(data_addr, &DI)) return;
145 InternalScopedString data_desc(GetPageSizeCached());
146 RenderData(&data_desc, fmt, &DI, common_flags()->strip_path_prefix);
147 internal_strncpy(out_buf, data_desc.data(), out_buf_size);
148 out_buf[out_buf_size - 1] = 0;
149 }
150
151 SANITIZER_INTERFACE_ATTRIBUTE
__sanitizer_get_module_and_offset_for_pc(uptr pc,char * module_name,uptr module_name_len,uptr * pc_offset)152 int __sanitizer_get_module_and_offset_for_pc( // NOLINT
153 uptr pc, char *module_name, uptr module_name_len, uptr *pc_offset) {
154 return __sanitizer::GetModuleAndOffsetForPc(pc, module_name, module_name_len,
155 pc_offset);
156 }
157 } // extern "C"
158