[NFC] Refactor symbol table parsing.

[clayborg]

Summary

Symbol table parsing has evolved over the years and many plug-ins contained duplicate code in the ObjectFile::GetSymtab() that used to be pure virtual. With this change, the "Symbtab *ObjectFile::GetSymtab()" is no longer virtual and will end up calling a new "void ObjectFile::ParseSymtab(Symtab &symtab)" pure virtual function to actually do the parsing. This helps centralize the code for parsing the symbol table and allows the ObjectFile base class to do all of the common work, like taking the necessary locks and creating the symbol table object itself. Plug-ins now just need to parse when they are asked to parse as the ParseSymtab function will only get called once.

This is a retry of the original patch https://reviews.llvm.org/D113965 which was reverted. There was a deadlock in the Manual DWARF indexing code during symbol preloading where the module was asked on the main thread to preload its symbols, and this would in turn cause the DWARF manual indexing to use a thread pool to index all of the compile units, and if there were relocations on the debug information sections, these threads could ask the ObjectFile to load section contents, which could cause a call to ObjectFileELF::RelocateSection() which would ask for the symbol table from the module and it would deadlock. We can't lock the module in ObjectFile::GetSymtab(), so the solution I am using is to use a llvm::once_flag to create the symbol table object once and then lock the Symtab object. Since all APIs on the symbol table use this lock, this will prevent anyone from using the symbol table before it is parsed and finalized and will avoid the deadlock I mentioned. ObjectFileELF::GetSymtab() was never locking the module lock before and would put off creating the symbol table until somewhere inside ObjectFileELF::GetSymtab(). Now we create it one time inside of the ObjectFile::GetSymtab() and immediately lock it which should be safe enough. This avoids the deadlocks and still provides safety.

[labath]

I don't believe this solution is correct.

How did this work before? Is it because ObjectFileELF::GetSymtab contained the same (incorrect) unique_ptr pattern?

How about we just prime the symtab (or whatever is needed) before we start the thread pool indexing?

lldb/source/Symbol/ObjectFile.cpp

723

This is not true. unique_ptr makes no guarantees about the safety of concurrent accesses to a single unique_ptr object. While this may work on current hardware (it will most likely work on x86), it will make tsan very unhappy.

[clayborg]

In D114288#3149188, @labath wrote:

I don't believe this solution is correct.

How did this work before? Is it because ObjectFileELF::GetSymtab contained the same (incorrect) unique_ptr pattern?

It did, but because each ObjectFile subclass did things there own way, it worked only because ObjectFileELF was never taking the module lock to begin with. All others object files did.

How about we just prime the symtab (or whatever is needed) before we start the thread pool indexing?

Doesn't work, I tried that. The problem is the way the .dwo file stuff currently works. With some of the tests, we are loading a .dwo file as the main module. In this cause we end up with a target module, then ends up opening up a ".dwo" module as a _separate_ object file in the DWO support in the DWARF classes (not the same ObjectFile that the target Module has, but a different one), but this extra object file is saying its module is the main module. I didn't make any of the DWO changes to our DWARF classes, so I am still coming up to speed with why this weird case where two different object files claim the same module is their owning module. It is probably because of the way the test was written. But that being said, we should be able to load the .dwo files as a main module to inspect what we can out of them. Do all .dwo files claim the main executable that references them is their owning module? If so, many other deadlocks can happen during indexing.

Regardless of this problem, the DWARF indexing has caused deadlocks before due to the module lock. Like the the Module::GetDescription(...) when we enabled DWARF logging. So even if we solve this one problem, we can run into it again the next time DWARF indexing causes some file to load/fetch something. For many of the things inside of the module that are populated once (section list, symbol table, etc), we will run into issues with any threading code do the module lock.

One way to possibly fix this is to stop the Module class from using the mutex when populating these "compute once and then hand out an object" and have them use a llvm::once_flag as a member variable to control access. We might need to pull the same trick I do with the ObjectFile where the llvm::once_flag is put into a std::unique_ptr<llvm::once_flag> so it can be cleared if the this object that has handed out can be cleared or changed (like the trick I used in ObjectFile::ClearSymtab()).

So the fix is not straight forward if we aren't comfortable with relying on the Symtab mutex to protect the symbol table that I proposed in this patch.

[labath]

In D114288#3152709, @clayborg wrote:

Do all .dwo files claim the main executable that references them is their owning module?

The short answer is "yes".

The reason for that is that the dwo files do not constitute a module in the normal sense (not even in the sense that is used by DebugMapModule in SymbolFileDWARFDebugMap). In contains some debug info, but only a part of it, and that part is meaningless without the information in the main file. Like, you can (syntactically) parse the DIE tree, but you won't be able to resolve any of the addresses contained therein. In an DebugMap module, the addresses will resolve to sections of the .o file, and then there's a separate fixup step (independent of dwarf) to remap them to the main file. OTOH, in a dwo file you just get nothing.

*However*, dwo files are still regular (elf) object files, and the object file component can be parsed independently of anything else. In this sense, it would be reasonable to create a separate module for them, to ensure their isolation. In fact, we currently need to jump through some hoops to ensure that the dwo object information does not leak into the main module (see the update_module_section_list argument to ObjectFile::GetSectionList). Having a separate Module object would remove the need for that.

Overall, in either case (a separate module or not) some part of the interface will end up being weird (a separate module is better for the object file class, a single module for the symbol file). It's possible the overall messiness would be reduced in the separate module version, but it's hard to say without trying to implement that.

However, maybe we don't figure that out now. See the inline comment.

lldb/source/Symbol/ObjectFile.cpp

723

That said, I think the fix could be as simple removing these two lines. call_once already has a fast path for already-initialized case, anyway, and going through the call_once function would ensure that a unique_ptr read cannot happen concurrently with any write to it.

[clayborg]

Let the call_once protect the ObjectFile::m_symtab_up as suggested.

[omjavaid]

Hi @clayborg
This breaks LLDB Arm/Linux buildbot. https://lab.llvm.org/buildbot/#/builders/17/builds/14035

[clayborg]

In D114288#3163808, @omjavaid wrote:

Hi @clayborg
This breaks LLDB Arm/Linux buildbot. https://lab.llvm.org/buildbot/#/builders/17/builds/14035

I will check this out on linux. Any reason why I did not get a message to my email that this was failing?

[clayborg]

In D114288#3165212, @clayborg wrote:

In D114288#3163808, @omjavaid wrote:

Hi @clayborg
This breaks LLDB Arm/Linux buildbot. https://lab.llvm.org/buildbot/#/builders/17/builds/14035

I will check this out on linux. Any reason why I did not get a message to my email that this was failing?

I checked this out on normal linux and it passes correctly.

I modified the test file to dump more input context so we can see what is going on on the lldb-arm-ubuntu buildbots in the error output with:

commit 266a66c915cbbc36b1a3887963eb97f32306c7e4 (HEAD -> main, origin/main, origin/HEAD)
Author: Greg Clayton <[e-mail]>
Date: Thu Dec 2 15:47:15 2021 -0800

Include extra input contents on this test so we can see why lldb-arm-ubuntu buildbot is failing.

Only lldb-arm-ubuntu is failing after https://reviews.llvm.org/D114288 and there isn't enough input context to see why this is failing. It works on x86_64 linux just fine.

[clayborg]

Thanks for doing that! I was able to successfully run the test on linux, and then I added extra context to the stop. It seems that the two breakpoints are set correctly, but the second breakpoint is not hit and the program exits. So all is good from the symbol table changes as far as I have been able to tell since both breakpoints were set. Below is the extra output that shows the first breakpoint was hit, and then we continue and don't hit the second breakpoint, but we do exit with the correct exit status of 12, so the program isn't crashing. In the lines below we now can see after the "continue" command, that is just exits with the expect statu of 12 (which is argc == 1 and it multiplies it by 3 and then by 4). I am happy to help look at this. If you can send a copy of the arm "minidebuginfo-set-and-hit-breakpoint.test.tmp.binary" binary I might be able to see what is going on.

 1: (lldb) command source -s 0 '/home/tcwg-buildslave/worker/lldb-arm-ubuntu/build/tools/lldb/test/Shell/lit-lldb-init' 
 2: Executing commands in '/home/tcwg-buildslave/worker/lldb-arm-ubuntu/build/tools/lldb/test/Shell/lit-lldb-init'. 
 3: (lldb) # LLDB init file for the LIT tests. 
 4: (lldb) settings set symbols.enable-external-lookup false 
 5: (lldb) settings set plugin.process.gdb-remote.packet-timeout 60 
 6: (lldb) settings set interpreter.echo-comment-commands false 
 7: (lldb) settings set symbols.clang-modules-cache-path "/home/tcwg-buildslave/worker/lldb-arm-ubuntu/build/lldb-test-build.noindex/module-cache-lldb" 
 8: (lldb) settings set target.auto-apply-fixits false 
 9: (lldb) settings set target.inherit-tcc true 
10: (lldb) settings set target.detach-on-error false 
11: (lldb) target create "/home/tcwg-buildslave/worker/lldb-arm-ubuntu/build/tools/lldb/test/Shell/ObjectFile/ELF/Output/minidebuginfo-set-and-hit-breakpoint.test.tmp.binary" 
12: Current executable set to '/home/tcwg-buildslave/worker/lldb-arm-ubuntu/build/tools/lldb/test/Shell/ObjectFile/ELF/Output/minidebuginfo-set-and-hit-breakpoint.test.tmp.binary' (arm). 
13: (lldb) b multiplyByThree 
14: Breakpoint 1: where = minidebuginfo-set-and-hit-breakpoint.test.tmp.binary`multiplyByThree, address = 0x00010440 
15: (lldb) b multiplyByFour 
16: Breakpoint 2: where = minidebuginfo-set-and-hit-breakpoint.test.tmp.binary`multiplyByFour, address = 0x00010428 
17: (lldb) run 
18: Process 3530626 stopped 
19: * thread #1, name = 'minidebuginfo-s', stop reason = breakpoint 1.1

