1 //===-- SymbolFileSymtab.cpp ------------------------------------*- C++ -*-===//
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 char SymbolFileSymtab::ID;
29 
30 void SymbolFileSymtab::Initialize() {
31   PluginManager::RegisterPlugin(GetPluginNameStatic(),
32                                 GetPluginDescriptionStatic(), CreateInstance);
33 }
34 
35 void SymbolFileSymtab::Terminate() {
36   PluginManager::UnregisterPlugin(CreateInstance);
37 }
38 
39 lldb_private::ConstString SymbolFileSymtab::GetPluginNameStatic() {
40   static ConstString g_name("symtab");
41   return g_name;
42 }
43 
44 const char *SymbolFileSymtab::GetPluginDescriptionStatic() {
45   return "Reads debug symbols from an object file's symbol table.";
46 }
47 
48 SymbolFile *SymbolFileSymtab::CreateInstance(ObjectFileSP objfile_sp) {
49   return new SymbolFileSymtab(std::move(objfile_sp));
50 }
51 
52 void SymbolFileSymtab::GetTypes(SymbolContextScope *sc_scope,
53                                 TypeClass type_mask,
54                                 lldb_private::TypeList &type_list) {}
55 
56 SymbolFileSymtab::SymbolFileSymtab(ObjectFileSP objfile_sp)
57     : SymbolFile(std::move(objfile_sp)), m_source_indexes(), m_func_indexes(),
58       m_code_indexes(), m_objc_class_name_to_index() {}
59 
60 SymbolFileSymtab::~SymbolFileSymtab() {}
61 
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 
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 
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 
134 lldb::LanguageType SymbolFileSymtab::ParseLanguage(CompileUnit &comp_unit) {
135   return eLanguageTypeUnknown;
136 }
137 
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 
209 size_t SymbolFileSymtab::ParseTypes(CompileUnit &comp_unit) { return 0; }
210 
211 bool SymbolFileSymtab::ParseLineTable(CompileUnit &comp_unit) { return false; }
212 
213 bool SymbolFileSymtab::ParseDebugMacros(CompileUnit &comp_unit) {
214   return false;
215 }
216 
217 bool SymbolFileSymtab::ParseSupportFiles(CompileUnit &comp_unit,
218                                          FileSpecList &support_files) {
219   return false;
220 }
221 
222 bool SymbolFileSymtab::ParseImportedModules(
223     const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
224   return false;
225 }
226 
227 size_t SymbolFileSymtab::ParseBlocksRecursive(Function &func) { return 0; }
228 
229 size_t SymbolFileSymtab::ParseVariablesForContext(const SymbolContext &sc) {
230   return 0;
231 }
232 
233 Type *SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid) {
234   return nullptr;
235 }
236 
237 llvm::Optional<SymbolFile::ArrayInfo>
238 SymbolFileSymtab::GetDynamicArrayInfoForUID(
239     lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
240   return llvm::None;
241 }
242 
243 bool SymbolFileSymtab::CompleteType(lldb_private::CompilerType &compiler_type) {
244   return false;
245 }
246 
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
265 lldb_private::ConstString SymbolFileSymtab::GetPluginName() {
266   return GetPluginNameStatic();
267 }
268 
269 uint32_t SymbolFileSymtab::GetPluginVersion() { return 1; }
270