LLDB  mainline
Symtab.h
Go to the documentation of this file.
1 //===-- Symtab.h ------------------------------------------------*- 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 #ifndef LLDB_SYMBOL_SYMTAB_H
10 #define LLDB_SYMBOL_SYMTAB_H
11 
13 #include "lldb/Symbol/Symbol.h"
14 #include "lldb/Utility/RangeMap.h"
15 #include "lldb/lldb-private.h"
16 #include <map>
17 #include <mutex>
18 #include <vector>
19 
20 namespace lldb_private {
21 
22 class Symtab {
23 public:
24  typedef std::vector<uint32_t> IndexCollection;
26 
27  enum Debug {
28  eDebugNo, // Not a debug symbol
29  eDebugYes, // A debug symbol
31  };
32 
34 
35  Symtab(ObjectFile *objfile);
36  ~Symtab();
37 
38  void PreloadSymbols();
39  void Reserve(size_t count);
40  Symbol *Resize(size_t count);
41  uint32_t AddSymbol(const Symbol &symbol);
42  size_t GetNumSymbols() const;
44  void
45  Dump(Stream *s, Target *target, SortOrder sort_type,
46  Mangled::NamePreference name_preference = Mangled::ePreferDemangled);
47  void Dump(Stream *s, Target *target, std::vector<uint32_t> &indexes,
48  Mangled::NamePreference name_preference =
49  Mangled::ePreferDemangled) const;
50  uint32_t GetIndexForSymbol(const Symbol *symbol) const;
51  std::recursive_mutex &GetMutex() { return m_mutex; }
53  Symbol *SymbolAtIndex(size_t idx);
54  const Symbol *SymbolAtIndex(size_t idx) const;
56  Debug symbol_debug_type,
57  Visibility symbol_visibility, uint32_t &start_idx);
58  /// Get the parent symbol for the given symbol.
59  ///
60  /// Many symbols in symbol tables are scoped by other symbols that
61  /// contain one or more symbol. This function will look for such a
62  /// containing symbol and return it if there is one.
63  const Symbol *GetParent(Symbol *symbol) const;
65  std::vector<uint32_t> &indexes,
66  uint32_t start_idx = 0,
67  uint32_t end_index = UINT32_MAX) const;
69  lldb::SymbolType symbol_type, uint32_t flags_value,
70  std::vector<uint32_t> &indexes, uint32_t start_idx = 0,
71  uint32_t end_index = UINT32_MAX) const;
73  Debug symbol_debug_type,
74  Visibility symbol_visibility,
75  std::vector<uint32_t> &matches,
76  uint32_t start_idx = 0,
77  uint32_t end_index = UINT32_MAX) const;
79  std::vector<uint32_t> &matches);
81  Debug symbol_debug_type,
82  Visibility symbol_visibility,
83  std::vector<uint32_t> &matches);
85  lldb::SymbolType symbol_type,
86  std::vector<uint32_t> &matches);
88  lldb::SymbolType symbol_type,
89  Debug symbol_debug_type,
90  Visibility symbol_visibility,
91  std::vector<uint32_t> &matches);
92  uint32_t
94  lldb::SymbolType symbol_type,
95  std::vector<uint32_t> &indexes);
97  const RegularExpression &regex, lldb::SymbolType symbol_type,
98  Debug symbol_debug_type, Visibility symbol_visibility,
99  std::vector<uint32_t> &indexes);
101  lldb::SymbolType symbol_type,
102  std::vector<uint32_t> &symbol_indexes);
104  lldb::SymbolType symbol_type,
105  Debug symbol_debug_type,
106  Visibility symbol_visibility,
107  std::vector<uint32_t> &symbol_indexes);
109  const RegularExpression &regex, lldb::SymbolType symbol_type,
110  Debug symbol_debug_type, Visibility symbol_visibility,
111  std::vector<uint32_t> &symbol_indexes);
113  lldb::SymbolType symbol_type,
114  Debug symbol_debug_type,
115  Visibility symbol_visibility);
119  lldb::addr_t file_addr, std::function<bool(Symbol *)> const &callback);
120  void FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
121  SymbolContextList &sc_list);
122  void CalculateSymbolSizes();
123 
124  void SortSymbolIndexesByValue(std::vector<uint32_t> &indexes,
125  bool remove_duplicates) const;
126 
127  static void DumpSymbolHeader(Stream *s);
128 
129  void Finalize() {
130  // Shrink to fit the symbols so we don't waste memory
131  if (m_symbols.capacity() > m_symbols.size()) {
132  collection new_symbols(m_symbols.begin(), m_symbols.end());
133  m_symbols.swap(new_symbols);
134  }
135  }
136 
137  void AppendSymbolNamesToMap(const IndexCollection &indexes,
138  bool add_demangled, bool add_mangled,
139  NameToIndexMap &name_to_index_map) const;
140 
142 
143 protected:
144  typedef std::vector<Symbol> collection;
145  typedef collection::iterator iterator;
146  typedef collection::const_iterator const_iterator;
148  public:
149  FileRangeToIndexMapCompare(const Symtab &symtab) : m_symtab(symtab) {}
150  bool operator()(const uint32_t a_data, const uint32_t b_data) const {
151  return rank(a_data) > rank(b_data);
152  }
153 
154  private:
155  // How much preferred is this symbol?
156  int rank(const uint32_t data) const {
157  const Symbol &symbol = *m_symtab.SymbolAtIndex(data);
158  if (symbol.IsExternal())
159  return 3;
160  if (symbol.IsWeak())
161  return 2;
162  if (symbol.IsDebug())
163  return 0;
164  return 1;
165  }
166  const Symtab &m_symtab;
167  };
171  void InitNameIndexes();
172  void InitAddressIndexes();
173 
177 
178  /// Maps function names to symbol indices (grouped by FunctionNameTypes)
179  std::map<lldb::FunctionNameType, UniqueCStringMap<uint32_t>>
181  mutable std::recursive_mutex
182  m_mutex; // Provide thread safety for this symbol table
184 
185 private:
187  GetNameToSymbolIndexMap(lldb::FunctionNameType type) {
188  auto map = m_name_to_symbol_indices.find(type);
189  assert(map != m_name_to_symbol_indices.end());
190  return map->second;
191  }
192  bool CheckSymbolAtIndex(size_t idx, Debug symbol_debug_type,
193  Visibility symbol_visibility) const {
194  switch (symbol_debug_type) {
195  case eDebugNo:
196  if (m_symbols[idx].IsDebug())
197  return false;
198  break;
199 
200  case eDebugYes:
201  if (!m_symbols[idx].IsDebug())
202  return false;
203  break;
204 
205  case eDebugAny:
206  break;
207  }
208 
209  switch (symbol_visibility) {
210  case eVisibilityAny:
211  return true;
212 
213  case eVisibilityExtern:
214  return m_symbols[idx].IsExternal();
215 
216  case eVisibilityPrivate:
217  return !m_symbols[idx].IsExternal();
218  }
219  return false;
220  }
221 
222  /// A helper function that looks up full function names.
223  ///
224  /// We generate unique names for synthetic symbols so that users can look
225  /// them up by name when needed. But because doing so is uncommon in normal
226  /// debugger use, we trade off some performance at lookup time for faster
227  /// symbol table building by detecting these symbols and generating their
228  /// names lazily, rather than adding them to the normal symbol indexes. This
229  /// function does the job of first consulting the name indexes, and if that
230  /// fails it extracts the information it needs from the synthetic name and
231  /// locates the symbol.
232  ///
233  /// @param[in] symbol_name The symbol name to search for.
234  ///
235  /// @param[out] indexes The vector if symbol indexes to update with results.
236  ///
237  /// @returns The number of indexes added to the index vector. Zero if no
238  /// matches were found.
239  uint32_t GetNameIndexes(ConstString symbol_name,
240  std::vector<uint32_t> &indexes);
241 
242  void SymbolIndicesToSymbolContextList(std::vector<uint32_t> &symbol_indexes,
243  SymbolContextList &sc_list);
244 
246  uint32_t value, std::set<const char *> &class_contexts,
247  std::vector<std::pair<NameToIndexMap::Entry, const char *>> &backlog,
248  RichManglingContext &rmc);
249 
251  const char *decl_context,
252  const std::set<const char *> &class_contexts);
253 
254  Symtab(const Symtab &) = delete;
255  const Symtab &operator=(const Symtab &) = delete;
256 };
257 
258 } // namespace lldb_private
259 
260 #endif // LLDB_SYMBOL_SYMTAB_H
lldb_private::Symtab::FileRangeToIndexMapCompare::FileRangeToIndexMapCompare
FileRangeToIndexMapCompare(const Symtab &symtab)
Definition: Symtab.h:149
lldb_private::Symtab::m_file_addr_to_index
FileRangeToIndexMap m_file_addr_to_index
Definition: Symtab.h:176
lldb_private::RegularExpression
Definition: RegularExpression.h:18
lldb_private::Symtab::m_objfile
ObjectFile * m_objfile
Definition: Symtab.h:174
lldb_private::Symtab::AppendSymbolIndexesWithTypeAndFlagsValue
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
Definition: Symtab.cpp:500
lldb_private::Symtab::AppendSymbolNamesToMap
void AppendSymbolNamesToMap(const IndexCollection &indexes, bool add_demangled, bool add_mangled, NameToIndexMap &name_to_index_map) const
Definition: Symtab.cpp:454
lldb_private::Symtab::GetNameToSymbolIndexMap
UniqueCStringMap< uint32_t > & GetNameToSymbolIndexMap(lldb::FunctionNameType type)
Definition: Symtab.h:187
lldb_private::Symbol
Definition: Symbol.h:20
lldb_private::Symtab::GetParent
const Symbol * GetParent(Symbol *symbol) const
Get the parent symbol for the given symbol.
Definition: Symtab.cpp:1138
lldb_private::Symtab::iterator
collection::iterator iterator
Definition: Symtab.h:145
lldb_private::Symtab::PreloadSymbols
void PreloadSymbols()
Definition: Symtab.cpp:449
lldb_private::Symtab::m_symbols
collection m_symbols
Definition: Symtab.h:175
lldb_private::Symtab::Debug
Debug
Definition: Symtab.h:27
lldb_private::Symtab::FileRangeToIndexMap
RangeDataVector< lldb::addr_t, lldb::addr_t, uint32_t, 0, FileRangeToIndexMapCompare > FileRangeToIndexMap
Definition: Symtab.h:170
lldb_private::Symtab::FileRangeToIndexMapCompare
Definition: Symtab.h:147
lldb_private::Symtab::~Symtab
~Symtab()
lldb_private::SymbolContextList
Definition: SymbolContext.h:379
lldb_private::Symtab::Symtab
Symtab(ObjectFile *objfile)
Definition: Symtab.cpp:29
lldb_private::Symtab::Finalize
void Finalize()
Definition: Symtab.h:129
lldb_private::Symtab::eVisibilityPrivate
@ eVisibilityPrivate
Definition: Symtab.h:33
lldb_private::Stream
Definition: Stream.h:28
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::Symtab::SymbolAtIndex
Symbol * SymbolAtIndex(size_t idx)
Definition: Symtab.cpp:210
RangeMap.h
UniqueCStringMap.h
lldb_private::Target
Definition: Target.h:450
lldb_private::Symtab::GetMutex
std::recursive_mutex & GetMutex()
Definition: Symtab.h:51
lldb_private::Symtab::FindFunctionSymbols
void FindFunctionSymbols(ConstString name, uint32_t name_type_mask, SymbolContextList &sc_list)
Definition: Symtab.cpp:1079
lldb_private::Symtab::eDebugNo
@ eDebugNo
Definition: Symtab.h:28
lldb_private::Symtab::NameToIndexMap
UniqueCStringMap< uint32_t > NameToIndexMap
Definition: Symtab.h:25
lldb_private::Symtab::FindFirstSymbolWithNameAndType
Symbol * FindFirstSymbolWithNameAndType(ConstString name, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility)
Definition: Symtab.cpp:854
lldb_private::Symtab::m_mutex
std::recursive_mutex m_mutex
Definition: Symtab.h:182
lldb_private::Symtab::eDebugYes
@ eDebugYes
Definition: Symtab.h:29
lldb_private::Symtab::m_name_to_symbol_indices
std::map< lldb::FunctionNameType, UniqueCStringMap< uint32_t > > m_name_to_symbol_indices
Maps function names to symbol indices (grouped by FunctionNameTypes)
Definition: Symtab.h:180
lldb_private::Symtab::Dump
void Dump(Stream *s, Target *target, SortOrder sort_type, Mangled::NamePreference name_preference=Mangled::ePreferDemangled)
Definition: Symtab.cpp:82
lldb_private::Symtab::DumpSymbolHeader
static void DumpSymbolHeader(Stream *s)
Definition: Symtab.cpp:179
lldb_private::Symtab::FileRangeToIndexMapCompare::rank
int rank(const uint32_t data) const
Definition: Symtab.h:156
lldb_private::Symtab::GetNameIndexes
uint32_t GetNameIndexes(ConstString symbol_name, std::vector< uint32_t > &indexes)
A helper function that looks up full function names.
Definition: Symtab.cpp:633
lldb_private::Symtab::m_file_addr_to_index_computed
bool m_file_addr_to_index_computed
Definition: Symtab.h:183
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::Symtab::FindSymbolContainingFileAddress
Symbol * FindSymbolContainingFileAddress(lldb::addr_t file_addr)
Definition: Symtab.cpp:1022
lldb_private::Symbol::IsExternal
bool IsExternal() const
Definition: Symbol.h:170
lldb_private::Symtab::const_iterator
collection::const_iterator const_iterator
Definition: Symtab.h:146
lldb_private::Symtab::eVisibilityExtern
@ eVisibilityExtern
Definition: Symtab.h:33
lldb_private::Symtab::GetIndexForSymbol
uint32_t GetIndexForSymbol(const Symbol *symbol) const
Definition: Symtab.cpp:543
lldb_private::Symtab::InitAddressIndexes
void InitAddressIndexes()
Definition: Symtab.cpp:918
lldb_private::Symtab::FindSymbolWithType
Symbol * FindSymbolWithType(lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, uint32_t &start_idx)
Definition: Symtab.cpp:787
lldb_private::Symtab::FindSymbolAtFileAddress
Symbol * FindSymbolAtFileAddress(lldb::addr_t file_addr)
Definition: Symtab.cpp:1007
lldb::SymbolType
SymbolType
Symbol types.
Definition: lldb-enumerations.h:612
lldb_private::UniqueCStringMap< uint32_t >
lldb_private::Symtab::RegisterBacklogEntry
void RegisterBacklogEntry(const NameToIndexMap::Entry &entry, const char *decl_context, const std::set< const char * > &class_contexts)
Definition: Symtab.cpp:431
lldb-private.h
Symbol.h
lldb_private::Symtab::GetNumSymbols
size_t GetNumSymbols() const
Definition: Symtab.cpp:71
lldb_private::Symtab::Reserve
void Reserve(size_t count)
Definition: Symtab.cpp:45
lldb_private::Symtab::InitNameIndexes
void InitNameIndexes()
Definition: Symtab.cpp:264
lldb_private::Symbol::IsDebug
bool IsDebug() const
Definition: Symbol.h:166
lldb_private::Symtab::AddSymbol
uint32_t AddSymbol(const Symbol &symbol)
Definition: Symtab.cpp:58
lldb_private::Symtab::CheckSymbolAtIndex
bool CheckSymbolAtIndex(size_t idx, Debug symbol_debug_type, Visibility symbol_visibility) const
Definition: Symtab.h:192
lldb_private::RichManglingContext
Uniform wrapper for access to rich mangling information from different providers.
Definition: RichManglingContext.h:25
lldb_private::Symtab::CalculateSymbolSizes
void CalculateSymbolSizes()
Definition: Symtab.cpp:1001
lldb_private::Symtab::FileRangeToIndexMapCompare::m_symtab
const Symtab & m_symtab
Definition: Symtab.h:166
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:482
lldb_private::Symtab
Definition: Symtab.h:22
lldb_private::Symtab::AppendSymbolIndexesWithName
uint32_t AppendSymbolIndexesWithName(ConstString symbol_name, std::vector< uint32_t > &matches)
Definition: Symtab.cpp:663
uint32_t
lldb_private::Symtab::operator=
const Symtab & operator=(const Symtab &)=delete
lldb_private::Symtab::GetObjectFile
ObjectFile * GetObjectFile()
Definition: Symtab.h:141
lldb_private::RangeDataVector
Definition: RangeMap.h:398
lldb_private::Symtab::FileRangeToIndexMapCompare::operator()
bool operator()(const uint32_t a_data, const uint32_t b_data) const
Definition: Symtab.h:150
lldb_private::Symtab::FindSymbolByID
Symbol * FindSymbolByID(lldb::user_id_t uid) const
Definition: Symtab.cpp:201
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:31
lldb_private::Symtab::Visibility
Visibility
Definition: Symtab.h:33
lldb_private::Symtab::AppendSymbolIndexesWithNameAndType
uint32_t AppendSymbolIndexesWithNameAndType(ConstString symbol_name, lldb::SymbolType symbol_type, std::vector< uint32_t > &matches)
Definition: Symtab.cpp:703
lldb_private::Symtab::SectionFileAddressesChanged
void SectionFileAddressesChanged()
Definition: Symtab.cpp:76
lldb_private::SortOrder
SortOrder
Definition: lldb-private-enumerations.h:110
lldb_private::Symbol::IsWeak
bool IsWeak() const
Definition: Symbol.h:178
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
lldb_private::Symtab::RegisterMangledNameEntry
void RegisterMangledNameEntry(uint32_t value, std::set< const char * > &class_contexts, std::vector< std::pair< NameToIndexMap::Entry, const char * >> &backlog, RichManglingContext &rmc)
Definition: Symtab.cpp:375
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::Symtab::eVisibilityAny
@ eVisibilityAny
Definition: Symtab.h:33
lldb_private::Symtab::AppendSymbolIndexesMatchingRegExAndType
uint32_t AppendSymbolIndexesMatchingRegExAndType(const RegularExpression &regex, lldb::SymbolType symbol_type, std::vector< uint32_t > &indexes)
Definition: Symtab.cpp:741
lldb_private::Symtab::eDebugAny
@ eDebugAny
Definition: Symtab.h:30
lldb_private::Symtab::FindAllSymbolsWithNameAndType
void FindAllSymbolsWithNameAndType(ConstString name, lldb::SymbolType symbol_type, std::vector< uint32_t > &symbol_indexes)
Definition: Symtab.cpp:807
lldb_private::Symtab::SortSymbolIndexesByValue
void SortSymbolIndexesByValue(std::vector< uint32_t > &indexes, bool remove_duplicates) const
Definition: Symtab.cpp:608
Entry
FormatEntity::Entry Entry
Definition: FormatEntity.cpp:82
lldb_private::Symtab::m_name_indexes_computed
bool m_name_indexes_computed
Definition: Symtab.h:183
lldb_private::Symtab::Resize
Symbol * Resize(size_t count)
Definition: Symtab.cpp:51
lldb_private::Symtab::collection
std::vector< Symbol > collection
Definition: Symtab.h:144
lldb_private::Symtab::IndexCollection
std::vector< uint32_t > IndexCollection
Definition: Symtab.h:24
lldb_private::Symtab::FindAllSymbolsMatchingRexExAndType
void FindAllSymbolsMatchingRexExAndType(const RegularExpression &regex, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector< uint32_t > &symbol_indexes)
Definition: Symtab.cpp:844
lldb_private::Symtab::SymbolIndicesToSymbolContextList
void SymbolIndicesToSymbolContextList(std::vector< uint32_t > &symbol_indexes, SymbolContextList &sc_list)
Definition: Symtab.cpp:1061
lldb_private::ObjectFile
Definition: ObjectFile.h:58
lldb_private::Symtab::ForEachSymbolContainingFileAddress
void ForEachSymbolContainingFileAddress(lldb::addr_t file_addr, std::function< bool(Symbol *)> const &callback)
Definition: Symtab.cpp:1038