SymbolVendor: Move locking into the Symbol Files

[labath]

Summary

The last bit of functionality in SymbolVendor passthrough functions is
the locking the module mutex. While it may be nice doing the locking in
a central place, we weren't really succesful in doing that right now,
because some SymbolFile function could still be called without going
through the SymbolVendor. This meant in SymbolFileDWARF (the only
battle-tested symbol file implementation) roughly a half of the
functions was taking additional locks and another half was asserting
that the lock is already held. By making the SymbolFile responsible for
locking, we can at least make the situation in SymbolFileDWARF more
consistent.

[clayborg]

We will need to watch future submissions closely as this increases the chance that someone will extend a SymbolFile by overriding a virtual function and forget to lock.

[labath]

In D65329#1604847, @clayborg wrote:

We will need to watch future submissions closely as this increases the chance that someone will extend a SymbolFile by overriding a virtual function and forget to lock.

I've though about addressing that by moving the actual implementations into private versions of these functions, and putting the locking into public functions which would just take the lock and then call the private version (essentially doing the same thing as it's done now, only without the methods being on different classes). I didn't do that now because:
a) it wouldn't make SymbolFileDWARF consistent anyway as it already has private methods which take the module lock
b) it forces a certain locking pattern on all the subclasses, whereas some subclasses could potentially want to implement a different locking strategy

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

 }
 
 size_t SymbolFileBreakpad::ParseFunctions(CompileUnit &comp_unit) {
   // TODO
   return 0;
 }
 
 bool SymbolFileBreakpad::ParseLineTable(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   CompUnitData &data = m_cu_data->GetEntryRef(comp_unit.GetID()).data;
 
   if (!data.line_table_up)
     ParseLineTableAndSupportFiles(comp_unit, data);
 
   comp_unit.SetLineTable(data.line_table_up.release());
   return true;
 }
 
 bool SymbolFileBreakpad::ParseSupportFiles(CompileUnit &comp_unit,
                                            FileSpecList &support_files) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   CompUnitData &data = m_cu_data->GetEntryRef(comp_unit.GetID()).data;
   if (!data.support_files)
     ParseLineTableAndSupportFiles(comp_unit, data);
 
   support_files = std::move(*data.support_files);
   return true;
 }
 
 uint32_t
 SymbolFileBreakpad::ResolveSymbolContext(const Address &so_addr,
                                          SymbolContextItem resolve_scope,
                                          SymbolContext &sc) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!(resolve_scope & (eSymbolContextCompUnit | eSymbolContextLineEntry)))
     return 0;
 
   ParseCUData();
   uint32_t idx =
       m_cu_data->FindEntryIndexThatContains(so_addr.GetFileAddress());
   if (idx == UINT32_MAX)
     return 0;
 
   sc.comp_unit = GetCompileUnitAtIndex(idx).get();
   SymbolContextItem result = eSymbolContextCompUnit;
   if (resolve_scope & eSymbolContextLineEntry) {
     if (sc.comp_unit->GetLineTable()->FindLineEntryByAddress(so_addr,
                                                              sc.line_entry)) {
       result |= eSymbolContextLineEntry;
     }
   }
 
   return result;
 }
 
 uint32_t SymbolFileBreakpad::ResolveSymbolContext(
     const FileSpec &file_spec, uint32_t line, bool check_inlines,
     lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!(resolve_scope & eSymbolContextCompUnit))
     return 0;
 
   uint32_t old_size = sc_list.GetSize();
   for (size_t i = 0, size = GetNumCompileUnits(); i < size; ++i) {
     CompileUnit &cu = *GetCompileUnitAtIndex(i);
     cu.ResolveSymbolContext(file_spec, line, check_inlines,
                             /*exact*/ false, resolve_scope, sc_list);

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

 }
 
 SymbolFile *SymbolFileDWARF::CreateInstance(ObjectFile *obj_file) {
   return new SymbolFileDWARF(obj_file,
                              /*dwo_section_list*/ nullptr);
 }
 
 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());
   if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
     return debug_map_symfile->GetTypeList();
   return SymbolFile::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) {
     }
   }
 }
 
 size_t SymbolFileDWARF::GetTypes(SymbolContextScope *sc_scope,
                                  TypeClass type_mask, TypeList &type_list)
 
 {
-  ASSERT_MODULE_LOCK(this);
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   TypeSet type_set;
 
   CompileUnit *comp_unit = nullptr;
   DWARFUnit *dwarf_cu = nullptr;
   if (sc_scope)
     comp_unit = sc_scope->CalculateSymbolContextCompileUnit();
 
   if (comp_unit) {
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::ParseLanguage(CompileUnit &comp_unit) {
-  ASSERT_MODULE_LOCK(this);
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
     return dwarf_cu->GetLanguageType();
   else
     return eLanguageTypeUnknown;
 }
 
 size_t SymbolFileDWARF::ParseFunctions(CompileUnit &comp_unit) {
-  ASSERT_MODULE_LOCK(this);
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (!dwarf_cu)
     return 0;
 
   size_t functions_added = 0;
   std::vector<DWARFDIE> function_dies;
   dwarf_cu->AppendDIEsWithTag(DW_TAG_subprogram, function_dies);
   for (const DWARFDIE &die : function_dies) {
     if (comp_unit.FindFunctionByUID(die.GetID()))
       continue;
     if (ParseFunction(comp_unit, die))
       ++functions_added;
   }
   // FixupTypes();
   return functions_added;
 }
 
 bool SymbolFileDWARF::ParseSupportFiles(CompileUnit &comp_unit,
                                         FileSpecList &support_files) {
-  ASSERT_MODULE_LOCK(this);
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (DWARFUnit *unit = GetDWARFCompileUnit(&comp_unit)) {
     const dw_offset_t stmt_list = unit->GetLineTableOffset();
     if (stmt_list != DW_INVALID_OFFSET) {
       // All file indexes in DWARF are one based and a file of index zero is
       // supposed to be the compile unit itself.
       support_files.Append(comp_unit);
       return DWARFDebugLine::ParseSupportFiles(comp_unit.GetModule(),
                                                m_context.getOrLoadLineData(),
if (iter_bool.second) {
     DWARFDebugLine::ParseSupportFiles(GetObjectFile()->GetModule(),
                                       m_context.getOrLoadLineData(), offset,
                                       list, &tu);
   }
   return list;
 }
 
 bool SymbolFileDWARF::ParseIsOptimized(CompileUnit &comp_unit) {
-  ASSERT_MODULE_LOCK(this);
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
     return dwarf_cu->GetIsOptimized();
   return false;
 }
 
 bool SymbolFileDWARF::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
     std::vector<SourceModule> &imported_modules) {
-  ASSERT_MODULE_LOCK(this);
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   assert(sc.comp_unit);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (!dwarf_cu)
     return false;
   if (!ClangModulesDeclVendor::LanguageSupportsClangModules(
           sc.comp_unit->GetLanguage()))
     return false;
   UpdateExternalModuleListIfNeeded();
SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset) {
   DWARFDebugMacroEntry::ReadMacroEntries(
       debug_macro_data, m_context.getOrLoadStrData(), header.OffsetIs64Bit(),
       offset, this, debug_macros_sp);
 
   return debug_macros_sp;
 }
 
 bool SymbolFileDWARF::ParseDebugMacros(CompileUnit &comp_unit) {
-  ASSERT_MODULE_LOCK(this);
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu == nullptr)
     return false;
 
   const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
   if (!dwarf_cu_die)
     return false;
SymbolFileDWARF::GetDeclContextForUID(lldb::user_id_t type_uid) {
   // SymbolFileDWARF::GetDIE() for details.
   if (DWARFDIE die = GetDIE(type_uid))
     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::GetDIE(). See comments inside the
   // SymbolFileDWARF::GetDIE() for details.
   if (DWARFDIE die = GetDIE(type_uid))
     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::GetDIE(). See comments inside the
   // SymbolFileDWARF::GetDIE() for details.
   if (DWARFDIE type_die = GetDIE(type_uid))
     return type_die.ResolveType();
   else
     return nullptr;
if (!m_global_aranges_up) {
     m_global_aranges_up->Sort();
   }
   return *m_global_aranges_up;
 }
 
 uint32_t SymbolFileDWARF::ResolveSymbolContext(const Address &so_addr,
                                                SymbolContextItem resolve_scope,
                                                SymbolContext &sc) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat,
                      "SymbolFileDWARF::"
                      "ResolveSymbolContext (so_addr = { "
                      "section = %p, offset = 0x%" PRIx64
                      " }, resolve_scope = 0x%8.8x)",
                      static_cast<void *>(so_addr.GetSection().get()),
                      so_addr.GetOffset(), resolve_scope);
uint32_t SymbolFileDWARF::ResolveSymbolContext(const Address &so_addr,
   return resolved;
 }
 
 uint32_t SymbolFileDWARF::ResolveSymbolContext(const FileSpec &file_spec,
                                                uint32_t line,
                                                bool check_inlines,
                                                SymbolContextItem resolve_scope,
                                                SymbolContextList &sc_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   const uint32_t prev_size = sc_list.GetSize();
   if (resolve_scope & eSymbolContextCompUnit) {
     for (uint32_t cu_idx = 0, num_cus = GetNumCompileUnits(); cu_idx < num_cus;
          ++cu_idx) {
       CompileUnit *dc_cu = ParseCompileUnitAtIndex(cu_idx).get();
       if (!dc_cu)
         continue;
 
GetObjectFile()->GetModule()->LogMessage(
         log, "Valid namespace does not match symbol file");
 
   return false;
 }
 
 uint32_t SymbolFileDWARF::FindGlobalVariables(
     ConstString name, const CompilerDeclContext *parent_decl_ctx,
     uint32_t max_matches, VariableList &variables) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log)
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
         "parent_decl_ctx=%p, max_matches=%u, variables)",
         name.GetCString(), static_cast<const void *>(parent_decl_ctx),
GetObjectFile()->GetModule()->LogMessage(
         max_matches, num_matches);
   }
   return num_matches;
 }
 
 uint32_t SymbolFileDWARF::FindGlobalVariables(const RegularExpression &regex,
                                               uint32_t max_matches,
                                               VariableList &variables) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", "
         "max_matches=%u, variables)",
         regex.GetText().str().c_str(), max_matches);
bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext *decl_ctx,
   }
   return false;
 }
 
 uint32_t SymbolFileDWARF::FindFunctions(
     ConstString name, const CompilerDeclContext *parent_decl_ctx,
     FunctionNameType name_type_mask, bool include_inlines, bool append,
     SymbolContextList &sc_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (name = '%s')",
                      name.AsCString());
 
   // eFunctionNameTypeAuto should be pre-resolved by a call to
   // Module::LookupInfo::LookupInfo()
   assert((name_type_mask & eFunctionNameTypeAuto) == 0);
 
