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