check:71'0 X error: no match found

20:  frame #0: 0x00010440 minidebuginfo-set-and-hit-breakpoint.test.tmp.binary`multiplyByThree

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
check:71'1 ? possible intended match

21: minidebuginfo-set-and-hit-breakpoint.test.tmp.binary`multiplyByThree:

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

22: -> 0x10440 <+0>: sub sp, sp, #4

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

23:  0x10444 <+4>: str r0, [sp]

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

24:  0x10448 <+8>: ldr r0, [sp]

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

25:  0x1044c <+12>: movw r1, #0x3

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

26: Process 3530626 launched: '/home/tcwg-buildslave/worker/lldb-arm-ubuntu/build/tools/lldb/test/Shell/ObjectFile/ELF/Output/minidebuginfo-set-and-hit-breakpoint.test.tmp.binary' (arm)

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

27: (lldb) continue

check:71'0 ~~~~~~~~~~~~~~~~

28: Process 3530626 resuming

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~

29: Process 3530626 exited with status = 12 (0x0000000c)

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

30: (lldb) breakpoint list -v

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~~

31: Current breakpoints:

check:71'0 ~~~~~~~~~~~~~~~~~~~~~

32: 1: name = 'multiplyByThree'

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

33:  1.1:

check:71'0 ~~~~~~~

34:  module = /home/tcwg-buildslave/worker/lldb-arm-ubuntu/build/tools/lldb/test/Shell/ObjectFile/ELF/Output/minidebuginfo-set-and-hit-breakpoint.test.tmp.binary

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

35:  symbol = multiplyByThree

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~~~~~

36:  address = 0x00010440

check:71'0 ~~~~~~~~~~~~~~~~~~~~~~

37:  resolved = true

check:71'0 ~~~~~~~~~~~~~~~~~

38:  hardware = false

check:71'0 ~~~~~~~~~~~~~~~~~~

39:  hit count = 1

check:71'0 ~~~~~~~~~~~~~~~~

40:

check:71'0 ~

[kastiglione]

lldb/source/Symbol/ObjectFile.cpp

739

During expression evaluation, I am hitting a deadlock where a reentrant call to ObjectFile::GetSymtab is happening with he same once_flag, causing it to block. This is macOS/arm64.

Here's a (simplified) stack:

frame #4: void llvm::call_once<lldb_private::ObjectFile::GetSymtab()::$_0>(flag=0x..., F=0x...)::$_0&&) at Threading.h:89
frame #5: lldb_private::ObjectFile::GetSymtab(this=0x...) at ObjectFile.cpp:758
frame #6: SymbolFileSymtab::CalculateAbilities(this=0x...) at SymbolFileSymtab.cpp:60
frame #7: lldb_private::SymbolFile::GetAbilities(this=0x...) at SymbolFile.h:105
frame #8: lldb_private::SymbolFile::FindPlugin(objfile_sp=std::shared_ptr<lldb_private::ObjectFile>::element_type @ 0x... strong=7 weak=2) at SymbolFile.cpp:72
frame #9: lldb_private::SymbolVendor::AddSymbolFileRepresentation(this=0x..., objfile_sp=std::shared_ptr<lldb_private::ObjectFile>::element_type @ 0x... strong=7 weak=2) at SymbolVendor.cpp:71
frame #10:`lldb_private::SymbolVendor::FindPlugin(module_sp=std::shared_ptr<lldb_private::Module>::element_type @ 0x... strong=12 weak=12, feedback_strm=0x...) at SymbolVendor.cpp:57
frame #11:`lldb_private::Module::GetSymbolFile(this=0x..., can_create=true, feedback_strm=0x...) at Module.cpp:1070
frame #12:`lldb_private::Module::FindFunctions(this=0x..., name="$s17_StringProcessing14AnyRegexOutputVMa", parent_decl_ctx=0x..., name_type_mask=eFunctionNameTypeFull, options=0x..., sc_list=0x...) at Module.cpp:830
frame #13:`lldb_private::ModuleList::FindFunctions(this=0x..., name="$s17_StringProcessing14AnyRegexOutputVMa", name_type_mask=eFunctionNameTypeFull, options=0x..., sc_list=0x...) const at ModuleList.cpp:512
frame #14:`lldb_private::IRExecutionUnit::FindInSymbols(this=0x..., names=size=2, sc=0x..., symbol_was_missing_weak=0x...) at IRExecutionUnit.cpp:841
frame #15:`lldb_private::IRExecutionUnit::FindSymbol(this=0x..., name="_$s17_StringProcessing14AnyRegexOutputVMa", missing_weak=0x...) at IRExecutionUnit.cpp:913
frame #16:`lldb_private::IRExecutionUnit::MemoryManager::GetSymbolAddressAndPresence(this=0x..., Name="_$s17_StringProcessing14AnyRegexOutputVMa", missing_weak=0x...) at IRExecutionUnit.cpp:1008
frame #17:`lldb_private::IRExecutionUnit::MemoryManager::findSymbol(this=0x..., Name="_$s17_StringProcessing14AnyRegexOutputVMa") at IRExecutionUnit.cpp:986
frame #18:`llvm::LinkingSymbolResolver::findSymbol(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) + 128
frame #19:`llvm::LegacyJITSymbolResolver::lookup(std::set<llvm::StringRef, std::less<llvm::StringRef>, std::allocator<llvm::StringRef> > const&, llvm::unique_function<void (llvm::Expected<std::map<llvm::StringRef, llvm::JITEvaluatedSymbol, std::less<llvm::StringRef>, std::allocator<std::pair<llvm::StringRef const, llvm::JITEvaluatedSymbol> > > >)>) + 308
frame #20:`llvm::RuntimeDyldImpl::resolveExternalSymbols() + 708
frame #21:`llvm::RuntimeDyldImpl::resolveRelocations() + 248
frame #22:`llvm::MCJIT::finalizeLoadedModules() + 56
frame #23:`llvm::MCJIT::getGlobalValueAddress(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) + 68
frame #24:`lldb_private::IRExecutionUnit::PopulateSymtab(this=0x..., obj_file=0x..., symtab=0x...) at IRExecutionUnit.cpp:1244
frame #25:`ObjectFileJIT::ParseSymtab(this=0x..., symtab=0x...) at ObjectFileJIT.cpp:112
frame #26:`lldb_private::ObjectFile::GetSymtab(this=0x...)::$_0::operator()() const at ObjectFile.cpp:764
frame #27:`decltype(__f=0x...)::$_0>(fp)()) std::__invoke<lldb_private::ObjectFile::GetSymtab()::$_0>(lldb_private::ObjectFile::GetSymtab()::$_0&&) at type_traits:3918
frame #28:`void std::__call_once_param<std::tuple<lldb_private::ObjectFile::GetSymtab()::$_0&&> >::__execute<>(this=0x..., (null)=__tuple_indices<> @ 0x...) at mutex:630
frame #29:`std::__call_once_param<std::tuple<lldb_private::ObjectFile::GetSymtab()::$_0&&> >::operator(this=0x...)() at mutex:622
frame #30:`void std::__call_once_proxy<std::tuple<lldb_private::ObjectFile::GetSymtab()::$_0&&> >(__vp=0x...) at mutex:658
frame #31:++.1.dylib`std::__call_once(unsigned long volatile&, void*, void (*)(void*)) + 180
frame #32:`void std::call_once<lldb_private::ObjectFile::GetSymtab()::$_0>(__flag=0x..., __func=0x...)::$_0&&) at mutex:676
frame #33:`void llvm::call_once<lldb_private::ObjectFile::GetSymtab()::$_0>(flag=0x..., F=0x...)::$_0&&) at Threading.h:89
frame #34:`lldb_private::ObjectFile::GetSymtab(this=0x...) at ObjectFile.cpp:758

[kastiglione]

@clayborg friendly ping

[clayborg]

In D114288#3781084, @kastiglione wrote:

@clayborg friendly ping

Do you have an repro case that will show this issue? I would need to debug it. The main issue is ObjectFileJIT::ParseSymtab() is doing global lookups when it is creating it's own symbol table, which causes the deadlock

[kastiglione]

Do you have an repro case that will show this issue? I would need to debug it.

@clayborg sorry for the late reply. The repro happened to me while debugging some Swift:

func main() {
    let digits = /\d+/
    let match = "abc123".firstMatch(of: digits)
    // stop here
}

at the stop command, I ran p match?.anyRegexOutput which causes the deadlock.

lldb/include/lldb/Symbol/ObjectFile.h

 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/UnwindTable.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-private.h"
+#include "llvm/Support/Threading.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class ObjectFileJITDelegate {
 public:
   ObjectFileJITDelegate() = default;
 
public:
 
   /// Notify the ObjectFile that the file addresses in the Sections for this
   /// module have been changed.
   virtual void SectionFileAddressesChanged() {}
 
   /// Gets the symbol table for the currently selected architecture (and
   /// object for archives).
   ///
-  /// Symbol table parsing can be deferred by ObjectFile instances until this
-  /// accessor is called the first time.
+  /// This function will manage when ParseSymtab(...) is called to actually do
+  /// the symbol table parsing in each plug-in. This function will take care of
+  /// taking all the necessary locks and finalizing the symbol table when the
+  /// symbol table does get parsed.
   ///
   /// \return
   ///     The symbol table for this object file.
-  virtual Symtab *GetSymtab() = 0;
+  Symtab *GetSymtab();
+
+  /// Parse the symbol table into the provides symbol table object.
+  ///
+  /// Symbol table parsing will be done once when this function is called by
+  /// each object file plugin. All of the necessary locks will already be
+  /// acquired before this function is called and the symbol table object to
+  /// populate is supplied as an argument and doesn't need to be created by
+  /// each plug-in.
+  ///
+  /// \param
+  ///     The symbol table to populate.
+  virtual void ParseSymtab(Symtab &symtab) = 0;
 
   /// Perform relocations on the section if necessary.
   ///
   virtual void RelocateSection(lldb_private::Section *section);
 
   /// Appends a Symbol for the specified so_addr to the symbol table.
   ///
   /// If verify_unique is false, the symbol table is not searched to determine
