Remove SymbolVendor::GetSymtab

[labath]

Summary

This patch removes the GetSymtab method from the SymbolVendor, which is
a no-op as it's implementation just forwards to the relevant SymbolFile.
Instead it creates a Module::GetSymtab, which calls the SymbolFile
method directly.

All callers have been updated to use the Module method directly instead
of a two phase GetSymbolVendor->GetSymtab search, which leads to reduced
intentation in a lot of deeply nested code.

lldb/trunk/include/lldb/Core/Module.h

public:
   ///     object and remains valid as long as the object is around.
   virtual SymbolVendor *
   GetSymbolVendor(bool can_create = true,
                   lldb_private::Stream *feedback_strm = nullptr);
 
   SymbolFile *GetSymbolFile(bool can_create = true,
                             Stream *feedback_strm = nullptr);
 
+  Symtab *GetSymtab();
+
   /// Get a reference to the UUID value contained in this object.
   ///
   /// If the executable image file doesn't not have a UUID value built into
   /// the file format, an MD5 checksum of the entire file, or slice of the
   /// file for the current architecture should be used.
   ///
   /// \return
   ///     A const pointer to the internal copy of the UUID value in

lldb/trunk/include/lldb/Symbol/SymbolVendor.h

public:
 
   virtual size_t GetTypes(SymbolContextScope *sc_scope,
                           lldb::TypeClass type_mask, TypeList &type_list);
 
   SymbolFile *GetSymbolFile() { return m_sym_file_up.get(); }
 
   FileSpec GetMainFileSpec() const;
 
-  // Get module unified section list symbol table.
-  virtual Symtab *GetSymtab();
-
   /// Notify the SymbolVendor that the file addresses in the Sections
   /// for this module have been changed.
   virtual void SectionFileAddressesChanged();
 
   // PluginInterface protocol
   ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;

lldb/trunk/source/API/SBModule.cpp

SBSymbolContextList SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) {
   if (sb_file_spec.IsValid() && module_sp) {
     const bool append = true;
     module_sp->FindCompileUnits(*sb_file_spec, append, *sb_sc_list);
   }
   return LLDB_RECORD_RESULT(sb_sc_list);
 }
 
 static Symtab *GetUnifiedSymbolTable(const lldb::ModuleSP &module_sp) {
-  if (module_sp) {
-    SymbolVendor *symbols = module_sp->GetSymbolVendor();
-    if (symbols)
-      return symbols->GetSymtab();
-  }
+  if (module_sp)
+    return module_sp->GetSymtab();
   return nullptr;
 }
 
 size_t SBModule::GetNumSymbols() {
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols);
 
   ModuleSP module_sp(GetSP());
-  if (module_sp) {
-    Symtab *symtab = GetUnifiedSymbolTable(module_sp);
-    if (symtab)
-      return symtab->GetNumSymbols();
-  }
+  if (Symtab *symtab = GetUnifiedSymbolTable(module_sp))
   return 0;
 }
 
 SBSymbol SBModule::GetSymbolAtIndex(size_t idx) {
   LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), idx);
 
   SBSymbol sb_symbol;
   ModuleSP module_sp(GetSP());

lldb/trunk/source/Commands/CommandObjectTarget.cpp

