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.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::FillAddressAndModuleInfo(uptr addr, const char *mod_name,
  37                                            uptr mod_offset) {
  38   address = addr;
  39   module = internal_strdup(mod_name);
  40   module_offset = mod_offset;
  41 }
  42
  43 SymbolizedStack::SymbolizedStack() : next(nullptr), info() {}
  44
  45 SymbolizedStack *SymbolizedStack::New(uptr addr) {
  46   void *mem = InternalAlloc(sizeof(SymbolizedStack));
  47   SymbolizedStack *res = new(mem) SymbolizedStack();
  48   res->info.address = addr;
  49   return res;
  50 }
  51
  52 void SymbolizedStack::ClearAll() {
  53   info.Clear();
  54   if (next)
  55     next->ClearAll();
  56   InternalFree(this);
  57 }
  58
  59 DataInfo::DataInfo() {
  60   internal_memset(this, 0, sizeof(DataInfo));
  61 }
  62
  63 void DataInfo::Clear() {
  64   InternalFree(module);
  65   InternalFree(name);
  66   internal_memset(this, 0, sizeof(DataInfo));
  67 }
  68
  69 Symbolizer *Symbolizer::symbolizer_;
  70 StaticSpinMutex Symbolizer::init_mu_;
  71 LowLevelAllocator Symbolizer::symbolizer_allocator_;
  72
  73 Symbolizer *Symbolizer::Disable() {
  74   CHECK_EQ(0, symbolizer_);
  75   // Initialize a dummy symbolizer.
  76   symbolizer_ = new(symbolizer_allocator_) Symbolizer;
  77   return symbolizer_;
  78 }
  79
  80 void Symbolizer::AddHooks(Symbolizer::StartSymbolizationHook start_hook,
  81                           Symbolizer::EndSymbolizationHook end_hook) {
  82   CHECK(start_hook_ == 0 && end_hook_ == 0);
  83   start_hook_ = start_hook;
  84   end_hook_ = end_hook;
  85 }
  86
  87 Symbolizer::Symbolizer() : start_hook_(0), end_hook_(0) {}
  88
  89 Symbolizer::SymbolizerScope::SymbolizerScope(const Symbolizer *sym)
  90     : sym_(sym) {
  91   if (sym_->start_hook_)
  92     sym_->start_hook_();
  93 }
  94
  95 Symbolizer::SymbolizerScope::~SymbolizerScope() {
  96   if (sym_->end_hook_)
  97     sym_->end_hook_();
  98 }
  99
 100 }  // namespace __sanitizer