SymbolVendor: Have plugins return symbol files directly

[labath]

Summary

This is the last patch in the SymbolVendor series. Now that the symbol
vendors don't do anything, we can avoid creating their instances
completely, and just return SymbolFiles directly, removing a lot of
boilerplate in the process.

SymbolVendors still remain responsible for finding symbol files, and I've
updated all the comments I could find to reflect that.

[clayborg]

So I am confused. Are we keeping SymbolVendor around for locating symbols files or are we getting rid of it entirely?

include/lldb/Core/Module.h

989–996

Maybe we _just_ have "m_symfiles" here and document that the last entry is always the current symbol file? No need for two ivars here?

include/lldb/Symbol/SymbolVendor.h

12–13

Just delete this entire file?

source/Core/Module.cpp

1041

rename to SymbolFile::FindPlugin?

source/Core/PluginManager.cpp

1743

Rename to SymbolFile?

1745

ditto

[labath]

In D65952#1623297, @clayborg wrote:

So I am confused. Are we keeping SymbolVendor around for locating symbols files or are we getting rid of it entirely?

Well... right now my idea was to keep it around as an class with just some static methods for the purposes of locating symbol files, though I'm open to other ideas too. After this patch the SymbolVendor class will contain just one method (FindPlugin), but I think that in the future it could be used to host functionality that is common for different symbol vendors. Here, I'm mainly thinking of Symbols/LocateSymbolFile.cpp (formerly Host/Symbols.cpp), which contains a bunch of functionality for searching for symbol files (so it could fall under the symbol vendor mandate), and it is currently being called by other symbol vendors to do their job. However, it is also being called from placed other than symbol vendors, and so more refactoring would be needed for that to fit in neatly.

[labath]

Greg, any thoughts on my last comment? My biggest question is that if we remove the SymbolVendor completely, then where will the code that's currently in SymbolVendorELF and SymbolVendorMacOS go to...

[clayborg]

In D65952#1624799, @labath wrote:

In D65952#1623297, @clayborg wrote:

So I am confused. Are we keeping SymbolVendor around for locating symbols files or are we getting rid of it entirely?

Well... right now my idea was to keep it around as an class with just some static methods for the purposes of locating symbol files, though I'm open to other ideas too. After this patch the SymbolVendor class will contain just one method (FindPlugin), but I think that in the future it could be used to host functionality that is common for different symbol vendors. Here, I'm mainly thinking of Symbols/LocateSymbolFile.cpp (formerly Host/Symbols.cpp), which contains a bunch of functionality for searching for symbol files (so it could fall under the symbol vendor mandate), and it is currently being called by other symbol vendors to do their job. However, it is also being called from placed other than symbol vendors, and so more refactoring would be needed for that to fit in neatly.

IMHO: The functionality that locates symbol files should be moved into the Platform and we can get rid of SymbolVendor completely. So sounds like refactoring around that is a good idea. I am fine with this patch standing and addressing that refactor in a next patch?

[labath]

In D65952#1641539, @clayborg wrote:

In D65952#1624799, @labath wrote:

In D65952#1623297, @clayborg wrote:

So I am confused. Are we keeping SymbolVendor around for locating symbols files or are we getting rid of it entirely?

Well... right now my idea was to keep it around as an class with just some static methods for the purposes of locating symbol files, though I'm open to other ideas too. After this patch the SymbolVendor class will contain just one method (FindPlugin), but I think that in the future it could be used to host functionality that is common for different symbol vendors. Here, I'm mainly thinking of Symbols/LocateSymbolFile.cpp (formerly Host/Symbols.cpp), which contains a bunch of functionality for searching for symbol files (so it could fall under the symbol vendor mandate), and it is currently being called by other symbol vendors to do their job. However, it is also being called from placed other than symbol vendors, and so more refactoring would be needed for that to fit in neatly.

IMHO: The functionality that locates symbol files should be moved into the Platform and we can get rid of SymbolVendor completely.

This sounded like an interesting idea at first, because Platforms already do some work with finding files and stuff. However, after thinking about it a bit, I am not so sure anymore :). The reason for that is twofold:

• Platform objects are tied to a Debugger (they don't reference it directly, but their instances are owned by the Debugger object), where as Modules are trying to be independent of the Debuggers. This would make it tricky for example to fetch a platform instance when searching for a symbol file.
• even if we work around that (say by making the search logic a static member of the platform class), then there still the issue that some symbol finding logic is not really tied to any particular platform. It is true that the two current symbol vendors could be assigned to platforms relatively cleanly (SymbolVendorELF -> PlatformPOSIX, SymbolVendorMacOSX -> PlatformDarwin), but then we'd have a problem with where to put the Breakpad finding logic (it isn't implemented yet, but I am hoping to get around to it eventually). Breakpad system for searching for symbol files involves directory structures like $SYMBOL_NAME/$UUID/$SYMBOL_NAME.sym (e.g. ConsoleApplication1.pdb/897DD83EA8C8411897F3A925EE4BF7411/ConsoleApplication1.sym). I think this system is inspired by some Microsoft scheme, but breakpad uses it everywhere, which means there isn't a single platform class that could house this functionality.

