]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - contrib/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc
Upgrade Unbound to 1.8.0. More to follow.
[FreeBSD/FreeBSD.git] / contrib / compiler-rt / lib / sanitizer_common / sanitizer_stacktrace_libcdep.cc
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
22 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
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
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
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   RenderFrame(&frame_desc, fmt, 0, frame->info,
118               common_flags()->symbolize_vs_style,
119               common_flags()->strip_path_prefix);
120   internal_strncpy(out_buf, frame_desc.data(), out_buf_size);
121   out_buf[out_buf_size - 1] = 0;
122 }
123
124 SANITIZER_INTERFACE_ATTRIBUTE
125 void __sanitizer_symbolize_global(uptr data_addr, const char *fmt,
126                                   char *out_buf, uptr out_buf_size) {
127   if (!out_buf_size) return;
128   out_buf[0] = 0;
129   DataInfo DI;
130   if (!Symbolizer::GetOrInit()->SymbolizeData(data_addr, &DI)) return;
131   InternalScopedString data_desc(GetPageSizeCached());
132   RenderData(&data_desc, fmt, &DI, common_flags()->strip_path_prefix);
133   internal_strncpy(out_buf, data_desc.data(), out_buf_size);
134   out_buf[out_buf_size - 1] = 0;
135 }
136
137 SANITIZER_INTERFACE_ATTRIBUTE
138 int __sanitizer_get_module_and_offset_for_pc( // NOLINT
139     uptr pc, char *module_name, uptr module_name_len, uptr *pc_offset) {
140   return __sanitizer::GetModuleAndOffsetForPc(pc, module_name, module_name_len,
141                                               pc_offset);
142 }
143 }  // extern "C"