[DWARFSymbolFile] Add the module lock where necessary and assert that we own it.

[JDevlieghere]

Summary

As discussed with Greg at the dev meeting, we need to ensure we have the module lock in the SymbolFile. Usually the symbol file is accessed through the symbol vendor which ensures that the necessary locks are taken. However, there are a few methods that are accessed by the expression parser and were lacking the lock.

This patch adds the locking where necessary and everywhere else asserts that we actually already own the lock.

[clayborg]

It is the SymbolVendor's job to do the locking. And in many cases it already is. I stopped with inlined comments after a few comments as it would apply to this entire patch.

It would be great if we can replace all of the locations where you added lock guards with lldbasserts to assert that the lock is already taken. Then we might be able to catch places where the locks are not being respected. But in general the symbol vendor should take the lock, use N number of SymbolFile instances to complete the request, and then release the lock. Makes things easier on the lldb_private::SymbolFile subclasses this way.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

263–264

This shouldn't require locking as it is just handing out a type list ivar from one place or another.

275–276

This is not a SymbolFile override. It shouldn't require the locking.

439–440

This shouldn't require locking as it is just handing out a type system from one place or another.

860–861

SymbolVendor::GetNumCompileUnits() already takes the module lock for us. All other internal calls to this should be protected as well

867–868

SymbolVendor already takes the module lock for us

880–881

SymbolVendor requests that lead to this call should take the lock for us...

[JDevlieghere]

In D52543#1246877, @clayborg wrote:

It is the SymbolVendor's job to do the locking. And in many cases it already is. I stopped with inlined comments after a few comments as it would apply to this entire patch.

Thanks Greg. Honestly I don't know the code well enough to be sure where we *need* a lock and where we can get away without. Since it's a recursive mutex I figured there's no harm in playing it safe. Not everything goes through the symbol vendor though, for example the backtrace below is the result of a corruption and it looks like we're calling directly into SymbolFileDWARF.

