Refactor protected virtual functions from SymbolFile into new SymbolFileActual class.

[yinghuitan]

Summary

This is a preparatory patch for https://reviews.llvm.org/D121631.
It refactors protected virtual member functions of SymbolFile
into a new SymbolFileActual class per suggestion in:
https://reviews.llvm.org/D121631

This will avoid the friendship declaration in that patch.

[clayborg]

I might suggest we rename things like suggested in my inline comment, and then have the "SymbolFile.h" class just include the extra needed header file? Many of the changes in this diff would just go away. I am not a fan of the SymbolFileActual class nor having to switch to SymbolFileActual.h. I would almost prefer both SymbolFileActual and SymbolFile to stay in SymbolFile.h.

I will wait for Pavel to chime in as this was his suggestion.

lldb/include/lldb/Symbol/SymbolFile.h

45

Maybe just rename this to SymbolFileInterface, and then rename "SymbolFileActual" to "SymbolFile"?

lldb/include/lldb/Symbol/SymbolFileActual.h

18 ↗

(On Diff #423971)

[labath]

In D124110#3463380, @clayborg wrote:

I might suggest we rename things like suggested in my inline comment, and then have the "SymbolFile.h" class just include the extra needed header file? Many of the changes in this diff would just go away.

Those would be consistent with some existing libraries (e.g. those which use the I prefix to denote pure interfaces), but if the goal is to reduce the number of changes, then I don't think it will help, as pretty much everything should still refer to the objects through the interface name. The name SymbolFileActual should pretty much only be used in the class declaration. but there are many more places that one would need to change from SymbolFile to SymbolFileInterface.

Instead of the name Actual, I might go for Common -- I'm thinking of the class as something that contains implementations "common" to many (but not necessarily all) symbol file classes.

I am not a fan of the SymbolFileActual class nor having to switch to SymbolFileActual.h. I would almost prefer both SymbolFileActual and SymbolFile to stay in SymbolFile.h.

Having SymbolFile.h include the other header would be strange, as the include would have to go to the bottom of the file. I did something like that recently, but only as a temporary transition aid.

However, I don't have a problem with having both classes be defined in the same header file. I don't know if there's any direct reference from SymbolFileOnDemand to SymbolFileActual. Ideally there wouldn't be, but if there is, then that class would also have to be defined in the same file -- also not a tragedy if the file does not get too big.

lldb/include/lldb/Symbol/SymbolFile.h

124–126

The comment probably not necessary. In this setup, there's no way that a non-virtual method can make sense, as there is nothing one could use to implement it.

430–440

What's up with the rest of the members. Can we move these too?
Any member that stays here runs the risk of going out of sync when we have two instances floating around.

[yinghuitan]

Sounds good.

Here are the changes I plan to do:

1. Rename SymbolFileActual => SymbolFileCommon.
2. Inline SymbolFileCommon.h content into SymbolFile.h,
3. Move all remaining member fields of SymbolFile class into SymbolFileCommon.

lldb/include/lldb/Symbol/SymbolFile.h

124–126

Sounds good.

430–440

Sure, I can move them.
I did not do in this patch initially because I want to avoid change too much code and get further feedback.

[yinghuitan]

Address review comments.

[labath]

Yes, that's pretty much what I had in mind. Thanks.

lldb/include/lldb/Symbol/SymbolFile.h

76

= default (or just delete altogether)

[yinghuitan]

Address review comment.

[JDevlieghere]

Before I read the comments I was going to make the same suggestion as Greg, but this makes sense to limit churn. LGMT.

lldb/include/lldb/Symbol/SymbolFile.h

 #if defined(LLDB_CONFIGURATION_DEBUG)
 #define ASSERT_MODULE_LOCK(expr) (expr->AssertModuleLock())
 #else
 #define ASSERT_MODULE_LOCK(expr) ((void)0)
 #endif
 
 namespace lldb_private {
 
+/// Provides public interface for all SymbolFiles. Any protected
+/// virtual members should go into SymbolFileCommon; most SymbolFile
+/// implementations should inherit from SymbolFileCommon to override
+/// the behaviors except SymbolFileOnDemand which inherits
+/// public interfaces from SymbolFile and forward to underlying concrete
+/// SymbolFile implementation.
 class SymbolFile : public PluginInterface {
   /// LLVM RTTI support.
   static char ID;
 
 public:
   /// LLVM RTTI support.
   /// \{
   virtual bool isA(const void *ClassID) const { return ClassID == &ID; }
   static bool classof(const SymbolFile *obj) { return obj->isA(&ID); }
enum Abilities {
     LocalVariables = (1u << 5),
     VariableTypes = (1u << 6),
     kAllAbilities = ((1u << 7) - 1u)
   };
 
   static SymbolFile *FindPlugin(lldb::ObjectFileSP objfile_sp);
 
   // Constructors and Destructors
-  SymbolFile(lldb::ObjectFileSP objfile_sp)
-      : m_objfile_sp(std::move(objfile_sp)) {}
+  SymbolFile() = default;
 
   ~SymbolFile() override = default;
 
   /// Get a mask of what this symbol file supports for the object file
   /// that it was constructed with.
   ///
   /// Each symbol file gets to respond with a mask of abilities that
   /// it supports for each object file. This happens when we are
public:
   /// having more abilities. Any initialization work should be saved
   /// for "void SymbolFile::InitializeObject()" which will get called
   /// on the SymbolFile object with the best set of abilities.
   ///
   /// \return
   ///     A uint32_t mask containing bits from the SymbolFile::Abilities
   ///     enumeration. Any bits that are set represent an ability that
   ///     this symbol plug-in can parse from the object file.
-  uint32_t GetAbilities() {
-    if (!m_calculated_abilities) {
-      m_abilities = CalculateAbilities();
-      m_calculated_abilities = true;
-    }
-
-    return m_abilities;
-  }
-
+  virtual uint32_t GetAbilities() = 0;
   virtual uint32_t CalculateAbilities() = 0;
 
   /// Symbols file subclasses should override this to return the Module that
   /// owns the TypeSystem that this symbol file modifies type information in.
   virtual std::recursive_mutex &GetModuleMutex() const;
 
   /// Initialize the SymbolFile object.
   ///
   /// The SymbolFile object with the best set of abilities (detected
   /// in "uint32_t SymbolFile::GetAbilities()) will have this function
   /// called if it is chosen to parse an object file. More complete
   /// initialization can happen in this function which will get called
   /// prior to any other functions in the SymbolFile protocol.
   virtual void InitializeObject() {}
 
   // Compile Unit function calls
   // Approach 1 - iterator
-  uint32_t GetNumCompileUnits();
-  lldb::CompUnitSP GetCompileUnitAtIndex(uint32_t idx);
+  virtual uint32_t GetNumCompileUnits() = 0;
+  virtual lldb::CompUnitSP GetCompileUnitAtIndex(uint32_t idx) = 0;
 
-  Symtab *GetSymtab();
+  virtual Symtab *GetSymtab() = 0;
 
   virtual lldb::LanguageType ParseLanguage(CompileUnit &comp_unit) = 0;
   /// Return the Xcode SDK comp_unit was compiled against.
   virtual XcodeSDK ParseXcodeSDK(CompileUnit &comp_unit) { return {}; }
   virtual size_t ParseFunctions(CompileUnit &comp_unit) = 0;
   virtual bool ParseLineTable(CompileUnit &comp_unit) = 0;
   virtual bool ParseDebugMacros(CompileUnit &comp_unit) = 0;
 
public:
 
   virtual void GetTypes(lldb_private::SymbolContextScope *sc_scope,
                         lldb::TypeClass type_mask,
                         lldb_private::TypeList &type_list) = 0;
 
   virtual void PreloadSymbols();
 
   virtual llvm::Expected<lldb_private::TypeSystem &>
-  GetTypeSystemForLanguage(lldb::LanguageType language);
+  GetTypeSystemForLanguage(lldb::LanguageType language) = 0;
 
   virtual CompilerDeclContext
   FindNamespace(ConstString name, const CompilerDeclContext &parent_decl_ctx) {
     return CompilerDeclContext();
   }
 
-  ObjectFile *GetObjectFile() { return m_objfile_sp.get(); }
-  const ObjectFile *GetObjectFile() const { return m_objfile_sp.get(); }
-  ObjectFile *GetMainObjectFile();
+  virtual ObjectFile *GetObjectFile() = 0;
+  virtual const ObjectFile *GetObjectFile() const = 0;
+  virtual ObjectFile *GetMainObjectFile() = 0;
 
   virtual std::vector<std::unique_ptr<CallEdge>>
   ParseCallEdgesInFunction(UserID func_id) {
     return {};
   }
 
   virtual void AddSymbols(Symtab &symtab) {}
 
   /// Notify the SymbolFile that the file addresses in the Sections
   /// for this module have been changed.
-  virtual void SectionFileAddressesChanged();
+  virtual void SectionFileAddressesChanged() = 0;
 
   struct RegisterInfoResolver {
     virtual ~RegisterInfoResolver(); // anchor
 
     virtual const RegisterInfo *ResolveName(llvm::StringRef name) const = 0;
     virtual const RegisterInfo *ResolveNumber(lldb::RegisterKind kind,
                                               uint32_t number) const = 0;
   };
   virtual lldb::UnwindPlanSP
   GetUnwindPlan(const Address &address, const RegisterInfoResolver &resolver) {
     return nullptr;
   }
 
   /// Return the number of stack bytes taken up by the parameters to this
   /// function.
   virtual llvm::Expected<lldb::addr_t> GetParameterStackSize(Symbol &symbol) {
     return llvm::createStringError(make_error_code(llvm::errc::not_supported),
                                    "Operation not supported.");
   }
 
-  virtual void Dump(Stream &s);
+  virtual void Dump(Stream &s) = 0;
 
   /// Metrics gathering functions
 
   /// Return the size in bytes of all debug information in the symbol file.
   ///
   /// If the debug information is contained in sections of an ObjectFile, then
   /// this call should add the size of all sections that contain debug
   /// information. Symbols the symbol tables are not considered debug
   /// information for this call to make it easy and quick for this number to be
   /// calculated. If the symbol file is all debug information, the size of the
   /// entire file should be returned. The default implementation of this
   /// function will iterate over all sections in a module and add up their
   /// debug info only section byte sizes.
-  virtual uint64_t GetDebugInfoSize();
+  virtual uint64_t GetDebugInfoSize() = 0;
 
   /// Return the time taken to parse the debug information.
   ///
   /// \returns 0.0 if no information has been parsed or if there is
   /// no computational cost to parsing the debug information.
   virtual StatsDuration::Duration GetDebugInfoParseTime() { return {}; }
 
   /// Return the time it took to index the debug information in the object
public:
   /// from, or saved to the module index cache.
   ///
   /// In statistics it is handy to know if a module's debug info was loaded from
   /// or saved to the cache. When the debug info index is loaded from the cache
   /// startup times can be faster. When the cache is enabled and the debug info
   /// index is saved to the cache, debug sessions can be slower. These accessors
   /// can be accessed by the statistics and emitted to help track these costs.
   /// \{
-  bool GetDebugInfoIndexWasLoadedFromCache() const {
+  virtual bool GetDebugInfoIndexWasLoadedFromCache() const = 0;
+  virtual void SetDebugInfoIndexWasLoadedFromCache() = 0;
+  virtual bool GetDebugInfoIndexWasSavedToCache() const = 0;
+  virtual void SetDebugInfoIndexWasSavedToCache() = 0;
+  /// \}
+
+protected:
+  void AssertModuleLock();
+
+private:
+  SymbolFile(const SymbolFile &) = delete;
+  const SymbolFile &operator=(const SymbolFile &) = delete;
+};
+
+/// Containing protected virtual methods for child classes to override.
+/// Most actual SymbolFile implementations should inherit from this class.
+class SymbolFileCommon : public SymbolFile {
+  /// LLVM RTTI support.
+  static char ID;
+
+public:
+  /// LLVM RTTI support.
+  /// \{
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || SymbolFile::isA(ClassID);
+  }
+  static bool classof(const SymbolFileCommon *obj) { return obj->isA(&ID); }
+  /// \}
+
+  // Constructors and Destructors
+  SymbolFileCommon(lldb::ObjectFileSP objfile_sp)
+      : m_objfile_sp(std::move(objfile_sp)) {}
+
+  ~SymbolFileCommon() override = default;
+
+  uint32_t GetAbilities() override {
+    if (!m_calculated_abilities) {
+      m_abilities = CalculateAbilities();
+      m_calculated_abilities = true;
+    }
+    return m_abilities;
+  }
+
+  Symtab *GetSymtab() override;
+
+  ObjectFile *GetObjectFile() override { return m_objfile_sp.get(); }
+  const ObjectFile *GetObjectFile() const override {
+    return m_objfile_sp.get();
+  }
+  ObjectFile *GetMainObjectFile() override;
+
+  /// Notify the SymbolFile that the file addresses in the Sections
+  /// for this module have been changed.
+  void SectionFileAddressesChanged() override;
+
+  // Compile Unit function calls
+  // Approach 1 - iterator
+  uint32_t GetNumCompileUnits() override;
+  lldb::CompUnitSP GetCompileUnitAtIndex(uint32_t idx) override;
+
+  llvm::Expected<lldb_private::TypeSystem &>
+  GetTypeSystemForLanguage(lldb::LanguageType language) override;
+
+  void Dump(Stream &s) override;
+
+  uint64_t GetDebugInfoSize() override;
+
+  bool GetDebugInfoIndexWasLoadedFromCache() const override {
     return m_index_was_loaded_from_cache;
   }
-  void SetDebugInfoIndexWasLoadedFromCache() {
+  void SetDebugInfoIndexWasLoadedFromCache() override {
     m_index_was_loaded_from_cache = true;
   }
-  bool GetDebugInfoIndexWasSavedToCache() const {
+  bool GetDebugInfoIndexWasSavedToCache() const override {
     return m_index_was_saved_to_cache;
   }
-  void SetDebugInfoIndexWasSavedToCache() {
+  void SetDebugInfoIndexWasSavedToCache() override {
     m_index_was_saved_to_cache = true;
   }
-  /// \}
 
 protected:
-  void AssertModuleLock();
   virtual uint32_t CalculateNumCompileUnits() = 0;
   virtual lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t idx) = 0;
   virtual TypeList &GetTypeList() { return m_type_list; }
-
   void SetCompileUnitAtIndex(uint32_t idx, const lldb::CompUnitSP &cu_sp);
 
   lldb::ObjectFileSP m_objfile_sp; // Keep a reference to the object file in
                                    // case it isn't the same as the module
                                    // object file (debug symbols in a separate
                                    // file)
   llvm::Optional<std::vector<lldb::CompUnitSP>> m_compile_units;
   TypeList m_type_list;
   Symtab *m_symtab = nullptr;
   uint32_t m_abilities = 0;
   bool m_calculated_abilities = false;
   bool m_index_was_loaded_from_cache = false;
   bool m_index_was_saved_to_cache = false;
 
 private:
-  SymbolFile(const SymbolFile &) = delete;
-  const SymbolFile &operator=(const SymbolFile &) = delete;
+  SymbolFileCommon(const SymbolFileCommon &) = delete;
+  const SymbolFileCommon &operator=(const SymbolFileCommon &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_SYMBOLFILE_H

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

 #include "lldb/Symbol/PostfixExpression.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 
 namespace lldb_private {
 
 namespace breakpad {
 
-class SymbolFileBreakpad : public SymbolFile {
+class SymbolFileBreakpad : public SymbolFileCommon {
   /// LLVM RTTI support.
   static char ID;
 
 public:
   /// LLVM RTTI support.
   /// \{
   bool isA(const void *ClassID) const override {
-    return ClassID == &ID || SymbolFile::isA(ClassID);
+    return ClassID == &ID || SymbolFileCommon::isA(ClassID);
   }
   static bool classof(const SymbolFile *obj) { return obj->isA(&ID); }
   /// \}
 
   // Static Functions
   static void Initialize();
   static void Terminate();
   static void DebuggerInitialize(Debugger &debugger) {}
   static llvm::StringRef GetPluginNameStatic() { return "breakpad"; }
 
   static llvm::StringRef GetPluginDescriptionStatic() {
     return "Breakpad debug symbol file reader.";
   }
 
   static SymbolFile *CreateInstance(lldb::ObjectFileSP objfile_sp) {
     return new SymbolFileBreakpad(std::move(objfile_sp));
   }
 
   // Constructors and Destructors
   SymbolFileBreakpad(lldb::ObjectFileSP objfile_sp)
-      : SymbolFile(std::move(objfile_sp)) {}
+      : SymbolFileCommon(std::move(objfile_sp)) {}
 
   ~SymbolFileBreakpad() override = default;
 
   uint32_t CalculateAbilities() override;
 
   void InitializeObject() override {}
 
   // Compile Unit function calls

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

 class DWARFFormValue;
 class DWARFTypeUnit;
 class SymbolFileDWARFDebugMap;
 class SymbolFileDWARFDwo;
 class SymbolFileDWARFDwp;
 
 #define DIE_IS_BEING_PARSED ((lldb_private::Type *)1)
 
-class SymbolFileDWARF : public lldb_private::SymbolFile,
+class SymbolFileDWARF : public lldb_private::SymbolFileCommon,
                         public lldb_private::UserID {
   /// LLVM RTTI support.
   static char ID;
 
 public:
   /// LLVM RTTI support.
   /// \{
   bool isA(const void *ClassID) const override {
-    return ClassID == &ID || SymbolFile::isA(ClassID);
+    return ClassID == &ID || SymbolFileCommon::isA(ClassID);
   }
   static bool classof(const SymbolFile *obj) { return obj->isA(&ID); }
   /// \}
 
   friend class SymbolFileDWARFDebugMap;
   friend class SymbolFileDWARFDwo;
   friend class DebugMapModule;
   friend class DWARFCompileUnit;

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

SymbolFile *SymbolFileDWARF::CreateInstance(ObjectFileSP objfile_sp) {
   return new SymbolFileDWARF(std::move(objfile_sp),
                              /*dwo_section_list*/ nullptr);
 }
 
 TypeList &SymbolFileDWARF::GetTypeList() {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
     return debug_map_symfile->GetTypeList();
-  return SymbolFile::GetTypeList();
+  return SymbolFileCommon::GetTypeList();
 }
 void SymbolFileDWARF::GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset,
                                dw_offset_t max_die_offset, uint32_t type_mask,
                                TypeSet &type_set) {
   if (die) {
     const dw_offset_t die_offset = die.GetOffset();
 
     if (die_offset >= max_die_offset)
default:
       break;
     }
   }
   return DWARFDIE();
 }
 
 SymbolFileDWARF::SymbolFileDWARF(ObjectFileSP objfile_sp,
                                  SectionList *dwo_section_list)
-    : SymbolFile(std::move(objfile_sp)),
+    : SymbolFileCommon(std::move(objfile_sp)),
       UserID(0x7fffffff00000000), // Used by SymbolFileDWARFDebugMap to
                                   // when this class parses .o files to
                                   // contain the .o file index/ID
       m_debug_map_module_wp(), m_debug_map_symfile(nullptr),
       m_context(m_objfile_sp->GetModule()->GetSectionList(), dwo_section_list),
       m_fetched_external_modules(false),
       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
 
SymbolFileDWARF::ParseCallEdgesInFunction(UserID func_id) {
   // would be racy.
   DWARFDIE func_die = GetDIE(func_id.GetID());
   if (func_die.IsValid())
     return CollectCallEdges(GetObjectFile()->GetModule(), func_die);
   return {};
 }
 
 void SymbolFileDWARF::Dump(lldb_private::Stream &s) {
-  SymbolFile::Dump(s);
+  SymbolFileCommon::Dump(s);
   m_index->Dump(s);
 }
 
 void SymbolFileDWARF::DumpClangAST(Stream &s) {
   auto ts_or_err = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus);
   if (!ts_or_err)
     return;
   TypeSystemClang *clang =

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

 #include <vector>
 
 #include "UniqueDWARFASTType.h"
 
 class SymbolFileDWARF;
 class DWARFDebugAranges;
 class DWARFDeclContext;
 
-class SymbolFileDWARFDebugMap : public lldb_private::SymbolFile {
+class SymbolFileDWARFDebugMap : public lldb_private::SymbolFileCommon {
   /// LLVM RTTI support.
   static char ID;
 
 public:
   /// LLVM RTTI support.
   /// \{
   bool isA(const void *ClassID) const override {
-    return ClassID == &ID || SymbolFile::isA(ClassID);
+    return ClassID == &ID || SymbolFileCommon::isA(ClassID);
   }
   static bool classof(const SymbolFile *obj) { return obj->isA(&ID); }
   /// \}
 
   // Static Functions
   static void Initialize();
 
   static void Terminate();

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

llvm::StringRef SymbolFileDWARFDebugMap::GetPluginDescriptionStatic() {
   return "DWARF and DWARF3 debug symbol file reader (debug map).";
 }
 
 SymbolFile *SymbolFileDWARFDebugMap::CreateInstance(ObjectFileSP objfile_sp) {
   return new SymbolFileDWARFDebugMap(std::move(objfile_sp));
 }
 
 SymbolFileDWARFDebugMap::SymbolFileDWARFDebugMap(ObjectFileSP objfile_sp)
-    : SymbolFile(std::move(objfile_sp)), m_flags(), m_compile_unit_infos(),
+    : SymbolFileCommon(std::move(objfile_sp)), m_flags(), m_compile_unit_infos(),
       m_func_indexes(), m_glob_indexes(),
       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
 
 SymbolFileDWARFDebugMap::~SymbolFileDWARFDebugMap() = default;
 
 void SymbolFileDWARFDebugMap::InitializeObject() {}
 
 void SymbolFileDWARFDebugMap::InitOSO() {

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

 } // namespace codeview
 } // namespace llvm
 
 namespace lldb_private {
 
 namespace npdb {
 class PdbAstBuilder;
 
-class SymbolFileNativePDB : public SymbolFile {
+class SymbolFileNativePDB : public SymbolFileCommon {
   friend class UdtRecordCompleter;
 
   /// LLVM RTTI support.
   static char ID;
 
 public:
   /// LLVM RTTI support.
   /// \{
   bool isA(const void *ClassID) const override {
-    return ClassID == &ID || SymbolFile::isA(ClassID);
+    return ClassID == &ID || SymbolFileCommon::isA(ClassID);
   }
   static bool classof(const SymbolFile *obj) { return obj->isA(&ID); }
   /// \}
 
   // Static Functions
   static void Initialize();
 
   static void Terminate();

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

llvm::StringRef SymbolFileNativePDB::GetPluginDescriptionStatic() {
   return "Microsoft PDB debug symbol cross-platform file reader.";
 }
 
 SymbolFile *SymbolFileNativePDB::CreateInstance(ObjectFileSP objfile_sp) {
   return new SymbolFileNativePDB(std::move(objfile_sp));
 }
 
 SymbolFileNativePDB::SymbolFileNativePDB(ObjectFileSP objfile_sp)
-    : SymbolFile(std::move(objfile_sp)) {}
+    : SymbolFileCommon(std::move(objfile_sp)) {}
 
 SymbolFileNativePDB::~SymbolFileNativePDB() = default;
 
 uint32_t SymbolFileNativePDB::CalculateAbilities() {
   uint32_t abilities = 0;
   if (!m_objfile_sp)
     return 0;
 
SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
   }
   return type_system_or_err;
 }
 
 uint64_t SymbolFileNativePDB::GetDebugInfoSize() {
   // PDB files are a separate file that contains all debug info.
   return m_index->pdb().getFileSize();
 }
-

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
 
 class PDBASTParser;
 
-class SymbolFilePDB : public lldb_private::SymbolFile {
+class SymbolFilePDB : public lldb_private::SymbolFileCommon {
   /// LLVM RTTI support.
   static char ID;
 
 public:
   /// LLVM RTTI support.
   /// \{
   bool isA(const void *ClassID) const override {
-    return ClassID == &ID || SymbolFile::isA(ClassID);
+    return ClassID == &ID || SymbolFileCommon::isA(ClassID);
   }
   static bool classof(const SymbolFile *obj) { return obj->isA(&ID); }
   /// \}
 
   // Static Functions
   static void Initialize();
 
   static void Terminate();

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

 }
 
 lldb_private::SymbolFile *
 SymbolFilePDB::CreateInstance(ObjectFileSP objfile_sp) {
   return new SymbolFilePDB(std::move(objfile_sp));
 }
 
 SymbolFilePDB::SymbolFilePDB(lldb::ObjectFileSP objfile_sp)
-    : SymbolFile(std::move(objfile_sp)), m_session_up(), m_global_scope_up() {}
+    : SymbolFileCommon(std::move(objfile_sp)), m_session_up(), m_global_scope_up() {}
 
 SymbolFilePDB::~SymbolFilePDB() = default;
 
 uint32_t SymbolFilePDB::CalculateAbilities() {
   uint32_t abilities = 0;
   if (!m_objfile_sp)
     return 0;
 

lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_SYMTAB_SYMBOLFILESYMTAB_H
 
 #include <map>
 #include <vector>
 
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/Symtab.h"
 
-class SymbolFileSymtab : public lldb_private::SymbolFile {
+class SymbolFileSymtab : public lldb_private::SymbolFileCommon {
   /// LLVM RTTI support.
   static char ID;
 
 public:
   /// LLVM RTTI support.
   /// \{
   bool isA(const void *ClassID) const override {
-    return ClassID == &ID || SymbolFile::isA(ClassID);
+    return ClassID == &ID || SymbolFileCommon::isA(ClassID);
   }
   static bool classof(const SymbolFile *obj) { return obj->isA(&ID); }
   /// \}
 
   // Constructors and Destructors
   SymbolFileSymtab(lldb::ObjectFileSP objfile_sp);
 
   // Static Functions

lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

SymbolFile *SymbolFileSymtab::CreateInstance(ObjectFileSP objfile_sp) {
   return new SymbolFileSymtab(std::move(objfile_sp));
 }
 
 void SymbolFileSymtab::GetTypes(SymbolContextScope *sc_scope,
                                 TypeClass type_mask,
                                 lldb_private::TypeList &type_list) {}
 
 SymbolFileSymtab::SymbolFileSymtab(ObjectFileSP objfile_sp)
-    : SymbolFile(std::move(objfile_sp)), m_source_indexes(), m_func_indexes(),
-      m_code_indexes(), m_objc_class_name_to_index() {}
+    : SymbolFileCommon(std::move(objfile_sp)), m_source_indexes(),
+      m_func_indexes(), m_code_indexes(), m_objc_class_name_to_index() {}
 
 uint32_t SymbolFileSymtab::CalculateAbilities() {
   uint32_t abilities = 0;
   if (m_objfile_sp) {
     const Symtab *symtab = m_objfile_sp->GetSymtab();
     if (symtab) {
       // The snippet of code below will get the indexes the module symbol table
       // entries that are code, data, or function related (debug info), sort

lldb/source/Symbol/SymbolFile.cpp

 #include "lldb/lldb-private.h"
 
 #include <future>
 
 using namespace lldb_private;
 using namespace lldb;
 
 char SymbolFile::ID;
+char SymbolFileCommon::ID;
 
 void SymbolFile::PreloadSymbols() {
   // No-op for most implementations.
 }
 
 std::recursive_mutex &SymbolFile::GetModuleMutex() const {
   return GetObjectFile()->GetModule()->GetMutex();
 }
-ObjectFile *SymbolFile::GetMainObjectFile() {
-  return m_objfile_sp->GetModule()->GetObjectFile();
-}
 
 SymbolFile *SymbolFile::FindPlugin(ObjectFileSP objfile_sp) {
   std::unique_ptr<SymbolFile> best_symfile_up;
   if (objfile_sp != nullptr) {
 
     // We need to test the abilities of this section list. So create what it
     // would be with this new objfile_sp.
     lldb::ModuleSP module_sp(objfile_sp->GetModule());
if (best_symfile_up) {
       // Let the winning symbol file parser initialize itself more completely
       // now that it has been chosen
       best_symfile_up->InitializeObject();
     }
   }
   return best_symfile_up.release();
 }
 
-llvm::Expected<TypeSystem &>
-SymbolFile::GetTypeSystemForLanguage(lldb::LanguageType language) {
-  auto type_system_or_err =
-      m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
-  if (type_system_or_err) {
-    type_system_or_err->SetSymbolFile(this);
-  }
-  return type_system_or_err;
-}
-
 uint32_t
 SymbolFile::ResolveSymbolContext(const SourceLocationSpec &src_location_spec,
                                  lldb::SymbolContextItem resolve_scope,
                                  SymbolContextList &sc_list) {
   return 0;
 }
 
 void SymbolFile::FindGlobalVariables(ConstString name,
assert(std::async(
              std::launch::async,
              [this] {
                return this->GetModuleMutex().try_lock();
              }).get() == false &&
          "Module is not locked");
 #endif
 }
 
-uint32_t SymbolFile::GetNumCompileUnits() {
+SymbolFile::RegisterInfoResolver::~RegisterInfoResolver() = default;
+
+Symtab *SymbolFileCommon::GetSymtab() {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
+  if (m_symtab)
+    return m_symtab;
+
+  // Fetch the symtab from the main object file.
+  m_symtab = GetMainObjectFile()->GetSymtab();
+
+  // Then add our symbols to it.
+  if (m_symtab)
+    AddSymbols(*m_symtab);
+
+  return m_symtab;
+}
+
+ObjectFile *SymbolFileCommon::GetMainObjectFile() {
+  return m_objfile_sp->GetModule()->GetObjectFile();
+}
+
+void SymbolFileCommon::SectionFileAddressesChanged() {
+  ObjectFile *module_objfile = GetMainObjectFile();
+  ObjectFile *symfile_objfile = GetObjectFile();
+  if (symfile_objfile != module_objfile)
+    symfile_objfile->SectionFileAddressesChanged();
+  if (m_symtab)
+    m_symtab->SectionFileAddressesChanged();
+}
+
+uint32_t SymbolFileCommon::GetNumCompileUnits() {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!m_compile_units) {
     // Create an array of compile unit shared pointers -- which will each
     // remain NULL until someone asks for the actual compile unit information.
     m_compile_units.emplace(CalculateNumCompileUnits());
   }
   return m_compile_units->size();
 }
 
-CompUnitSP SymbolFile::GetCompileUnitAtIndex(uint32_t idx) {
+CompUnitSP SymbolFileCommon::GetCompileUnitAtIndex(uint32_t idx) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   uint32_t num = GetNumCompileUnits();
   if (idx >= num)
     return nullptr;
   lldb::CompUnitSP &cu_sp = (*m_compile_units)[idx];
   if (!cu_sp)
     cu_sp = ParseCompileUnitAtIndex(idx);
   return cu_sp;
 }
 
-void SymbolFile::SetCompileUnitAtIndex(uint32_t idx, const CompUnitSP &cu_sp) {
+void SymbolFileCommon::SetCompileUnitAtIndex(uint32_t idx,
+                                             const CompUnitSP &cu_sp) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   const size_t num_compile_units = GetNumCompileUnits();
   assert(idx < num_compile_units);
   (void)num_compile_units;
 
   // Fire off an assertion if this compile unit already exists for now. The
   // partial parsing should take care of only setting the compile unit
   // once, so if this assertion fails, we need to make sure that we don't
   // have a race condition, or have a second parse of the same compile
   // unit.
   assert((*m_compile_units)[idx] == nullptr);
   (*m_compile_units)[idx] = cu_sp;
 }
 
-Symtab *SymbolFile::GetSymtab() {
-  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  if (m_symtab)
-    return m_symtab;
-
-  // Fetch the symtab from the main object file.
-  m_symtab = GetMainObjectFile()->GetSymtab();
-
-  // Then add our symbols to it.
-  if (m_symtab)
-    AddSymbols(*m_symtab);
-
-  return m_symtab;
+llvm::Expected<TypeSystem &>
+SymbolFileCommon::GetTypeSystemForLanguage(lldb::LanguageType language) {
+  auto type_system_or_err =
+      m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
+  if (type_system_or_err) {
+    type_system_or_err->SetSymbolFile(this);
+  }
+  return type_system_or_err;
 }
 
-void SymbolFile::SectionFileAddressesChanged() {
-  ObjectFile *module_objfile = GetMainObjectFile();
-  ObjectFile *symfile_objfile = GetObjectFile();
-  if (symfile_objfile != module_objfile)
-    symfile_objfile->SectionFileAddressesChanged();
-  if (m_symtab)
-    m_symtab->SectionFileAddressesChanged();
+uint64_t SymbolFileCommon::GetDebugInfoSize() {
+  if (!m_objfile_sp)
+    return 0;
+  ModuleSP module_sp(m_objfile_sp->GetModule());
+  if (!module_sp)
+    return 0;
+  const SectionList *section_list = module_sp->GetSectionList();
+  if (section_list)
+    return section_list->GetDebugInfoSize();
+  return 0;
 }
 
-void SymbolFile::Dump(Stream &s) {
+void SymbolFileCommon::Dump(Stream &s) {
   s.Format("SymbolFile {0} ({1})\n", GetPluginName(),
            GetMainObjectFile()->GetFileSpec());
   s.PutCString("Types:\n");
   m_type_list.Dump(&s, /*show_context*/ false);
   s.PutChar('\n');
 
   s.PutCString("Compile units:\n");
   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;
-
-uint64_t SymbolFile::GetDebugInfoSize() {
-  if (!m_objfile_sp)
-    return 0;
-  ModuleSP module_sp(m_objfile_sp->GetModule());
-  if (!module_sp)
-    return 0;
-  const SectionList *section_list = module_sp->GetSectionList();
-  if (section_list)
-    return section_list->GetDebugInfoSize();
-  return 0;
-}