Home | History | Annotate | Line # | Download | only in sanitizer_common 
      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   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
    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
    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