GetObjectFile()->GetModule()->LogMessage(
         num_matches);
   }
   return num_matches;
 }
 
 uint32_t SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
                                         bool include_inlines, bool append,
                                         SymbolContextList &sc_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (regex = '%s')",
                      regex.GetText().str().c_str());
 
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
void SymbolFileDWARF::GetMangledNamesForFunction(
   }
 }
 
 uint32_t SymbolFileDWARF::FindTypes(
     ConstString name, const CompilerDeclContext *parent_decl_ctx,
     bool append, uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // If we aren't appending the results to this list, then clear the list
   if (!append)
     types.Clear();
 
   // Make sure we haven't already searched this SymbolFile before...
   if (searched_symbol_files.count(this))
     return 0;
   else
if (num_die_matches) {
     }
   }
 
   return 0;
 }
 
 size_t SymbolFileDWARF::FindTypes(const std::vector<CompilerContext> &context,
                                   bool append, TypeMap &types) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!append)
     types.Clear();
 
   if (context.empty())
     return 0;
 
   ConstString name = context.back().name;
 
if (num_die_matches) {
     return num_matches;
   }
   return 0;
 }
 
 CompilerDeclContext
 SymbolFileDWARF::FindNamespace(ConstString name,
                                const CompilerDeclContext *parent_decl_ctx) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
         log, "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")",
         name.GetCString());
   }
 