if (num_modules > 0) {
     }
     strm.IndentLess();
   }
   return num_dumped;
 }
 
 static void DumpModuleSymtab(CommandInterpreter &interpreter, Stream &strm,
                              Module *module, SortOrder sort_order) {
-  if (module) {
-    SymbolVendor *sym_vendor = module->GetSymbolVendor();
-    if (sym_vendor) {
-      Symtab *symtab = sym_vendor->GetSymtab();
-      if (symtab)
-        symtab->Dump(&strm, interpreter.GetExecutionContext().GetTargetPtr(),
-                     sort_order);
-    }
-  }
-}
+  if (!module)
+    return;
+  if (Symtab *symtab = module->GetSymtab())
 
 static void DumpModuleSections(CommandInterpreter &interpreter, Stream &strm,
                                Module *module) {
   if (module) {
     SectionList *section_list = module->GetSectionList();
     if (section_list) {
       strm.Printf("Sections for '%s' (%s):\n",
                   module->GetSpecificationDescription().c_str(),
static bool LookupAddressInModule(CommandInterpreter &interpreter, Stream &strm,
 
   return false;
 }
 
 static uint32_t LookupSymbolInModule(CommandInterpreter &interpreter,
                                      Stream &strm, Module *module,
                                      const char *name, bool name_is_regex,
                                      bool verbose) {
-  if (module) {
-    SymbolContext sc;
+  if (!module)
+    return 0;
+
+  Symtab *symtab = module->GetSymtab();
+  if (!symtab)
+    return 0;
 
-    SymbolVendor *sym_vendor = module->GetSymbolVendor();
-    if (sym_vendor) {
-      Symtab *symtab = sym_vendor->GetSymtab();
-      if (symtab) {
-        std::vector<uint32_t> match_indexes;
-        ConstString symbol_name(name);
-        uint32_t num_matches = 0;
-        if (name_is_regex) {
-          RegularExpression name_regexp(symbol_name.GetStringRef());
-          num_matches = symtab->AppendSymbolIndexesMatchingRegExAndType(
-              name_regexp, eSymbolTypeAny, match_indexes);
-        } else {
-          num_matches =
-              symtab->AppendSymbolIndexesWithName(symbol_name, match_indexes);
-        }
+  SymbolContext sc;
 
-        if (num_matches > 0) {
-          strm.Indent();
-          strm.Printf("%u symbols match %s'%s' in ", num_matches,
-                      name_is_regex ? "the regular expression " : "", name);
-          DumpFullpath(strm, &module->GetFileSpec(), 0);
-          strm.PutCString(":\n");
-          strm.IndentMore();
-          for (uint32_t i = 0; i < num_matches; ++i) {
-            Symbol *symbol = symtab->SymbolAtIndex(match_indexes[i]);
-            if (symbol && symbol->ValueIsAddress()) {
-              DumpAddress(interpreter.GetExecutionContext()
-                              .GetBestExecutionContextScope(),
-                          symbol->GetAddressRef(), verbose, strm);
-            }
-          }
-          strm.IndentLess();
-          return num_matches;
-        }
-      }
-    }
-  }
-  return 0;
+        DumpAddress(
+            interpreter.GetExecutionContext().GetBestExecutionContextScope(),
+  return num_matches;
 }
 
 static void DumpSymbolContextList(ExecutionContextScope *exe_scope,
                                   Stream &strm, SymbolContextList &sc_list,
                                   bool verbose) {
   strm.IndentMore();
 
   const uint32_t num_matches = sc_list.GetSize();

lldb/trunk/source/Core/Address.cpp

if (IsSectionOffset()) {
         pointer_size = module_sp->GetArchitecture().GetAddressByteSize();
 
       bool showed_info = false;
       if (section_sp) {
         SectionType sect_type = section_sp->GetType();
         switch (sect_type) {
         case eSectionTypeData:
           if (module_sp) {
-            SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
-            if (sym_vendor) {
-              Symtab *symtab = sym_vendor->GetSymtab();
-              if (symtab) {
-                const addr_t file_Addr = GetFileAddress();
-                Symbol *symbol =
-                    symtab->FindSymbolContainingFileAddress(file_Addr);
-                if (symbol) {
-                  const char *symbol_name = symbol->GetName().AsCString();
-                  if (symbol_name) {
-                    s->PutCString(symbol_name);
-                    addr_t delta =
-                        file_Addr - symbol->GetAddressRef().GetFileAddress();
-                    if (delta)
-                      s->Printf(" + %" PRIu64, delta);
-                    showed_info = true;
-                  }
-                }
-              }
-            }
-          }
+            if (Symtab *symtab = module_sp->GetSymtab()) {
           break;
 
         case eSectionTypeDataCString:
           // Read the C string from memory and display it
           showed_info = true;
           ReadCStringFromMemory(exe_scope, *this, s);
           break;
 
bool lldb_private::operator!=(const Address &a, const Address &rhs) {
   return a.GetOffset() != rhs.GetOffset() || a.GetSection() != rhs.GetSection();
 }
 
 AddressClass Address::GetAddressClass() const {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     ObjectFile *obj_file = module_sp->GetObjectFile();
     if (obj_file) {
-      // Give the symbol vendor a chance to add to the unified section list
-      // and to symtab from symbol file
-      if (SymbolVendor *vendor = module_sp->GetSymbolVendor())
-        vendor->GetSymtab();
+      // Give the symbol file a chance to add to the unified section list
+      // and to the symtab.
+      module_sp->GetSymtab();
       return obj_file->GetAddressClass(GetFileAddress());
     }
   }
   return AddressClass::eUnknown;
 }
 
 bool Address::SetLoadAddress(lldb::addr_t load_addr, Target *target,
                              bool allow_section_end) {
   if (target && target->GetSectionLoadList().ResolveLoadAddress(
                     load_addr, *this, allow_section_end))
     return true;
   m_section_wp.reset();
   m_offset = load_addr;
   return false;
 }

lldb/trunk/source/Core/Module.cpp

 }
 
 SymbolFile *Module::GetSymbolFile(bool can_create, Stream *feedback_strm) {
   if (SymbolVendor *vendor = GetSymbolVendor(can_create, feedback_strm))
     return vendor->GetSymbolFile();
   return nullptr;
 }
 
+Symtab *Module::GetSymtab() {
+  if (SymbolFile *symbols = GetSymbolFile())
+    return symbols->GetSymtab();
+  return nullptr;
+}
+
 void Module::SetFileSpecAndObjectName(const FileSpec &file,
                                       ConstString object_name) {
   // Container objects whose paths do not specify a file directly can call this
   // function to correct the file and object names.
   m_file = file;
   m_mod_time = FileSystem::Instance().GetModificationTime(file);
   m_object_name = object_name;
 }
s->Printf("Module %s%s%s%s\n", m_file.GetPath().c_str(),
             m_object_name ? ")" : "");
 
   s->IndentMore();
 
   ObjectFile *objfile = GetObjectFile();
   if (objfile)
     objfile->Dump(s);
 
-  SymbolVendor *symbols = GetSymbolVendor();
-  if (symbols)
-    symbols->Dump(s);
+  if (SymbolFile *symbols = GetSymbolFile())
+    symbols->Dump(*s);
 
   s->IndentLess();
 }
 
 ConstString Module::GetObjectName() const { return m_object_name; }
 
 ObjectFile *Module::GetObjectFile() {
   if (!m_did_load_objfile.load()) {

 }
 
 const Symbol *Module::FindFirstSymbolWithNameAndType(ConstString name,
                                                      SymbolType symbol_type) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
       func_cat, "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)",
       name.AsCString(), symbol_type);
-  SymbolVendor *sym_vendor = GetSymbolVendor();
-  if (sym_vendor) {
-    Symtab *symtab = sym_vendor->GetSymtab();
-    if (symtab)
-      return symtab->FindFirstSymbolWithNameAndType(
-          name, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny);
-  }
+  if (Symtab *symtab = GetSymtab())
   return nullptr;
 }
 void Module::SymbolIndicesToSymbolContextList(
     Symtab *symtab, std::vector<uint32_t> &symbol_indexes,
     SymbolContextList &sc_list) {
   // No need to protect this call using m_mutex all other method calls are
   // already thread safe.
 

 
 size_t Module::FindFunctionSymbols(ConstString name,
                                    uint32_t name_type_mask,
                                    SymbolContextList &sc_list) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat,
                      "Module::FindSymbolsFunctions (name = %s, mask = 0x%8.8x)",
                      name.AsCString(), name_type_mask);
-  SymbolVendor *sym_vendor = GetSymbolVendor();
-  if (sym_vendor) {
-    Symtab *symtab = sym_vendor->GetSymtab();
-    if (symtab)
-      return symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
-  }
+  if (Symtab *symtab = GetSymtab())
   return 0;
 }
 
 size_t Module::FindSymbolsWithNameAndType(ConstString name,
                                           SymbolType symbol_type,
                                           SymbolContextList &sc_list) {
   // No need to protect this call using m_mutex all other method calls are
   // already thread safe.
 
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
       func_cat, "Module::FindSymbolsWithNameAndType (name = %s, type = %i)",
       name.AsCString(), symbol_type);
   const size_t initial_size = sc_list.GetSize();
-  SymbolVendor *sym_vendor = GetSymbolVendor();
-  if (sym_vendor) {
-    Symtab *symtab = sym_vendor->GetSymtab();
-    if (symtab) {
-      std::vector<uint32_t> symbol_indexes;
-      symtab->FindAllSymbolsWithNameAndType(name, symbol_type, symbol_indexes);
-      SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
-    }
-  }
+  if (Symtab *symtab = GetSymtab()) {
   return sc_list.GetSize() - initial_size;
 }
 
 size_t Module::FindSymbolsMatchingRegExAndType(const RegularExpression &regex,
                                                SymbolType symbol_type,
                                                SymbolContextList &sc_list) {
   // No need to protect this call using m_mutex all other method calls are
   // already thread safe.
 
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
       func_cat,
       "Module::FindSymbolsMatchingRegExAndType (regex = %s, type = %i)",
       regex.GetText().str().c_str(), symbol_type);
   const size_t initial_size = sc_list.GetSize();
-  SymbolVendor *sym_vendor = GetSymbolVendor();
-  if (sym_vendor) {
-    Symtab *symtab = sym_vendor->GetSymtab();
-    if (symtab) {
-      std::vector<uint32_t> symbol_indexes;
-      symtab->FindAllSymbolsMatchingRexExAndType(
-          regex, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny,
-          symbol_indexes);
-      SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
-    }
-  }
+  if (Symtab *symtab = GetSymtab()) {
   return sc_list.GetSize() - initial_size;
 }
 
 void Module::PreloadSymbols() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   SymbolFile *sym_file = GetSymbolFile();
   if (!sym_file)
     return;

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp

if (m_break_id == LLDB_INVALID_BREAK_ID) {
     }
   }
   return m_break_id != LLDB_INVALID_BREAK_ID;
 }
 
 addr_t
 DynamicLoaderMacOS::GetDyldLockVariableAddressFromModule(Module *module) {
   SymbolContext sc;
-  SymbolVendor *sym_vendor = module->GetSymbolVendor();
   Target &target = m_process->GetTarget();
-  if (sym_vendor) {
-    Symtab *symtab = sym_vendor->GetSymtab();
-    if (symtab) {
-      std::vector<uint32_t> match_indexes;
-      ConstString g_symbol_name("_dyld_global_lock_held");
-      uint32_t num_matches = 0;
-      num_matches =
-          symtab->AppendSymbolIndexesWithName(g_symbol_name, match_indexes);
-      if (num_matches == 1) {
-        Symbol *symbol = symtab->SymbolAtIndex(match_indexes[0]);
-        if (symbol &&
-            (symbol->ValueIsAddress() || symbol->GetAddressRef().IsValid())) {
-          return symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
-        }
-      }
-    }
-  }
+  if (Symtab *symtab = module->GetSymtab()) {
   return LLDB_INVALID_ADDRESS;
 }
 
 //  Look for this symbol:
 //
 //  int __attribute__((visibility("hidden")))           _dyld_global_lock_held =
 //  0;
 //

lldb/trunk/source/Symbol/SymbolFile.cpp

void SymbolFile::Dump(Stream &s) {
   if (m_compile_units) {
     for (const CompUnitSP &cu_sp : *m_compile_units) {
       // We currently only dump the compile units that have been parsed
       if (cu_sp)
         cu_sp->Dump(&s, /*show_context*/ false);
     }
   }
   s.PutChar('\n');
+
+  if (Symtab *symtab = GetSymtab())
+    symtab->Dump(&s, nullptr, eSortOrderNone);
 }
 
 SymbolFile::RegisterInfoResolver::~RegisterInfoResolver() = default;

lldb/trunk/source/Symbol/SymbolVendor.cpp

if (m_sym_file_up) {
           objfile_file_spec.Dump(s);
           s->PutChar(')');
         }
       }
     }
     s->EOL();
     if (m_sym_file_up)
       m_sym_file_up->Dump(*s);
-    s->IndentMore();
-
-    if (Symtab *symtab = GetSymtab())
-      symtab->Dump(s, nullptr, eSortOrderNone);
-
-    s->IndentLess();
   }
 }
 
 CompUnitSP SymbolVendor::GetCompileUnitAtIndex(size_t idx) {
   if (m_sym_file_up)
     return m_sym_file_up->GetCompileUnitAtIndex(idx);
   return nullptr;
 }
 
 FileSpec SymbolVendor::GetMainFileSpec() const {
   if (m_sym_file_up) {
     const ObjectFile *symfile_objfile = m_sym_file_up->GetObjectFile();
     if (symfile_objfile)
       return symfile_objfile->GetFileSpec();
   }
 
   return FileSpec();
 }
 
-Symtab *SymbolVendor::GetSymtab() {
-  if (m_sym_file_up)
-    return m_sym_file_up->GetSymtab();
-  return nullptr;
-}
-
 void SymbolVendor::SectionFileAddressesChanged() {
   if (m_sym_file_up)
     m_sym_file_up->SectionFileAddressesChanged();
 }
 
 // PluginInterface protocol
 lldb_private::ConstString SymbolVendor::GetPluginName() {
   static ConstString g_name("vendor-default");
   return g_name;
 }
 
 uint32_t SymbolVendor::GetPluginVersion() { return 1; }