I also considered putting this functionality inside the SymbolFile classes. That would solve the Debugger problem, and it would definitely work for breakpad. However, it would mean munging ELF and MacOS symbol vendors into the DWARF symbol file, which has enough on its plate already (though maybe there is a case to be made for moving SymbolFileDWARFDebugMap into a separate plugin, in which case the symbol vendor could go there -- however that's pretty hard to do right now).

So, overall, I think its still best to keep symbol finding/vending as a separate piece of functionality, albeit without a a real (isntantiatable) class backing it. Theoretically, we could keep this as a separate entry point in the PluginManager, but get rid of the Plugins/SymbolVendor directories by spreading the implementation over various other plugin kinds (breakpad vendor -> SymbolFileBreakpad, "elf" vendor -> ObjectFileELF (?), macos vendor -> PlatformDarwin), but given that they these folders already exist, I don't see much of a reason for changing them.

[labath]

merge m_old_symfiles and m_symfiles_up. I am not entirely satisfied with how I implemented that, but then again the original implementation wasn't totally clean either.

include/lldb/Core/Module.h

protected:
   uint64_t m_object_offset;
   llvm::sys::TimePoint<> m_object_mod_time;
   lldb::ObjectFileSP m_objfile_sp; ///< A shared pointer to the object file
                                    ///parser for this module as it may or may
                                    ///not be shared with the SymbolFile
   llvm::Optional<UnwindTable> m_unwind_table; ///< Table of FuncUnwinders
                                               /// objects created for this
                                               /// Module's functions
-  lldb::SymbolVendorUP
-      m_symfile_up; ///< A pointer to the symbol vendor for this module.
-  std::vector<lldb::SymbolVendorUP>
-      m_old_symfiles; ///< If anyone calls Module::SetSymbolFileFileSpec() and
-                      ///changes the symbol file,
-  ///< we need to keep all old symbol files around in case anyone has type
-  ///references to them
+
+  /// Symbol files for this module. The last entry in the vector is the active
+  /// file, but we also need keep all old symbol files around in case anyone has
+  /// type references to them
+  std::vector<std::unique_ptr<SymbolFile>> m_symfiles;
+
   TypeSystemMap m_type_system_map;   ///< A map of any type systems associated
                                      ///with this module
   PathMappingList m_source_mappings; ///< Module specific source remappings for
                                      ///when you have debug info for a module
                                      ///that doesn't match where the sources
                                      ///currently are
   lldb::SectionListUP m_sections_up; ///< Unified section list for module that
                                      /// is used by the ObjectFile and and
                                      /// ObjectFile instances for the debug info
 
   std::atomic<bool> m_did_load_objfile{false};

include/lldb/Core/PluginManager.h

public:
 
   static SymbolFileCreateInstance
   GetSymbolFileCreateCallbackAtIndex(uint32_t idx);
 
   static SymbolFileCreateInstance
   GetSymbolFileCreateCallbackForPluginName(ConstString name);
 
   // SymbolVendor
-  static bool RegisterPlugin(ConstString name, const char *description,
-                             SymbolVendorCreateInstance create_callback);
+  static bool RegisterPlugin(SymbolVendorCreateInstance create_callback);
 
   static bool UnregisterPlugin(SymbolVendorCreateInstance create_callback);
 
   static SymbolVendorCreateInstance
   GetSymbolVendorCreateCallbackAtIndex(uint32_t idx);
 
-  static SymbolVendorCreateInstance
-  GetSymbolVendorCreateCallbackForPluginName(ConstString name);
-
   // UnwindAssembly
   static bool RegisterPlugin(ConstString name, const char *description,
                              UnwindAssemblyCreateInstance create_callback);
 
   static bool UnregisterPlugin(UnwindAssemblyCreateInstance create_callback);
 
   static UnwindAssemblyCreateInstance
   GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx);

include/lldb/Symbol/SymbolVendor.h

 //===-- SymbolVendor.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_SymbolVendor_h_
 #define liblldb_SymbolVendor_h_
 
