contrib/llvm-project/lldb/include/lldb/Symbol/Symtab.h

   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 liblldb_Symtab_h_
  10 #define liblldb_Symtab_h_
  11
  12 #include "lldb/Core/UniqueCStringMap.h"
  13 #include "lldb/Symbol/Symbol.h"
  14 #include "lldb/Utility/RangeMap.h"
  15 #include "lldb/lldb-private.h"
  16 #include <mutex>
  17 #include <vector>
  18
  19 namespace lldb_private {
  20
  21 class Symtab {
  22 public:
  23   typedef std::vector<uint32_t> IndexCollection;
  24   typedef UniqueCStringMap<uint32_t> NameToIndexMap;
  25
  26   enum Debug {
  27     eDebugNo,  // Not a debug symbol
  28     eDebugYes, // A debug symbol
  29     eDebugAny
  30   };
  31
  32   enum Visibility { eVisibilityAny, eVisibilityExtern, eVisibilityPrivate };
  33
  34   Symtab(ObjectFile *objfile);
  35   ~Symtab();
  36
  37   void PreloadSymbols();
  38   void Reserve(size_t count);
  39   Symbol *Resize(size_t count);
  40   uint32_t AddSymbol(const Symbol &symbol);
  41   size_t GetNumSymbols() const;
  42   void SectionFileAddressesChanged();
  43   void Dump(Stream *s, Target *target, SortOrder sort_type);
  44   void Dump(Stream *s, Target *target, std::vector<uint32_t> &indexes) const;
  45   uint32_t GetIndexForSymbol(const Symbol *symbol) const;
  46   std::recursive_mutex &GetMutex() { return m_mutex; }
  47   Symbol *FindSymbolByID(lldb::user_id_t uid) const;
  48   Symbol *SymbolAtIndex(size_t idx);
  49   const Symbol *SymbolAtIndex(size_t idx) const;
  50   Symbol *FindSymbolWithType(lldb::SymbolType symbol_type,
  51                              Debug symbol_debug_type,
  52                              Visibility symbol_visibility, uint32_t &start_idx);
  53   /// Get the parent symbol for the given symbol.
  54   ///
  55   /// Many symbols in symbol tables are scoped by other symbols that
  56   /// contain one or more symbol. This function will look for such a
  57   /// containing symbol and return it if there is one.
  58   const Symbol *GetParent(Symbol *symbol) const;
  59   uint32_t AppendSymbolIndexesWithType(lldb::SymbolType symbol_type,
  60                                        std::vector<uint32_t> &indexes,
  61                                        uint32_t start_idx = 0,
  62                                        uint32_t end_index = UINT32_MAX) const;
  63   uint32_t AppendSymbolIndexesWithTypeAndFlagsValue(
  64       lldb::SymbolType symbol_type, uint32_t flags_value,
  65       std::vector<uint32_t> &indexes, uint32_t start_idx = 0,
  66       uint32_t end_index = UINT32_MAX) const;
  67   uint32_t AppendSymbolIndexesWithType(lldb::SymbolType symbol_type,
  68                                        Debug symbol_debug_type,
  69                                        Visibility symbol_visibility,
  70                                        std::vector<uint32_t> &matches,
  71                                        uint32_t start_idx = 0,
  72                                        uint32_t end_index = UINT32_MAX) const;
  73   uint32_t AppendSymbolIndexesWithName(ConstString symbol_name,
  74                                        std::vector<uint32_t> &matches);
  75   uint32_t AppendSymbolIndexesWithName(ConstString symbol_name,
  76                                        Debug symbol_debug_type,
  77                                        Visibility symbol_visibility,
  78                                        std::vector<uint32_t> &matches);
  79   uint32_t AppendSymbolIndexesWithNameAndType(ConstString symbol_name,
  80                                               lldb::SymbolType symbol_type,
  81                                               std::vector<uint32_t> &matches);
  82   uint32_t AppendSymbolIndexesWithNameAndType(ConstString symbol_name,
  83                                               lldb::SymbolType symbol_type,
  84                                               Debug symbol_debug_type,
  85                                               Visibility symbol_visibility,
  86                                               std::vector<uint32_t> &matches);
  87   uint32_t
  88   AppendSymbolIndexesMatchingRegExAndType(const RegularExpression &regex,
  89                                           lldb::SymbolType symbol_type,
  90                                           std::vector<uint32_t> &indexes);
  91   uint32_t AppendSymbolIndexesMatchingRegExAndType(
  92       const RegularExpression &regex, lldb::SymbolType symbol_type,
  93       Debug symbol_debug_type, Visibility symbol_visibility,
  94       std::vector<uint32_t> &indexes);
  95   size_t FindAllSymbolsWithNameAndType(ConstString name,
  96                                        lldb::SymbolType symbol_type,
  97                                        std::vector<uint32_t> &symbol_indexes);
  98   size_t FindAllSymbolsWithNameAndType(ConstString name,
  99                                        lldb::SymbolType symbol_type,
 100                                        Debug symbol_debug_type,
 101                                        Visibility symbol_visibility,
 102                                        std::vector<uint32_t> &symbol_indexes);
 103   size_t FindAllSymbolsMatchingRexExAndType(
 104       const RegularExpression &regex, lldb::SymbolType symbol_type,
 105       Debug symbol_debug_type, Visibility symbol_visibility,
 106       std::vector<uint32_t> &symbol_indexes);
 107   Symbol *FindFirstSymbolWithNameAndType(ConstString name,
 108                                          lldb::SymbolType symbol_type,
 109                                          Debug symbol_debug_type,
 110                                          Visibility symbol_visibility);
 111   Symbol *FindSymbolAtFileAddress(lldb::addr_t file_addr);
 112   Symbol *FindSymbolContainingFileAddress(lldb::addr_t file_addr);
 113   void ForEachSymbolContainingFileAddress(
 114       lldb::addr_t file_addr, std::function<bool(Symbol *)> const &callback);
 115   size_t FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
 116                              SymbolContextList &sc_list);
 117   void CalculateSymbolSizes();
 118
 119   void SortSymbolIndexesByValue(std::vector<uint32_t> &indexes,
 120                                 bool remove_duplicates) const;
 121
 122   static void DumpSymbolHeader(Stream *s);
 123
 124   void Finalize() {
 125     // Shrink to fit the symbols so we don't waste memory
 126     if (m_symbols.capacity() > m_symbols.size()) {
 127       collection new_symbols(m_symbols.begin(), m_symbols.end());
 128       m_symbols.swap(new_symbols);
 129     }
 130   }
 131
 132   void AppendSymbolNamesToMap(const IndexCollection &indexes,
 133                               bool add_demangled, bool add_mangled,
 134                               NameToIndexMap &name_to_index_map) const;
 135
 136   ObjectFile *GetObjectFile() { return m_objfile; }
 137
 138 protected:
 139   typedef std::vector<Symbol> collection;
 140   typedef collection::iterator iterator;
 141   typedef collection::const_iterator const_iterator;
 142   typedef RangeDataVector<lldb::addr_t, lldb::addr_t, uint32_t>
 143       FileRangeToIndexMap;
 144   void InitNameIndexes();
 145   void InitAddressIndexes();
 146
 147   ObjectFile *m_objfile;
 148   collection m_symbols;
 149   FileRangeToIndexMap m_file_addr_to_index;
 150   UniqueCStringMap<uint32_t> m_name_to_index;
 151   UniqueCStringMap<uint32_t> m_basename_to_index;
 152   UniqueCStringMap<uint32_t> m_method_to_index;
 153   UniqueCStringMap<uint32_t> m_selector_to_index;
 154   mutable std::recursive_mutex
 155       m_mutex; // Provide thread safety for this symbol table
 156   bool m_file_addr_to_index_computed : 1, m_name_indexes_computed : 1;
 157
 158 private:
 159   bool CheckSymbolAtIndex(size_t idx, Debug symbol_debug_type,
 160                           Visibility symbol_visibility) const {
 161     switch (symbol_debug_type) {
 162     case eDebugNo:
 163       if (m_symbols[idx].IsDebug())
 164         return false;
 165       break;
 166
 167     case eDebugYes:
 168       if (!m_symbols[idx].IsDebug())
 169         return false;
 170       break;
 171
 172     case eDebugAny:
 173       break;
 174     }
 175
 176     switch (symbol_visibility) {
 177     case eVisibilityAny:
 178       return true;
 179
 180     case eVisibilityExtern:
 181       return m_symbols[idx].IsExternal();
 182
 183     case eVisibilityPrivate:
 184       return !m_symbols[idx].IsExternal();
 185     }
 186     return false;
 187   }
 188
 189   void SymbolIndicesToSymbolContextList(std::vector<uint32_t> &symbol_indexes,
 190                                         SymbolContextList &sc_list);
 191
 192   void RegisterMangledNameEntry(
 193       uint32_t value, std::set<const char *> &class_contexts,
 194       std::vector<std::pair<NameToIndexMap::Entry, const char *>> &backlog,
 195       RichManglingContext &rmc);
 196
 197   void RegisterBacklogEntry(const NameToIndexMap::Entry &entry,
 198                             const char *decl_context,
 199                             const std::set<const char *> &class_contexts);
 200
 201   DISALLOW_COPY_AND_ASSIGN(Symtab);
 202 };
 203
 204 } // namespace lldb_private
 205
 206 #endif // liblldb_Symtab_h_