contrib/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.cc

   1 //===-- sanitizer_symbolizer.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_allocator_internal.h"
  15 #include "sanitizer_platform.h"
  16 #include "sanitizer_internal_defs.h"
  17 #include "sanitizer_libc.h"
  18 #include "sanitizer_placement_new.h"
  19 #include "sanitizer_symbolizer_internal.h"
  20
  21 namespace __sanitizer {
  22
  23 AddressInfo::AddressInfo() {
  24   internal_memset(this, 0, sizeof(AddressInfo));
  25   function_offset = kUnknown;
  26 }
  27
  28 void AddressInfo::Clear() {
  29   InternalFree(module);
  30   InternalFree(function);
  31   InternalFree(file);
  32   internal_memset(this, 0, sizeof(AddressInfo));
  33   function_offset = kUnknown;
  34 }
  35
  36 void AddressInfo::FillModuleInfo(const char *mod_name, uptr mod_offset) {
  37   module = internal_strdup(mod_name);
  38   module_offset = mod_offset;
  39 }
  40
  41 SymbolizedStack::SymbolizedStack() : next(nullptr), info() {}
  42
  43 SymbolizedStack *SymbolizedStack::New(uptr addr) {
  44   void *mem = InternalAlloc(sizeof(SymbolizedStack));
  45   SymbolizedStack *res = new(mem) SymbolizedStack();
  46   res->info.address = addr;
  47   return res;
  48 }
  49
  50 void SymbolizedStack::ClearAll() {
  51   info.Clear();
  52   if (next)
  53     next->ClearAll();
  54   InternalFree(this);
  55 }
  56
  57 DataInfo::DataInfo() {
  58   internal_memset(this, 0, sizeof(DataInfo));
  59 }
  60
  61 void DataInfo::Clear() {
  62   InternalFree(module);
  63   InternalFree(file);
  64   InternalFree(name);
  65   internal_memset(this, 0, sizeof(DataInfo));
  66 }
  67
  68 Symbolizer *Symbolizer::symbolizer_;
  69 StaticSpinMutex Symbolizer::init_mu_;
  70 LowLevelAllocator Symbolizer::symbolizer_allocator_;
  71
  72 void Symbolizer::AddHooks(Symbolizer::StartSymbolizationHook start_hook,
  73                           Symbolizer::EndSymbolizationHook end_hook) {
  74   CHECK(start_hook_ == 0 && end_hook_ == 0);
  75   start_hook_ = start_hook;
  76   end_hook_ = end_hook;
  77 }
  78
  79 const char *Symbolizer::ModuleNameOwner::GetOwnedCopy(const char *str) {
  80   mu_->CheckLocked();
  81
  82   // 'str' will be the same string multiple times in a row, optimize this case.
  83   if (last_match_ && !internal_strcmp(last_match_, str))
  84     return last_match_;
  85
  86   // FIXME: this is linear search.
  87   // We should optimize this further if this turns out to be a bottleneck later.
  88   for (uptr i = 0; i < storage_.size(); ++i) {
  89     if (!internal_strcmp(storage_[i], str)) {
  90       last_match_ = storage_[i];
  91       return last_match_;
  92     }
  93   }
  94   last_match_ = internal_strdup(str);
  95   storage_.push_back(last_match_);
  96   return last_match_;
  97 }
  98
  99 Symbolizer::Symbolizer(IntrusiveList<SymbolizerTool> tools)
 100     : module_names_(&mu_), modules_(), modules_fresh_(false), tools_(tools),
 101       start_hook_(0), end_hook_(0) {}
 102
 103 Symbolizer::SymbolizerScope::SymbolizerScope(const Symbolizer *sym)
 104     : sym_(sym) {
 105   if (sym_->start_hook_)
 106     sym_->start_hook_();
 107 }
 108
 109 Symbolizer::SymbolizerScope::~SymbolizerScope() {
 110   if (sym_->end_hook_)
 111     sym_->end_hook_();
 112 }
 113
 114 }  // namespace __sanitizer