lldb::addr_t m_length; ///< The length of this object file if it is known (can
                          ///be zero if length is unknown or can't be
                          ///determined).
   DataExtractor
       m_data; ///< The data for this object file so things can be parsed lazily.
   lldb::ProcessWP m_process_wp;
   const lldb::addr_t m_memory_addr;
   std::unique_ptr<lldb_private::SectionList> m_sections_up;
   std::unique_ptr<lldb_private::Symtab> m_symtab_up;
-  uint32_t m_synthetic_symbol_idx;
+  /// We need a llvm::once_flag that we can use to avoid locking the module
+  /// lock and deadlocking LLDB. See comments in ObjectFile::GetSymtab() for
+  /// the full details. We also need to be able to clear the symbol table, so we
+  /// need to use a std::unique_ptr to a llvm::once_flag so if we clear the
+  /// symbol table, we can have a new once flag to use when it is created again.
+  std::unique_ptr<llvm::once_flag> m_symtab_once_up;
 
   /// Sets the architecture for a module.  At present the architecture can
   /// only be set if it is invalid.  It is not allowed to switch from one
   /// concrete architecture to another.
   ///
   /// \param[in] new_arch
   ///     The architecture this module will be set to.
   ///

lldb/include/lldb/Symbol/Symtab.h

Symbol *FindFirstSymbolWithNameAndType(ConstString name,
                                          Debug symbol_debug_type,
                                          Visibility symbol_visibility);
   Symbol *FindSymbolAtFileAddress(lldb::addr_t file_addr);
   Symbol *FindSymbolContainingFileAddress(lldb::addr_t file_addr);
   void ForEachSymbolContainingFileAddress(
       lldb::addr_t file_addr, std::function<bool(Symbol *)> const &callback);
   void FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
                            SymbolContextList &sc_list);
-  void CalculateSymbolSizes();
 
   void SortSymbolIndexesByValue(std::vector<uint32_t> &indexes,
                                 bool remove_duplicates) const;
 
   static void DumpSymbolHeader(Stream *s);
 
-  void Finalize() {
-    // Shrink to fit the symbols so we don't waste memory
-    if (m_symbols.capacity() > m_symbols.size()) {
-      collection new_symbols(m_symbols.begin(), m_symbols.end());
-      m_symbols.swap(new_symbols);
-    }
-  }
+  void Finalize();
 
   void AppendSymbolNamesToMap(const IndexCollection &indexes,
                               bool add_demangled, bool add_mangled,
                               NameToIndexMap &name_to_index_map) const;
 
   ObjectFile *GetObjectFile() { return m_objfile; }
 
 protected:

lldb/source/Core/Module.cpp

 }
 
 void Module::PreloadSymbols() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   SymbolFile *sym_file = GetSymbolFile();
   if (!sym_file)
     return;
 
-  // Prime the symbol file first, since it adds symbols to the symbol table.
-  sym_file->PreloadSymbols();
-
-  // Now we can prime the symbol table.
+  // Load the object file symbol table and any symbols from the SymbolFile that
+  // get appended using SymbolFile::AddSymbols(...).
   if (Symtab *symtab = sym_file->GetSymtab())
     symtab->PreloadSymbols();
