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