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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
|
//===-- Symtab.h ------------------------------------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Symtab_h_
#define liblldb_Symtab_h_
#include "lldb/Core/UniqueCStringMap.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Utility/RangeMap.h"
#include "lldb/lldb-private.h"
#include <mutex>
#include <vector>
namespace lldb_private {
class Symtab {
public:
typedef std::vector<uint32_t> IndexCollection;
typedef UniqueCStringMap<uint32_t> NameToIndexMap;
enum Debug {
eDebugNo, // Not a debug symbol
eDebugYes, // A debug symbol
eDebugAny
};
enum Visibility { eVisibilityAny, eVisibilityExtern, eVisibilityPrivate };
Symtab(ObjectFile *objfile);
~Symtab();
void PreloadSymbols();
void Reserve(size_t count);
Symbol *Resize(size_t count);
uint32_t AddSymbol(const Symbol &symbol);
size_t GetNumSymbols() const;
void SectionFileAddressesChanged();
void
Dump(Stream *s, Target *target, SortOrder sort_type,
Mangled::NamePreference name_preference = Mangled::ePreferDemangled);
void Dump(Stream *s, Target *target, std::vector<uint32_t> &indexes,
Mangled::NamePreference name_preference =
Mangled::ePreferDemangled) const;
uint32_t GetIndexForSymbol(const Symbol *symbol) const;
std::recursive_mutex &GetMutex() { return m_mutex; }
Symbol *FindSymbolByID(lldb::user_id_t uid) const;
Symbol *SymbolAtIndex(size_t idx);
const Symbol *SymbolAtIndex(size_t idx) const;
Symbol *FindSymbolWithType(lldb::SymbolType symbol_type,
Debug symbol_debug_type,
Visibility symbol_visibility, uint32_t &start_idx);
/// Get the parent symbol for the given symbol.
///
/// Many symbols in symbol tables are scoped by other symbols that
/// contain one or more symbol. This function will look for such a
/// containing symbol and return it if there is one.
const Symbol *GetParent(Symbol *symbol) const;
uint32_t AppendSymbolIndexesWithType(lldb::SymbolType symbol_type,
std::vector<uint32_t> &indexes,
uint32_t start_idx = 0,
uint32_t end_index = UINT32_MAX) const;
uint32_t AppendSymbolIndexesWithTypeAndFlagsValue(
lldb::SymbolType symbol_type, uint32_t flags_value,
std::vector<uint32_t> &indexes, uint32_t start_idx = 0,
uint32_t end_index = UINT32_MAX) const;
uint32_t AppendSymbolIndexesWithType(lldb::SymbolType symbol_type,
Debug symbol_debug_type,
Visibility symbol_visibility,
std::vector<uint32_t> &matches,
uint32_t start_idx = 0,
uint32_t end_index = UINT32_MAX) const;
uint32_t AppendSymbolIndexesWithName(ConstString symbol_name,
std::vector<uint32_t> &matches);
uint32_t AppendSymbolIndexesWithName(ConstString symbol_name,
Debug symbol_debug_type,
Visibility symbol_visibility,
std::vector<uint32_t> &matches);
uint32_t AppendSymbolIndexesWithNameAndType(ConstString symbol_name,
lldb::SymbolType symbol_type,
std::vector<uint32_t> &matches);
uint32_t AppendSymbolIndexesWithNameAndType(ConstString symbol_name,
lldb::SymbolType symbol_type,
Debug symbol_debug_type,
Visibility symbol_visibility,
std::vector<uint32_t> &matches);
uint32_t
AppendSymbolIndexesMatchingRegExAndType(const RegularExpression ®ex,
lldb::SymbolType symbol_type,
std::vector<uint32_t> &indexes);
uint32_t AppendSymbolIndexesMatchingRegExAndType(
const RegularExpression ®ex, lldb::SymbolType symbol_type,
Debug symbol_debug_type, Visibility symbol_visibility,
std::vector<uint32_t> &indexes);
void FindAllSymbolsWithNameAndType(ConstString name,
lldb::SymbolType symbol_type,
std::vector<uint32_t> &symbol_indexes);
void FindAllSymbolsWithNameAndType(ConstString name,
lldb::SymbolType symbol_type,
Debug symbol_debug_type,
Visibility symbol_visibility,
std::vector<uint32_t> &symbol_indexes);
void FindAllSymbolsMatchingRexExAndType(
const RegularExpression ®ex, lldb::SymbolType symbol_type,
Debug symbol_debug_type, Visibility symbol_visibility,
std::vector<uint32_t> &symbol_indexes);
Symbol *FindFirstSymbolWithNameAndType(ConstString name,
lldb::SymbolType symbol_type,
Debug symbol_debug_type,
Visibility symbol_visibility);
Symbol *FindSymbolAtFileAddress(lldb::addr_t file_addr);
Symbol *FindSymbolContainingFileAddress(lldb::addr_t file_addr);
void ForEachSymbolContainingFileAddress(
lldb::addr_t file_addr, std::function<bool(Symbol *)> const &callback);
void FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
SymbolContextList &sc_list);
void CalculateSymbolSizes();
void SortSymbolIndexesByValue(std::vector<uint32_t> &indexes,
bool remove_duplicates) const;
static void DumpSymbolHeader(Stream *s);
void Finalize() {
// Shrink to fit the symbols so we don't waste memory
if (m_symbols.capacity() > m_symbols.size()) {
collection new_symbols(m_symbols.begin(), m_symbols.end());
m_symbols.swap(new_symbols);
}
}
void AppendSymbolNamesToMap(const IndexCollection &indexes,
bool add_demangled, bool add_mangled,
NameToIndexMap &name_to_index_map) const;
ObjectFile *GetObjectFile() { return m_objfile; }
protected:
typedef std::vector<Symbol> collection;
typedef collection::iterator iterator;
typedef collection::const_iterator const_iterator;
class FileRangeToIndexMapCompare {
public:
FileRangeToIndexMapCompare(const Symtab &symtab) : m_symtab(symtab) {}
bool operator()(const uint32_t a_data, const uint32_t b_data) const {
return rank(a_data) > rank(b_data);
}
private:
// How much preferred is this symbol?
int rank(const uint32_t data) const {
const Symbol &symbol = *m_symtab.SymbolAtIndex(data);
if (symbol.IsExternal())
return 3;
if (symbol.IsWeak())
return 2;
if (symbol.IsDebug())
return 0;
return 1;
}
const Symtab &m_symtab;
};
typedef RangeDataVector<lldb::addr_t, lldb::addr_t, uint32_t, 0,
FileRangeToIndexMapCompare>
FileRangeToIndexMap;
void InitNameIndexes();
void InitAddressIndexes();
ObjectFile *m_objfile;
collection m_symbols;
FileRangeToIndexMap m_file_addr_to_index;
UniqueCStringMap<uint32_t> m_name_to_index;
UniqueCStringMap<uint32_t> m_basename_to_index;
UniqueCStringMap<uint32_t> m_method_to_index;
UniqueCStringMap<uint32_t> m_selector_to_index;
mutable std::recursive_mutex
m_mutex; // Provide thread safety for this symbol table
bool m_file_addr_to_index_computed : 1, m_name_indexes_computed : 1;
private:
bool CheckSymbolAtIndex(size_t idx, Debug symbol_debug_type,
Visibility symbol_visibility) const {
switch (symbol_debug_type) {
case eDebugNo:
if (m_symbols[idx].IsDebug())
return false;
break;
case eDebugYes:
if (!m_symbols[idx].IsDebug())
return false;
break;
case eDebugAny:
break;
}
switch (symbol_visibility) {
case eVisibilityAny:
return true;
case eVisibilityExtern:
return m_symbols[idx].IsExternal();
case eVisibilityPrivate:
return !m_symbols[idx].IsExternal();
}
return false;
}
void SymbolIndicesToSymbolContextList(std::vector<uint32_t> &symbol_indexes,
SymbolContextList &sc_list);
void RegisterMangledNameEntry(
uint32_t value, std::set<const char *> &class_contexts,
std::vector<std::pair<NameToIndexMap::Entry, const char *>> &backlog,
RichManglingContext &rmc);
void RegisterBacklogEntry(const NameToIndexMap::Entry &entry,
const char *decl_context,
const std::set<const char *> &class_contexts);
DISALLOW_COPY_AND_ASSIGN(Symtab);
};
} // namespace lldb_private
#endif // liblldb_Symtab_h_
|