+
+  // Now let the symbol file preload its data and the symbol table will be
+  // available without needing to take the module lock.
+  sym_file->PreloadSymbols();
+
 }
 
 void Module::SetSymbolFileFileSpec(const FileSpec &file) {
   if (!FileSystem::Instance().Exists(file))
     return;
   if (m_symfile_up) {
     // Remove any sections in the unified section list that come from the
     // current symbol vendor.

lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.h

public:
   uint32_t GetAddressByteSize() const override {
     return m_arch.GetAddressByteSize();
   }
 
   AddressClass GetAddressClass(lldb::addr_t file_addr) override {
     return AddressClass::eInvalid;
   }
 
-  Symtab *GetSymtab() override;
+  void ParseSymtab(lldb_private::Symtab &symtab) override;
 
   bool IsStripped() override { return false; }
 
   void CreateSections(SectionList &unified_section_list) override;
 
   void Dump(Stream *s) override {}
 
   ArchSpec GetArchitecture() override { return m_arch; }

lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp

ObjectFileBreakpad::ObjectFileBreakpad(const ModuleSP &module_sp,
     : ObjectFile(module_sp, file, offset, length, data_sp, data_offset),
       m_arch(std::move(arch)), m_uuid(std::move(uuid)) {}
 
 bool ObjectFileBreakpad::ParseHeader() {
   // We already parsed the header during initialization.
   return true;
 }
 
-Symtab *ObjectFileBreakpad::GetSymtab() {
-  // TODO
-  return nullptr;
+void ObjectFileBreakpad::ParseSymtab(Symtab &symtab) {
+  // Nothing to do for breakpad files, all information is parsed as debug info
+  // which means "lldb_private::Function" objects are used, or symbols are added
+  // by the SymbolFileBreakpad::AddSymbols(...) function in the symbol file.
 }
 
 void ObjectFileBreakpad::CreateSections(SectionList &unified_section_list) {
   if (m_sections_up)
     return;
   m_sections_up = std::make_unique<SectionList>();
 
   llvm::Optional<Record::Kind> current_section;

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

public:
   lldb::ByteOrder GetByteOrder() const override;
 
   bool IsExecutable() const override;
 
   uint32_t GetAddressByteSize() const override;
 
   lldb_private::AddressClass GetAddressClass(lldb::addr_t file_addr) override;
 
-  lldb_private::Symtab *GetSymtab() override;
+  void ParseSymtab(lldb_private::Symtab &symtab) override;
 
   bool IsStripped() override;
 
   void CreateSections(lldb_private::SectionList &unified_section_list) override;
 
   void Dump(lldb_private::Stream *s) override;
 
   lldb_private::ArchSpec GetArchitecture() override;
 
   lldb_private::UUID GetUUID() override;
 
   /// Return the contents of the .gnu_debuglink section, if the object file
-  /// contains it. 
+  /// contains it.
   llvm::Optional<lldb_private::FileSpec> GetDebugLink();
 
   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;
 
   lldb_private::Address
   GetImageInfoAddress(lldb_private::Target *target) override;
 
   lldb_private::Address GetEntryPointAddress() override;
private:
   /// modules parsed.
   size_t ParseDependentModules();
 
   /// Parses the dynamic symbol table and populates m_dynamic_symbols.  The
   /// vector retains the order as found in the object file.  Returns the
   /// number of dynamic symbols parsed.
   size_t ParseDynamicSymbols();
 
-  /// Populates m_symtab_up will all non-dynamic linker symbols.  This method
-  /// will parse the symbols only once.  Returns the number of symbols parsed.
+  /// Populates the symbol table with all non-dynamic linker symbols.  This
+  /// method will parse the symbols only once.  Returns the number of symbols
+  /// parsed.
   unsigned ParseSymbolTable(lldb_private::Symtab *symbol_table,
                             lldb::user_id_t start_id,
                             lldb_private::Section *symtab);
 
   /// Helper routine for ParseSymbolTable().
   unsigned ParseSymbols(lldb_private::Symtab *symbol_table,
                         lldb::user_id_t start_id,
                         lldb_private::SectionList *section_list,
private:
   unsigned PLTRelocationType();
 
   static lldb_private::Status
   RefineModuleDetailsFromNote(lldb_private::DataExtractor &data,
                               lldb_private::ArchSpec &arch_spec,
                               lldb_private::UUID &uuid);
 
   bool AnySegmentHasPhysicalAddress();
-  
   /// Takes the .gnu_debugdata and returns the decompressed object file that is
   /// stored within that section.
   ///
   /// \returns either the decompressed object file stored within the
   /// .gnu_debugdata section or \c nullptr if an error occured or if there's no
   /// section with that name.
   std::shared_ptr<ObjectFileELF> GetGnuDebugDataObjectFile();
 };
 
 #endif // LLDB_SOURCE_PLUGINS_OBJECTFILE_ELF_OBJECTFILEELF_H

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (GetData(rel->GetFileOffset(), rel->GetFileSize(), rel_data) &&
       GetData(debug->GetFileOffset(), debug->GetFileSize(), debug_data)) {
     ApplyRelocations(thetab, &m_header, rel_hdr, symtab_hdr, debug_hdr,
                      rel_data, symtab_data, debug_data, debug);
   }
 
   return 0;
 }
 
-Symtab *ObjectFileELF::GetSymtab() {
+void ObjectFileELF::ParseSymtab(Symtab &lldb_symtab) {
   ModuleSP module_sp(GetModule());
   if (!module_sp)
-    return nullptr;
+    return;
+
+  Progress progress(
+      llvm::formatv("Parsing symbol table for {0}",
+                    m_file.GetFilename().AsCString("<Unknown>")));
+  ElapsedTime elapsed(module_sp->GetSymtabParseTime());
 
   // We always want to use the main object file so we (hopefully) only have one
   // cached copy of our symtab, dynamic sections, etc.
   ObjectFile *module_obj_file = module_sp->GetObjectFile();
   if (module_obj_file && module_obj_file != this)
-    return module_obj_file->GetSymtab();
+    return module_obj_file->ParseSymtab(lldb_symtab);
 
-  if (m_symtab_up == nullptr) {
-    Progress progress(
-        llvm::formatv("Parsing symbol table for {0}",
-                      m_file.GetFilename().AsCString("<Unknown>")));
-    ElapsedTime elapsed(module_sp->GetSymtabParseTime());
-    SectionList *section_list = module_sp->GetSectionList();
-    if (!section_list)
-      return nullptr;
+    return;
 
-    uint64_t symbol_id = 0;
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
-    // Sharable objects and dynamic executables usually have 2 distinct symbol
-    // tables, one named ".symtab", and the other ".dynsym". The dynsym is a
-    // smaller version of the symtab that only contains global symbols. The
-    // information found in the dynsym is therefore also found in the symtab,
-    // while the reverse is not necessarily true.
-    Section *symtab =
-        section_list->FindSectionByType(eSectionTypeELFSymbolTable, true).get();
-    if (symtab) {
-      m_symtab_up = std::make_unique<Symtab>(symtab->GetObjectFile());
-      symbol_id += ParseSymbolTable(m_symtab_up.get(), symbol_id, symtab);
-    }
+  if (symtab)
+    symbol_id += ParseSymbolTable(&lldb_symtab, symbol_id, symtab);
 
-    // The symtab section is non-allocable and can be stripped, while the
-    // .dynsym section which should always be always be there. To support the
-    // minidebuginfo case we parse .dynsym when there's a .gnu_debuginfo
-    // section, nomatter if .symtab was already parsed or not. This is because
-    // minidebuginfo normally removes the .symtab symbols which have their
-    // matching .dynsym counterparts.
-    if (!symtab ||
-        GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata"))) {
-      Section *dynsym =
-          section_list->FindSectionByType(eSectionTypeELFDynamicSymbols, true)
-              .get();
-      if (dynsym) {
-        if (!m_symtab_up)
-          m_symtab_up = std::make_unique<Symtab>(dynsym->GetObjectFile());
-        symbol_id += ParseSymbolTable(m_symtab_up.get(), symbol_id, dynsym);
-      }
-    }
+    if (dynsym)
+      symbol_id += ParseSymbolTable(&lldb_symtab, symbol_id, dynsym);
 
-    // DT_JMPREL
-    //      If present, this entry's d_ptr member holds the address of
-    //      relocation
-    //      entries associated solely with the procedure linkage table.
-    //      Separating
-    //      these relocation entries lets the dynamic linker ignore them during
-    //      process initialization, if lazy binding is enabled. If this entry is
-    //      present, the related entries of types DT_PLTRELSZ and DT_PLTREL must
-    //      also be present.
-    const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL);
-    if (symbol) {
-      // Synthesize trampoline symbols to help navigate the PLT.
-      addr_t addr = symbol->d_ptr;
-      Section *reloc_section =
-          section_list->FindSectionContainingFileAddress(addr).get();
-      if (reloc_section) {
-        user_id_t reloc_id = reloc_section->GetID();
-        const ELFSectionHeaderInfo *reloc_header =
-            GetSectionHeaderByIndex(reloc_id);
-        if (reloc_header) {
-          if (m_symtab_up == nullptr)
-            m_symtab_up =
-                std::make_unique<Symtab>(reloc_section->GetObjectFile());
-
-          ParseTrampolineSymbols(m_symtab_up.get(), symbol_id, reloc_header,
-                                 reloc_id);
-        }
-      }
-    }
+      if (reloc_header)
+        ParseTrampolineSymbols(&lldb_symtab, symbol_id, reloc_header, reloc_id);
 
-    if (DWARFCallFrameInfo *eh_frame =
-            GetModule()->GetUnwindTable().GetEHFrameInfo()) {
-      if (m_symtab_up == nullptr)
-        m_symtab_up = std::make_unique<Symtab>(this);
-      ParseUnwindSymbols(m_symtab_up.get(), eh_frame);
-    }
+    ParseUnwindSymbols(&lldb_symtab, eh_frame);
 
-    // If we still don't have any symtab then create an empty instance to avoid
-    // do the section lookup next time.
-    if (m_symtab_up == nullptr)
-      m_symtab_up = std::make_unique<Symtab>(this);
-
-    // In the event that there's no symbol entry for the entry point we'll
-    // artificially create one. We delegate to the symtab object the figuring
-    // out of the proper size, this will usually make it span til the next
-    // symbol it finds in the section. This means that if there are missing
-    // symbols the entry point might span beyond its function definition.
-    // We're fine with this as it doesn't make it worse than not having a
-    // symbol entry at all.
-    if (CalculateType() == eTypeExecutable) {
-      ArchSpec arch = GetArchitecture();
-      auto entry_point_addr = GetEntryPointAddress();
-      bool is_valid_entry_point =
-          entry_point_addr.IsValid() && entry_point_addr.IsSectionOffset();
-      addr_t entry_point_file_addr = entry_point_addr.GetFileAddress();
-      if (is_valid_entry_point && !m_symtab_up->FindSymbolContainingFileAddress(
-                                      entry_point_file_addr)) {
-        uint64_t symbol_id = m_symtab_up->GetNumSymbols();
-        // Don't set the name for any synthetic symbols, the Symbol
-        // object will generate one if needed when the name is accessed
-        // via accessors.
-        SectionSP section_sp = entry_point_addr.GetSection();
-        Symbol symbol(
-            /*symID=*/symbol_id,
-            /*name=*/llvm::StringRef(), // Name will be auto generated.
-            /*type=*/eSymbolTypeCode,
-            /*external=*/true,
-            /*is_debug=*/false,
-            /*is_trampoline=*/false,
-            /*is_artificial=*/true,
-            /*section_sp=*/section_sp,
-            /*offset=*/0,
-            /*size=*/0, // FDE can span multiple symbols so don't use its size.
-            /*size_is_valid=*/false,
-            /*contains_linker_annotations=*/false,
-            /*flags=*/0);
-        // When the entry point is arm thumb we need to explicitly set its
-        // class address to reflect that. This is important because expression
-        // evaluation relies on correctly setting a breakpoint at this
-        // address.
-        if (arch.GetMachine() == llvm::Triple::arm &&
-            (entry_point_file_addr & 1)) {
-          symbol.GetAddressRef().SetOffset(entry_point_addr.GetOffset() ^ 1);
-          m_address_class_map[entry_point_file_addr ^ 1] =
-              AddressClass::eCodeAlternateISA;
-        } else {
-          m_address_class_map[entry_point_file_addr] = AddressClass::eCode;
-        }
-        m_symtab_up->AddSymbol(symbol);
-      }
-    }
-
-    m_symtab_up->CalculateSymbolSizes();
-  }
-
-  return m_symtab_up.get();
+    if (is_valid_entry_point && !lldb_symtab.FindSymbolContainingFileAddress(
+      uint64_t symbol_id = lldb_symtab.GetNumSymbols();
+      lldb_symtab.AddSymbol(symbol);
 }
 
 void ObjectFileELF::RelocateSection(lldb_private::Section *section)
 {
   static const char *debug_prefix = ".debug";
 
   // Set relocated bit so we stop getting called, regardless of whether we
   // actually relocate.

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.h

bool SetLoadAddress(lldb_private::Target &target, lldb::addr_t value,
                       bool value_is_offset) override;
 
   lldb::ByteOrder GetByteOrder() const override;
 
   bool IsExecutable() const override;
 
   uint32_t GetAddressByteSize() const override;
 
-  lldb_private::Symtab *GetSymtab() override;
+  void ParseSymtab(lldb_private::Symtab &symtab) override;
 
   bool IsStripped() override;
 
   void CreateSections(lldb_private::SectionList &unified_section_list) override;
 
   void Dump(lldb_private::Stream *s) override;
 
   lldb_private::ArchSpec GetArchitecture() override;

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

 ByteOrder ObjectFileJIT::GetByteOrder() const { return m_data.GetByteOrder(); }
 
 bool ObjectFileJIT::IsExecutable() const { return false; }
 
 uint32_t ObjectFileJIT::GetAddressByteSize() const {
   return m_data.GetAddressByteSize();
 }
 
-Symtab *ObjectFileJIT::GetSymtab() {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_symtab_up == nullptr) {
-      ElapsedTime elapsed(module_sp->GetSymtabParseTime());
-      m_symtab_up = std::make_unique<Symtab>(this);
-      std::lock_guard<std::recursive_mutex> symtab_guard(
-          m_symtab_up->GetMutex());
-      ObjectFileJITDelegateSP delegate_sp(m_delegate_wp.lock());
-      if (delegate_sp)
-        delegate_sp->PopulateSymtab(this, *m_symtab_up);
-      // TODO: get symbols from delegate
-      m_symtab_up->Finalize();
-    }
-  }
-  return m_symtab_up.get();
+void ObjectFileJIT::ParseSymtab(Symtab &symtab) {
+    delegate_sp->PopulateSymtab(this, symtab);
 }
 
 bool ObjectFileJIT::IsStripped() {
   return false; // JIT code that is in a module is never stripped
 }
 
 void ObjectFileJIT::CreateSections(SectionList &unified_section_list) {
   if (!m_sections_up) {

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h

public:
   bool IsDynamicLoader() const;
 
   bool IsSharedCacheBinary() const;
 
   uint32_t GetAddressByteSize() const override;
 
   lldb_private::AddressClass GetAddressClass(lldb::addr_t file_addr) override;
 
-  lldb_private::Symtab *GetSymtab() override;
+  void ParseSymtab(lldb_private::Symtab &symtab) override;
 
   bool IsStripped() override;
 
   void CreateSections(lldb_private::SectionList &unified_section_list) override;
 
   void Dump(lldb_private::Stream *s) override;
 
   lldb_private::ArchSpec GetArchitecture() override;

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

case eSymbolTypeObjCIVar:
       return AddressClass::eRuntime;
     case eSymbolTypeReExported:
       return AddressClass::eRuntime;
     }
   }
   return AddressClass::eUnknown;
 }
 
-Symtab *ObjectFileMachO::GetSymtab() {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_symtab_up == nullptr) {
-      ElapsedTime elapsed(module_sp->GetSymtabParseTime());
-      m_symtab_up = std::make_unique<Symtab>(this);
-      std::lock_guard<std::recursive_mutex> symtab_guard(
-          m_symtab_up->GetMutex());
-      ParseSymtab();
-      m_symtab_up->Finalize();
-    }
-  }
-  return m_symtab_up.get();
-}
-
 bool ObjectFileMachO::IsStripped() {
   if (m_dysymtab.cmd == 0) {
     ModuleSP module_sp(GetModule());
     if (module_sp) {
       lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
       for (uint32_t i = 0; i < m_header.ncmds; ++i) {
         const lldb::offset_t load_cmd_offset = offset;
 
ParseNList(DataExtractor &nlist_data, lldb::offset_t &nlist_data_offset,
   nlist.n_sect = nlist_data.GetU8_unchecked(&nlist_data_offset);
   nlist.n_desc = nlist_data.GetU16_unchecked(&nlist_data_offset);
   nlist.n_value = nlist_data.GetAddress_unchecked(&nlist_data_offset);
   return nlist;
 }
 
 enum { DebugSymbols = true, NonDebugSymbols = false };
 
-size_t ObjectFileMachO::ParseSymtab() {
+void ObjectFileMachO::ParseSymtab(Symtab &symtab) {
   LLDB_SCOPED_TIMERF("ObjectFileMachO::ParseSymtab () module = %s",
                      m_file.GetFilename().AsCString(""));
   ModuleSP module_sp(GetModule());
   if (!module_sp)
-    return 0;
+    return;
 
   Progress progress(llvm::formatv("Parsing symbol table for {0}",
                                   m_file.GetFilename().AsCString("<Unknown>")));
 
   llvm::MachO::symtab_command symtab_load_command = {0, 0, 0, 0, 0, 0};
   llvm::MachO::linkedit_data_command function_starts_load_command = {0, 0, 0, 0};
   llvm::MachO::linkedit_data_command exports_trie_load_command = {0, 0, 0, 0};
   llvm::MachO::dyld_info_command dyld_info = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
for (i = 0; i < m_header.ncmds; ++i) {
     // Watch for the symbol table load command
     switch (lc.cmd) {
     case LC_SYMTAB:
       symtab_load_command.cmd = lc.cmd;
       symtab_load_command.cmdsize = lc.cmdsize;
       // Read in the rest of the symtab load command
       if (m_data.GetU32(&offset, &symtab_load_command.symoff, 4) ==
           nullptr) // fill in symoff, nsyms, stroff, strsize fields
-        return 0;
+        return;
       break;
 
     case LC_DYLD_INFO:
     case LC_DYLD_INFO_ONLY:
       if (m_data.GetU32(&offset, &dyld_info.rebase_off, 10)) {
         dyld_info.cmd = lc.cmd;
         dyld_info.cmdsize = lc.cmdsize;
       } else {
for (i = 0; i < m_header.ncmds; ++i) {
 
     default:
       break;
     }
     offset = cmd_offset + lc.cmdsize;
   }
 
   if (!symtab_load_command.cmd)
-    return 0;
+    return;
 
-  Symtab *symtab = m_symtab_up.get();
   SectionList *section_list = GetSectionList();
   if (section_list == nullptr)
-    return 0;
+    return;
 
   const uint32_t addr_byte_size = m_data.GetAddressByteSize();
   const ByteOrder byte_order = m_data.GetByteOrder();
   bool bit_width_32 = addr_byte_size == 4;
   const size_t nlist_byte_size =
       bit_width_32 ? sizeof(struct nlist) : sizeof(struct nlist_64);
 
   DataExtractor nlist_data(nullptr, 0, byte_order, addr_byte_size);
if (process && m_header.filetype != llvm::MachO::MH_OBJECT &&
 
     nlist_data.SetData(m_data, symtab_load_command.symoff,
                        nlist_data_byte_size);
     strtab_data.SetData(m_data, symtab_load_command.stroff,
                         strtab_data_byte_size);
 
     // We shouldn't have exports data from both the LC_DYLD_INFO command
     // AND the LC_DYLD_EXPORTS_TRIE command in the same binary:
-    lldbassert(!((dyld_info.export_size > 0) 
+    lldbassert(!((dyld_info.export_size > 0)
                  && (exports_trie_load_command.datasize > 0)));
     if (dyld_info.export_size > 0) {
       dyld_trie_data.SetData(m_data, dyld_info.export_off,
                              dyld_info.export_size);
     } else if (exports_trie_load_command.datasize > 0) {
       dyld_trie_data.SetData(m_data, exports_trie_load_command.dataoff,
                              exports_trie_load_command.datasize);
     }
if (dsc_data_sp) {
               local_symbols_entry.nlistCount =
                   dsc_local_symbols_data.GetU32(&offset);
 
               if (header_file_offset == local_symbols_entry.dylibOffset) {
                 unmapped_local_symbols_found = local_symbols_entry.nlistCount;
 
                 // The normal nlist code cannot correctly size the Symbols
                 // array, we need to allocate it here.
-                sym = symtab->Resize(
+                sym = symtab.Resize(
                     symtab_load_command.nsyms + m_dysymtab.nindirectsyms +
                     unmapped_local_symbols_found - m_dysymtab.nlocalsym);
-                num_syms = symtab->GetNumSymbols();
+                num_syms = symtab.GetNumSymbols();
 
                 nlist_data_offset =
                     local_symbols_info.nlistOffset +
                     (nlist_byte_size * local_symbols_entry.nlistStartIndex);
                 uint32_t string_table_offset = local_symbols_info.stringsOffset;
 
                 for (uint32_t nlist_index = 0;
                      nlist_index < local_symbols_entry.nlistCount;
if (dsc_data_sp) {
                         } else {
                           type = eSymbolTypeCompiler;
 
                           if (!N_FUN_indexes.empty()) {
                             // Copy the size of the function into the
                             // original
                             // STAB entry so we don't have
                             // to hunt for it later
-                            symtab->SymbolAtIndex(N_FUN_indexes.back())
+                            symtab.SymbolAtIndex(N_FUN_indexes.back())
                                 ->SetByteSize(nlist.n_value);
                             N_FUN_indexes.pop_back();
                             // We don't really need the end function STAB as
                             // it contains the size which we already placed
                             // with the original symbol, so don't add it if
                             // we want a minimal symbol table
                             add_nlist = false;
                           }
if (dsc_data_sp) {
                         type = eSymbolTypeSourceFile;
                         if (symbol_name == NULL) {
                           add_nlist = false;
                           if (N_SO_index != UINT32_MAX) {
                             // Set the size of the N_SO to the terminating
                             // index of this N_SO so that we can always skip
                             // the entire N_SO if we need to navigate more
                             // quickly at the source level when parsing STABS
-                            symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
+                            symbol_ptr = symtab.SymbolAtIndex(N_SO_index);
                             symbol_ptr->SetByteSize(sym_idx);
                             symbol_ptr->SetSizeIsSibling(true);
                           }
                           N_NSYM_indexes.clear();
                           N_INCL_indexes.clear();
                           N_BRAC_indexes.clear();
                           N_COMM_indexes.clear();
                           N_FUN_indexes.clear();
if (dsc_data_sp) {
                       case N_EINCL:
                         // include file end: name,,NO_SECT,0,0
                         // Set the size of the N_BINCL to the terminating
                         // index of this N_EINCL so that we can always skip
                         // the entire symbol if we need to navigate more
                         // quickly at the source level when parsing STABS
                         if (!N_INCL_indexes.empty()) {
                           symbol_ptr =
-                              symtab->SymbolAtIndex(N_INCL_indexes.back());
+                              symtab.SymbolAtIndex(N_INCL_indexes.back());
                           symbol_ptr->SetByteSize(sym_idx + 1);
                           symbol_ptr->SetSizeIsSibling(true);
                           N_INCL_indexes.pop_back();
                         }
                         type = eSymbolTypeScopeEnd;
                         break;
 
                       case N_SOL:
if (dsc_data_sp) {
                         // Set the size of the N_LBRAC to the terminating
                         // index of this N_RBRAC so that we can always skip
                         // the entire symbol if we need to navigate more
                         // quickly at the source level when parsing STABS
                         symbol_section = section_info.GetSection(nlist.n_sect,
                                                                  nlist.n_value);
                         if (!N_BRAC_indexes.empty()) {
                           symbol_ptr =
-                              symtab->SymbolAtIndex(N_BRAC_indexes.back());
+                              symtab.SymbolAtIndex(N_BRAC_indexes.back());
                           symbol_ptr->SetByteSize(sym_idx + 1);
                           symbol_ptr->SetSizeIsSibling(true);
                           N_BRAC_indexes.pop_back();
                         }
                         type = eSymbolTypeScopeEnd;
                         break;
 
                       case N_EXCL:
if (dsc_data_sp) {
                         // end common: name,,n_sect,0,0
                         // Set the size of the N_BCOMM to the terminating
                         // index of this N_ECOMM/N_ECOML so that we can
                         // always skip the entire symbol if we need to
                         // navigate more quickly at the source level when
                         // parsing STABS
                         if (!N_COMM_indexes.empty()) {
                           symbol_ptr =
-                              symtab->SymbolAtIndex(N_COMM_indexes.back());
+                              symtab.SymbolAtIndex(N_COMM_indexes.back());
                           symbol_ptr->SetByteSize(sym_idx + 1);
                           symbol_ptr->SetSizeIsSibling(true);
                           N_COMM_indexes.pop_back();
                         }
                         type = eSymbolTypeScopeEnd;
                         break;
 
                       case N_LENG:

 #endif
 
   if (nlist_data.GetByteSize() > 0) {
 
     // If the sym array was not created while parsing the DSC unmapped
     // symbols, create it now.
     if (sym == nullptr) {
       sym =
-          symtab->Resize(symtab_load_command.nsyms + m_dysymtab.nindirectsyms);
-      num_syms = symtab->GetNumSymbols();
+          symtab.Resize(symtab_load_command.nsyms + m_dysymtab.nindirectsyms);
+      num_syms = symtab.GetNumSymbols();
     }
 
     if (unmapped_local_symbols_found) {
       assert(m_dysymtab.ilocalsym == 0);
       nlist_data_offset += (m_dysymtab.nlocalsym * nlist_byte_size);
       nlist_idx = m_dysymtab.nlocalsym;
     } else {
       nlist_idx = 0;
auto ParseSymbolLambda = [&](struct nlist_64 &nlist, uint32_t nlist_idx,
             // out
             N_FUN_indexes.push_back(sym_idx);
           } else {
             type = eSymbolTypeCompiler;
 
             if (!N_FUN_indexes.empty()) {
               // Copy the size of the function into the original STAB entry
               // so we don't have to hunt for it later
-              symtab->SymbolAtIndex(N_FUN_indexes.back())
+              symtab.SymbolAtIndex(N_FUN_indexes.back())
                   ->SetByteSize(nlist.n_value);
               N_FUN_indexes.pop_back();
               // We don't really need the end function STAB as it contains
               // the size which we already placed with the original symbol,
               // so don't add it if we want a minimal symbol table
               add_nlist = false;
             }
           }
auto ParseSymbolLambda = [&](struct nlist_64 &nlist, uint32_t nlist_idx,
           type = eSymbolTypeSourceFile;
           if (symbol_name == nullptr) {
             add_nlist = false;
             if (N_SO_index != UINT32_MAX) {
               // Set the size of the N_SO to the terminating index of this
               // N_SO so that we can always skip the entire N_SO if we need
               // to navigate more quickly at the source level when parsing
               // STABS
-              symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
+              symbol_ptr = symtab.SymbolAtIndex(N_SO_index);
               symbol_ptr->SetByteSize(sym_idx);
               symbol_ptr->SetSizeIsSibling(true);
             }
             N_NSYM_indexes.clear();
             N_INCL_indexes.clear();
             N_BRAC_indexes.clear();
             N_COMM_indexes.clear();
             N_FUN_indexes.clear();
auto ParseSymbolLambda = [&](struct nlist_64 &nlist, uint32_t nlist_idx,
           break;
 
         case N_EINCL:
           // include file end: name,,NO_SECT,0,0
           // Set the size of the N_BINCL to the terminating index of this
           // N_EINCL so that we can always skip the entire symbol if we need
           // to navigate more quickly at the source level when parsing STABS
           if (!N_INCL_indexes.empty()) {
-            symbol_ptr = symtab->SymbolAtIndex(N_INCL_indexes.back());
+            symbol_ptr = symtab.SymbolAtIndex(N_INCL_indexes.back());
             symbol_ptr->SetByteSize(sym_idx + 1);
             symbol_ptr->SetSizeIsSibling(true);
             N_INCL_indexes.pop_back();
           }
           type = eSymbolTypeScopeEnd;
           break;
 
         case N_SOL:
auto ParseSymbolLambda = [&](struct nlist_64 &nlist, uint32_t nlist_idx,
 
         case N_RBRAC:
           // right bracket: 0,,NO_SECT,nesting level,address Set the size of
           // the N_LBRAC to the terminating index of this N_RBRAC so that we
           // can always skip the entire symbol if we need to navigate more
           // quickly at the source level when parsing STABS
           symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
           if (!N_BRAC_indexes.empty()) {
-            symbol_ptr = symtab->SymbolAtIndex(N_BRAC_indexes.back());
+            symbol_ptr = symtab.SymbolAtIndex(N_BRAC_indexes.back());
             symbol_ptr->SetByteSize(sym_idx + 1);
             symbol_ptr->SetSizeIsSibling(true);
             N_BRAC_indexes.pop_back();
           }
           type = eSymbolTypeScopeEnd;
           break;
 
         case N_EXCL:
auto ParseSymbolLambda = [&](struct nlist_64 &nlist, uint32_t nlist_idx,
 
         case N_ECOMM:
           // end common: name,,n_sect,0,0
           // Set the size of the N_BCOMM to the terminating index of this
           // N_ECOMM/N_ECOML so that we can always skip the entire symbol if
           // we need to navigate more quickly at the source level when
           // parsing STABS
           if (!N_COMM_indexes.empty()) {
-            symbol_ptr = symtab->SymbolAtIndex(N_COMM_indexes.back());
+            symbol_ptr = symtab.SymbolAtIndex(N_COMM_indexes.back());
             symbol_ptr->SetByteSize(sym_idx + 1);
             symbol_ptr->SetSizeIsSibling(true);
             N_COMM_indexes.pop_back();
           }
           type = eSymbolTypeScopeEnd;
           break;
 
         case N_LENG:
#endif
   int trie_symbol_table_augment_count = 0;
   for (auto &e : external_sym_trie_entries) {
     if (symbols_added.find(e.entry.address) == symbols_added.end())
       trie_symbol_table_augment_count++;
   }
 
   if (num_syms < sym_idx + trie_symbol_table_augment_count) {
     num_syms = sym_idx + trie_symbol_table_augment_count;
-    sym = symtab->Resize(num_syms);
+    sym = symtab.Resize(num_syms);
   }
   uint32_t synthetic_sym_id = symtab_load_command.nsyms;
 
   // Add symbols from the trie to the symbol table.
   for (auto &e : external_sym_trie_entries) {
     if (symbols_added.find(e.entry.address) != symbols_added.end())
       continue;
 
for (i = 0; i < function_starts_count; ++i) {
       if (symbols_added.find(function_starts.GetEntryRef(i).addr) ==
           symbols_added.end())
         ++num_synthetic_function_symbols;
     }
 
     if (num_synthetic_function_symbols > 0) {
       if (num_syms < sym_idx + num_synthetic_function_symbols) {
         num_syms = sym_idx + num_synthetic_function_symbols;
-        sym = symtab->Resize(num_syms);
+        sym = symtab.Resize(num_syms);
       }
       for (i = 0; i < function_starts_count; ++i) {
         const FunctionStarts::Entry *func_start_entry =
             function_starts.GetEntryAtIndex(i);
         if (symbols_added.find(func_start_entry->addr) == symbols_added.end()) {
           addr_t symbol_file_addr = func_start_entry->addr;
           uint32_t symbol_flags = 0;
           if (func_start_entry->data)
if (num_synthetic_function_symbols > 0) {
       }
     }
   }
 
   // Trim our symbols down to just what we ended up with after removing any
   // symbols.
   if (sym_idx < num_syms) {
     num_syms = sym_idx;
-    sym = symtab->Resize(num_syms);
+    sym = symtab.Resize(num_syms);
   }
 
   // Now synthesize indirect symbols
   if (m_dysymtab.nindirectsyms != 0) {
     if (indirect_symbol_index_data.GetByteSize()) {
       NListIndexToSymbolIndexMap::const_iterator end_index_pos =
           m_nlist_idx_to_sym_idx.end();
 
if (indirect_symbol_index_data.GetByteSize()) {
                 continue;
 
               NListIndexToSymbolIndexMap::const_iterator index_pos =
                   m_nlist_idx_to_sym_idx.find(stub_sym_id);
               Symbol *stub_symbol = nullptr;
               if (index_pos != end_index_pos) {
                 // We have a remapping from the original nlist index to a
                 // current symbol index, so just look this up by index
-                stub_symbol = symtab->SymbolAtIndex(index_pos->second);
+                stub_symbol = symtab.SymbolAtIndex(index_pos->second);
               } else {
                 // We need to lookup a symbol using the original nlist symbol
                 // index since this index is coming from the S_SYMBOL_STUBS
-                stub_symbol = symtab->FindSymbolByID(stub_sym_id);
+                stub_symbol = symtab.FindSymbolByID(stub_sym_id);
               }
 
               if (stub_symbol) {
                 Address so_addr(symbol_stub_addr, section_list);
 
                 if (stub_symbol->GetType() == eSymbolTypeUndefined) {
                   // Change the external symbol into a trampoline that makes
                   // sense These symbols were N_UNDF N_EXT, and are useless
                   // to us, so we can re-use them so we don't have to make up
                   // a synthetic symbol for no good reason.
                   if (resolver_addresses.find(symbol_stub_addr) ==
                       resolver_addresses.end())
                     stub_symbol->SetType(eSymbolTypeTrampoline);
                   else
                     stub_symbol->SetType(eSymbolTypeResolver);
                   stub_symbol->SetExternal(false);
                   stub_symbol->GetAddressRef() = so_addr;
                   stub_symbol->SetByteSize(symbol_stub_byte_size);
                 } else {
                   // Make a synthetic symbol to describe the trampoline stub
                   Mangled stub_symbol_mangled_name(stub_symbol->GetMangled());
                   if (sym_idx >= num_syms) {
-                    sym = symtab->Resize(++num_syms);
+                    sym = symtab.Resize(++num_syms);
                     stub_symbol = nullptr; // this pointer no longer valid
                   }
                   sym[sym_idx].SetID(synthetic_sym_id++);
                   sym[sym_idx].GetMangled() = stub_symbol_mangled_name;
                   if (resolver_addresses.find(symbol_stub_addr) ==
                       resolver_addresses.end())
                     sym[sym_idx].SetType(eSymbolTypeTrampoline);
                   else
if (!reexport_trie_entries.empty()) {
     for (const auto &e : reexport_trie_entries) {
       if (e.entry.import_name) {
         // Only add indirect symbols from the Trie entries if we didn't have
         // a N_INDR nlist entry for this already
         if (indirect_symbol_names.find(e.entry.name) ==
             indirect_symbol_names.end()) {
           // Make a synthetic symbol to describe re-exported symbol.
           if (sym_idx >= num_syms)
-            sym = symtab->Resize(++num_syms);
+            sym = symtab.Resize(++num_syms);
           sym[sym_idx].SetID(synthetic_sym_id++);
           sym[sym_idx].GetMangled() = Mangled(e.entry.name);
           sym[sym_idx].SetType(eSymbolTypeReExported);
           sym[sym_idx].SetIsSynthetic(true);
           sym[sym_idx].SetReExportedSymbolName(e.entry.import_name);
           if (e.entry.other > 0 && e.entry.other <= dylib_files.GetSize()) {
             sym[sym_idx].SetReExportedSymbolSharedLibrary(
                 dylib_files.GetFileSpecAtIndex(e.entry.other - 1));
           }
           ++sym_idx;
         }
       }
     }
   }
-
-  //        StreamFile s(stdout, false);
-  //        s.Printf ("Symbol table before CalculateSymbolSizes():\n");
-  //        symtab->Dump(&s, NULL, eSortOrderNone);
-  // Set symbol byte sizes correctly since mach-o nlist entries don't have
-  // sizes
-  symtab->CalculateSymbolSizes();
-
-  //        s.Printf ("Symbol table after CalculateSymbolSizes():\n");
-  //        symtab->Dump(&s, NULL, eSortOrderNone);
-
-  return symtab->GetNumSymbols();
 }
 
 void ObjectFileMachO::Dump(Stream *s) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     s->Printf("%p: ", static_cast<void *>(this));
     s->Indent();

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.h

public:
   lldb::ByteOrder GetByteOrder() const override {
     return lldb::eByteOrderLittle;
   }
 
   bool ParseHeader() override { return true; }
 
   bool IsExecutable() const override { return false; }
 
-  Symtab *GetSymtab() override { return nullptr; }
+  void ParseSymtab(lldb_private::Symtab &symtab) override {}
 
   bool IsStripped() override { return false; }
 
   // No section in PDB file.
   void CreateSections(SectionList &unified_section_list) override {}
 
   void Dump(Stream *s) override {}
 

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

public:
 
   bool IsExecutable() const override;
 
   uint32_t GetAddressByteSize() const override;
 
   //    virtual lldb_private::AddressClass
   //    GetAddressClass (lldb::addr_t file_addr);
 
-  lldb_private::Symtab *GetSymtab() override;
+  void ParseSymtab(lldb_private::Symtab &symtab) override;
 
   bool IsStripped() override;
 
   void CreateSections(lldb_private::SectionList &unified_section_list) override;
 
   void Dump(lldb_private::Stream *s) override;
 
   lldb_private::ArchSpec GetArchitecture() override;

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

lldb::offset_t string_file_offset =
         m_coff_header.symoff + (m_coff_header.nsyms * 18) + stroff;
     if (const char *name = m_data.GetCStr(&string_file_offset))
       return name;
     return "";
   }
   return hdr_name;
 }
 
-// GetNListSymtab
-Symtab *ObjectFilePECOFF::GetSymtab() {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_symtab_up == nullptr) {
-      ElapsedTime elapsed(module_sp->GetSymtabParseTime());
-      SectionList *sect_list = GetSectionList();
-      m_symtab_up = std::make_unique<Symtab>(this);
-      std::lock_guard<std::recursive_mutex> guard(m_symtab_up->GetMutex());
-
-      const uint32_t num_syms = m_coff_header.nsyms;
-
-      if (m_file && num_syms > 0 && m_coff_header.symoff > 0) {
-        const uint32_t symbol_size = 18;
-        const size_t symbol_data_size = num_syms * symbol_size;
-        // Include the 4-byte string table size at the end of the symbols
-        DataExtractor symtab_data =
-            ReadImageData(m_coff_header.symoff, symbol_data_size + 4);
-        lldb::offset_t offset = symbol_data_size;
-        const uint32_t strtab_size = symtab_data.GetU32(&offset);
-        if (strtab_size > 0) {
-          DataExtractor strtab_data = ReadImageData(
-              m_coff_header.symoff + symbol_data_size, strtab_size);
+void ObjectFilePECOFF::ParseSymtab(Symtab &symtab) {
 
-          offset = 0;
-          std::string symbol_name;
-          Symbol *symbols = m_symtab_up->Resize(num_syms);
-          for (uint32_t i = 0; i < num_syms; ++i) {
-            coff_symbol_t symbol;
-            const uint32_t symbol_offset = offset;
-            const char *symbol_name_cstr = nullptr;
-            // If the first 4 bytes of the symbol string are zero, then they
-            // are followed by a 4-byte string table offset. Else these
-            // 8 bytes contain the symbol name
-            if (symtab_data.GetU32(&offset) == 0) {
-              // Long string that doesn't fit into the symbol table name, so
-              // now we must read the 4 byte string table offset
-              uint32_t strtab_offset = symtab_data.GetU32(&offset);
-              symbol_name_cstr = strtab_data.PeekCStr(strtab_offset);
-              symbol_name.assign(symbol_name_cstr);
-            } else {
-              // Short string that fits into the symbol table name which is 8
-              // bytes
-              offset += sizeof(symbol.name) - 4; // Skip remaining
-              symbol_name_cstr = symtab_data.PeekCStr(symbol_offset);
-              if (symbol_name_cstr == nullptr)
-                break;
-              symbol_name.assign(symbol_name_cstr, sizeof(symbol.name));
-            }
-            symbol.value = symtab_data.GetU32(&offset);
-            symbol.sect = symtab_data.GetU16(&offset);
-            symbol.type = symtab_data.GetU16(&offset);
-            symbol.storage = symtab_data.GetU8(&offset);
-            symbol.naux = symtab_data.GetU8(&offset);
-            symbols[i].GetMangled().SetValue(ConstString(symbol_name.c_str()));
-            if ((int16_t)symbol.sect >= 1) {
-              Address symbol_addr(sect_list->FindSectionByID(symbol.sect),
-                                  symbol.value);
-              symbols[i].GetAddressRef() = symbol_addr;
-              symbols[i].SetType(MapSymbolType(symbol.type));
-            }
+      Symbol *symbols = symtab.Resize(num_syms);
 
-            if (symbol.naux > 0) {
-              i += symbol.naux;
-              offset += symbol.naux * symbol_size;
-            }
-          }
-        }
-      }
 
-      // Read export header
-      if (coff_data_dir_export_table < m_coff_header_opt.data_dirs.size() &&
-          m_coff_header_opt.data_dirs[coff_data_dir_export_table].vmsize > 0 &&
-          m_coff_header_opt.data_dirs[coff_data_dir_export_table].vmaddr > 0) {
-        export_directory_entry export_table;
-        uint32_t data_start =
-            m_coff_header_opt.data_dirs[coff_data_dir_export_table].vmaddr;
 
-        DataExtractor symtab_data = ReadImageDataByRVA(
-            data_start, m_coff_header_opt.data_dirs[0].vmsize);
-        lldb::offset_t offset = 0;
 
-        // Read export_table header
-        export_table.characteristics = symtab_data.GetU32(&offset);
-        export_table.time_date_stamp = symtab_data.GetU32(&offset);
-        export_table.major_version = symtab_data.GetU16(&offset);
-        export_table.minor_version = symtab_data.GetU16(&offset);
-        export_table.name = symtab_data.GetU32(&offset);
-        export_table.base = symtab_data.GetU32(&offset);
-        export_table.number_of_functions = symtab_data.GetU32(&offset);
-        export_table.number_of_names = symtab_data.GetU32(&offset);
-        export_table.address_of_functions = symtab_data.GetU32(&offset);
-        export_table.address_of_names = symtab_data.GetU32(&offset);
-        export_table.address_of_name_ordinals = symtab_data.GetU32(&offset);
 
-        bool has_ordinal = export_table.address_of_name_ordinals != 0;
 
-        lldb::offset_t name_offset = export_table.address_of_names - data_start;
-        lldb::offset_t name_ordinal_offset =
-            export_table.address_of_name_ordinals - data_start;
 
-        Symbol *symbols = m_symtab_up->Resize(export_table.number_of_names);
+    Symbol *symbols = symtab.Resize(export_table.number_of_names);
 
-        std::string symbol_name;
 
-        // Read each export table entry
-        for (size_t i = 0; i < export_table.number_of_names; ++i) {
-          uint32_t name_ordinal =
-              has_ordinal ? symtab_data.GetU16(&name_ordinal_offset) : i;
-          uint32_t name_address = symtab_data.GetU32(&name_offset);
 
-          const char *symbol_name_cstr =
-              symtab_data.PeekCStr(name_address - data_start);
-          symbol_name.assign(symbol_name_cstr);
 
-          lldb::offset_t function_offset = export_table.address_of_functions -
-                                           data_start +
-                                           sizeof(uint32_t) * name_ordinal;
-          uint32_t function_rva = symtab_data.GetU32(&function_offset);
 
-          Address symbol_addr(m_coff_header_opt.image_base + function_rva,
-                              sect_list);
-          symbols[i].GetMangled().SetValue(ConstString(symbol_name.c_str()));
-          symbols[i].GetAddressRef() = symbol_addr;
-          symbols[i].SetType(lldb::eSymbolTypeCode);
-          symbols[i].SetDebug(true);
-        }
-      }
-      m_symtab_up->CalculateSymbolSizes();
-    }
-  }
-  return m_symtab_up.get();
 }
 
 std::unique_ptr<CallFrameInfo> ObjectFilePECOFF::CreateCallFrameInfo() {
   if (coff_data_dir_exception_table >= m_coff_header_opt.data_dirs.size())
     return {};
 
   data_directory data_dir_exception =
       m_coff_header_opt.data_dirs[coff_data_dir_exception_table];

lldb/source/Plugins/ObjectFile/wasm/ObjectFileWasm.h

public:
   uint32_t GetAddressByteSize() const override {
     return m_arch.GetAddressByteSize();
   }
 
   AddressClass GetAddressClass(lldb::addr_t file_addr) override {
     return AddressClass::eInvalid;
   }
 
-  Symtab *GetSymtab() override;
+  void ParseSymtab(lldb_private::Symtab &symtab) override;
 
   bool IsStripped() override { return !!GetExternalDebugInfoFileSpec(); }
 
   void CreateSections(SectionList &unified_section_list) override;
 
   void Dump(Stream *s) override;
 
   ArchSpec GetArchitecture() override { return m_arch; }

lldb/source/Plugins/ObjectFile/wasm/ObjectFileWasm.cpp

ObjectFileWasm::ObjectFileWasm(const lldb::ModuleSP &module_sp,
     : ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
       m_arch("wasm32-unknown-unknown-wasm") {}
 
 bool ObjectFileWasm::ParseHeader() {
   // We already parsed the header during initialization.
   return true;
 }
 
-Symtab *ObjectFileWasm::GetSymtab() { return nullptr; }
+void ObjectFileWasm::ParseSymtab(Symtab &symtab) {}
 
 static SectionType GetSectionTypeFromName(llvm::StringRef Name) {
   if (Name.consume_front(".debug_") || Name.consume_front(".zdebug_")) {
     return llvm::StringSwitch<SectionType>(Name)
         .Case("abbrev", eSectionTypeDWARFDebugAbbrev)
         .Case("abbrev.dwo", eSectionTypeDWARFDebugAbbrevDwo)
         .Case("addr", eSectionTypeDWARFDebugAddr)
         .Case("aranges", eSectionTypeDWARFDebugAranges)

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

public:
   }
   bool ParseHeader() override { return true; }
   Type CalculateType() override { return eTypeUnknown; }
   Strata CalculateStrata() override { return eStrataUnknown; }
   uint32_t GetDependentModules(FileSpecList &file_list) override { return 0; }
   bool IsExecutable() const override { return false; }
   ArchSpec GetArchitecture() override { return m_arch; }
   UUID GetUUID() override { return m_uuid; }
-  Symtab *GetSymtab() override { return m_symtab_up.get(); }
+  void ParseSymtab(lldb_private::Symtab &symtab) override {}
   bool IsStripped() override { return true; }
   ByteOrder GetByteOrder() const override { return m_arch.GetByteOrder(); }
 
   uint32_t GetAddressByteSize() const override {
     return m_arch.GetAddressByteSize();
   }
 
   Address GetBaseAddress() override {

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

for (llvm::StringRef line : lines(Record::Public)) {
     if (auto record = PublicRecord::parse(line))
       add_symbol(record->Address, llvm::None, record->Name);
     else
       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", line);
   }
 
   for (Symbol &symbol : symbols)
     symtab.AddSymbol(std::move(symbol));
-  symtab.CalculateSymbolSizes();
+  symtab.Finalize();
 }
 
 llvm::Expected<lldb::addr_t>
 SymbolFileBreakpad::GetParameterStackSize(Symbol &symbol) {
   ParseUnwindData();
   if (auto *entry = m_unwind_data->win.FindEntryThatContains(
           symbol.GetAddress().GetFileAddress())) {
     auto record = StackWinRecord::parse(
void SymbolFileBreakpad::ParseUnwindData() {
   }
   m_unwind_data->win.Sort();
 }
 
 uint64_t SymbolFileBreakpad::GetDebugInfoSize() {
   // Breakpad files are all debug info.
   return m_objfile_sp->GetByteSize();
 }
-

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

for (uint32_t cu_idx = 0, num_cus = GetNumCompileUnits(); cu_idx < num_cus;
           break;
       }
     }
   }
   return sc_list.GetSize() - prev_size;
 }
 
 void SymbolFileDWARF::PreloadSymbols() {
+  // Get the symbol table for the symbol file prior to taking the module lock
+  // so that it is available without needing to take the module lock. The DWARF
+  // indexing might end up needing to relocate items when DWARF sections are
+  // loaded as they might end up getting the section contents which can call
+  // ObjectFileELF::RelocateSection() which in turn will ask for the symbol
+  // table and can cause deadlocks.
+  GetSymtab();
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   m_index->Preload();
 }
 
 std::recursive_mutex &SymbolFileDWARF::GetModuleMutex() const {
   lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());
   if (module_sp)
     return module_sp->GetMutex();

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

symtab.AddSymbol(
                offset,    // value
                size,      // size
                size != 0, // size_is_valid
                false,     // contains_linker_annotations
                0          // flags
                ));
   }
 
-  symtab.CalculateSymbolSizes();
   symtab.Finalize();
 }
 
 void SymbolFilePDB::FindTypes(
     lldb_private::ConstString name, const CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     lldb_private::TypeMap &types) {

lldb/source/Symbol/ObjectFile.cpp

ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp,
                        lldb::offset_t file_offset, lldb::offset_t length,
                        const lldb::DataBufferSP &data_sp,
                        lldb::offset_t data_offset)
     : ModuleChild(module_sp),
       m_file(), // This file could be different from the original module's file
       m_type(eTypeInvalid), m_strata(eStrataInvalid),
       m_file_offset(file_offset), m_length(length), m_data(), m_process_wp(),
       m_memory_addr(LLDB_INVALID_ADDRESS), m_sections_up(), m_symtab_up(),
-      m_synthetic_symbol_idx(0) {
+      m_symtab_once_up(new llvm::once_flag()) {
   if (file_spec_ptr)
     m_file = *file_spec_ptr;
   if (data_sp)
     m_data.SetData(data_sp, data_offset, length);
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
   LLDB_LOGF(log,
             "%p ObjectFile::ObjectFile() module = %p (%s), file = %s, "
             "file_offset = 0x%8.8" PRIx64 ", size = %" PRIu64,
             static_cast<void *>(this), static_cast<void *>(module_sp.get()),
             module_sp->GetSpecificationDescription().c_str(),
             m_file ? m_file.GetPath().c_str() : "<NULL>", m_file_offset,
             m_length);
 }
 
 ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp,
                        const ProcessSP &process_sp, lldb::addr_t header_addr,
                        DataBufferSP &header_data_sp)
     : ModuleChild(module_sp), m_file(), m_type(eTypeInvalid),
       m_strata(eStrataInvalid), m_file_offset(0), m_length(0), m_data(),
       m_process_wp(process_sp), m_memory_addr(header_addr), m_sections_up(),
-      m_symtab_up(), m_synthetic_symbol_idx(0) {
+      m_symtab_up(), m_symtab_once_up(new llvm::once_flag()) {
   if (header_data_sp)
     m_data.SetData(header_data_sp, 0, header_data_sp->GetByteSize());
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
   LLDB_LOGF(log,
             "%p ObjectFile::ObjectFile() module = %p (%s), process = %p, "
             "header_addr = 0x%" PRIx64,
             static_cast<void *>(this), static_cast<void *>(module_sp.get()),
             module_sp->GetSpecificationDescription().c_str(),
if (must_exist && !FileSystem::Instance().Exists(archive_file))
     return false;
   archive_object.SetString(object);
   return true;
 }
 
 void ObjectFile::ClearSymtab() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
     LLDB_LOGF(log, "%p ObjectFile::ClearSymtab () symtab = %p",
               static_cast<void *>(this),
               static_cast<void *>(m_symtab_up.get()));
+    // Since we need to clear the symbol table, we need a new llvm::once_flag
+    // instance so we can safely create another symbol table
+    m_symtab_once_up.reset(new llvm::once_flag());
     m_symtab_up.reset();
   }
 }
 
 SectionList *ObjectFile::GetSectionList(bool update_module_section_list) {
   if (m_sections_up == nullptr) {
     if (update_module_section_list) {
       ModuleSP module_sp(GetModule());
void llvm::format_provider<ObjectFile::Strata>::format(
   case ObjectFile::eStrataRawImage:
     OS << "raw image";
     break;
   case ObjectFile::eStrataJIT:
     OS << "jit";
     break;
   }
 }
+
+
+Symtab *ObjectFile::GetSymtab() {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    // We can't take the module lock in ObjectFile::GetSymtab() or we can
+    // deadlock in DWARF indexing when any file asks for the symbol table from
+    // an object file. This currently happens in the preloading of symbols in
+    // SymbolFileDWARF::PreloadSymbols() because the main thread will take the
+    // module lock, and then threads will be spun up to index the DWARF and
+    // any of those threads might end up trying to relocate items in the DWARF
+    // sections which causes ObjectFile::GetSectionData(...) to relocate section
+    // data which requires the symbol table.
+    //
+    // So to work around this, we create the symbol table one time using
+    // llvm::once_flag, lock it, and then set the unique pointer. Any other
+    // thread that gets ahold of the symbol table before parsing is done, will
+    // not be able to access the symbol table contents since all APIs in Symtab
+    // are protected by a mutex in the Symtab object itself.
+    llvm::call_once(*m_symtab_once_up, [&]() {
+       ElapsedTime elapsed(module_sp->GetSymtabParseTime());
+       Symtab *symtab = new Symtab(this);
+       std::lock_guard<std::recursive_mutex> symtab_guard(symtab->GetMutex());
+       m_symtab_up.reset(symtab);
+       ParseSymtab(*m_symtab_up);
+       m_symtab_up->Finalize();
+    });
+  }
+  return m_symtab_up.get();
+}

lldb/source/Symbol/Symtab.cpp

if (num_entries > 0) {
       }
 
       // Sort again in case the range size changes the ordering
       m_file_addr_to_index.Sort();
     }
   }
 }
 
-void Symtab::CalculateSymbolSizes() {
+void Symtab::Finalize() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  // Size computation happens inside InitAddressIndexes.
+  // Calculate the size of symbols inside InitAddressIndexes.
   InitAddressIndexes();
+  // Shrink to fit the symbols so we don't waste memory
+  if (m_symbols.capacity() > m_symbols.size()) {
+    collection new_symbols(m_symbols.begin(), m_symbols.end());
+    m_symbols.swap(new_symbols);
+  }
 }
 
 Symbol *Symtab::FindSymbolAtFileAddress(addr_t file_addr) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (!m_file_addr_to_index_computed)
     InitAddressIndexes();
 
   const FileRangeToIndexMap::Entry *entry =