-#include <vector>
-
-#include "lldb/Core/ModuleChild.h"
-#include "lldb/Core/PluginInterface.h"
-#include "lldb/Symbol/SourceModule.h"
-#include "lldb/Symbol/TypeMap.h"
-#include "lldb/lldb-private.h"
-#include "llvm/ADT/DenseSet.h"
+#include "lldb/lldb-forward.h"
+#include <memory>
 
 namespace lldb_private {
 
-// The symbol vendor class is designed to abstract the process of searching for
-// debug information for a given module. Platforms can subclass this class and
-// provide extra ways to find debug information. Examples would be a subclass
-// that would allow for locating a stand alone debug file, parsing debug maps,
-// or runtime data in the object files. A symbol vendor can use multiple
-// sources (SymbolFile objects) to provide the information and only parse as
-// deep as needed in order to provide the information that is requested.
-class SymbolVendor : public ModuleChild, public PluginInterface {
+/// Symbol vendors perform the task of searching for debug information which is
+/// located in a standalone debug file. New symbol vendors can be registered via
+/// the plugin manager. Symbol vendors return symbol file (instances of
+/// SymbolFile class), which perform the actual parsing of the located debug
+/// info.
+class SymbolVendor {
 public:
-  static SymbolVendor *FindPlugin(const lldb::ModuleSP &module_sp,
+  /// Consult the registered symbol vendor plugins and return the symbol file
+  /// they created. If no symbol vendor returns a valid symbol file. The default
+  /// behavior is to create a symbol file instance based on the Module's symbol
+  /// file spec (if one exists), or simply return a symbol file which reads the
+  /// debug information from the Module's main object file.
+  static std::unique_ptr<SymbolFile> FindPlugin(const lldb::ModuleSP &module_sp,
                                                 Stream *feedback_strm);
 
-  // Constructors and Destructors
-  SymbolVendor(const lldb::ModuleSP &module_sp);
-
-  ~SymbolVendor() override;
-
-  void AddSymbolFileRepresentation(const lldb::ObjectFileSP &objfile_sp);
-
-  SymbolFile *GetSymbolFile() { return m_sym_file_up.get(); }
-
-  // PluginInterface protocol
-  ConstString GetPluginName() override;
-
-  uint32_t GetPluginVersion() override;
-
-protected:
-  std::unique_ptr<SymbolFile> m_sym_file_up; // A single symbol file. Subclasses
-                                             // can add more of these if needed.
-
-private:
-  // For SymbolVendor only
-  DISALLOW_COPY_AND_ASSIGN(SymbolVendor);
+  SymbolVendor() = delete;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_SymbolVendor_h_

include/lldb/lldb-private-interfaces.h

 typedef lldb::PlatformSP (*PlatformCreateInstance)(bool force,
                                                    const ArchSpec *arch);
 typedef lldb::ProcessSP (*ProcessCreateInstance)(
     lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
     const FileSpec *crash_file_path);
 typedef lldb::ScriptInterpreterSP (*ScriptInterpreterCreateInstance)(
     Debugger &debugger);
 typedef SymbolFile *(*SymbolFileCreateInstance)(lldb::ObjectFileSP objfile_sp);
-typedef SymbolVendor *(*SymbolVendorCreateInstance)(
+typedef std::unique_ptr<SymbolFile> (*SymbolVendorCreateInstance)(
     const lldb::ModuleSP &module_sp,
     lldb_private::Stream
         *feedback_strm); // Module can be NULL for default system symbol vendor
 typedef bool (*BreakpointHitCallback)(void *baton,
                                       StoppointCallbackContext *context,
                                       lldb::user_id_t break_id,
                                       lldb::user_id_t break_loc_id);
 typedef bool (*WatchpointHitCallback)(void *baton,

source/Core/Module.cpp

LLDB_LOGF(log, "%p Module::~Module((%s) '%s%s%s%s')",
               m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""),
               m_object_name.IsEmpty() ? "" : ")");
   // Release any auto pointers before we start tearing down our member
   // variables since the object file and symbol files might need to make
   // function calls back into this module object. The ordering is important
   // here because symbol files can require the module object file. So we tear
   // down the symbol file first, then the object file.
   m_sections_up.reset();
-  m_symfile_up.reset();
+  m_symfiles.clear();
   m_objfile_sp.reset();
 }
 
 ObjectFile *Module::GetMemoryObjectFile(const lldb::ProcessSP &process_sp,
                                         lldb::addr_t header_addr, Status &error,
                                         size_t size_to_read) {
   if (m_objfile_sp) {
     error.SetErrorString("object file already exists");
if (num_matches > 0) {
     SymbolContext sc;
     sc.module_sp = shared_from_this();
     sc.SortTypeList(typesmap, types);
   }
   return num_matches;
 }
 
 SymbolFile *Module::GetSymbolFile(bool can_create, Stream *feedback_strm) {
-  if (!m_did_load_symfile.load()) {
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    if (!m_did_load_symfile.load() && can_create) {
-      ObjectFile *obj_file = GetObjectFile();
-      if (obj_file != nullptr) {
-        static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
-        Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
-        m_symfile_up.reset(
-            SymbolVendor::FindPlugin(shared_from_this(), feedback_strm));
-        m_did_load_symfile = true;
-      }
-    }
-  }
-  return m_symfile_up ? m_symfile_up->GetSymbolFile() : nullptr;
+  if (m_did_load_symfile.load())
+    return m_symfiles.back().get();
+
+  if (m_did_load_symfile.load())
+    return m_symfiles.back().get();
+
+  if (!can_create)
+    return nullptr;
+
+  if (!GetObjectFile())
+    return nullptr;
+
+  m_symfiles.push_back(
+  return m_symfiles.back().get();
 }
 
 Symtab *Module::GetSymtab() {
   if (SymbolFile *symbols = GetSymbolFile())
     return symbols->GetSymtab();
   return nullptr;
 }
 
void Module::PreloadSymbols() {
   // Now we can prime the symbol table.
   if (Symtab *symtab = sym_file->GetSymtab())
     symtab->PreloadSymbols();
 }
 
 void Module::SetSymbolFileFileSpec(const FileSpec &file) {
   if (!FileSystem::Instance().Exists(file))
     return;
-  if (m_symfile_up) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  if (m_did_load_symfile.load()) {
     // Remove any sections in the unified section list that come from the
     // current symbol vendor.
     SectionList *section_list = GetSectionList();
     SymbolFile *symbol_file = GetSymbolFile();
     if (section_list && symbol_file) {
       ObjectFile *obj_file = symbol_file->GetObjectFile();
       // Make sure we have an object file and that the symbol vendor's objfile
       // isn't the same as the module's objfile before we remove any sections
if (section_list && symbol_file) {
                 section_list->GetSectionAtIndex(idx - 1));
             if (section_sp->GetObjectFile() == obj_file) {
               section_list->DeleteSection(idx - 1);
             }
           }
         }
       }
     }
-    // Keep all old symbol files around in case there are any lingering type
-    // references in any SBValue objects that might have been handed out.
-    m_old_symfiles.push_back(std::move(m_symfile_up));
   }
   m_symfile_spec = file;
-  m_symfile_up.reset();
   m_did_load_symfile = false;
 }
 
 bool Module::IsExecutable() {
   if (GetObjectFile() == nullptr)
     return false;
   else
     return GetObjectFile()->IsExecutable();

source/Core/PluginManager.cpp

if (name) {
     for (pos = instances.begin(); pos != end; ++pos) {
       if (name == pos->name)
         return pos->create_callback;
     }
   }
   return nullptr;
 }
 
 #pragma mark SymbolVendor
 
-struct SymbolVendorInstance {
-  SymbolVendorInstance() : name(), description(), create_callback(nullptr) {}
-
-  ConstString name;
-  std::string description;
-  SymbolVendorCreateInstance create_callback;
-};
-
-typedef std::vector<SymbolVendorInstance> SymbolVendorInstances;
+typedef std::vector<SymbolVendorCreateInstance> SymbolVendorInstances;
 
 static std::recursive_mutex &GetSymbolVendorMutex() {
   static std::recursive_mutex g_instances_mutex;
   return g_instances_mutex;
 }
 
 static SymbolVendorInstances &GetSymbolVendorInstances() {
   static SymbolVendorInstances g_instances;
   return g_instances;
 }
 
-bool PluginManager::RegisterPlugin(ConstString name,
-                                   const char *description,
-                                   SymbolVendorCreateInstance create_callback) {
+bool PluginManager::RegisterPlugin(SymbolVendorCreateInstance create_callback) {
   if (create_callback) {
-    SymbolVendorInstance instance;
-    assert((bool)name);
-    instance.name = name;
-    if (description && description[0])
-      instance.description = description;
-    instance.create_callback = create_callback;
     std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
-    GetSymbolVendorInstances().push_back(instance);
+    GetSymbolVendorInstances().push_back(create_callback);
   }
   return false;
 }
 
 bool PluginManager::UnregisterPlugin(
     SymbolVendorCreateInstance create_callback) {
   if (create_callback) {
     std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
     SymbolVendorInstances &instances = GetSymbolVendorInstances();
 
     SymbolVendorInstances::iterator pos, end = instances.end();
     for (pos = instances.begin(); pos != end; ++pos) {
-      if (pos->create_callback == create_callback) {
+      if (*pos == create_callback) {
         instances.erase(pos);
         return true;
       }
     }
   }
   return false;
 }
 
 SymbolVendorCreateInstance
 PluginManager::GetSymbolVendorCreateCallbackAtIndex(uint32_t idx) {
   std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
   SymbolVendorInstances &instances = GetSymbolVendorInstances();
   if (idx < instances.size())
-    return instances[idx].create_callback;
-  return nullptr;
-}
-
-SymbolVendorCreateInstance
-PluginManager::GetSymbolVendorCreateCallbackForPluginName(
-    ConstString name) {
-  if (name) {
-    std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
-    SymbolVendorInstances &instances = GetSymbolVendorInstances();
-
-    SymbolVendorInstances::iterator pos, end = instances.end();
-    for (pos = instances.begin(); pos != end; ++pos) {
-      if (name == pos->name)
-        return pos->create_callback;
-    }
-  }
+    return instances[idx];
   return nullptr;
 }
 
 #pragma mark UnwindAssembly
 
 struct UnwindAssemblyInstance {
   UnwindAssemblyInstance() : name(), description(), create_callback(nullptr) {}
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

DebugMapModule(const ModuleSP &exe_module_sp, uint32_t cu_idx,
       : Module(file_spec, arch, object_name, object_offset, object_mod_time),
         m_exe_module_wp(exe_module_sp), m_cu_idx(cu_idx) {}
 
   ~DebugMapModule() override = default;
 
   SymbolFile *
   GetSymbolFile(bool can_create = true,
                 lldb_private::Stream *feedback_strm = nullptr) override {
-    // Scope for locker
-    if (m_symfile_up.get() || !can_create)
-      return m_symfile_up ? m_symfile_up->GetSymbolFile() : nullptr;
+    // If the symbol file has been created already, or we're not allowed to
+    // create it, we are done.
+    SymbolFile *symfile = Module::GetSymbolFile(/*can_create*/ false);
+    if (symfile || !can_create)
+      return symfile;
 
+    // Otherwise, create the file and link it up to the debug map.
     ModuleSP exe_module_sp(m_exe_module_wp.lock());
     if (exe_module_sp) {
       // Now get the object file outside of a locking scope
       ObjectFile *oso_objfile = GetObjectFile();
       if (oso_objfile) {
         std::lock_guard<std::recursive_mutex> guard(m_mutex);
         if (SymbolFile *symfile =
                 Module::GetSymbolFile(can_create, feedback_strm)) {

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolVendor.h"
+#include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Utility/Log.h"
 
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"

source/Plugins/SymbolVendor/ELF/SymbolVendorELF.h

 //===-- SymbolVendorELF.h ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_SymbolVendorELF_h_
 #define liblldb_SymbolVendorELF_h_
 
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/lldb-private.h"
 
 class SymbolVendorELF : public lldb_private::SymbolVendor {
 public:
-  // Constructors and Destructors
-  SymbolVendorELF(const lldb::ModuleSP &module_sp);
-
-  ~SymbolVendorELF() override;
-
   // Static Functions
   static void Initialize();
 
   static void Terminate();
 
-  static lldb_private::ConstString GetPluginNameStatic();
-
-  static const char *GetPluginDescriptionStatic();
-
-  static lldb_private::SymbolVendor *
+  static std::unique_ptr<lldb_private::SymbolFile>
   CreateInstance(const lldb::ModuleSP &module_sp,
                  lldb_private::Stream *feedback_strm);
-
-  // PluginInterface protocol
-  lldb_private::ConstString GetPluginName() override;
-
-  uint32_t GetPluginVersion() override;
-
-private:
-  DISALLOW_COPY_AND_ASSIGN(SymbolVendorELF);
 };
 
 #endif // liblldb_SymbolVendorELF_h_

source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp

 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-// SymbolVendorELF constructor
-SymbolVendorELF::SymbolVendorELF(const lldb::ModuleSP &module_sp)
-    : SymbolVendor(module_sp) {}
-
-// Destructor
-SymbolVendorELF::~SymbolVendorELF() {}
-
 void SymbolVendorELF::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                GetPluginDescriptionStatic(), CreateInstance);
+  PluginManager::RegisterPlugin(CreateInstance);
 }
 
 void SymbolVendorELF::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
-lldb_private::ConstString SymbolVendorELF::GetPluginNameStatic() {
-  static ConstString g_name("ELF");
-  return g_name;
-}
-
-const char *SymbolVendorELF::GetPluginDescriptionStatic() {
-  return "Symbol vendor for ELF that looks for dSYM files that match "
-         "executables.";
-}
-
 // CreateInstance
 //
 // Platforms can register a callback to use when creating symbol vendors to
 // allow for complex debug information file setups, and to also allow for
 // finding separate debug information files.
-SymbolVendor *
+std::unique_ptr<SymbolFile>
 SymbolVendorELF::CreateInstance(const lldb::ModuleSP &module_sp,
                                 lldb_private::Stream *feedback_strm) {
   if (!module_sp)
     return nullptr;
 
   ObjectFileELF *obj_file =
       llvm::dyn_cast_or_null<ObjectFileELF>(module_sp->GetObjectFile());
   if (!obj_file)
SymbolVendorELF::CreateInstance(const lldb::ModuleSP &module_sp,
   if (!dsym_objfile_sp)
     return nullptr;
 
   // This objfile is for debugging purposes. Sadly, ObjectFileELF won't
   // be able to figure this out consistently as the symbol file may not
   // have stripped the code sections, etc.
   dsym_objfile_sp->SetType(ObjectFile::eTypeDebugInfo);
 
-  SymbolVendorELF *symbol_vendor = new SymbolVendorELF(module_sp);
-
   // Get the module unified section list and add our debug sections to
   // that.
   SectionList *module_section_list = module_sp->GetSectionList();
   SectionList *objfile_section_list = dsym_objfile_sp->GetSectionList();
 
   static const SectionType g_sections[] = {
       eSectionTypeDWARFDebugAbbrev,   eSectionTypeDWARFDebugAddr,
       eSectionTypeDWARFDebugAranges,  eSectionTypeDWARFDebugCuIndex,
if (SectionSP section_sp =
               module_section_list->FindSectionByType(section_type, true))
         module_section_list->ReplaceSection(module_section_sp->GetID(),
                                             section_sp);
       else
         module_section_list->AddSection(section_sp);
     }
   }
 
-  symbol_vendor->AddSymbolFileRepresentation(dsym_objfile_sp);
-  return symbol_vendor;
+  return std::unique_ptr<SymbolFile>(
+      SymbolFile::FindPlugin(std::move(dsym_objfile_sp)));
 }
-
-// PluginInterface protocol
-ConstString SymbolVendorELF::GetPluginName() { return GetPluginNameStatic(); }
-
-uint32_t SymbolVendorELF::GetPluginVersion() { return 1; }

source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.h

 
 class SymbolVendorMacOSX : public lldb_private::SymbolVendor {
 public:
   // Static Functions
   static void Initialize();
 
   static void Terminate();
 
-  static lldb_private::ConstString GetPluginNameStatic();
-
-  static const char *GetPluginDescriptionStatic();
-
-  static lldb_private::SymbolVendor *
+  static std::unique_ptr<lldb_private::SymbolFile>
   CreateInstance(const lldb::ModuleSP &module_sp,
                  lldb_private::Stream *feedback_strm);
-
-  // Constructors and Destructors
-  SymbolVendorMacOSX(const lldb::ModuleSP &module_sp);
-
-  virtual ~SymbolVendorMacOSX();
-
-  // PluginInterface protocol
-  virtual lldb_private::ConstString GetPluginName();
-
-  virtual uint32_t GetPluginVersion();
-
-private:
-  DISALLOW_COPY_AND_ASSIGN(SymbolVendorMacOSX);
 };
 
 #endif // liblldb_SymbolVendorMacOSX_h_

source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp

 //===-- SymbolVendorMacOSX.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolVendorMacOSX.h"
 
 #include <string.h>
 
 #include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Section.h"
-#include "lldb/Host/Host.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Target/Target.h"
-#include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-// SymbolVendorMacOSX constructor
-SymbolVendorMacOSX::SymbolVendorMacOSX(const lldb::ModuleSP &module_sp)
-    : SymbolVendor(module_sp) {}
-
-// Destructor
-SymbolVendorMacOSX::~SymbolVendorMacOSX() {}
-
 static bool UUIDsMatch(Module *module, ObjectFile *ofile,
                        lldb_private::Stream *feedback_strm) {
   if (module && ofile) {
     // Make sure the UUIDs match
     lldb_private::UUID dsym_uuid = ofile->GetUUID();
     if (!dsym_uuid) {
       if (feedback_strm) {
         feedback_strm->PutCString(
if (feedback_strm) {
       ofile->GetFileSpec().Dump(feedback_strm);
       feedback_strm->EOL();
     }
   }
   return false;
 }
 
 void SymbolVendorMacOSX::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                GetPluginDescriptionStatic(), CreateInstance);
+  PluginManager::RegisterPlugin(CreateInstance);
 }
 
 void SymbolVendorMacOSX::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
-lldb_private::ConstString SymbolVendorMacOSX::GetPluginNameStatic() {
-  static ConstString g_name("macosx");
-  return g_name;
-}
-
-const char *SymbolVendorMacOSX::GetPluginDescriptionStatic() {
-  return "Symbol vendor for MacOSX that looks for dSYM files that match "
-         "executables.";
-}
-
 // CreateInstance
-//
-// Platforms can register a callback to use when creating symbol vendors to
-// allow for complex debug information file setups, and to also allow for
-// finding separate debug information files.
-SymbolVendor *
+std::unique_ptr<SymbolFile>
 SymbolVendorMacOSX::CreateInstance(const lldb::ModuleSP &module_sp,
                                    lldb_private::Stream *feedback_strm) {
   if (!module_sp)
     return NULL;
 
   ObjectFile *obj_file =
       llvm::dyn_cast_or_null<ObjectFileMachO>(module_sp->GetObjectFile());
   if (!obj_file)
     return NULL;
 
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat,
                      "SymbolVendorMacOSX::CreateInstance (module = %s)",
                      module_sp->GetFileSpec().GetPath().c_str());
-  SymbolVendorMacOSX *symbol_vendor = new SymbolVendorMacOSX(module_sp);
-  if (symbol_vendor) {
-    char path[PATH_MAX];
-    path[0] = '\0';
 
-    // Try and locate the dSYM file on Mac OS X
-    static Timer::Category func_cat2(
-        "SymbolVendorMacOSX::CreateInstance() locate dSYM");
-    Timer scoped_timer2(
-        func_cat2,
-        "SymbolVendorMacOSX::CreateInstance (module = %s) locate dSYM",
-        module_sp->GetFileSpec().GetPath().c_str());
+      func_cat2, "SymbolVendorMacOSX::CreateInstance (module = %s) locate dSYM",
 
-    // First check to see if the module has a symbol file in mind already. If
-    // it does, then we MUST use that.
-    FileSpec dsym_fspec(module_sp->GetSymbolFileFileSpec());
 
-    ObjectFileSP dsym_objfile_sp;
-    if (!dsym_fspec) {
-      // No symbol file was specified in the module, lets try and find one
-      // ourselves.
-      FileSpec file_spec = obj_file->GetFileSpec();
-      if (!file_spec)
-        file_spec = module_sp->GetFileSpec();
 
-      ModuleSpec module_spec(file_spec, module_sp->GetArchitecture());
-      module_spec.GetUUID() = module_sp->GetUUID();
-      FileSpecList search_paths = Target::GetDefaultDebugFileSearchPaths();
-      dsym_fspec =
-          Symbols::LocateExecutableSymbolFile(module_spec, search_paths);
-      if (module_spec.GetSourceMappingList().GetSize())
-        module_sp->GetSourceMappingList().Append(
-            module_spec.GetSourceMappingList(), true);
-    }
+    dsym_fspec = Symbols::LocateExecutableSymbolFile(module_spec, search_paths);
 
-    if (dsym_fspec) {
-      DataBufferSP dsym_file_data_sp;
-      lldb::offset_t dsym_file_data_offset = 0;
-      dsym_objfile_sp =
-          ObjectFile::FindPlugin(module_sp, &dsym_fspec, 0,
-                                 FileSystem::Instance().GetByteSize(dsym_fspec),
-                                 dsym_file_data_sp, dsym_file_data_offset);
-      if (UUIDsMatch(module_sp.get(), dsym_objfile_sp.get(), feedback_strm)) {
-        // We need a XML parser if we hope to parse a plist...
-        if (XMLDocument::XMLEnabled()) {
-          char dsym_path[PATH_MAX];
-          if (module_sp->GetSourceMappingList().IsEmpty() &&
-              dsym_fspec.GetPath(dsym_path, sizeof(dsym_path))) {
-            lldb_private::UUID dsym_uuid = dsym_objfile_sp->GetUUID();
-            if (dsym_uuid) {
-              std::string uuid_str = dsym_uuid.GetAsString();
-              if (!uuid_str.empty()) {
-                char *resources = strstr(dsym_path, "/Contents/Resources/");
-                if (resources) {
-                  char dsym_uuid_plist_path[PATH_MAX];
-                  resources[strlen("/Contents/Resources/")] = '\0';
-                  snprintf(dsym_uuid_plist_path, sizeof(dsym_uuid_plist_path),
-                           "%s%s.plist", dsym_path, uuid_str.c_str());
-                  FileSpec dsym_uuid_plist_spec(dsym_uuid_plist_path);
-                  if (FileSystem::Instance().Exists(dsym_uuid_plist_spec)) {
-                    ApplePropertyList plist(dsym_uuid_plist_path);
-                    if (plist) {
-                      std::string DBGBuildSourcePath;
-                      std::string DBGSourcePath;
+  if (!dsym_fspec)
+    return nullptr;
+
+  dsym_objfile_sp = ObjectFile::FindPlugin(
+      module_sp, &dsym_fspec, 0, FileSystem::Instance().GetByteSize(dsym_fspec),
+  if (!UUIDsMatch(module_sp.get(), dsym_objfile_sp.get(), feedback_strm)) {
+    // Just create our symbol file using the current objfile as this is
+    // either an executable with no dSYM (that we could locate), an executable
+    // with a dSYM that has a UUID that doesn't match.
+    return std::unique_ptr<SymbolFile>(
+        SymbolFile::FindPlugin(obj_file->shared_from_this()));
+  }
+
 
-                      // DBGSourcePathRemapping is a dictionary in the plist
-                      // with keys which are DBGBuildSourcePath file paths and
-                      // values which are DBGSourcePath file paths
 
-                      StructuredData::ObjectSP plist_sp =
-                          plist.GetStructuredData();
-                      if (plist_sp.get() && plist_sp->GetAsDictionary() &&
-                          plist_sp->GetAsDictionary()->HasKey(
-                              "DBGSourcePathRemapping") &&
-                          plist_sp->GetAsDictionary()
-                              ->GetValueForKey("DBGSourcePathRemapping")
-                              ->GetAsDictionary()) {
+                StructuredData::ObjectSP plist_sp = plist.GetStructuredData();
 
-                        // If DBGVersion 1 or DBGVersion missing, ignore DBGSourcePathRemapping.
-                        // If DBGVersion 2, strip last two components of path remappings from
-                        //                  entries to fix an issue with a specific set of
-                        //                  DBGSourcePathRemapping entries that lldb worked
-                        //                  with.
-                        // If DBGVersion 3, trust & use the source path remappings as-is.
-                        //
+                  // If DBGVersion 1 or DBGVersion missing, ignore
+                  // DBGSourcePathRemapping. If DBGVersion 2, strip last two
+                  // components of path remappings from entries to fix an issue
+                  // with a specific set of DBGSourcePathRemapping entries that
+                  // lldb worked with.  If DBGVersion 3, trust & use the source
+                  // path remappings as-is.
 
-                        bool new_style_source_remapping_dictionary = false;
-                        bool do_truncate_remapping_names = false;
-                        std::string original_DBGSourcePath_value =
-                            DBGSourcePath;
-                        if (plist_sp->GetAsDictionary()->HasKey("DBGVersion")) {
-                          std::string version_string =
-                              plist_sp->GetAsDictionary()
-                                  ->GetValueForKey("DBGVersion")
-                                  ->GetStringValue("");
-                          if (!version_string.empty() &&
-                              isdigit(version_string[0])) {
-                            int version_number = atoi(version_string.c_str());
-                            if (version_number > 1) {
-                              new_style_source_remapping_dictionary = true;
-                            }
-                            if (version_number == 2) {
-                                do_truncate_remapping_names = true;
-                            }
-                          }
-                        }
+                  std::string original_DBGSourcePath_value = DBGSourcePath;
+                    if (!version_string.empty() && isdigit(version_string[0])) {
 
-                        StructuredData::Dictionary *remappings_dict =
-                            plist_sp->GetAsDictionary()
-                                ->GetValueForKey("DBGSourcePathRemapping")
-                                ->GetAsDictionary();
-                        remappings_dict->ForEach(
-                            [&module_sp, new_style_source_remapping_dictionary,
-                             original_DBGSourcePath_value, do_truncate_remapping_names](
-                                ConstString key,
-                                StructuredData::Object *object) -> bool {
-                              if (object && object->GetAsString()) {
+                       original_DBGSourcePath_value,
+                       do_truncate_remapping_names](
 
-                                // key is DBGBuildSourcePath
-                                // object is DBGSourcePath
-                                std::string DBGSourcePath =
-                                    object->GetStringValue();
-                                if (!new_style_source_remapping_dictionary &&
-                                    !original_DBGSourcePath_value.empty()) {
-                                  DBGSourcePath = original_DBGSourcePath_value;
-                                }
-                                if (DBGSourcePath[0] == '~') {
-                                  FileSpec resolved_source_path(
-                                      DBGSourcePath.c_str());
-                                  FileSystem::Instance().Resolve(
-                                      resolved_source_path);
-                                  DBGSourcePath =
-                                      resolved_source_path.GetPath();
-                                }
-                                module_sp->GetSourceMappingList().Append(
-                                    key, ConstString(DBGSourcePath), true);
-                                // With version 2 of DBGSourcePathRemapping, we
-                                // can chop off the last two filename parts
-                                // from the source remapping and get a more
-                                // general source remapping that still works.
-                                // Add this as another option in addition to
-                                // the full source path remap.
-                                if (do_truncate_remapping_names) {
-                                  FileSpec build_path(key.AsCString());
-                                  FileSpec source_path(DBGSourcePath.c_str());
-                                  build_path.RemoveLastPathComponent();
-                                  build_path.RemoveLastPathComponent();
-                                  source_path.RemoveLastPathComponent();
-                                  source_path.RemoveLastPathComponent();
-                                  module_sp->GetSourceMappingList().Append(
-                                      ConstString(build_path.GetPath().c_str()),
-                                      ConstString(source_path.GetPath().c_str()), true);
-                                }
-                              }
-                              return true;
-                            });
-                      }
+                          std::string DBGSourcePath = object->GetStringValue();
+                            DBGSourcePath = resolved_source_path.GetPath();
+                                ConstString(source_path.GetPath().c_str()),
+                                true);
 
-                      // If we have a DBGBuildSourcePath + DBGSourcePath pair,
-                      // append those to the source path remappings.
 
-                      plist.GetValueAsString("DBGBuildSourcePath",
-                                             DBGBuildSourcePath);
-                      plist.GetValueAsString("DBGSourcePath", DBGSourcePath);
-                      if (!DBGBuildSourcePath.empty() &&
-                          !DBGSourcePath.empty()) {
-                        if (DBGSourcePath[0] == '~') {
-                          FileSpec resolved_source_path(DBGSourcePath.c_str());
-                          FileSystem::Instance().Resolve(resolved_source_path);
-                          DBGSourcePath = resolved_source_path.GetPath();
-                        }
-                        module_sp->GetSourceMappingList().Append(
-                            ConstString(DBGBuildSourcePath),
-                            ConstString(DBGSourcePath), true);
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
+                if (!DBGBuildSourcePath.empty() && !DBGSourcePath.empty()) {
 
-        symbol_vendor->AddSymbolFileRepresentation(dsym_objfile_sp);
-        return symbol_vendor;
-      }
-    }
-
-    // Just create our symbol vendor using the current objfile as this is
-    // either an executable with no dSYM (that we could locate), an executable
-    // with a dSYM that has a UUID that doesn't match.
-    symbol_vendor->AddSymbolFileRepresentation(obj_file->shared_from_this());
-  }
-  return symbol_vendor;
-}
-
-// PluginInterface protocol
-ConstString SymbolVendorMacOSX::GetPluginName() {
-  return GetPluginNameStatic();
-}
-
-uint32_t SymbolVendorMacOSX::GetPluginVersion() { return 1; }
+  return std::unique_ptr<SymbolFile>(
+      SymbolFile::FindPlugin(std::move(dsym_objfile_sp)));

source/Symbol/SymbolContext.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
+#include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

source/Symbol/SymbolVendor.cpp

 //===-- SymbolVendor.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/SymbolVendor.h"
-
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
-#include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // FindPlugin
 //
 // Platforms can register a callback to use when creating symbol vendors to
 // allow for complex debug information file setups, and to also allow for
 // finding separate debug information files.
-SymbolVendor *SymbolVendor::FindPlugin(const lldb::ModuleSP &module_sp,
-                                       lldb_private::Stream *feedback_strm) {
-  std::unique_ptr<SymbolVendor> instance_up;
+std::unique_ptr<SymbolFile>
+SymbolVendor::FindPlugin(const lldb::ModuleSP &module_sp,
+  std::unique_ptr<SymbolFile> instance_up;
   SymbolVendorCreateInstance create_callback;
 
   for (size_t idx = 0;
        (create_callback = PluginManager::GetSymbolVendorCreateCallbackAtIndex(
             idx)) != nullptr;
        ++idx) {
-    instance_up.reset(create_callback(module_sp, feedback_strm));
+    instance_up = create_callback(module_sp, feedback_strm);
 
-    if (instance_up) {
-      return instance_up.release();
-    }
+    if (instance_up)
+      return instance_up;
   }
   // The default implementation just tries to create debug information using
   // the file representation for the module.
   ObjectFileSP sym_objfile_sp;
   FileSpec sym_spec = module_sp->GetSymbolFileFileSpec();
   if (sym_spec && sym_spec != module_sp->GetObjectFile()->GetFileSpec()) {
     DataBufferSP data_sp;
     offset_t data_offset = 0;
     sym_objfile_sp = ObjectFile::FindPlugin(
         module_sp, &sym_spec, 0, FileSystem::Instance().GetByteSize(sym_spec),
         data_sp, data_offset);
   }
   if (!sym_objfile_sp)
     sym_objfile_sp = module_sp->GetObjectFile()->shared_from_this();
-  instance_up.reset(new SymbolVendor(module_sp));
-  instance_up->AddSymbolFileRepresentation(sym_objfile_sp);
-  return instance_up.release();
-}
-
-// SymbolVendor constructor
-SymbolVendor::SymbolVendor(const lldb::ModuleSP &module_sp)
-    : ModuleChild(module_sp), m_sym_file_up() {}
-
-// Destructor
-SymbolVendor::~SymbolVendor() {}
-
-// Add a representation given an object file.
-void SymbolVendor::AddSymbolFileRepresentation(const ObjectFileSP &objfile_sp) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (objfile_sp)
-      m_sym_file_up.reset(SymbolFile::FindPlugin(objfile_sp));
-  }
+  return std::unique_ptr<SymbolFile>(
+      SymbolFile::FindPlugin(std::move(sym_objfile_sp)));
 }
-
-// PluginInterface protocol
-lldb_private::ConstString SymbolVendor::GetPluginName() {
-  static ConstString g_name("vendor-default");
-  return g_name;
-}
-
-uint32_t SymbolVendor::GetPluginVersion() { return 1; }