LLDB  mainline
SymbolFileSymtab.cpp
Go to the documentation of this file.
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"
14 #include "lldb/Symbol/Function.h"
15 #include "lldb/Symbol/ObjectFile.h"
16 #include "lldb/Symbol/Symbol.h"
18 #include "lldb/Symbol/Symtab.h"
19 #include "lldb/Symbol/TypeList.h"
21 #include "lldb/Utility/Timer.h"
22 
23 #include <memory>
24 
25 using namespace lldb;
26 using namespace lldb_private;
27 
29 
31 
33  PluginManager::RegisterPlugin(GetPluginNameStatic(),
34  GetPluginDescriptionStatic(), CreateInstance);
35 }
36 
38  PluginManager::UnregisterPlugin(CreateInstance);
39 }
40 
42  return "Reads debug symbols from an object file's symbol table.";
43 }
44 
45 SymbolFile *SymbolFileSymtab::CreateInstance(ObjectFileSP objfile_sp) {
46  return new SymbolFileSymtab(std::move(objfile_sp));
47 }
48 
50  TypeClass type_mask,
51  lldb_private::TypeList &type_list) {}
52 
53 SymbolFileSymtab::SymbolFileSymtab(ObjectFileSP objfile_sp)
54  : SymbolFileCommon(std::move(objfile_sp)), m_source_indexes(),
55  m_func_indexes(), m_code_indexes(), m_objc_class_name_to_index() {}
56 
58  uint32_t abilities = 0;
59  if (m_objfile_sp) {
60  const Symtab *symtab = m_objfile_sp->GetSymtab();
61  if (symtab) {
62  // The snippet of code below will get the indexes the module symbol table
63  // entries that are code, data, or function related (debug info), sort
64  // them by value (address) and dump the sorted symbols.
67  abilities |= CompileUnits;
68  }
69 
70  if (symtab->AppendSymbolIndexesWithType(
71  eSymbolTypeCode, Symtab::eDebugYes, Symtab::eVisibilityAny,
72  m_func_indexes)) {
74  abilities |= Functions;
75  }
76 
77  if (symtab->AppendSymbolIndexesWithType(eSymbolTypeCode, Symtab::eDebugNo,
78  Symtab::eVisibilityAny,
79  m_code_indexes)) {
81  abilities |= Functions;
82  }
83 
85  m_data_indexes)) {
87  abilities |= GlobalVariables;
88  }
89 
90  lldb_private::Symtab::IndexCollection objc_class_indexes;
92  objc_class_indexes)) {
93  symtab->AppendSymbolNamesToMap(objc_class_indexes, true, true,
96  }
97  }
98  }
99  return abilities;
100 }
101 
103  // If we don't have any source file symbols we will just have one compile
104  // unit for the entire object file
105  if (m_source_indexes.empty())
106  return 0;
107 
108  // If we have any source file symbols we will logically organize the object
109  // symbols using these.
110  return m_source_indexes.size();
111 }
112 
114  CompUnitSP cu_sp;
115 
116  // If we don't have any source file symbols we will just have one compile
117  // unit for the entire object file
118  if (idx < m_source_indexes.size()) {
119  const Symbol *cu_symbol =
120  m_objfile_sp->GetSymtab()->SymbolAtIndex(m_source_indexes[idx]);
121  if (cu_symbol)
122  cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr,
123  cu_symbol->GetName().AsCString(), 0,
125  }
126  return cu_sp;
127 }
128 
130  return eLanguageTypeUnknown;
131 }
132 
134  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
135  size_t num_added = 0;
136  // We must at least have a valid compile unit
137  const Symtab *symtab = m_objfile_sp->GetSymtab();
138  const Symbol *curr_symbol = nullptr;
139  const Symbol *next_symbol = nullptr;
140  // const char *prefix = m_objfile_sp->SymbolPrefix();
141  // if (prefix == NULL)
142  // prefix == "";
143  //
144  // const uint32_t prefix_len = strlen(prefix);
145 
146  // If we don't have any source file symbols we will just have one compile
147  // unit for the entire object file
148  if (m_source_indexes.empty()) {
149  // The only time we will have a user ID of zero is when we don't have and
150  // source file symbols and we declare one compile unit for the entire
151  // object file
152  if (!m_func_indexes.empty()) {
153  }
154 
155  if (!m_code_indexes.empty()) {
156  // StreamFile s(stdout);
157  // symtab->Dump(&s, m_code_indexes);
158 
159  uint32_t idx = 0; // Index into the indexes
160  const uint32_t num_indexes = m_code_indexes.size();
161  for (idx = 0; idx < num_indexes; ++idx) {
162  uint32_t symbol_idx = m_code_indexes[idx];
163  curr_symbol = symtab->SymbolAtIndex(symbol_idx);
164  if (curr_symbol) {
165  // Union of all ranges in the function DIE (if the function is
166  // discontiguous)
167  AddressRange func_range(curr_symbol->GetAddress(), 0);
168  if (func_range.GetBaseAddress().IsSectionOffset()) {
169  uint32_t symbol_size = curr_symbol->GetByteSize();
170  if (symbol_size != 0 && !curr_symbol->GetSizeIsSibling())
171  func_range.SetByteSize(symbol_size);
172  else if (idx + 1 < num_indexes) {
173  next_symbol = symtab->SymbolAtIndex(m_code_indexes[idx + 1]);
174  if (next_symbol) {
175  func_range.SetByteSize(
176  next_symbol->GetAddressRef().GetOffset() -
177  curr_symbol->GetAddressRef().GetOffset());
178  }
179  }
180 
181  FunctionSP func_sp(
182  new Function(&comp_unit,
183  symbol_idx, // UserID is the DIE offset
184  LLDB_INVALID_UID, // We don't have any type info
185  // for this function
186  curr_symbol->GetMangled(), // Linker/mangled name
187  nullptr, // no return type for a code symbol...
188  func_range)); // first address range
189 
190  if (func_sp.get() != nullptr) {
191  comp_unit.AddFunction(func_sp);
192  ++num_added;
193  }
194  }
195  }
196  }
197  }
198  } else {
199  // We assume we
200  }
201  return num_added;
202 }
203 
204 size_t SymbolFileSymtab::ParseTypes(CompileUnit &comp_unit) { return 0; }
205 
206 bool SymbolFileSymtab::ParseLineTable(CompileUnit &comp_unit) { return false; }
207 
209  return false;
210 }
211 
213  FileSpecList &support_files) {
214  return false;
215 }
216 
218  const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
219  return false;
220 }
221 
223 
225  return 0;
226 }
227 
229  return nullptr;
230 }
231 
232 llvm::Optional<SymbolFile::ArrayInfo>
234  lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
235  return llvm::None;
236 }
237 
239  return false;
240 }
241 
243  SymbolContextItem resolve_scope,
244  SymbolContext &sc) {
245  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
246  if (m_objfile_sp->GetSymtab() == nullptr)
247  return 0;
248 
249  uint32_t resolved_flags = 0;
250  if (resolve_scope & eSymbolContextSymbol) {
251  sc.symbol = m_objfile_sp->GetSymtab()->FindSymbolContainingFileAddress(
252  so_addr.GetFileAddress());
253  if (sc.symbol)
254  resolved_flags |= eSymbolContextSymbol;
255  }
256  return resolved_flags;
257 }
RegularExpression.h
lldb_private::AddressRange::GetBaseAddress
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
SymbolFileSymtab::ParseDebugMacros
bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override
Definition: SymbolFileSymtab.cpp:208
lldb_private::SymbolFile
Provides public interface for all SymbolFiles.
Definition: SymbolFile.h:45
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
SymbolFileSymtab::Terminate
static void Terminate()
Definition: SymbolFileSymtab.cpp:37
lldb_private::UniqueCStringMap::Sort
void Sort()
Definition: UniqueCStringMap.h:168
SymbolFileSymtab::ParseLineTable
bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override
Definition: SymbolFileSymtab.cpp:206
lldb::eSymbolTypeCode
@ eSymbolTypeCode
Definition: lldb-enumerations.h:624
lldb_private::Symtab::AppendSymbolNamesToMap
void AppendSymbolNamesToMap(const IndexCollection &indexes, bool add_demangled, bool add_mangled, NameToIndexMap &name_to_index_map) const
Definition: Symtab.cpp:459
CompileUnit.h
lldb_private::Symbol
Definition: Symbol.h:20
SymbolFileSymtab.h
SymbolFileSymtab::GetPluginDescriptionStatic
static llvm::StringRef GetPluginDescriptionStatic()
Definition: SymbolFileSymtab.cpp:41
LLDB_INVALID_UID
#define LLDB_INVALID_UID
Definition: lldb-defines.h:80
lldb_private::SymbolFile::GetModuleMutex
virtual std::recursive_mutex & GetModuleMutex() const
Symbols file subclasses should override this to return the Module that owns the TypeSystem that this ...
Definition: SymbolFile.cpp:35
SymbolFileSymtab::CompleteType
bool CompleteType(lldb_private::CompilerType &compiler_type) override
Definition: SymbolFileSymtab.cpp:238
Module.h
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb::eSymbolTypeData
@ eSymbolTypeData
Definition: lldb-enumerations.h:626
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
lldb_private::SymbolFile::CompileUnits
@ CompileUnits
Definition: SymbolFile.h:63
SymbolFileSymtab::GetTypes
void GetTypes(lldb_private::SymbolContextScope *sc_scope, lldb::TypeClass type_mask, lldb_private::TypeList &type_list) override
Definition: SymbolFileSymtab.cpp:49
lldb_private::Symtab::SymbolAtIndex
Symbol * SymbolAtIndex(size_t idx)
Definition: Symtab.cpp:217
SymbolFileSymtab::ResolveSymbolContext
uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr, lldb::SymbolContextItem resolve_scope, lldb_private::SymbolContext &sc) override
Definition: SymbolFileSymtab.cpp:242
SymbolFileSymtab::CalculateAbilities
uint32_t CalculateAbilities() override
Definition: SymbolFileSymtab.cpp:57
lldb_private::SymbolFileCommon
Containing protected virtual methods for child classes to override.
Definition: SymbolFile.h:374
SymbolFileSymtab::ParseLanguage
lldb::LanguageType ParseLanguage(lldb_private::CompileUnit &comp_unit) override
Definition: SymbolFileSymtab.cpp:129
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::SymbolFile::Functions
@ Functions
Definition: SymbolFile.h:65
SymbolFileSymtab::ParseFunctions
size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override
Definition: SymbolFileSymtab.cpp:133
SymbolFileSymtab::Initialize
static void Initialize()
Definition: SymbolFileSymtab.cpp:32
lldb_private::CompileUnit
Definition: CompileUnit.h:38
SymbolFileSymtab::ID
static char ID
LLVM RTTI support.
Definition: SymbolFileSymtab.h:20
lldb_private::SymbolContext::symbol
Symbol * symbol
The Symbol for a given query.
Definition: SymbolContext.h:323
SymbolFileSymtab::ResolveTypeUID
lldb_private::Type * ResolveTypeUID(lldb::user_id_t type_uid) override
Definition: SymbolFileSymtab.cpp:228
lldb_private::SymbolFileCommon::m_objfile_sp
lldb::ObjectFileSP m_objfile_sp
Definition: SymbolFile.h:444
lldb_private::Symbol::GetSizeIsSibling
bool GetSizeIsSibling() const
Definition: Symbol.h:191
lldb_private::Function
Definition: Function.h:409
SymbolFileSymtab::ParseBlocksRecursive
size_t ParseBlocksRecursive(lldb_private::Function &func) override
Definition: SymbolFileSymtab.cpp:222
SymbolFileSymtab::ParseCompileUnitAtIndex
lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override
Definition: SymbolFileSymtab.cpp:113
lldb::eSymbolTypeSourceFile
@ eSymbolTypeSourceFile
Definition: lldb-enumerations.h:630
SymbolFileSymtab::CreateInstance
static lldb_private::SymbolFile * CreateInstance(lldb::ObjectFileSP objfile_sp)
Definition: SymbolFileSymtab.cpp:45
SymbolFileSymtab::m_func_indexes
lldb_private::Symtab::IndexCollection m_func_indexes
Definition: SymbolFileSymtab.h:98
lldb_private::Address::GetFileAddress
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:291
lldb_private::Symbol::GetAddressRef
Address & GetAddressRef()
Definition: Symbol.h:57
lldb_private::CompileUnit::AddFunction
void AddFunction(lldb::FunctionSP &function_sp)
Add a function to this compile unit.
Definition: CompileUnit.cpp:139
SymbolFileSymtab::CalculateNumCompileUnits
uint32_t CalculateNumCompileUnits() override
Definition: SymbolFileSymtab.cpp:102
SymbolFileSymtab::ParseVariablesForContext
size_t ParseVariablesForContext(const lldb_private::SymbolContext &sc) override
Definition: SymbolFileSymtab.cpp:224
lldb_private::AddressRange
Definition: AddressRange.h:25
Timer.h
SymbolFileSymtab::SymbolFileSymtab
SymbolFileSymtab(lldb::ObjectFileSP objfile_sp)
Definition: SymbolFileSymtab.cpp:53
lldb::eSymbolTypeObjCClass
@ eSymbolTypeObjCClass
Definition: lldb-enumerations.h:648
lldb_private::Symbol::GetMangled
Mangled & GetMangled()
Definition: Symbol.h:121
lldb_private::SymbolContextScope
Definition: SymbolContextScope.h:64
ObjectFile.h
TypeList.h
Symbol.h
lldb_private::Symbol::GetName
ConstString GetName() const
Definition: Symbol.cpp:501
lldb_private::Symtab::AppendSymbolIndexesWithType
uint32_t AppendSymbolIndexesWithType(lldb::SymbolType symbol_type, std::vector< uint32_t > &indexes, uint32_t start_idx=0, uint32_t end_index=UINT32_MAX) const
Definition: Symtab.cpp:487
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
lldb_private::Symtab
Definition: Symtab.h:22
uint32_t
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
SymbolFileSymtab::ParseImportedModules
bool ParseImportedModules(const lldb_private::SymbolContext &sc, std::vector< lldb_private::SourceModule > &imported_modules) override
Definition: SymbolFileSymtab.cpp:217
lldb_private::Address
Definition: Address.h:59
SymbolFileSymtab
Definition: SymbolFileSymtab.h:18
lldb_private::Type
Definition: Type.h:66
SymbolFileSymtab::ParseTypes
size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override
Definition: SymbolFileSymtab.cpp:204
Symtab.h
lldb_private::Symbol::GetByteSize
lldb::addr_t GetByteSize() const
Definition: Symbol.cpp:415
PluginManager.h
lldb_private::AddressRange::SetByteSize
void SetByteSize(lldb::addr_t byte_size)
Set accessor for the byte size of this range.
Definition: AddressRange.h:237
SymbolFileSymtab::m_code_indexes
lldb_private::Symtab::IndexCollection m_code_indexes
Definition: SymbolFileSymtab.h:99
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
Function.h
SymbolFileSymtab::ParseSupportFiles
bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit, lldb_private::FileSpecList &support_files) override
Definition: SymbolFileSymtab.cpp:212
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
SymbolContext.h
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
SymbolFileSymtab::GetDynamicArrayInfoForUID
llvm::Optional< ArrayInfo > GetDynamicArrayInfoForUID(lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) override
If type_uid points to an array type, return its characteristics.
Definition: SymbolFileSymtab.cpp:233
lldb_private::TypeList
Definition: TypeList.h:20
lldb_private::Symtab::SortSymbolIndexesByValue
void SortSymbolIndexesByValue(std::vector< uint32_t > &indexes, bool remove_duplicates) const
Definition: Symtab.cpp:613
lldb_private::Address::IsSectionOffset
bool IsSectionOffset() const
Check if an address is section offset.
Definition: Address.h:332
lldb_private::Address::GetOffset
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:319
LLDB_PLUGIN_DEFINE
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
lldb_private::SymbolFile::GlobalVariables
@ GlobalVariables
Definition: SymbolFile.h:67
lldb_private::Symtab::IndexCollection
std::vector< uint32_t > IndexCollection
Definition: Symtab.h:24
SymbolFileSymtab::m_objc_class_name_to_index
lldb_private::Symtab::NameToIndexMap m_objc_class_name_to_index
Definition: SymbolFileSymtab.h:101
lldb
Definition: SBAddress.h:15
SymbolFileSymtab::m_data_indexes
lldb_private::Symtab::IndexCollection m_data_indexes
Definition: SymbolFileSymtab.h:100
SymbolFileSymtab::m_source_indexes
lldb_private::Symtab::IndexCollection m_source_indexes
Definition: SymbolFileSymtab.h:97
lldb_private::Symbol::GetAddress
Address GetAddress() const
Definition: Symbol.h:73