if (parse_siblings)
       die = die.GetSibling();
     else
       die.Clear();
   }
   return types_added;
 }
 
 size_t SymbolFileDWARF::ParseBlocksRecursive(Function &func) {
-  ASSERT_MODULE_LOCK(this);
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   CompileUnit *comp_unit = func.GetCompileUnit();
   lldbassert(comp_unit);
 
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(comp_unit);
   if (!dwarf_cu)
     return 0;
 
   size_t functions_added = 0;
   const dw_offset_t function_die_offset = func.GetID();
   DWARFDIE function_die = dwarf_cu->GetDIE(function_die_offset);
   if (function_die) {
     ParseBlocksRecursive(*comp_unit, &func.GetBlock(false), function_die,
                          LLDB_INVALID_ADDRESS, 0);
   }
 
   return functions_added;
 }
 
 size_t SymbolFileDWARF::ParseTypes(CompileUnit &comp_unit) {
-  ASSERT_MODULE_LOCK(this);
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   size_t types_added = 0;
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu) {
     DWARFDIE dwarf_cu_die = dwarf_cu->DIE();
     if (dwarf_cu_die && dwarf_cu_die.HasChildren()) {
       SymbolContext sc;
       sc.comp_unit = &comp_unit;
       types_added = ParseTypes(sc, dwarf_cu_die.GetFirstChild(), true, true);
     }
   }
 
   return types_added;
 }
 
 size_t SymbolFileDWARF::ParseVariablesForContext(const SymbolContext &sc) {
-  ASSERT_MODULE_LOCK(this);
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (sc.comp_unit != nullptr) {
     DWARFDebugInfo *info = DebugInfo();
     if (info == nullptr)
       return 0;
 
     if (sc.function) {
       DWARFDIE function_die = GetDIE(sc.function->GetID());
 

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

for (uint32_t i = 0; i < cu_count; ++i) {
     if (module == GetModuleByCompUnitInfo(&m_compile_unit_infos[i]))
       cu_infos.push_back(&m_compile_unit_infos[i]);
   }
   return cu_infos.size();
 }
 
 lldb::LanguageType
 SymbolFileDWARFDebugMap::ParseLanguage(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseLanguage(comp_unit);
   return eLanguageTypeUnknown;
 }
 
 size_t SymbolFileDWARFDebugMap::ParseFunctions(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseFunctions(comp_unit);
   return 0;
 }
 
 bool SymbolFileDWARFDebugMap::ParseLineTable(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseLineTable(comp_unit);
   return false;
 }
 
 bool SymbolFileDWARFDebugMap::ParseDebugMacros(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseDebugMacros(comp_unit);
   return false;
 }
 
 bool SymbolFileDWARFDebugMap::ParseSupportFiles(CompileUnit &comp_unit,
                                                 FileSpecList &support_files) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseSupportFiles(comp_unit, support_files);
   return false;
 }
 
 bool SymbolFileDWARFDebugMap::ParseIsOptimized(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseIsOptimized(comp_unit);
   return false;
 }
 
 bool SymbolFileDWARFDebugMap::ParseImportedModules(
     const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
   if (oso_dwarf)
     return oso_dwarf->ParseImportedModules(sc, imported_modules);
   return false;
 }
 
 size_t SymbolFileDWARFDebugMap::ParseBlocksRecursive(Function &func) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   CompileUnit *comp_unit = func.GetCompileUnit();
   if (!comp_unit)
     return 0;
 
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(*comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseBlocksRecursive(func);
   return 0;
 }
 
 size_t SymbolFileDWARFDebugMap::ParseTypes(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseTypes(comp_unit);
   return 0;
 }
 
 size_t
 SymbolFileDWARFDebugMap::ParseVariablesForContext(const SymbolContext &sc) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
   if (oso_dwarf)
     return oso_dwarf->ParseVariablesForContext(sc);
   return 0;
 }
 
 Type *SymbolFileDWARFDebugMap::ResolveTypeUID(lldb::user_id_t type_uid) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid);
   SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
   if (oso_dwarf)
     return oso_dwarf->ResolveTypeUID(type_uid);
   return nullptr;
 }
 
 llvm::Optional<SymbolFile::ArrayInfo>