>  1 com.apple.LLDB.framework       0x02f8dcf5 bool llvm::DenseMapBase<llvm::DenseMap<void*, DIERef, llvm::DenseMapInfo<void*>, llvm::detail::DenseMapPair<void*, DIERef> >, void*, DIERef, llvm::DenseMapInfo<void*>, llvm::detail::DenseMapPair<void*, DIERef> >::LookupBucketFor<void*>(void* const&, llvm::detail::DenseMapPair<void*, DIERef> const*&) const + 45
   2 com.apple.LLDB.framework       0x02f8e91e llvm::DenseMapBase<llvm::DenseMap<DWARFDebugInfoEntry const*, clang::Decl*, llvm::DenseMapInfo<DWARFDebugInfoEntry const*>, llvm::detail::DenseMapPair<DWARFDebugInfoEntry const*, clang::Decl*> >, DWARFDebugInfoEntry const*, clang::Decl*, llvm::DenseMapInfo<DWARFDebugInfoEntry const*>, llvm::detail::DenseMapPair<DWARFDebugInfoEntry const*, clang::Decl*> >::FindAndConstruct(DWARFDebugInfoEntry const*&&) + 28
   3 com.apple.LLDB.framework       0x02f81f94 DWARFASTParserClang::ParseTypeFromDWARF(lldb_private::SymbolContext const&, DWARFDIE const&, lldb_private::Log*, bool*) + 6144
   4 com.apple.LLDB.framework       0x03150f75 SymbolFileDWARF::ParseType(lldb_private::SymbolContext const&, DWARFDIE const&, bool*) + 209
   5 com.apple.LLDB.framework       0x0314a70e SymbolFileDWARF::GetTypeForDIE(DWARFDIE const&, bool) + 486
   6 com.apple.LLDB.framework       0x03149ee2 SymbolFileDWARF::ResolveType(DWARFDIE const&, bool, bool) + 68
   7 com.apple.LLDB.framework       0x02f88728 DWARFASTParserClang::GetClangDeclContextForDIE(DWARFDIE const&) + 176
   8 com.apple.LLDB.framework       0x02f8c0ae DWARFASTParserClang::GetDeclContextForUIDFromDWARF(DWARFDIE const&) + 24
   9 com.apple.LLDB.framework       0x031636fe DWARFDIE::GetDeclContext() const + 60
  10 com.apple.LLDB.framework       0x03149dd5 SymbolFileDWARF::GetDeclContextForUID(unsigned long long) + 53
  11 com.apple.LLDB.framework       0x0315c6ed SymbolFileDWARFDebugMap::GetDeclContextForUID(u

It would be great if we can replace all of the locations where you added lock guards with lldbasserts to assert that the lock is already taken. Then we might be able to catch places where the locks are not being respected. But in general the symbol vendor should take the lock, use N number of SymbolFile instances to complete the request, and then release the lock. Makes things easier on the lldb_private::SymbolFile subclasses this way.

That sounds like a really good idea, I'll definitely do that.

[JDevlieghere]

My first observations:

• We call ResolveTypeUID without going through the symbol vendor (similar to GetDeclContextForUID in the stack trace). This is easy to fix, just add locking to these functions.
• The module in the symbol vendor is different from the one in the symbol file. This seems more tricky and I'm not sure if this expected?

I looked at TestCallCPPFunction where my newly added assertion triggered in ParseCompileUnitSupportFiles which I found odd since we're taking the module lock in symbol vendor.

frame #4: 0x000000010590c083 _lldb.so`lldb_private::SymbolFile::AssertModuleLock(this=0x000000010388ac00) at SymbolFile.cpp:160
   157    // We assert that we have to module lock by trying to acquire the lock from a
   158    // different thread. Note that we must abort if the result is true to
   159    // guarantee correctness.
-> 160    assert(std::async(
   161               std::launch::async,
   162               [this] {
   163                 return this->GetObjectFile()->GetModule()->GetMutex().try_lock();
(lldb) p GetObjectFile()->GetModule()
(lldb::ModuleSP) $1 = std::__1::shared_ptr<lldb_private::Module>::element_type @ 0x0000000118905378 strong=1 weak=1 {
  __ptr_ = 0x0000000118905378
}
(lldb) fr sel 7
frame #7: 0x000000010591035b _lldb.so`lldb_private::SymbolVendor::ParseCompileUnitSupportFiles(this=0x0000000100184f90, sc=0x00007ffeefbf79a8, support_files=0x0000000118904d70) at SymbolVendor.cpp:171
   168    if (module_sp) {
   169      std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
   170      if (m_sym_file_ap.get())
-> 171        return m_sym_file_ap->ParseCompileUnitSupportFiles(sc, support_files);
   172    }
   173    return false;
   174  }
(lldb) p module_sp
(lldb::ModuleSP) $0 = std::__1::shared_ptr<lldb_private::Module>::element_type @ 0x0000000100189ec0 strong=6 weak=18 {
  __ptr_ = 0x0000000100189ec0
}

[JDevlieghere]

• Add assertions per Greg's suggestion.

[xbolva00]

source/Symbol/SymbolFile.cpp

164

lldbassert?

[clayborg]

See inlined comments

include/lldb/Symbol/SymbolFile.h

104

Might add a comment here stating something like "Symbols file subclasses should override this to return the Module that owns the TypeSystem that this symbol file modifies type information in".

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

2022–2025

Possible race condition and crasher here. Best coded as:

lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());
if (module_sp)
  return module_sp->GetMutex();
return GetObjectFile()->GetModule()->GetMutex();

Otherwise some other thread could clear "m_debug_map_module_wp" after "m_debug_map_module_wp.expired()" is called, but before "m_debug_map_module_wp.lock()" is called and we would crash.

source/Symbol/SymbolFile.cpp

160–168

We should make this entire thing and all uses of it into a macro so we can enable it for Debug builds, but disable it for Release builds and have no extra code in release builds. We really shouldn't be starting threads up all the time for every function in SymbolFile subclasses for Release builds. It is ok for Debug builds or maybe manually enable this when we run into issues, but this is too expensive to leave in for all builds.

[JDevlieghere]

Address Greg's feedback.

[clayborg]

LGTM

[JDevlieghere]

I think we can close this after rL344945?

[clayborg]

yep

include/lldb/Symbol/SymbolFile.h

 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/DenseSet.h"
 
+#include <mutex>
+
+#if defined(LLDB_CONFIGURATION_DEBUG)
+#define ASSERT_MODULE_LOCK(expr) (expr->AssertModuleLock();)
+#else
+#define ASSERT_MODULE_LOCK(expr) ((void)0)
+#endif
+
 namespace lldb_private {
 
 class SymbolFile : public PluginInterface {
 public:
   //------------------------------------------------------------------
   // Symbol file ability bits.
   //
   // Each symbol file can claim to support one or more symbol file abilities.
if (!m_calculated_abilities) {
       m_calculated_abilities = true;
     }
 
     return m_abilities;
   }
 
   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.
   //------------------------------------------------------------------
public:
   /// Notify the SymbolFile that the file addresses in the Sections
   /// for this module have been changed.
   //------------------------------------------------------------------
   virtual void SectionFileAddressesChanged() {}
 
   virtual void Dump(Stream &s) {}
 
 protected:
+  void AssertModuleLock();
+
   ObjectFile *m_obj_file; // The object file that symbols can be extracted from.
   uint32_t m_abilities;
   bool m_calculated_abilities;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(SymbolFile);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_SymbolFile_h_

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
 
   lldb_private::CompilerDeclContext FindNamespace(
       const lldb_private::SymbolContext &sc,
       const lldb_private::ConstString &name,
       const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
 
   void PreloadSymbols() override;
 
+  std::recursive_mutex &GetModuleMutex() const override;
+
   //------------------------------------------------------------------
   // PluginInterface protocol
   //------------------------------------------------------------------
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
   const lldb_private::DWARFDataExtractor &get_debug_abbrev_data();

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

const char *SymbolFileDWARF::GetPluginDescriptionStatic() {
   return "DWARF and DWARF3 debug symbol file reader.";
 }
 
 SymbolFile *SymbolFileDWARF::CreateInstance(ObjectFile *obj_file) {
   return new SymbolFileDWARF(obj_file);
 }
 
 TypeList *SymbolFileDWARF::GetTypeList() {
+  // This method can be called without going through the symbol vendor so we
+  // need to lock the module.
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
   if (debug_map_symfile)
     return debug_map_symfile->GetTypeList();
   else
     return m_obj_file->GetModule()->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)
       return;
 
     if (die_offset >= min_die_offset) {
       const dw_tag_t tag = die.Tag();
 
       bool add_type = false;
if (die) {
     }
   }
 }
 
 size_t SymbolFileDWARF::GetTypes(SymbolContextScope *sc_scope,
                                  uint32_t type_mask, TypeList &type_list)
 
 {
+  ASSERT_MODULE_LOCK(this);
   TypeSet type_set;
 
   CompileUnit *comp_unit = NULL;
   DWARFUnit *dwarf_cu = NULL;
   if (sc_scope)
     comp_unit = sc_scope->CalculateSymbolContextCompileUnit();
 
   if (comp_unit) {
UniqueDWARFASTTypeMap &SymbolFileDWARF::GetUniqueDWARFASTTypeMap() {
   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
   if (debug_map_symfile)
     return debug_map_symfile->GetUniqueDWARFASTTypeMap();
   else
     return m_unique_ast_type_map;
 }
 
 TypeSystem *SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) {
   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
   TypeSystem *type_system;
   if (debug_map_symfile) {
     type_system = debug_map_symfile->GetTypeSystemForLanguage(language);
   } else {
     type_system = m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
     if (type_system)
       type_system->SetSymbolFile(this);
   }
   return type_system;
if (comp_unit) {
         }
       }
     }
   }
   return cu_sp;
 }
 
 uint32_t SymbolFileDWARF::GetNumCompileUnits() {
   DWARFDebugInfo *info = DebugInfo();
   if (info)
     return info->GetNumCompileUnits();
   return 0;
 }
 
 CompUnitSP SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx) {
+  ASSERT_MODULE_LOCK(this);
   CompUnitSP cu_sp;
   DWARFDebugInfo *info = DebugInfo();
   if (info) {
     DWARFUnit *dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
     if (dwarf_cu)
       cu_sp = ParseCompileUnit(dwarf_cu, cu_idx);
   }
   return cu_sp;
 }
 
 Function *SymbolFileDWARF::ParseCompileUnitFunction(const SymbolContext &sc,
                                                     const DWARFDIE &die) {
+  ASSERT_MODULE_LOCK(this);
   if (die.IsValid()) {
     TypeSystem *type_system =
         GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
 
     if (type_system) {
       DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
       if (dwarf_ast)
         return dwarf_ast->ParseFunctionFromDWARF(sc, die);
     }
   }
   return nullptr;
 }
 
 bool SymbolFileDWARF::FixupAddress(Address &addr) {
   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
   if (debug_map_symfile) {
     return debug_map_symfile->LinkOSOAddress(addr);
   }
   // This is a normal DWARF file, no address fixups need to happen
   return true;
 }
 lldb::LanguageType
 SymbolFileDWARF::ParseCompileUnitLanguage(const SymbolContext &sc) {
+  ASSERT_MODULE_LOCK(this);
   assert(sc.comp_unit);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu)
     return dwarf_cu->GetLanguageType();
   else
     return eLanguageTypeUnknown;
 }
 
 size_t SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc) {
+  ASSERT_MODULE_LOCK(this);
   assert(sc.comp_unit);
   size_t functions_added = 0;
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     DWARFDIECollection function_dies;
     const size_t num_functions =
         dwarf_cu->AppendDIEsWithTag(DW_TAG_subprogram, function_dies);
     size_t func_idx;
     for (func_idx = 0; func_idx < num_functions; ++func_idx) {
       DWARFDIE die = function_dies.GetDIEAtIndex(func_idx);
       if (sc.comp_unit->FindFunctionByUID(die.GetID()).get() == NULL) {
         if (ParseCompileUnitFunction(sc, die))
           ++functions_added;
       }
     }
     // FixupTypes();
   }
   return functions_added;
 }
 
 bool SymbolFileDWARF::ParseCompileUnitSupportFiles(
     const SymbolContext &sc, FileSpecList &support_files) {
+  ASSERT_MODULE_LOCK(this);
   assert(sc.comp_unit);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     const DWARFBaseDIE cu_die = dwarf_cu->GetUnitDIEOnly();
 
     if (cu_die) {
       FileSpec cu_comp_dir = resolveCompDir(
           cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr));
if (cu_die) {
       }
     }
   }
   return false;
 }
 
 bool SymbolFileDWARF::ParseCompileUnitIsOptimized(
     const lldb_private::SymbolContext &sc) {
+  ASSERT_MODULE_LOCK(this);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu)
     return dwarf_cu->GetIsOptimized();
   return false;
 }
 
 bool SymbolFileDWARF::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
     std::vector<lldb_private::ConstString> &imported_modules) {
+  ASSERT_MODULE_LOCK(this);
   assert(sc.comp_unit);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     if (ClangModulesDeclVendor::LanguageSupportsClangModules(
             sc.comp_unit->GetLanguage())) {
       UpdateExternalModuleListIfNeeded();
 
       if (sc.comp_unit) {
if (state.end_sequence) {
       line_table->InsertSequence(info->sequence_ap.get());
       // Then, empty it to prepare for the next sequence.
       info->sequence_ap->Clear();
     }
   }
 }
 
 bool SymbolFileDWARF::ParseCompileUnitLineTable(const SymbolContext &sc) {
+  ASSERT_MODULE_LOCK(this);
   assert(sc.comp_unit);
   if (sc.comp_unit->GetLineTable() != NULL)
     return true;
 
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
     if (dwarf_cu_die) {
SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset) {
   DWARFDebugMacroEntry::ReadMacroEntries(debug_macro_data, get_debug_str_data(),
                                          header.OffsetIs64Bit(), offset, this,
                                          debug_macros_sp);
 
   return debug_macros_sp;
 }
 
 bool SymbolFileDWARF::ParseCompileUnitDebugMacros(const SymbolContext &sc) {
+  ASSERT_MODULE_LOCK(this);
   assert(sc.comp_unit);
 
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu == nullptr)
     return false;
 
   const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
   if (!dwarf_cu_die)
void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
 
   for (DWARFDIE decl_ctx_die : decl_ctx_die_list)
     for (DWARFDIE decl = decl_ctx_die.GetFirstChild(); decl;
          decl = decl.GetSibling())
       ast_parser->GetDeclForUIDFromDWARF(decl);
 }
 
 SymbolFileDWARF *SymbolFileDWARF::GetDWARFForUID(lldb::user_id_t uid) {
+  // This method can be called without going through the symbol vendor so we
+  // need to lock the module.
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API we
   // must make sure we use the correct DWARF file when resolving things. On
   // MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
   // SymbolFileDWARF classes, one for each .o file. We can often end up with
   // references to other DWARF objects and we must be ready to receive a
   // "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
   // instance.
   SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile();
   if (debug_map)
     return debug_map->GetSymbolFileByOSOIndex(
         debug_map->GetOSOIndexFromUserID(uid));
   return this;
 }
 
 DWARFDIE
 SymbolFileDWARF::GetDIEFromUID(lldb::user_id_t uid) {
+  // This method can be called without going through the symbol vendor so we
+  // need to lock the module.
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API we
   // must make sure we use the correct DWARF file when resolving things. On
   // MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
   // SymbolFileDWARF classes, one for each .o file. We can often end up with
   // references to other DWARF objects and we must be ready to receive a
   // "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
   // instance.
   SymbolFileDWARF *dwarf = GetDWARFForUID(uid);
   if (dwarf)
     return dwarf->GetDIE(DIERef(uid, dwarf));
   return DWARFDIE();
 }
 
 CompilerDecl SymbolFileDWARF::GetDeclForUID(lldb::user_id_t type_uid) {
+  // This method can be called without going through the symbol vendor so we
+  // need to lock the module.
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
   // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
   // SymbolFileDWARF::GetDIEFromUID() for details.
   DWARFDIE die = GetDIEFromUID(type_uid);
   if (die)
     return die.GetDecl();
   return CompilerDecl();
 }
 
 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextForUID(lldb::user_id_t type_uid) {
+  // This method can be called without going through the symbol vendor so we
+  // need to lock the module.
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
   // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
   // SymbolFileDWARF::GetDIEFromUID() for details.
   DWARFDIE die = GetDIEFromUID(type_uid);
   if (die)
     return die.GetDeclContext();
   return CompilerDeclContext();
 }
 
 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextContainingUID(lldb::user_id_t type_uid) {
+  // This method can be called without going through the symbol vendor so we
+  // need to lock the module.
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
   // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
   // SymbolFileDWARF::GetDIEFromUID() for details.
   DWARFDIE die = GetDIEFromUID(type_uid);
   if (die)
     return die.GetContainingDeclContext();
   return CompilerDeclContext();
 }
 
 Type *SymbolFileDWARF::ResolveTypeUID(lldb::user_id_t type_uid) {
+  // This method can be called without going through the symbol vendor so we
+  // need to lock the module.
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
   // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
   // SymbolFileDWARF::GetDIEFromUID() for details.
   DWARFDIE type_die = GetDIEFromUID(type_uid);
   if (type_die)
     return type_die.ResolveType();
   else
     return nullptr;
bool SymbolFileDWARF::HasForwardDeclForClangType(
   if (!clang_type_system)
     return false;
   DWARFASTParserClang *ast_parser =
       static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
   return ast_parser->GetClangASTImporter().CanImport(compiler_type);
 }
 
 bool SymbolFileDWARF::CompleteType(CompilerType &compiler_type) {
-  std::lock_guard<std::recursive_mutex> guard(
-      GetObjectFile()->GetModule()->GetMutex());
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
   ClangASTContext *clang_type_system =
       llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem());
   if (clang_type_system) {
     DWARFASTParserClang *ast_parser =
         static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
     if (ast_parser &&
         ast_parser->GetClangASTImporter().CanImport(compiler_type))
if (debug_info) {
         }
       }
     }
   }
   return sc_list.GetSize() - prev_size;
 }
 
 void SymbolFileDWARF::PreloadSymbols() {
-  std::lock_guard<std::recursive_mutex> guard(
-      GetObjectFile()->GetModule()->GetMutex());
+  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();
+  return GetObjectFile()->GetModule()->GetMutex();
+}
+
 bool SymbolFileDWARF::DeclContextMatchesThisSymbolFile(
     const lldb_private::CompilerDeclContext *decl_ctx) {
   if (decl_ctx == nullptr || !decl_ctx->IsValid()) {
     // Invalid namespace decl which means we aren't matching only things in
     // this symbol file, so return true to indicate it matches this symbol
     // file.
     return true;
   }
if (parse_siblings)
       die = die.GetSibling();
     else
       die.Clear();
   }
   return types_added;
 }
 
 size_t SymbolFileDWARF::ParseFunctionBlocks(const SymbolContext &sc) {
+  ASSERT_MODULE_LOCK(this);
   assert(sc.comp_unit && sc.function);
   size_t functions_added = 0;
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     const dw_offset_t function_die_offset = sc.function->GetID();
     DWARFDIE function_die = dwarf_cu->GetDIE(function_die_offset);
     if (function_die) {
       ParseFunctionBlocks(sc, &sc.function->GetBlock(false), function_die,
                           LLDB_INVALID_ADDRESS, 0);
     }
   }
 
   return functions_added;
 }
 
 size_t SymbolFileDWARF::ParseTypes(const SymbolContext &sc) {
+  ASSERT_MODULE_LOCK(this);
   // At least a compile unit must be valid
   assert(sc.comp_unit);
   size_t types_added = 0;
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     if (sc.function) {
       dw_offset_t function_die_offset = sc.function->GetID();
       DWARFDIE func_die = dwarf_cu->GetDIE(function_die_offset);
       if (func_die && func_die.HasChildren()) {
         types_added = ParseTypes(sc, func_die.GetFirstChild(), true, true);
       }
     } else {
       DWARFDIE dwarf_cu_die = dwarf_cu->DIE();
       if (dwarf_cu_die && dwarf_cu_die.HasChildren()) {
         types_added = ParseTypes(sc, dwarf_cu_die.GetFirstChild(), true, true);
       }
     }
   }
 
   return types_added;
 }
 
 size_t SymbolFileDWARF::ParseVariablesForContext(const SymbolContext &sc) {
+  ASSERT_MODULE_LOCK(this);
   if (sc.comp_unit != NULL) {
     DWARFDebugInfo *info = DebugInfo();
     if (info == NULL)
       return 0;
 
     if (sc.function) {
       DWARFDIE function_die = info->GetDIE(DIERef(sc.function->GetID(), this));
 

source/Symbol/SymbolFile.cpp

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-private.h"
 
+#include <future>
+
 using namespace lldb_private;
 
 void SymbolFile::PreloadSymbols() {
   // No-op for most implementations.
 }
 
+std::recursive_mutex &SymbolFile::GetModuleMutex() const {
+  return GetObjectFile()->GetModule()->GetMutex();
+}
+
 SymbolFile *SymbolFile::FindPlugin(ObjectFile *obj_file) {
   std::unique_ptr<SymbolFile> best_symfile_ap;
   if (obj_file != nullptr) {
 
     // We need to test the abilities of this section list. So create what it
     // would be with this new obj_file.
     lldb::ModuleSP module_sp(obj_file->GetModule());
     if (module_sp) {

 }
 
 size_t SymbolFile::FindTypes(const std::vector<CompilerContext> &context,
                              bool append, TypeMap &types) {
   if (!append)
     types.Clear();
   return 0;
 }
+
+void SymbolFile::AssertModuleLock() {
+  // The code below is too expensive to leave enabled in release builds. It's
+  // enabled in debug builds or when the correct macro is set.
+#if defined(LLDB_CONFIGURATION_DEBUG)
+  // We assert that we have to module lock by trying to acquire the lock from a
+  // different thread. Note that we must abort if the result is true to
+  // guarantee correctness.
+  assert(std::async(std::launch::async,
+                    [this] { return this->GetModuleMutex().try_lock(); })
+                 .get() == false &&
+         "Module is not locked");
+#endif
+}