1 //===-- SymbolFileSymtab.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 #include "SymbolFileSymtab.h"
10
11 #include "lldb/Core/Module.h"
12 #include "lldb/Core/PluginManager.h"
13 #include "lldb/Symbol/CompileUnit.h"
14 #include "lldb/Symbol/Function.h"
15 #include "lldb/Symbol/ObjectFile.h"
16 #include "lldb/Symbol/Symbol.h"
17 #include "lldb/Symbol/SymbolContext.h"
18 #include "lldb/Symbol/Symtab.h"
19 #include "lldb/Symbol/TypeList.h"
20 #include "lldb/Utility/RegularExpression.h"
21 #include "lldb/Utility/Timer.h"
22
23 #include <memory>
24
25 using namespace lldb;
26 using namespace lldb_private;
27
28 LLDB_PLUGIN_DEFINE(SymbolFileSymtab)
29
30 char SymbolFileSymtab::ID;
31
Initialize()32 void SymbolFileSymtab::Initialize() {
33 PluginManager::RegisterPlugin(GetPluginNameStatic(),
34 GetPluginDescriptionStatic(), CreateInstance);
35 }
36
Terminate()37 void SymbolFileSymtab::Terminate() {
38 PluginManager::UnregisterPlugin(CreateInstance);
39 }
40
GetPluginNameStatic()41 lldb_private::ConstString SymbolFileSymtab::GetPluginNameStatic() {
42 static ConstString g_name("symtab");
43 return g_name;
44 }
45
GetPluginDescriptionStatic()46 const char *SymbolFileSymtab::GetPluginDescriptionStatic() {
47 return "Reads debug symbols from an object file's symbol table.";
48 }
49
CreateInstance(ObjectFileSP objfile_sp)50 SymbolFile *SymbolFileSymtab::CreateInstance(ObjectFileSP objfile_sp) {
51 return new SymbolFileSymtab(std::move(objfile_sp));
52 }
53
GetTypes(SymbolContextScope * sc_scope,TypeClass type_mask,lldb_private::TypeList & type_list)54 void SymbolFileSymtab::GetTypes(SymbolContextScope *sc_scope,
55 TypeClass type_mask,
56 lldb_private::TypeList &type_list) {}
57
SymbolFileSymtab(ObjectFileSP objfile_sp)58 SymbolFileSymtab::SymbolFileSymtab(ObjectFileSP objfile_sp)
59 : SymbolFile(std::move(objfile_sp)), m_source_indexes(), m_func_indexes(),
60 m_code_indexes(), m_objc_class_name_to_index() {}
61
CalculateAbilities()62 uint32_t SymbolFileSymtab::CalculateAbilities() {
63 uint32_t abilities = 0;
64 if (m_objfile_sp) {
65 const Symtab *symtab = m_objfile_sp->GetSymtab();
66 if (symtab) {
67 // The snippet of code below will get the indexes the module symbol table
68 // entries that are code, data, or function related (debug info), sort
69 // them by value (address) and dump the sorted symbols.
70 if (symtab->AppendSymbolIndexesWithType(eSymbolTypeSourceFile,
71 m_source_indexes)) {
72 abilities |= CompileUnits;
73 }
74
75 if (symtab->AppendSymbolIndexesWithType(
76 eSymbolTypeCode, Symtab::eDebugYes, Symtab::eVisibilityAny,
77 m_func_indexes)) {
78 symtab->SortSymbolIndexesByValue(m_func_indexes, true);
79 abilities |= Functions;
80 }
81
82 if (symtab->AppendSymbolIndexesWithType(eSymbolTypeCode, Symtab::eDebugNo,
83 Symtab::eVisibilityAny,
84 m_code_indexes)) {
85 symtab->SortSymbolIndexesByValue(m_code_indexes, true);
86 abilities |= Functions;
87 }
88
89 if (symtab->AppendSymbolIndexesWithType(eSymbolTypeData,
90 m_data_indexes)) {
91 symtab->SortSymbolIndexesByValue(m_data_indexes, true);
92 abilities |= GlobalVariables;
93 }
94
95 lldb_private::Symtab::IndexCollection objc_class_indexes;
96 if (symtab->AppendSymbolIndexesWithType(eSymbolTypeObjCClass,
97 objc_class_indexes)) {
98 symtab->AppendSymbolNamesToMap(objc_class_indexes, true, true,
99 m_objc_class_name_to_index);
100 m_objc_class_name_to_index.Sort();
101 }
102 }
103 }
104 return abilities;
105 }
106
CalculateNumCompileUnits()107 uint32_t SymbolFileSymtab::CalculateNumCompileUnits() {
108 // If we don't have any source file symbols we will just have one compile
109 // unit for the entire object file
110 if (m_source_indexes.empty())
111 return 0;
112
113 // If we have any source file symbols we will logically organize the object
114 // symbols using these.
115 return m_source_indexes.size();
116 }
117
ParseCompileUnitAtIndex(uint32_t idx)118 CompUnitSP SymbolFileSymtab::ParseCompileUnitAtIndex(uint32_t idx) {
119 CompUnitSP cu_sp;
120
121 // If we don't have any source file symbols we will just have one compile
122 // unit for the entire object file
123 if (idx < m_source_indexes.size()) {
124 const Symbol *cu_symbol =
125 m_objfile_sp->GetSymtab()->SymbolAtIndex(m_source_indexes[idx]);
126 if (cu_symbol)
127 cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr,
128 cu_symbol->GetName().AsCString(), 0,
129 eLanguageTypeUnknown, eLazyBoolNo);
130 }
131 return cu_sp;
132 }
133
ParseLanguage(CompileUnit & comp_unit)134 lldb::LanguageType SymbolFileSymtab::ParseLanguage(CompileUnit &comp_unit) {
135 return eLanguageTypeUnknown;
136 }
137
ParseFunctions(CompileUnit & comp_unit)138 size_t SymbolFileSymtab::ParseFunctions(CompileUnit &comp_unit) {
139 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
140 size_t num_added = 0;
141 // We must at least have a valid compile unit
142 const Symtab *symtab = m_objfile_sp->GetSymtab();
143 const Symbol *curr_symbol = nullptr;
144 const Symbol *next_symbol = nullptr;
145 // const char *prefix = m_objfile_sp->SymbolPrefix();
146 // if (prefix == NULL)
147 // prefix == "";
148 //
149 // const uint32_t prefix_len = strlen(prefix);
150
151 // If we don't have any source file symbols we will just have one compile
152 // unit for the entire object file
153 if (m_source_indexes.empty()) {
154 // The only time we will have a user ID of zero is when we don't have and
155 // source file symbols and we declare one compile unit for the entire
156 // object file
157 if (!m_func_indexes.empty()) {
158 }
159
160 if (!m_code_indexes.empty()) {
161 // StreamFile s(stdout);
162 // symtab->Dump(&s, m_code_indexes);
163
164 uint32_t idx = 0; // Index into the indexes
165 const uint32_t num_indexes = m_code_indexes.size();
166 for (idx = 0; idx < num_indexes; ++idx) {
167 uint32_t symbol_idx = m_code_indexes[idx];
168 curr_symbol = symtab->SymbolAtIndex(symbol_idx);
169 if (curr_symbol) {
170 // Union of all ranges in the function DIE (if the function is
171 // discontiguous)
172 AddressRange func_range(curr_symbol->GetAddress(), 0);
173 if (func_range.GetBaseAddress().IsSectionOffset()) {
174 uint32_t symbol_size = curr_symbol->GetByteSize();
175 if (symbol_size != 0 && !curr_symbol->GetSizeIsSibling())
176 func_range.SetByteSize(symbol_size);
177 else if (idx + 1 < num_indexes) {
178 next_symbol = symtab->SymbolAtIndex(m_code_indexes[idx + 1]);
179 if (next_symbol) {
180 func_range.SetByteSize(
181 next_symbol->GetAddressRef().GetOffset() -
182 curr_symbol->GetAddressRef().GetOffset());
183 }
184 }
185
186 FunctionSP func_sp(
187 new Function(&comp_unit,
188 symbol_idx, // UserID is the DIE offset
189 LLDB_INVALID_UID, // We don't have any type info
190 // for this function
191 curr_symbol->GetMangled(), // Linker/mangled name
192 nullptr, // no return type for a code symbol...
193 func_range)); // first address range
194
195 if (func_sp.get() != nullptr) {
196 comp_unit.AddFunction(func_sp);
197 ++num_added;
198 }
199 }
200 }
201 }
202 }
203 } else {
204 // We assume we
205 }
206 return num_added;
207 }
208
ParseTypes(CompileUnit & comp_unit)209 size_t SymbolFileSymtab::ParseTypes(CompileUnit &comp_unit) { return 0; }
210
ParseLineTable(CompileUnit & comp_unit)211 bool SymbolFileSymtab::ParseLineTable(CompileUnit &comp_unit) { return false; }
212
ParseDebugMacros(CompileUnit & comp_unit)213 bool SymbolFileSymtab::ParseDebugMacros(CompileUnit &comp_unit) {
214 return false;
215 }
216
ParseSupportFiles(CompileUnit & comp_unit,FileSpecList & support_files)217 bool SymbolFileSymtab::ParseSupportFiles(CompileUnit &comp_unit,
218 FileSpecList &support_files) {
219 return false;
220 }
221
ParseImportedModules(const SymbolContext & sc,std::vector<SourceModule> & imported_modules)222 bool SymbolFileSymtab::ParseImportedModules(
223 const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
224 return false;
225 }
226
ParseBlocksRecursive(Function & func)227 size_t SymbolFileSymtab::ParseBlocksRecursive(Function &func) { return 0; }
228
ParseVariablesForContext(const SymbolContext & sc)229 size_t SymbolFileSymtab::ParseVariablesForContext(const SymbolContext &sc) {
230 return 0;
231 }
232
ResolveTypeUID(lldb::user_id_t type_uid)233 Type *SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid) {
234 return nullptr;
235 }
236
237 llvm::Optional<SymbolFile::ArrayInfo>
GetDynamicArrayInfoForUID(lldb::user_id_t type_uid,const lldb_private::ExecutionContext * exe_ctx)238 SymbolFileSymtab::GetDynamicArrayInfoForUID(
239 lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
240 return llvm::None;
241 }
242
CompleteType(lldb_private::CompilerType & compiler_type)243 bool SymbolFileSymtab::CompleteType(lldb_private::CompilerType &compiler_type) {
244 return false;
245 }
246
ResolveSymbolContext(const Address & so_addr,SymbolContextItem resolve_scope,SymbolContext & sc)247 uint32_t SymbolFileSymtab::ResolveSymbolContext(const Address &so_addr,
248 SymbolContextItem resolve_scope,
249 SymbolContext &sc) {
250 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
251 if (m_objfile_sp->GetSymtab() == nullptr)
252 return 0;
253
254 uint32_t resolved_flags = 0;
255 if (resolve_scope & eSymbolContextSymbol) {
256 sc.symbol = m_objfile_sp->GetSymtab()->FindSymbolContainingFileAddress(
257 so_addr.GetFileAddress());
258 if (sc.symbol)
259 resolved_flags |= eSymbolContextSymbol;
260 }
261 return resolved_flags;
262 }
263
264 // PluginInterface protocol
GetPluginName()265 lldb_private::ConstString SymbolFileSymtab::GetPluginName() {
266 return GetPluginNameStatic();
267 }
268
GetPluginVersion()269 uint32_t SymbolFileSymtab::GetPluginVersion() { return 1; }
270