bool SymbolFileDWARFDebugMap::CompleteType(CompilerType &compiler_type) {
   }
   return success;
 }
 
 uint32_t
 SymbolFileDWARFDebugMap::ResolveSymbolContext(const Address &exe_so_addr,
                                               SymbolContextItem resolve_scope,
                                               SymbolContext &sc) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   uint32_t resolved_flags = 0;
   Symtab *symtab = m_obj_file->GetSymtab();
   if (symtab) {
     const addr_t exe_file_addr = exe_so_addr.GetFileAddress();
 
     const DebugMap::Entry *debug_map_entry =
         m_debug_map.FindEntryThatContains(exe_file_addr);
     if (debug_map_entry) {
if (symtab) {
     }
   }
   return resolved_flags;
 }
 
 uint32_t SymbolFileDWARFDebugMap::ResolveSymbolContext(
     const FileSpec &file_spec, uint32_t line, bool check_inlines,
     SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   const uint32_t initial = sc_list.GetSize();
   const uint32_t cu_count = GetNumCompileUnits();
 
   for (uint32_t i = 0; i < cu_count; ++i) {
     // If we are checking for inlines, then we need to look through all compile
     // units no matter if "file_spec" matches.
     bool resolve = check_inlines;
 
for (size_t i = 0; i < match_count; ++i) {
     }
   }
   return variables.GetSize() - original_size;
 }
 
 uint32_t SymbolFileDWARFDebugMap::FindGlobalVariables(
     ConstString name, const CompilerDeclContext *parent_decl_ctx,
     uint32_t max_matches, VariableList &variables) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
   // Remember how many variables are in the list before we search.
   const uint32_t original_size = variables.GetSize();
 
   uint32_t total_matches = 0;
 
   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
     const uint32_t oso_matches = oso_dwarf->FindGlobalVariables(
uint32_t SymbolFileDWARFDebugMap::FindGlobalVariables(
   // Return the number of variable that were appended to the list
   return variables.GetSize() - original_size;
 }
 
 uint32_t
 SymbolFileDWARFDebugMap::FindGlobalVariables(const RegularExpression &regex,
                                              uint32_t max_matches,
                                              VariableList &variables) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Remember how many variables are in the list before we search.
   const uint32_t original_size = variables.GetSize();
 
   uint32_t total_matches = 0;
   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
     const uint32_t oso_matches =
         oso_dwarf->FindGlobalVariables(regex, max_matches, variables);
     if (oso_matches > 0) {
while (i < sc_list.GetSize()) {
     ++i;
   }
 }
 
 uint32_t SymbolFileDWARFDebugMap::FindFunctions(
     ConstString name, const CompilerDeclContext *parent_decl_ctx,
     FunctionNameType name_type_mask, bool include_inlines, bool append,
     SymbolContextList &sc_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat,
                      "SymbolFileDWARFDebugMap::FindFunctions (name = %s)",
                      name.GetCString());
 
   uint32_t initial_size = 0;
   if (append)
     initial_size = sc_list.GetSize();
uint32_t SymbolFileDWARFDebugMap::FindFunctions(
 
   return sc_list.GetSize() - initial_size;
 }
 
 uint32_t SymbolFileDWARFDebugMap::FindFunctions(const RegularExpression &regex,
                                                 bool include_inlines,
                                                 bool append,
                                                 SymbolContextList &sc_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat,
                      "SymbolFileDWARFDebugMap::FindFunctions (regex = '%s')",
                      regex.GetText().str().c_str());
 
   uint32_t initial_size = 0;
   if (append)
     initial_size = sc_list.GetSize();
uint32_t SymbolFileDWARFDebugMap::FindFunctions(const RegularExpression &regex,
   });
 
   return sc_list.GetSize() - initial_size;
 }
 
 size_t SymbolFileDWARFDebugMap::GetTypes(SymbolContextScope *sc_scope,
                                          lldb::TypeClass type_mask,
                                          TypeList &type_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat,
                      "SymbolFileDWARFDebugMap::GetTypes (type_mask = 0x%8.8x)",
                      type_mask);
 
   uint32_t initial_size = type_list.GetSize();
   SymbolFileDWARF *oso_dwarf = nullptr;
   if (sc_scope) {
TypeSP SymbolFileDWARFDebugMap::FindCompleteObjCDefinitionTypeForDIE(
   return TypeSP();
 }
 
 uint32_t SymbolFileDWARFDebugMap::FindTypes(
     ConstString name, const CompilerDeclContext *parent_decl_ctx,
     bool append, uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!append)
     types.Clear();
 
   const uint32_t initial_types_size = types.GetSize();
 
   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
     oso_dwarf->FindTypes(name, parent_decl_ctx, append, max_matches,
                          searched_symbol_files, types);

 //      return oso_dwarf->FindTypes (sc, regex, append, max_matches, encoding,
 //      udt_uid, types);
 //  return 0;
 //}
 
 CompilerDeclContext SymbolFileDWARFDebugMap::FindNamespace(
     lldb_private::ConstString name,
     const CompilerDeclContext *parent_decl_ctx) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   CompilerDeclContext matching_namespace;
 
   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
     matching_namespace = oso_dwarf->FindNamespace(name, parent_decl_ctx);
 
     return (bool)matching_namespace;
   });
 

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

