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