1 //===-- sanitizer_symbolizer.cpp ------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file is shared between AddressSanitizer and ThreadSanitizer
10 // run-time libraries.
11 //===----------------------------------------------------------------------===//
12
13 #include "sanitizer_allocator_internal.h"
14 #include "sanitizer_platform.h"
15 #include "sanitizer_internal_defs.h"
16 #include "sanitizer_libc.h"
17 #include "sanitizer_placement_new.h"
18 #include "sanitizer_symbolizer_internal.h"
19
20 namespace __sanitizer {
21
AddressInfo()22 AddressInfo::AddressInfo() {
23 internal_memset(this, 0, sizeof(AddressInfo));
24 function_offset = kUnknown;
25 }
26
Clear()27 void AddressInfo::Clear() {
28 InternalFree(module);
29 InternalFree(function);
30 InternalFree(file);
31 internal_memset(this, 0, sizeof(AddressInfo));
32 function_offset = kUnknown;
33 }
34
FillModuleInfo(const char * mod_name,uptr mod_offset,ModuleArch mod_arch)35 void AddressInfo::FillModuleInfo(const char *mod_name, uptr mod_offset,
36 ModuleArch mod_arch) {
37 module = internal_strdup(mod_name);
38 module_offset = mod_offset;
39 module_arch = mod_arch;
40 }
41
SymbolizedStack()42 SymbolizedStack::SymbolizedStack() : next(nullptr), info() {}
43
New(uptr addr)44 SymbolizedStack *SymbolizedStack::New(uptr addr) {
45 void *mem = InternalAlloc(sizeof(SymbolizedStack));
46 SymbolizedStack *res = new(mem) SymbolizedStack();
47 res->info.address = addr;
48 return res;
49 }
50
ClearAll()51 void SymbolizedStack::ClearAll() {
52 info.Clear();
53 if (next)
54 next->ClearAll();
55 InternalFree(this);
56 }
57
DataInfo()58 DataInfo::DataInfo() {
59 internal_memset(this, 0, sizeof(DataInfo));
60 }
61
Clear()62 void DataInfo::Clear() {
63 InternalFree(module);
64 InternalFree(file);
65 InternalFree(name);
66 internal_memset(this, 0, sizeof(DataInfo));
67 }
68
Clear()69 void FrameInfo::Clear() {
70 InternalFree(module);
71 for (LocalInfo &local : locals) {
72 InternalFree(local.function_name);
73 InternalFree(local.name);
74 InternalFree(local.decl_file);
75 }
76 locals.clear();
77 }
78
79 Symbolizer *Symbolizer::symbolizer_;
80 StaticSpinMutex Symbolizer::init_mu_;
81 LowLevelAllocator Symbolizer::symbolizer_allocator_;
82
InvalidateModuleList()83 void Symbolizer::InvalidateModuleList() {
84 modules_fresh_ = false;
85 }
86
AddHooks(Symbolizer::StartSymbolizationHook start_hook,Symbolizer::EndSymbolizationHook end_hook)87 void Symbolizer::AddHooks(Symbolizer::StartSymbolizationHook start_hook,
88 Symbolizer::EndSymbolizationHook end_hook) {
89 CHECK(start_hook_ == 0 && end_hook_ == 0);
90 start_hook_ = start_hook;
91 end_hook_ = end_hook;
92 }
93
GetOwnedCopy(const char * str)94 const char *Symbolizer::ModuleNameOwner::GetOwnedCopy(const char *str) {
95 mu_->CheckLocked();
96
97 // 'str' will be the same string multiple times in a row, optimize this case.
98 if (last_match_ && !internal_strcmp(last_match_, str))
99 return last_match_;
100
101 // FIXME: this is linear search.
102 // We should optimize this further if this turns out to be a bottleneck later.
103 for (uptr i = 0; i < storage_.size(); ++i) {
104 if (!internal_strcmp(storage_[i], str)) {
105 last_match_ = storage_[i];
106 return last_match_;
107 }
108 }
109 last_match_ = internal_strdup(str);
110 storage_.push_back(last_match_);
111 return last_match_;
112 }
113
Symbolizer(IntrusiveList<SymbolizerTool> tools)114 Symbolizer::Symbolizer(IntrusiveList<SymbolizerTool> tools)
115 : module_names_(&mu_), modules_(), modules_fresh_(false), tools_(tools),
116 start_hook_(0), end_hook_(0) {}
117
SymbolizerScope(const Symbolizer * sym)118 Symbolizer::SymbolizerScope::SymbolizerScope(const Symbolizer *sym)
119 : sym_(sym) {
120 if (sym_->start_hook_)
121 sym_->start_hook_();
122 }
123
~SymbolizerScope()124 Symbolizer::SymbolizerScope::~SymbolizerScope() {
125 if (sym_->end_hook_)
126 sym_->end_hook_();
127 }
128
LateInitializeTools()129 void Symbolizer::LateInitializeTools() {
130 for (auto &tool : tools_) {
131 tool.LateInitialize();
132 }
133 }
134
135 } // namespace __sanitizer
136