if (index >= UINT16_MAX)
     return nullptr;
 
   CompilandIndexItem &item = m_index->compilands().GetOrCreateCompiland(index);
 
   return GetOrCreateCompileUnit(item);
 }
 
 lldb::LanguageType SymbolFileNativePDB::ParseLanguage(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   PdbSymUid uid(comp_unit.GetID());
   lldbassert(uid.kind() == PdbSymUidKind::Compiland);
 
   CompilandIndexItem *item =
       m_index->compilands().GetCompiland(uid.asCompiland().modi);
   lldbassert(item);
   if (!item->m_compile_opts)
     return lldb::eLanguageTypeUnknown;
 
   return TranslateLanguage(item->m_compile_opts->getLanguage());
 }
 
 void SymbolFileNativePDB::AddSymbols(Symtab &symtab) { return; }
 
 size_t SymbolFileNativePDB::ParseFunctions(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   PdbSymUid uid{comp_unit.GetID()};
   lldbassert(uid.kind() == PdbSymUidKind::Compiland);
   uint16_t modi = uid.asCompiland().modi;
   CompilandIndexItem &cii = m_index->compilands().GetOrCreateCompiland(modi);
 
   size_t count = comp_unit.GetNumFunctions();
   const CVSymbolArray &syms = cii.m_debug_stream.getSymbolArray();
   for (auto iter = syms.begin(); iter != syms.end(); ++iter) {
static bool NeedsResolvedCompileUnit(uint32_t resolve_scope) {
   flags |= eSymbolContextFunction;
   flags |= eSymbolContextBlock;
   flags |= eSymbolContextLineEntry;
   return (resolve_scope & flags) != 0;
 }
 
 uint32_t SymbolFileNativePDB::ResolveSymbolContext(
     const Address &addr, SymbolContextItem resolve_scope, SymbolContext &sc) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   uint32_t resolved_flags = 0;
   lldb::addr_t file_addr = addr.GetFileAddress();
 
   if (NeedsResolvedCompileUnit(resolve_scope)) {
     llvm::Optional<uint16_t> modi = m_index->GetModuleIndexForVa(file_addr);
     if (!modi)
       return 0;
     CompilandIndexItem *cci = m_index->compilands().GetCompiland(*modi);
static void TerminateLineSequence(LineTable &table,
   table.InsertSequence(seq.release());
 }
 
 bool SymbolFileNativePDB::ParseLineTable(CompileUnit &comp_unit) {
   // Unfortunately LLDB is set up to parse the entire compile unit line table
   // all at once, even if all it really needs is line info for a specific
   // function.  In the future it would be nice if it could set the sc.m_function
   // member, and we could only get the line info for the function in question.
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   PdbSymUid cu_id(comp_unit.GetID());
   lldbassert(cu_id.kind() == PdbSymUidKind::Compiland);
   CompilandIndexItem *cci =
       m_index->compilands().GetCompiland(cu_id.asCompiland().modi);
   lldbassert(cci);
   auto line_table = llvm::make_unique<LineTable>(&comp_unit);
 
   // This is basically a copy of the .debug$S subsections from all original COFF

 
 bool SymbolFileNativePDB::ParseDebugMacros(CompileUnit &comp_unit) {
   // PDB doesn't contain information about macros
   return false;
 }
 
 bool SymbolFileNativePDB::ParseSupportFiles(CompileUnit &comp_unit,
                                             FileSpecList &support_files) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   PdbSymUid cu_id(comp_unit.GetID());
   lldbassert(cu_id.kind() == PdbSymUidKind::Compiland);
   CompilandIndexItem *cci =
       m_index->compilands().GetCompiland(cu_id.asCompiland().modi);
   lldbassert(cci);
 
   for (llvm::StringRef f : cci->m_file_list) {
     FileSpec::Style style =

 
 bool SymbolFileNativePDB::ParseImportedModules(
     const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
   // PDB does not yet support module debug info
   return false;
 }
 
 size_t SymbolFileNativePDB::ParseBlocksRecursive(Function &func) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   GetOrCreateBlock(PdbSymUid(func.GetID()).asCompilandSym());
   // FIXME: Parse child blocks
   return 1;
 }
 
 void SymbolFileNativePDB::DumpClangAST(Stream &s) { m_ast->Dump(s); }
 
 uint32_t SymbolFileNativePDB::FindGlobalVariables(
     ConstString name, const CompilerDeclContext *parent_decl_ctx,
     uint32_t max_matches, VariableList &variables) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
 
   std::vector<SymbolAndOffset> results = m_index->globals().findRecordsByName(
       name.GetStringRef(), m_index->symrecords());
   for (const SymbolAndOffset &result : results) {
     VariableSP var;
     switch (result.second.kind()) {
     case SymbolKind::S_GDATA32:
uint32_t SymbolFileNativePDB::FindGlobalVariables(
   }
   return variables.GetSize();
 }
 
 uint32_t SymbolFileNativePDB::FindFunctions(
     ConstString name, const CompilerDeclContext *parent_decl_ctx,
     FunctionNameType name_type_mask, bool include_inlines, bool append,
     SymbolContextList &sc_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // For now we only support lookup by method name.
   if (!(name_type_mask & eFunctionNameTypeMethod))
     return 0;
 
   using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
 
   std::vector<SymbolAndOffset> matches = m_index->globals().findRecordsByName(
       name.GetStringRef(), m_index->symrecords());
uint32_t SymbolFileNativePDB::FindFunctions(const RegularExpression &regex,
                                             SymbolContextList &sc_list) {
   return 0;
 }
 
 uint32_t SymbolFileNativePDB::FindTypes(
     ConstString name, const CompilerDeclContext *parent_decl_ctx,
     bool append, uint32_t max_matches,
     llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!append)
     types.Clear();
   if (!name)
     return 0;
 
   searched_symbol_files.clear();
   searched_symbol_files.insert(this);
 
for (TypeIndex ti : matches) {
 
     types.Insert(type);
     ++match_count;
   }
   return match_count;
 }
 
 size_t SymbolFileNativePDB::ParseTypes(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Only do the full type scan the first time.
   if (m_done_full_type_scan)
     return 0;
 
   const size_t old_count = GetTypeList().GetSize();
   LazyRandomTypeCollection &types = m_index->tpi().typeCollection();
 
   // First process the entire TPI stream.
size_t SymbolFileNativePDB::ParseVariablesForBlock(PdbCompilandSymId block_id) {
   // Pass false for set_children, since we call this recursively so that the
   // children will call this for themselves.
   block.SetDidParseVariables(true, false);
 
   return count;
 }
 
 size_t SymbolFileNativePDB::ParseVariablesForContext(const SymbolContext &sc) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   lldbassert(sc.function || sc.comp_unit);
 
   VariableListSP variables;
   if (sc.block) {
     PdbSymUid block_id(sc.block->GetID());
 
     size_t count = ParseVariablesForBlock(block_id.asCompilandSym());
     return count;

 
 CompilerDeclContext
 SymbolFileNativePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
   clang::DeclContext *context = m_ast->GetParentDeclContext(PdbSymUid(uid));
   return m_ast->ToCompilerDeclContext(*context);
 }
 
 Type *SymbolFileNativePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   auto iter = m_types.find(type_uid);
   // lldb should not be passing us non-sensical type uids.  the only way it
   // could have a type uid in the first place is if we handed it out, in which
   // case we should know about the type.  However, that doesn't mean we've
   // instantiated it yet.  We can vend out a UID for a future type.  So if the
   // type doesn't exist, let's instantiate it now.
   if (iter != m_types.end())
     return &*iter->second;

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

if (!results)
     return CompUnitSP();
   auto compiland_up = results->getChildAtIndex(index);
   if (!compiland_up)
     return CompUnitSP();
   return ParseCompileUnitForUID(compiland_up->getSymIndexId(), index);
 }
 
 lldb::LanguageType SymbolFilePDB::ParseLanguage(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
   if (!compiland_up)
     return lldb::eLanguageTypeUnknown;
   auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
   if (!details)
     return lldb::eLanguageTypeUnknown;
   return TranslateLanguage(details->getLanguage());
 }
SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(const PDBSymbolFunc &pdb_func,
   if (!clang_type_system)
     return nullptr;
   clang_type_system->GetPDBParser()->GetDeclForSymbol(pdb_func);
 
   return func_sp.get();
 }
 
 size_t SymbolFilePDB::ParseFunctions(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   size_t func_added = 0;
   auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
   if (!compiland_up)
     return 0;
   auto results_up = compiland_up->findAllChildren<PDBSymbolFunc>();
   if (!results_up)
     return 0;
   while (auto pdb_func_up = results_up->getNext()) {
     auto func_sp = comp_unit.FindFunctionByUID(pdb_func_up->getSymIndexId());
     if (!func_sp) {
       if (ParseCompileUnitFunctionForPDBFunc(*pdb_func_up, comp_unit))
         ++func_added;
     }
   }
   return func_added;
 }
 
 bool SymbolFilePDB::ParseLineTable(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (comp_unit.GetLineTable())
     return true;
   return ParseCompileUnitLineTable(comp_unit, 0);
 }
 
 bool SymbolFilePDB::ParseDebugMacros(CompileUnit &comp_unit) {
   // PDB doesn't contain information about macros
   return false;
 }
 
 bool SymbolFilePDB::ParseSupportFiles(
     CompileUnit &comp_unit, lldb_private::FileSpecList &support_files) {
 
   // In theory this is unnecessary work for us, because all of this information
   // is easily (and quickly) accessible from DebugInfoPDB, so caching it a
   // second time seems like a waste.  Unfortunately, there's no good way around
   // this short of a moderate refactor since SymbolVendor depends on being able
   // to cache this list.
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
   if (!compiland_up)
     return false;
   auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
   if (!files || files->getChildCount() == 0)
     return false;
 
   while (auto file = files->getNext()) {
static size_t ParseFunctionBlocksForPDBSymbol(
   } break;
   default:
     break;
   }
   return num_added;
 }
 
 size_t SymbolFilePDB::ParseBlocksRecursive(Function &func) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   size_t num_added = 0;
   auto uid = func.GetID();
   auto pdb_func_up = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(uid);
   if (!pdb_func_up)
     return 0;
   Block &parent_block = func.GetBlock(false);
   num_added = ParseFunctionBlocksForPDBSymbol(
       pdb_func_up->getVirtualAddress(), pdb_func_up.get(), &parent_block, true);
   return num_added;
 }
 
 size_t SymbolFilePDB::ParseTypes(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
   size_t num_added = 0;
   auto compiland = GetPDBCompilandByUID(comp_unit.GetID());
   if (!compiland)
     return 0;
 
   auto ParseTypesByTagFn = [&num_added, this](const PDBSymbol &raw_sym) {
     std::unique_ptr<IPDBEnumSymbols> results;
if (!parse_all_global_types) {
     ParseTypesByTagFn(*m_global_scope_up);
     parse_all_global_types = true;
   }
   return num_added;
 }
 
 size_t
 SymbolFilePDB::ParseVariablesForContext(const lldb_private::SymbolContext &sc) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!sc.comp_unit)
     return 0;
 
   size_t num_added = 0;
   if (sc.function) {
     auto pdb_func = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(
         sc.function->GetID());
     if (!pdb_func)
if (sc.function) {
     // Parse variables in this compiland.
     num_added += ParseVariables(sc, *compiland);
   }
 
   return num_added;
 }
 
 lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   auto find_result = m_types.find(type_uid);
   if (find_result != m_types.end())
     return find_result->second.get();
 
   TypeSystem *type_system =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   ClangASTContext *clang_type_system =
       llvm::dyn_cast_or_null<ClangASTContext>(type_system);
void SymbolFilePDB::ParseDeclsForContext(
   pdb->ParseDeclsForDeclContext(
       static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext()));
 }
 
 uint32_t
 SymbolFilePDB::ResolveSymbolContext(const lldb_private::Address &so_addr,
                                     SymbolContextItem resolve_scope,
                                     lldb_private::SymbolContext &sc) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   uint32_t resolved_flags = 0;
   if (resolve_scope & eSymbolContextCompUnit ||
       resolve_scope & eSymbolContextVariable ||
       resolve_scope & eSymbolContextFunction ||
       resolve_scope & eSymbolContextBlock ||
       resolve_scope & eSymbolContextLineEntry) {
     auto cu_sp = GetCompileUnitContainsAddress(so_addr);
     if (!cu_sp) {
SymbolFilePDB::ResolveSymbolContext(const lldb_private::Address &so_addr,
   }
 
   return resolved_flags;
 }
 
 uint32_t SymbolFilePDB::ResolveSymbolContext(
     const lldb_private::FileSpec &file_spec, uint32_t line, bool check_inlines,
     SymbolContextItem resolve_scope, lldb_private::SymbolContextList &sc_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   const size_t old_size = sc_list.GetSize();
   if (resolve_scope & lldb::eSymbolContextCompUnit) {
     // Locate all compilation units with line numbers referencing the specified
     // file.  For example, if `file_spec` is <vector>, then this should return
     // all source files and header files that reference <vector>, either
     // directly or indirectly.
     auto compilands = m_session_up->findCompilandsForSourceFile(
         file_spec.GetPath(), PDB_NameSearchFlags::NS_CaseInsensitive);
SymbolFilePDB::ParseVariables(const lldb_private::SymbolContext &sc,
 
   return num_added;
 }
 
 uint32_t SymbolFilePDB::FindGlobalVariables(
     lldb_private::ConstString name,
     const lldb_private::CompilerDeclContext *parent_decl_ctx,
     uint32_t max_matches, lldb_private::VariableList &variables) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return 0;
   if (name.IsEmpty())
     return 0;
 
   auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
   if (!results)
     return 0;
uint32_t SymbolFilePDB::FindGlobalVariables(
 
   return matches;
 }
 
 uint32_t
 SymbolFilePDB::FindGlobalVariables(const lldb_private::RegularExpression &regex,
                                    uint32_t max_matches,
                                    lldb_private::VariableList &variables) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!regex.IsValid())
     return 0;
   auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
   if (!results)
     return 0;
 
   uint32_t matches = 0;
   size_t old_size = variables.GetSize();
void SymbolFilePDB::CacheFunctionNames() {
   m_func_base_names.SizeToFit();
 }
 
 uint32_t SymbolFilePDB::FindFunctions(
     lldb_private::ConstString name,
     const lldb_private::CompilerDeclContext *parent_decl_ctx,
     FunctionNameType name_type_mask, bool include_inlines, bool append,
     lldb_private::SymbolContextList &sc_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!append)
     sc_list.Clear();
   lldbassert((name_type_mask & eFunctionNameTypeAuto) == 0);
 
   if (name_type_mask == eFunctionNameTypeNone)
     return 0;
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return 0;
uint32_t SymbolFilePDB::FindFunctions(
   }
   return sc_list.GetSize() - old_size;
 }
 
 uint32_t
 SymbolFilePDB::FindFunctions(const lldb_private::RegularExpression &regex,
                              bool include_inlines, bool append,
                              lldb_private::SymbolContextList &sc_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!append)
     sc_list.Clear();
   if (!regex.IsValid())
     return 0;
 
   auto old_size = sc_list.GetSize();
   CacheFunctionNames();
 

 }
 
 uint32_t SymbolFilePDB::FindTypes(
     lldb_private::ConstString name,
     const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append,
     uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     lldb_private::TypeMap &types) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!append)
     types.Clear();
   if (!name)
     return 0;
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return 0;
 
   searched_symbol_files.clear();
void SymbolFilePDB::GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
   auto results_up = pdb_symbol.findAllChildren();
   while (auto symbol_up = results_up->getNext())
     GetTypesForPDBSymbol(*symbol_up, type_mask, type_collection);
 }
 
 size_t SymbolFilePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
                                TypeClass type_mask,
                                lldb_private::TypeList &type_list) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   TypeCollection type_collection;
   uint32_t old_size = type_list.GetSize();
   CompileUnit *cu =
       sc_scope ? sc_scope->CalculateSymbolContextCompileUnit() : nullptr;
   if (cu) {
     auto compiland_up = GetPDBCompilandByUID(cu->GetID());
     if (!compiland_up)
       return 0;
PDBASTParser *SymbolFilePDB::GetPDBAstParser() {
 
   return clang_type_system->GetPDBParser();
 }
 
 
 lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace(
     lldb_private::ConstString name,
     const lldb_private::CompilerDeclContext *parent_decl_ctx) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   auto clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
   if (!clang_type_system)
     return CompilerDeclContext();
 
   PDBASTParser *pdb = clang_type_system->GetPDBParser();
   if (!pdb)
     return CompilerDeclContext();

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

CompUnitSP SymbolFileSymtab::ParseCompileUnitAtIndex(uint32_t idx) {
   return cu_sp;
 }
 
 lldb::LanguageType SymbolFileSymtab::ParseLanguage(CompileUnit &comp_unit) {
   return eLanguageTypeUnknown;
 }
 
 size_t SymbolFileSymtab::ParseFunctions(CompileUnit &comp_unit) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   size_t num_added = 0;
   // We must at least have a valid compile unit
   const Symtab *symtab = m_obj_file->GetSymtab();
   const Symbol *curr_symbol = nullptr;
   const Symbol *next_symbol = nullptr;
   //  const char *prefix = m_obj_file->SymbolPrefix();
   //  if (prefix == NULL)
   //      prefix == "";

 
 bool SymbolFileSymtab::CompleteType(lldb_private::CompilerType &compiler_type) {
   return false;
 }
 
 uint32_t SymbolFileSymtab::ResolveSymbolContext(const Address &so_addr,
                                                 SymbolContextItem resolve_scope,
                                                 SymbolContext &sc) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (m_obj_file->GetSymtab() == nullptr)
     return 0;
 
   uint32_t resolved_flags = 0;
   if (resolve_scope & eSymbolContextSymbol) {
     sc.symbol = m_obj_file->GetSymtab()->FindSymbolContainingFileAddress(
         so_addr.GetFileAddress());
     if (sc.symbol)

lldb/trunk/source/Symbol/SymbolFile.cpp

if (!m_compile_units) {
     // Create an array of compile unit shared pointers -- which will each
     // remain NULL until someone asks for the actual compile unit information.
     m_compile_units.emplace(CalculateNumCompileUnits());
   }
   return m_compile_units->size();
 }
 
 CompUnitSP SymbolFile::GetCompileUnitAtIndex(uint32_t idx) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   uint32_t num = GetNumCompileUnits();
   if (idx >= num)
     return nullptr;
   lldb::CompUnitSP &cu_sp = (*m_compile_units)[idx];
   if (!cu_sp)
     cu_sp = ParseCompileUnitAtIndex(idx);
   return cu_sp;
 }

