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
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
| //===-- SymbolFile.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_SymbolFile_h_
#define liblldb_SymbolFile_h_
#include "lldb/Core/PluginInterface.h"
#include "lldb/Symbol/CompilerDecl.h"
#include "lldb/Symbol/CompilerDeclContext.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/SourceModule.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/lldb-private.h"
#include "llvm/ADT/DenseSet.h"
#include "llvm/Support/Errc.h"
#include <mutex>
#if defined(LLDB_CONFIGURATION_DEBUG)
#define ASSERT_MODULE_LOCK(expr) (expr->AssertModuleLock())
#else
#define ASSERT_MODULE_LOCK(expr) ((void)0)
#endif
namespace lldb_private {
class SymbolFile : public PluginInterface {
public:
// Symbol file ability bits.
//
// Each symbol file can claim to support one or more symbol file abilities.
// These get returned from SymbolFile::GetAbilities(). These help us to
// determine which plug-in will be best to load the debug information found
// in files.
enum Abilities {
CompileUnits = (1u << 0),
LineTables = (1u << 1),
Functions = (1u << 2),
Blocks = (1u << 3),
GlobalVariables = (1u << 4),
LocalVariables = (1u << 5),
VariableTypes = (1u << 6),
kAllAbilities = ((1u << 7) - 1u)
};
static SymbolFile *FindPlugin(lldb::ObjectFileSP objfile_sp);
// Constructors and Destructors
SymbolFile(lldb::ObjectFileSP objfile_sp)
: m_objfile_sp(std::move(objfile_sp)), m_abilities(0),
m_calculated_abilities(false) {}
~SymbolFile() override {}
/// Get a mask of what this symbol file supports for the object file
/// that it was constructed with.
///
/// Each symbol file gets to respond with a mask of abilities that
/// it supports for each object file. This happens when we are
/// trying to figure out which symbol file plug-in will get used
/// for a given object file. The plug-in that responds with the
/// best mix of "SymbolFile::Abilities" bits set, will get chosen to
/// be the symbol file parser. This allows each plug-in to check for
/// sections that contain data a symbol file plug-in would need. For
/// example the DWARF plug-in requires DWARF sections in a file that
/// contain debug information. If the DWARF plug-in doesn't find
/// these sections, it won't respond with many ability bits set, and
/// we will probably fall back to the symbol table SymbolFile plug-in
/// which uses any information in the symbol table. Also, plug-ins
/// might check for some specific symbols in a symbol table in the
/// case where the symbol table contains debug information (STABS
/// and COFF). Not a lot of work should happen in these functions
/// as the plug-in might not get selected due to another plug-in
/// having more abilities. Any initialization work should be saved
/// for "void SymbolFile::InitializeObject()" which will get called
/// on the SymbolFile object with the best set of abilities.
///
/// \return
/// A uint32_t mask containing bits from the SymbolFile::Abilities
/// enumeration. Any bits that are set represent an ability that
/// this symbol plug-in can parse from the object file.
uint32_t GetAbilities() {
if (!m_calculated_abilities) {
m_abilities = CalculateAbilities();
m_calculated_abilities = true;
}
return m_abilities;
}
virtual uint32_t CalculateAbilities() = 0;
/// Symbols file subclasses should override this to return the Module that
/// owns the TypeSystem that this symbol file modifies type information in.
virtual std::recursive_mutex &GetModuleMutex() const;
/// Initialize the SymbolFile object.
///
/// The SymbolFile object with the best set of abilities (detected
/// in "uint32_t SymbolFile::GetAbilities()) will have this function
/// called if it is chosen to parse an object file. More complete
/// initialization can happen in this function which will get called
/// prior to any other functions in the SymbolFile protocol.
virtual void InitializeObject() {}
// Compile Unit function calls
// Approach 1 - iterator
uint32_t GetNumCompileUnits();
lldb::CompUnitSP GetCompileUnitAtIndex(uint32_t idx);
Symtab *GetSymtab();
virtual lldb::LanguageType ParseLanguage(CompileUnit &comp_unit) = 0;
virtual size_t ParseFunctions(CompileUnit &comp_unit) = 0;
virtual bool ParseLineTable(CompileUnit &comp_unit) = 0;
virtual bool ParseDebugMacros(CompileUnit &comp_unit) = 0;
virtual void
ForEachExternalModule(CompileUnit &comp_unit,
llvm::function_ref<void(lldb::ModuleSP)> f) {}
virtual bool ParseSupportFiles(CompileUnit &comp_unit,
FileSpecList &support_files) = 0;
virtual size_t ParseTypes(CompileUnit &comp_unit) = 0;
virtual bool ParseIsOptimized(CompileUnit &comp_unit) { return false; }
virtual bool
ParseImportedModules(const SymbolContext &sc,
std::vector<SourceModule> &imported_modules) = 0;
virtual size_t ParseBlocksRecursive(Function &func) = 0;
virtual size_t ParseVariablesForContext(const SymbolContext &sc) = 0;
virtual Type *ResolveTypeUID(lldb::user_id_t type_uid) = 0;
/// The characteristics of an array type.
struct ArrayInfo {
int64_t first_index = 0;
llvm::SmallVector<uint64_t, 1> element_orders;
uint32_t byte_stride = 0;
uint32_t bit_stride = 0;
};
/// If \c type_uid points to an array type, return its characteristics.
/// To support variable-length array types, this function takes an
/// optional \p ExtecutionContext. If \c exe_ctx is non-null, the
/// dynamic characteristics for that context are returned.
virtual llvm::Optional<ArrayInfo>
GetDynamicArrayInfoForUID(lldb::user_id_t type_uid,
const lldb_private::ExecutionContext *exe_ctx) = 0;
virtual bool CompleteType(CompilerType &compiler_type) = 0;
virtual void ParseDeclsForContext(CompilerDeclContext decl_ctx) {}
virtual CompilerDecl GetDeclForUID(lldb::user_id_t uid) {
return CompilerDecl();
}
virtual CompilerDeclContext GetDeclContextForUID(lldb::user_id_t uid) {
return CompilerDeclContext();
}
virtual CompilerDeclContext GetDeclContextContainingUID(lldb::user_id_t uid) {
return CompilerDeclContext();
}
virtual uint32_t ResolveSymbolContext(const Address &so_addr,
lldb::SymbolContextItem resolve_scope,
SymbolContext &sc) = 0;
virtual uint32_t ResolveSymbolContext(const FileSpec &file_spec,
uint32_t line, bool check_inlines,
lldb::SymbolContextItem resolve_scope,
SymbolContextList &sc_list);
virtual void DumpClangAST(Stream &s) {}
virtual void
FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables);
virtual void FindGlobalVariables(const RegularExpression ®ex,
uint32_t max_matches,
VariableList &variables);
virtual void FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask,
bool include_inlines, SymbolContextList &sc_list);
virtual void FindFunctions(const RegularExpression ®ex,
bool include_inlines, SymbolContextList &sc_list);
virtual void
FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types);
/// Find types specified by a CompilerContextPattern.
/// \param languages Only return results in these languages.
virtual void FindTypes(llvm::ArrayRef<CompilerContext> pattern,
LanguageSet languages, TypeMap &types);
virtual void
GetMangledNamesForFunction(const std::string &scope_qualified_name,
std::vector<ConstString> &mangled_names);
virtual void GetTypes(lldb_private::SymbolContextScope *sc_scope,
lldb::TypeClass type_mask,
lldb_private::TypeList &type_list) = 0;
virtual void PreloadSymbols();
virtual llvm::Expected<lldb_private::TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language);
virtual CompilerDeclContext
FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) {
return CompilerDeclContext();
}
ObjectFile *GetObjectFile() { return m_objfile_sp.get(); }
const ObjectFile *GetObjectFile() const { return m_objfile_sp.get(); }
ObjectFile *GetMainObjectFile();
virtual std::vector<CallEdge> ParseCallEdgesInFunction(UserID func_id) {
return {};
}
virtual void AddSymbols(Symtab &symtab) {}
/// Notify the SymbolFile that the file addresses in the Sections
/// for this module have been changed.
virtual void SectionFileAddressesChanged();
struct RegisterInfoResolver {
virtual ~RegisterInfoResolver(); // anchor
virtual const RegisterInfo *ResolveName(llvm::StringRef name) const = 0;
virtual const RegisterInfo *ResolveNumber(lldb::RegisterKind kind,
uint32_t number) const = 0;
};
virtual lldb::UnwindPlanSP
GetUnwindPlan(const Address &address, const RegisterInfoResolver &resolver) {
return nullptr;
}
/// Return the number of stack bytes taken up by the parameters to this
/// function.
virtual llvm::Expected<lldb::addr_t> GetParameterStackSize(Symbol &symbol) {
return llvm::createStringError(make_error_code(llvm::errc::not_supported),
"Operation not supported.");
}
virtual void Dump(Stream &s);
protected:
void AssertModuleLock();
virtual uint32_t CalculateNumCompileUnits() = 0;
virtual lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t idx) = 0;
virtual TypeList &GetTypeList() { return m_type_list; }
void SetCompileUnitAtIndex(uint32_t idx, const lldb::CompUnitSP &cu_sp);
lldb::ObjectFileSP m_objfile_sp; // Keep a reference to the object file in
// case it isn't the same as the module
// object file (debug symbols in a separate
// file)
llvm::Optional<std::vector<lldb::CompUnitSP>> m_compile_units;
TypeList m_type_list;
Symtab *m_symtab = nullptr;
uint32_t m_abilities;
bool m_calculated_abilities;
private:
DISALLOW_COPY_AND_ASSIGN(SymbolFile);
};
} // namespace lldb_private
#endif // liblldb_SymbolFile_h_
|