libsanitizer/sanitizer_common/sanitizer_symbolizer.cc

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