lldb/trunk/source/Symbol/SymbolVendor.cpp

if (module_sp) {
     if (objfile_sp) {
       m_objfile_sp = objfile_sp;
       m_sym_file_up.reset(SymbolFile::FindPlugin(objfile_sp.get()));
     }
   }
 }
 
 size_t SymbolVendor::GetNumCompileUnits() {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->GetNumCompileUnits();
-  }
   return 0;
 }
 
 lldb::LanguageType SymbolVendor::ParseLanguage(CompileUnit &comp_unit) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ParseLanguage(comp_unit);
-  }
   return eLanguageTypeUnknown;
 }
 
 size_t SymbolVendor::ParseFunctions(CompileUnit &comp_unit) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ParseFunctions(comp_unit);
-  }
   return 0;
 }
 
 bool SymbolVendor::ParseLineTable(CompileUnit &comp_unit) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ParseLineTable(comp_unit);
-  }
   return false;
 }
 
 bool SymbolVendor::ParseDebugMacros(CompileUnit &comp_unit) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ParseDebugMacros(comp_unit);
-  }
   return false;
 }
 bool SymbolVendor::ParseSupportFiles(CompileUnit &comp_unit,
                                      FileSpecList &support_files) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ParseSupportFiles(comp_unit, support_files);
-  }
   return false;
 }
 
 bool SymbolVendor::ParseIsOptimized(CompileUnit &comp_unit) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ParseIsOptimized(comp_unit);
-  }
   return false;
 }
 
 bool SymbolVendor::ParseImportedModules(
     const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ParseImportedModules(sc, imported_modules);
-  }
   return false;
 }
 
 size_t SymbolVendor::ParseBlocksRecursive(Function &func) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ParseBlocksRecursive(func);
-  }
   return 0;
 }
 
 size_t SymbolVendor::ParseTypes(CompileUnit &comp_unit) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ParseTypes(comp_unit);
-  }
   return 0;
 }
 
 size_t SymbolVendor::ParseVariablesForContext(const SymbolContext &sc) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ParseVariablesForContext(sc);
-  }
   return 0;
 }
 
 Type *SymbolVendor::ResolveTypeUID(lldb::user_id_t type_uid) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ResolveTypeUID(type_uid);
-  }
   return nullptr;
 }
 
 uint32_t SymbolVendor::ResolveSymbolContext(const Address &so_addr,
                                             SymbolContextItem resolve_scope,
                                             SymbolContext &sc) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ResolveSymbolContext(so_addr, resolve_scope, sc);
-  }
   return 0;
 }
 
 uint32_t SymbolVendor::ResolveSymbolContext(const FileSpec &file_spec,
                                             uint32_t line, bool check_inlines,
                                             SymbolContextItem resolve_scope,
                                             SymbolContextList &sc_list) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->ResolveSymbolContext(file_spec, line, check_inlines,
-                                                 resolve_scope, sc_list);
-  }
   return 0;
 }
 
 size_t
 SymbolVendor::FindGlobalVariables(ConstString name,
                                   const CompilerDeclContext *parent_decl_ctx,
                                   size_t max_matches, VariableList &variables) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->FindGlobalVariables(name, parent_decl_ctx,
-                                                max_matches, variables);
-  }
   return 0;
 }
 
 size_t SymbolVendor::FindGlobalVariables(const RegularExpression &regex,
                                          size_t max_matches,
                                          VariableList &variables) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->FindGlobalVariables(regex, max_matches, variables);
-  }
   return 0;
 }
 
 size_t SymbolVendor::FindFunctions(ConstString name,
                                    const CompilerDeclContext *parent_decl_ctx,
                                    FunctionNameType name_type_mask,
                                    bool include_inlines, bool append,
                                    SymbolContextList &sc_list) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->FindFunctions(name, parent_decl_ctx, name_type_mask,
-                                          include_inlines, append, sc_list);
-  }
   return 0;
 }
 
 size_t SymbolVendor::FindFunctions(const RegularExpression &regex,
                                    bool include_inlines, bool append,
                                    SymbolContextList &sc_list) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->FindFunctions(regex, include_inlines, append,
-                                          sc_list);
-  }
   return 0;
 }
 
 size_t SymbolVendor::FindTypes(
     ConstString name, const CompilerDeclContext *parent_decl_ctx,
     bool append, size_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->FindTypes(name, parent_decl_ctx, append,
-                                      max_matches, searched_symbol_files,
-                                      types);
-  }
+    return m_sym_file_up->FindTypes(name, parent_decl_ctx, append, max_matches,
+                                    searched_symbol_files, types);
   if (!append)
     types.Clear();
   return 0;
 }
 
 size_t SymbolVendor::FindTypes(const std::vector<CompilerContext> &context,
                                bool append, TypeMap &types) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->FindTypes(context, append, types);
-  }
   if (!append)
     types.Clear();
   return 0;
 }
 
 size_t SymbolVendor::GetTypes(SymbolContextScope *sc_scope, TypeClass type_mask,
                               lldb_private::TypeList &type_list) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->GetTypes(sc_scope, type_mask, type_list);
-  }
   return 0;
 }
 
 CompilerDeclContext
 SymbolVendor::FindNamespace(ConstString name,
                             const CompilerDeclContext *parent_decl_ctx) {
   CompilerDeclContext namespace_decl_ctx;
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      namespace_decl_ctx = m_sym_file_up->FindNamespace(name, parent_decl_ctx);
-  }
   return namespace_decl_ctx;
 }
 
 void SymbolVendor::Dump(Stream *s) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
if (module_sp) {
     if (Symtab *symtab = GetSymtab())
       symtab->Dump(s, nullptr, eSortOrderNone);
 
     s->IndentLess();
   }
 }
 
 CompUnitSP SymbolVendor::GetCompileUnitAtIndex(size_t idx) {
-  ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    if (m_sym_file_up)
-      return m_sym_file_up->GetCompileUnitAtIndex(idx);
-  }
   return nullptr;
 }
 
 FileSpec SymbolVendor::GetMainFileSpec() const {
   if (m_sym_file_up) {
     const ObjectFile *symfile_objfile = m_sym_file_up->GetObjectFile();
     if (symfile_objfile)
       return symfile_objfile->GetFileSpec();