lldb/source/Core/ModuleList.cpp

   1 //===-- ModuleList.cpp ----------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Core/ModuleList.h"
  10 #include "lldb/Core/Module.h"
  11 #include "lldb/Core/ModuleSpec.h"
  12 #include "lldb/Core/PluginManager.h"
  13 #include "lldb/Host/FileSystem.h"
  14 #include "lldb/Interpreter/OptionValueFileSpec.h"
  15 #include "lldb/Interpreter/OptionValueFileSpecList.h"
  16 #include "lldb/Interpreter/OptionValueProperties.h"
  17 #include "lldb/Interpreter/Property.h"
  18 #include "lldb/Symbol/ObjectFile.h"
  19 #include "lldb/Symbol/SymbolContext.h"
  20 #include "lldb/Symbol/TypeList.h"
  21 #include "lldb/Symbol/VariableList.h"
  22 #include "lldb/Utility/ArchSpec.h"
  23 #include "lldb/Utility/ConstString.h"
  24 #include "lldb/Utility/FileSpecList.h"
  25 #include "lldb/Utility/LLDBLog.h"
  26 #include "lldb/Utility/Log.h"
  27 #include "lldb/Utility/UUID.h"
  28 #include "lldb/lldb-defines.h"
  29
  30 #if defined(_WIN32)
  31 #include "lldb/Host/windows/PosixApi.h"
  32 #endif
  33
  34 #include "clang/Driver/Driver.h"
  35 #include "llvm/ADT/StringRef.h"
  36 #include "llvm/Support/FileSystem.h"
  37 #include "llvm/Support/Threading.h"
  38 #include "llvm/Support/raw_ostream.h"
  39
  40 #include <chrono>
  41 #include <memory>
  42 #include <mutex>
  43 #include <string>
  44 #include <utility>
  45
  46 namespace lldb_private {
  47 class Function;
  48 }
  49 namespace lldb_private {
  50 class RegularExpression;
  51 }
  52 namespace lldb_private {
  53 class Stream;
  54 }
  55 namespace lldb_private {
  56 class SymbolFile;
  57 }
  58 namespace lldb_private {
  59 class Target;
  60 }
  61
  62 using namespace lldb;
  63 using namespace lldb_private;
  64
  65 namespace {
  66
  67 #define LLDB_PROPERTIES_modulelist
  68 #include "CoreProperties.inc"
  69
  70 enum {
  71 #define LLDB_PROPERTIES_modulelist
  72 #include "CorePropertiesEnum.inc"
  73 };
  74
  75 } // namespace
  76
  77 ModuleListProperties::ModuleListProperties() {
  78   m_collection_sp = std::make_shared<OptionValueProperties>("symbols");
  79   m_collection_sp->Initialize(g_modulelist_properties);
  80   m_collection_sp->SetValueChangedCallback(ePropertySymLinkPaths,
  81                                            [this] { UpdateSymlinkMappings(); });
  82
  83   llvm::SmallString<128> path;
  84   if (clang::driver::Driver::getDefaultModuleCachePath(path)) {
  85     lldbassert(SetClangModulesCachePath(FileSpec(path)));
  86   }
  87
  88   path.clear();
  89   if (llvm::sys::path::cache_directory(path)) {
  90     llvm::sys::path::append(path, "lldb");
  91     llvm::sys::path::append(path, "IndexCache");
  92     lldbassert(SetLLDBIndexCachePath(FileSpec(path)));
  93   }
  94
  95 }
  96
  97 bool ModuleListProperties::GetEnableExternalLookup() const {
  98   const uint32_t idx = ePropertyEnableExternalLookup;
  99   return GetPropertyAtIndexAs<bool>(
 100       idx, g_modulelist_properties[idx].default_uint_value != 0);
 101 }
 102
 103 bool ModuleListProperties::SetEnableExternalLookup(bool new_value) {
 104   return SetPropertyAtIndex(ePropertyEnableExternalLookup, new_value);
 105 }
 106
 107 SymbolDownload ModuleListProperties::GetSymbolAutoDownload() const {
 108   // Backward compatibility alias.
 109   if (GetPropertyAtIndexAs<bool>(ePropertyEnableBackgroundLookup, false))
 110     return eSymbolDownloadBackground;
 111
 112   const uint32_t idx = ePropertyAutoDownload;
 113   return GetPropertyAtIndexAs<lldb::SymbolDownload>(
 114       idx, static_cast<lldb::SymbolDownload>(
 115                g_modulelist_properties[idx].default_uint_value));
 116 }
 117
 118 FileSpec ModuleListProperties::GetClangModulesCachePath() const {
 119   const uint32_t idx = ePropertyClangModulesCachePath;
 120   return GetPropertyAtIndexAs<FileSpec>(idx, {});
 121 }
 122
 123 bool ModuleListProperties::SetClangModulesCachePath(const FileSpec &path) {
 124   const uint32_t idx = ePropertyClangModulesCachePath;
 125   return SetPropertyAtIndex(idx, path);
 126 }
 127
 128 FileSpec ModuleListProperties::GetLLDBIndexCachePath() const {
 129   const uint32_t idx = ePropertyLLDBIndexCachePath;
 130   return GetPropertyAtIndexAs<FileSpec>(idx, {});
 131 }
 132
 133 bool ModuleListProperties::SetLLDBIndexCachePath(const FileSpec &path) {
 134   const uint32_t idx = ePropertyLLDBIndexCachePath;
 135   return SetPropertyAtIndex(idx, path);
 136 }
 137
 138 bool ModuleListProperties::GetEnableLLDBIndexCache() const {
 139   const uint32_t idx = ePropertyEnableLLDBIndexCache;
 140   return GetPropertyAtIndexAs<bool>(
 141       idx, g_modulelist_properties[idx].default_uint_value != 0);
 142 }
 143
 144 bool ModuleListProperties::SetEnableLLDBIndexCache(bool new_value) {
 145   return SetPropertyAtIndex(ePropertyEnableLLDBIndexCache, new_value);
 146 }
 147
 148 uint64_t ModuleListProperties::GetLLDBIndexCacheMaxByteSize() {
 149   const uint32_t idx = ePropertyLLDBIndexCacheMaxByteSize;
 150   return GetPropertyAtIndexAs<uint64_t>(
 151       idx, g_modulelist_properties[idx].default_uint_value);
 152 }
 153
 154 uint64_t ModuleListProperties::GetLLDBIndexCacheMaxPercent() {
 155   const uint32_t idx = ePropertyLLDBIndexCacheMaxPercent;
 156   return GetPropertyAtIndexAs<uint64_t>(
 157       idx, g_modulelist_properties[idx].default_uint_value);
 158 }
 159
 160 uint64_t ModuleListProperties::GetLLDBIndexCacheExpirationDays() {
 161   const uint32_t idx = ePropertyLLDBIndexCacheExpirationDays;
 162   return GetPropertyAtIndexAs<uint64_t>(
 163       idx, g_modulelist_properties[idx].default_uint_value);
 164 }
 165
 166 void ModuleListProperties::UpdateSymlinkMappings() {
 167   FileSpecList list =
 168       GetPropertyAtIndexAs<FileSpecList>(ePropertySymLinkPaths, {});
 169   llvm::sys::ScopedWriter lock(m_symlink_paths_mutex);
 170   const bool notify = false;
 171   m_symlink_paths.Clear(notify);
 172   for (auto symlink : list) {
 173     FileSpec resolved;
 174     Status status = FileSystem::Instance().Readlink(symlink, resolved);
 175     if (status.Success())
 176       m_symlink_paths.Append(symlink.GetPath(), resolved.GetPath(), notify);
 177   }
 178 }
 179
 180 PathMappingList ModuleListProperties::GetSymlinkMappings() const {
 181   llvm::sys::ScopedReader lock(m_symlink_paths_mutex);
 182   return m_symlink_paths;
 183 }
 184
 185 bool ModuleListProperties::GetLoadSymbolOnDemand() {
 186   const uint32_t idx = ePropertyLoadSymbolOnDemand;
 187   return GetPropertyAtIndexAs<bool>(
 188       idx, g_modulelist_properties[idx].default_uint_value != 0);
 189 }
 190
 191 ModuleList::ModuleList() : m_modules(), m_modules_mutex() {}
 192
 193 ModuleList::ModuleList(const ModuleList &rhs) : m_modules(), m_modules_mutex() {
 194   std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
 195   std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
 196   m_modules = rhs.m_modules;
 197 }
 198
 199 ModuleList::ModuleList(ModuleList::Notifier *notifier)
 200     : m_modules(), m_modules_mutex(), m_notifier(notifier) {}
 201
 202 const ModuleList &ModuleList::operator=(const ModuleList &rhs) {
 203   if (this != &rhs) {
 204     std::lock(m_modules_mutex, rhs.m_modules_mutex);
 205     std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex,
 206                                                     std::adopt_lock);
 207     std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex,
 208                                                     std::adopt_lock);
 209     m_modules = rhs.m_modules;
 210   }
 211   return *this;
 212 }
 213
 214 ModuleList::~ModuleList() = default;
 215
 216 void ModuleList::AppendImpl(const ModuleSP &module_sp, bool use_notifier) {
 217   if (module_sp) {
 218     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 219     // We are required to keep the first element of the Module List as the
 220     // executable module.  So check here and if the first module is NOT an
 221     // but the new one is, we insert this module at the beginning, rather than
 222     // at the end.
 223     // We don't need to do any of this if the list is empty:
 224     if (m_modules.empty()) {
 225       m_modules.push_back(module_sp);
 226     } else {
 227       // Since producing the ObjectFile may take some work, first check the 0th
 228       // element, and only if that's NOT an executable look at the incoming
 229       // ObjectFile.  That way in the normal case we only look at the element
 230       // 0 ObjectFile.
 231       const bool elem_zero_is_executable
 232           = m_modules[0]->GetObjectFile()->GetType()
 233               == ObjectFile::Type::eTypeExecutable;
 234       lldb_private::ObjectFile *obj = module_sp->GetObjectFile();
 235       if (!elem_zero_is_executable && obj
 236           && obj->GetType() == ObjectFile::Type::eTypeExecutable) {
 237         m_modules.insert(m_modules.begin(), module_sp);
 238       } else {
 239         m_modules.push_back(module_sp);
 240       }
 241     }
 242     if (use_notifier && m_notifier)
 243       m_notifier->NotifyModuleAdded(*this, module_sp);
 244   }
 245 }
 246
 247 void ModuleList::Append(const ModuleSP &module_sp, bool notify) {
 248   AppendImpl(module_sp, notify);
 249 }
 250
 251 void ModuleList::ReplaceEquivalent(
 252     const ModuleSP &module_sp,
 253     llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules) {
 254   if (module_sp) {
 255     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 256
 257     // First remove any equivalent modules. Equivalent modules are modules
 258     // whose path, platform path and architecture match.
 259     ModuleSpec equivalent_module_spec(module_sp->GetFileSpec(),
 260                                       module_sp->GetArchitecture());
 261     equivalent_module_spec.GetPlatformFileSpec() =
 262         module_sp->GetPlatformFileSpec();
 263
 264     size_t idx = 0;
 265     while (idx < m_modules.size()) {
 266       ModuleSP test_module_sp(m_modules[idx]);
 267       if (test_module_sp->MatchesModuleSpec(equivalent_module_spec)) {
 268         if (old_modules)
 269           old_modules->push_back(test_module_sp);
 270         RemoveImpl(m_modules.begin() + idx);
 271       } else {
 272         ++idx;
 273       }
 274     }
 275     // Now add the new module to the list
 276     Append(module_sp);
 277   }
 278 }
 279
 280 bool ModuleList::AppendIfNeeded(const ModuleSP &new_module, bool notify) {
 281   if (new_module) {
 282     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 283     for (const ModuleSP &module_sp : m_modules) {
 284       if (module_sp.get() == new_module.get())
 285         return false; // Already in the list
 286     }
 287     // Only push module_sp on the list if it wasn't already in there.
 288     Append(new_module, notify);
 289     return true;
 290   }
 291   return false;
 292 }
 293
 294 void ModuleList::Append(const ModuleList &module_list) {
 295   for (auto pos : module_list.m_modules)
 296     Append(pos);
 297 }
 298
 299 bool ModuleList::AppendIfNeeded(const ModuleList &module_list) {
 300   bool any_in = false;
 301   for (auto pos : module_list.m_modules) {
 302     if (AppendIfNeeded(pos))
 303       any_in = true;
 304   }
 305   return any_in;
 306 }
 307
 308 bool ModuleList::RemoveImpl(const ModuleSP &module_sp, bool use_notifier) {
 309   if (module_sp) {
 310     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 311     collection::iterator pos, end = m_modules.end();
 312     for (pos = m_modules.begin(); pos != end; ++pos) {
 313       if (pos->get() == module_sp.get()) {
 314         m_modules.erase(pos);
 315         if (use_notifier && m_notifier)
 316           m_notifier->NotifyModuleRemoved(*this, module_sp);
 317         return true;
 318       }
 319     }
 320   }
 321   return false;
 322 }
 323
 324 ModuleList::collection::iterator
 325 ModuleList::RemoveImpl(ModuleList::collection::iterator pos,
 326                        bool use_notifier) {
 327   ModuleSP module_sp(*pos);
 328   collection::iterator retval = m_modules.erase(pos);
 329   if (use_notifier && m_notifier)
 330     m_notifier->NotifyModuleRemoved(*this, module_sp);
 331   return retval;
 332 }
 333
 334 bool ModuleList::Remove(const ModuleSP &module_sp, bool notify) {
 335   return RemoveImpl(module_sp, notify);
 336 }
 337
 338 bool ModuleList::ReplaceModule(const lldb::ModuleSP &old_module_sp,
 339                                const lldb::ModuleSP &new_module_sp) {
 340   if (!RemoveImpl(old_module_sp, false))
 341     return false;
 342   AppendImpl(new_module_sp, false);
 343   if (m_notifier)
 344     m_notifier->NotifyModuleUpdated(*this, old_module_sp, new_module_sp);
 345   return true;
 346 }
 347
 348 bool ModuleList::RemoveIfOrphaned(const Module *module_ptr) {
 349   if (module_ptr) {
 350     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 351     collection::iterator pos, end = m_modules.end();
 352     for (pos = m_modules.begin(); pos != end; ++pos) {
 353       if (pos->get() == module_ptr) {
 354         if (pos->use_count() == 1) {
 355           pos = RemoveImpl(pos);
 356           return true;
 357         } else
 358           return false;
 359       }
 360     }
 361   }
 362   return false;
 363 }
 364
 365 size_t ModuleList::RemoveOrphans(bool mandatory) {
 366   std::unique_lock<std::recursive_mutex> lock(m_modules_mutex, std::defer_lock);
 367
 368   if (mandatory) {
 369     lock.lock();
 370   } else {
 371     // Not mandatory, remove orphans if we can get the mutex
 372     if (!lock.try_lock())
 373       return 0;
 374   }
 375   size_t remove_count = 0;
 376   // Modules might hold shared pointers to other modules, so removing one
 377   // module might make other modules orphans. Keep removing modules until
 378   // there are no further modules that can be removed.
 379   bool made_progress = true;
 380   while (made_progress) {
 381     // Keep track if we make progress this iteration.
 382     made_progress = false;
 383     collection::iterator pos = m_modules.begin();
 384     while (pos != m_modules.end()) {
 385       if (pos->use_count() == 1) {
 386         pos = RemoveImpl(pos);
 387         ++remove_count;
 388         // We did make progress.
 389         made_progress = true;
 390       } else {
 391         ++pos;
 392       }
 393     }
 394   }
 395   return remove_count;
 396 }
 397
 398 size_t ModuleList::Remove(ModuleList &module_list) {
 399   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 400   size_t num_removed = 0;
 401   collection::iterator pos, end = module_list.m_modules.end();
 402   for (pos = module_list.m_modules.begin(); pos != end; ++pos) {
 403     if (Remove(*pos, false /* notify */))
 404       ++num_removed;
 405   }
 406   if (m_notifier)
 407     m_notifier->NotifyModulesRemoved(module_list);
 408   return num_removed;
 409 }
 410
 411 void ModuleList::Clear() { ClearImpl(); }
 412
 413 void ModuleList::Destroy() { ClearImpl(); }
 414
 415 void ModuleList::ClearImpl(bool use_notifier) {
 416   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 417   if (use_notifier && m_notifier)
 418     m_notifier->NotifyWillClearList(*this);
 419   m_modules.clear();
 420 }
 421
 422 Module *ModuleList::GetModulePointerAtIndex(size_t idx) const {
 423   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 424   if (idx < m_modules.size())
 425     return m_modules[idx].get();
 426   return nullptr;
 427 }
 428
 429 ModuleSP ModuleList::GetModuleAtIndex(size_t idx) const {
 430   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 431   return GetModuleAtIndexUnlocked(idx);
 432 }
 433
 434 ModuleSP ModuleList::GetModuleAtIndexUnlocked(size_t idx) const {
 435   ModuleSP module_sp;
 436   if (idx < m_modules.size())
 437     module_sp = m_modules[idx];
 438   return module_sp;
 439 }
 440
 441 void ModuleList::FindFunctions(ConstString name,
 442                                FunctionNameType name_type_mask,
 443                                const ModuleFunctionSearchOptions &options,
 444                                SymbolContextList &sc_list) const {
 445   const size_t old_size = sc_list.GetSize();
 446
 447   if (name_type_mask & eFunctionNameTypeAuto) {
 448     Module::LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
 449
 450     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 451     for (const ModuleSP &module_sp : m_modules) {
 452       module_sp->FindFunctions(lookup_info, CompilerDeclContext(), options,
 453                                sc_list);
 454     }
 455
 456     const size_t new_size = sc_list.GetSize();
 457
 458     if (old_size < new_size)
 459       lookup_info.Prune(sc_list, old_size);
 460   } else {
 461     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 462     for (const ModuleSP &module_sp : m_modules) {
 463       module_sp->FindFunctions(name, CompilerDeclContext(), name_type_mask,
 464                                options, sc_list);
 465     }
 466   }
 467 }
 468
 469 void ModuleList::FindFunctionSymbols(ConstString name,
 470                                      lldb::FunctionNameType name_type_mask,
 471                                      SymbolContextList &sc_list) {
 472   const size_t old_size = sc_list.GetSize();
 473
 474   if (name_type_mask & eFunctionNameTypeAuto) {
 475     Module::LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
 476
 477     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 478     for (const ModuleSP &module_sp : m_modules) {
 479       module_sp->FindFunctionSymbols(lookup_info.GetLookupName(),
 480                                      lookup_info.GetNameTypeMask(), sc_list);
 481     }
 482
 483     const size_t new_size = sc_list.GetSize();
 484
 485     if (old_size < new_size)
 486       lookup_info.Prune(sc_list, old_size);
 487   } else {
 488     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 489     for (const ModuleSP &module_sp : m_modules) {
 490       module_sp->FindFunctionSymbols(name, name_type_mask, sc_list);
 491     }
 492   }
 493 }
 494
 495 void ModuleList::FindFunctions(const RegularExpression &name,
 496                                const ModuleFunctionSearchOptions &options,
 497                                SymbolContextList &sc_list) {
 498   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 499   for (const ModuleSP &module_sp : m_modules)
 500     module_sp->FindFunctions(name, options, sc_list);
 501 }
 502
 503 void ModuleList::FindCompileUnits(const FileSpec &path,
 504                                   SymbolContextList &sc_list) const {
 505   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 506   for (const ModuleSP &module_sp : m_modules)
 507     module_sp->FindCompileUnits(path, sc_list);
 508 }
 509
 510 void ModuleList::FindGlobalVariables(ConstString name, size_t max_matches,
 511                                      VariableList &variable_list) const {
 512   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 513   for (const ModuleSP &module_sp : m_modules) {
 514     module_sp->FindGlobalVariables(name, CompilerDeclContext(), max_matches,
 515                                    variable_list);
 516   }
 517 }
 518
 519 void ModuleList::FindGlobalVariables(const RegularExpression &regex,
 520                                      size_t max_matches,
 521                                      VariableList &variable_list) const {
 522   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 523   for (const ModuleSP &module_sp : m_modules)
 524     module_sp->FindGlobalVariables(regex, max_matches, variable_list);
 525 }
 526
 527 void ModuleList::FindSymbolsWithNameAndType(ConstString name,
 528                                             SymbolType symbol_type,
 529                                             SymbolContextList &sc_list) const {
 530   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 531   for (const ModuleSP &module_sp : m_modules)
 532     module_sp->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
 533 }
 534
 535 void ModuleList::FindSymbolsMatchingRegExAndType(
 536     const RegularExpression &regex, lldb::SymbolType symbol_type,
 537     SymbolContextList &sc_list) const {
 538   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 539   for (const ModuleSP &module_sp : m_modules)
 540     module_sp->FindSymbolsMatchingRegExAndType(regex, symbol_type, sc_list);
 541 }
 542
 543 void ModuleList::FindModules(const ModuleSpec &module_spec,
 544                              ModuleList &matching_module_list) const {
 545   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 546   for (const ModuleSP &module_sp : m_modules) {
 547     if (module_sp->MatchesModuleSpec(module_spec))
 548       matching_module_list.Append(module_sp);
 549   }
 550 }
 551
 552 ModuleSP ModuleList::FindModule(const Module *module_ptr) const {
 553   ModuleSP module_sp;
 554
 555   // Scope for "locker"
 556   {
 557     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 558     collection::const_iterator pos, end = m_modules.end();
 559
 560     for (pos = m_modules.begin(); pos != end; ++pos) {
 561       if ((*pos).get() == module_ptr) {
 562         module_sp = (*pos);
 563         break;
 564       }
 565     }
 566   }
 567   return module_sp;
 568 }
 569
 570 ModuleSP ModuleList::FindModule(const UUID &uuid) const {
 571   ModuleSP module_sp;
 572
 573   if (uuid.IsValid()) {
 574     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 575     collection::const_iterator pos, end = m_modules.end();
 576
 577     for (pos = m_modules.begin(); pos != end; ++pos) {
 578       if ((*pos)->GetUUID() == uuid) {
 579         module_sp = (*pos);
 580         break;
 581       }
 582     }
 583   }
 584   return module_sp;
 585 }
 586
 587 void ModuleList::FindTypes(Module *search_first, const TypeQuery &query,
 588                            TypeResults &results) const {
 589   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 590   if (search_first) {
 591     search_first->FindTypes(query, results);
 592     if (results.Done(query))
 593       return;
 594   }
 595   for (const auto &module_sp : m_modules) {
 596     if (search_first != module_sp.get()) {
 597       module_sp->FindTypes(query, results);
 598       if (results.Done(query))
 599         return;
 600     }
 601   }
 602 }
 603
 604 bool ModuleList::FindSourceFile(const FileSpec &orig_spec,
 605                                 FileSpec &new_spec) const {
 606   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 607   for (const ModuleSP &module_sp : m_modules) {
 608     if (module_sp->FindSourceFile(orig_spec, new_spec))
 609       return true;
 610   }
 611   return false;
 612 }
 613
 614 void ModuleList::FindAddressesForLine(const lldb::TargetSP target_sp,
 615                                       const FileSpec &file, uint32_t line,
 616                                       Function *function,
 617                                       std::vector<Address> &output_local,
 618                                       std::vector<Address> &output_extern) {
 619   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 620   for (const ModuleSP &module_sp : m_modules) {
 621     module_sp->FindAddressesForLine(target_sp, file, line, function,
 622                                     output_local, output_extern);
 623   }
 624 }
 625
 626 ModuleSP ModuleList::FindFirstModule(const ModuleSpec &module_spec) const {
 627   ModuleSP module_sp;
 628   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 629   collection::const_iterator pos, end = m_modules.end();
 630   for (pos = m_modules.begin(); pos != end; ++pos) {
 631     ModuleSP module_sp(*pos);
 632     if (module_sp->MatchesModuleSpec(module_spec))
 633       return module_sp;
 634   }
 635   return module_sp;
 636 }
 637
 638 size_t ModuleList::GetSize() const {
 639   size_t size = 0;
 640   {
 641     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 642     size = m_modules.size();
 643   }
 644   return size;
 645 }
 646
 647 void ModuleList::Dump(Stream *s) const {
 648   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 649   for (const ModuleSP &module_sp : m_modules)
 650     module_sp->Dump(s);
 651 }
 652
 653 void ModuleList::LogUUIDAndPaths(Log *log, const char *prefix_cstr) {
 654   if (log != nullptr) {
 655     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 656     collection::const_iterator pos, begin = m_modules.begin(),
 657                                     end = m_modules.end();
 658     for (pos = begin; pos != end; ++pos) {
 659       Module *module = pos->get();
 660       const FileSpec &module_file_spec = module->GetFileSpec();
 661       LLDB_LOGF(log, "%s[%u] %s (%s) \"%s\"", prefix_cstr ? prefix_cstr : "",
 662                 (uint32_t)std::distance(begin, pos),
 663                 module->GetUUID().GetAsString().c_str(),
 664                 module->GetArchitecture().GetArchitectureName(),
 665                 module_file_spec.GetPath().c_str());
 666     }
 667   }
 668 }
 669
 670 bool ModuleList::ResolveFileAddress(lldb::addr_t vm_addr,
 671                                     Address &so_addr) const {
 672   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 673   for (const ModuleSP &module_sp : m_modules) {
 674     if (module_sp->ResolveFileAddress(vm_addr, so_addr))
 675       return true;
 676   }
 677
 678   return false;
 679 }
 680
 681 uint32_t
 682 ModuleList::ResolveSymbolContextForAddress(const Address &so_addr,
 683                                            SymbolContextItem resolve_scope,
 684                                            SymbolContext &sc) const {
 685   // The address is already section offset so it has a module
 686   uint32_t resolved_flags = 0;
 687   ModuleSP module_sp(so_addr.GetModule());
 688   if (module_sp) {
 689     resolved_flags =
 690         module_sp->ResolveSymbolContextForAddress(so_addr, resolve_scope, sc);
 691   } else {
 692     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 693     collection::const_iterator pos, end = m_modules.end();
 694     for (pos = m_modules.begin(); pos != end; ++pos) {
 695       resolved_flags =
 696           (*pos)->ResolveSymbolContextForAddress(so_addr, resolve_scope, sc);
 697       if (resolved_flags != 0)
 698         break;
 699     }
 700   }
 701
 702   return resolved_flags;
 703 }
 704
 705 uint32_t ModuleList::ResolveSymbolContextForFilePath(
 706     const char *file_path, uint32_t line, bool check_inlines,
 707     SymbolContextItem resolve_scope, SymbolContextList &sc_list) const {
 708   FileSpec file_spec(file_path);
 709   return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
 710                                           resolve_scope, sc_list);
 711 }
 712
 713 uint32_t ModuleList::ResolveSymbolContextsForFileSpec(
 714     const FileSpec &file_spec, uint32_t line, bool check_inlines,
 715     SymbolContextItem resolve_scope, SymbolContextList &sc_list) const {
 716   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 717   for (const ModuleSP &module_sp : m_modules) {
 718     module_sp->ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
 719                                                 resolve_scope, sc_list);
 720   }
 721
 722   return sc_list.GetSize();
 723 }
 724
 725 size_t ModuleList::GetIndexForModule(const Module *module) const {
 726   if (module) {
 727     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 728     collection::const_iterator pos;
 729     collection::const_iterator begin = m_modules.begin();
 730     collection::const_iterator end = m_modules.end();
 731     for (pos = begin; pos != end; ++pos) {
 732       if ((*pos).get() == module)
 733         return std::distance(begin, pos);
 734     }
 735   }
 736   return LLDB_INVALID_INDEX32;
 737 }
 738
 739 namespace {
 740 struct SharedModuleListInfo {
 741   ModuleList module_list;
 742   ModuleListProperties module_list_properties;
 743 };
 744 }
 745 static SharedModuleListInfo &GetSharedModuleListInfo()
 746 {
 747   static SharedModuleListInfo *g_shared_module_list_info = nullptr;
 748   static llvm::once_flag g_once_flag;
 749   llvm::call_once(g_once_flag, []() {
 750     // NOTE: Intentionally leak the module list so a program doesn't have to
 751     // cleanup all modules and object files as it exits. This just wastes time
 752     // doing a bunch of cleanup that isn't required.
 753     if (g_shared_module_list_info == nullptr)
 754       g_shared_module_list_info = new SharedModuleListInfo();
 755   });
 756   return *g_shared_module_list_info;
 757 }
 758
 759 static ModuleList &GetSharedModuleList() {
 760   return GetSharedModuleListInfo().module_list;
 761 }
 762
 763 ModuleListProperties &ModuleList::GetGlobalModuleListProperties() {
 764   return GetSharedModuleListInfo().module_list_properties;
 765 }
 766
 767 bool ModuleList::ModuleIsInCache(const Module *module_ptr) {
 768   if (module_ptr) {
 769     ModuleList &shared_module_list = GetSharedModuleList();
 770     return shared_module_list.FindModule(module_ptr).get() != nullptr;
 771   }
 772   return false;
 773 }
 774
 775 void ModuleList::FindSharedModules(const ModuleSpec &module_spec,
 776                                    ModuleList &matching_module_list) {
 777   GetSharedModuleList().FindModules(module_spec, matching_module_list);
 778 }
 779
 780 lldb::ModuleSP ModuleList::FindSharedModule(const UUID &uuid) {
 781   return GetSharedModuleList().FindModule(uuid);
 782 }
 783
 784 size_t ModuleList::RemoveOrphanSharedModules(bool mandatory) {
 785   return GetSharedModuleList().RemoveOrphans(mandatory);
 786 }
 787
 788 Status
 789 ModuleList::GetSharedModule(const ModuleSpec &module_spec, ModuleSP &module_sp,
 790                             const FileSpecList *module_search_paths_ptr,
 791                             llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules,
 792                             bool *did_create_ptr, bool always_create) {
 793   ModuleList &shared_module_list = GetSharedModuleList();
 794   std::lock_guard<std::recursive_mutex> guard(
 795       shared_module_list.m_modules_mutex);
 796   char path[PATH_MAX];
 797
 798   Status error;
 799
 800   module_sp.reset();
 801
 802   if (did_create_ptr)
 803     *did_create_ptr = false;
 804
 805   const UUID *uuid_ptr = module_spec.GetUUIDPtr();
 806   const FileSpec &module_file_spec = module_spec.GetFileSpec();
 807   const ArchSpec &arch = module_spec.GetArchitecture();
 808
 809   // Make sure no one else can try and get or create a module while this
 810   // function is actively working on it by doing an extra lock on the global
 811   // mutex list.
 812   if (!always_create) {
 813     ModuleList matching_module_list;
 814     shared_module_list.FindModules(module_spec, matching_module_list);
 815     const size_t num_matching_modules = matching_module_list.GetSize();
 816
 817     if (num_matching_modules > 0) {
 818       for (size_t module_idx = 0; module_idx < num_matching_modules;
 819            ++module_idx) {
 820         module_sp = matching_module_list.GetModuleAtIndex(module_idx);
 821
 822         // Make sure the file for the module hasn't been modified
 823         if (module_sp->FileHasChanged()) {
 824           if (old_modules)
 825             old_modules->push_back(module_sp);
 826
 827           Log *log = GetLog(LLDBLog::Modules);
 828           if (log != nullptr)
 829             LLDB_LOGF(
 830                 log, "%p '%s' module changed: removing from global module list",
 831                 static_cast<void *>(module_sp.get()),
 832                 module_sp->GetFileSpec().GetFilename().GetCString());
 833
 834           shared_module_list.Remove(module_sp);
 835           module_sp.reset();
 836         } else {
 837           // The module matches and the module was not modified from when it
 838           // was last loaded.
 839           return error;
 840         }
 841       }
 842     }
 843   }
 844
 845   if (module_sp)
 846     return error;
 847
 848   module_sp = std::make_shared<Module>(module_spec);
 849   // Make sure there are a module and an object file since we can specify a
 850   // valid file path with an architecture that might not be in that file. By
 851   // getting the object file we can guarantee that the architecture matches
 852   if (module_sp->GetObjectFile()) {
 853     // If we get in here we got the correct arch, now we just need to verify
 854     // the UUID if one was given
 855     if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) {
 856       module_sp.reset();
 857     } else {
 858       if (module_sp->GetObjectFile() &&
 859           module_sp->GetObjectFile()->GetType() ==
 860               ObjectFile::eTypeStubLibrary) {
 861         module_sp.reset();
 862       } else {
 863         if (did_create_ptr) {
 864           *did_create_ptr = true;
 865         }
 866
 867         shared_module_list.ReplaceEquivalent(module_sp, old_modules);
 868         return error;
 869       }
 870     }
 871   } else {
 872     module_sp.reset();
 873   }
 874
 875   if (module_search_paths_ptr) {
 876     const auto num_directories = module_search_paths_ptr->GetSize();
 877     for (size_t idx = 0; idx < num_directories; ++idx) {
 878       auto search_path_spec = module_search_paths_ptr->GetFileSpecAtIndex(idx);
 879       FileSystem::Instance().Resolve(search_path_spec);
 880       namespace fs = llvm::sys::fs;
 881       if (!FileSystem::Instance().IsDirectory(search_path_spec))
 882         continue;
 883       search_path_spec.AppendPathComponent(
 884           module_spec.GetFileSpec().GetFilename().GetStringRef());
 885       if (!FileSystem::Instance().Exists(search_path_spec))
 886         continue;
 887
 888       auto resolved_module_spec(module_spec);
 889       resolved_module_spec.GetFileSpec() = search_path_spec;
 890       module_sp = std::make_shared<Module>(resolved_module_spec);
 891       if (module_sp->GetObjectFile()) {
 892         // If we get in here we got the correct arch, now we just need to
 893         // verify the UUID if one was given
 894         if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) {
 895           module_sp.reset();
 896         } else {
 897           if (module_sp->GetObjectFile()->GetType() ==
 898               ObjectFile::eTypeStubLibrary) {
 899             module_sp.reset();
 900           } else {
 901             if (did_create_ptr)
 902               *did_create_ptr = true;
 903
 904             shared_module_list.ReplaceEquivalent(module_sp, old_modules);
 905             return Status();
 906           }
 907         }
 908       } else {
 909         module_sp.reset();
 910       }
 911     }
 912   }
 913
 914   // Either the file didn't exist where at the path, or no path was given, so
 915   // we now have to use more extreme measures to try and find the appropriate
 916   // module.
 917
 918   // Fixup the incoming path in case the path points to a valid file, yet the
 919   // arch or UUID (if one was passed in) don't match.
 920   ModuleSpec located_binary_modulespec =
 921       PluginManager::LocateExecutableObjectFile(module_spec);
 922
 923   // Don't look for the file if it appears to be the same one we already
 924   // checked for above...
 925   if (located_binary_modulespec.GetFileSpec() != module_file_spec) {
 926     if (!FileSystem::Instance().Exists(
 927             located_binary_modulespec.GetFileSpec())) {
 928       located_binary_modulespec.GetFileSpec().GetPath(path, sizeof(path));
 929       if (path[0] == '\0')
 930         module_file_spec.GetPath(path, sizeof(path));
 931       // How can this check ever be true? This branch it is false, and we
 932       // haven't modified file_spec.
 933       if (FileSystem::Instance().Exists(
 934               located_binary_modulespec.GetFileSpec())) {
 935         std::string uuid_str;
 936         if (uuid_ptr && uuid_ptr->IsValid())
 937           uuid_str = uuid_ptr->GetAsString();
 938
 939         if (arch.IsValid()) {
 940           if (!uuid_str.empty())
 941             error = Status::FromErrorStringWithFormat(
 942                 "'%s' does not contain the %s architecture and UUID %s", path,
 943                 arch.GetArchitectureName(), uuid_str.c_str());
 944           else
 945             error = Status::FromErrorStringWithFormat(
 946                 "'%s' does not contain the %s architecture.", path,
 947                 arch.GetArchitectureName());
 948         }
 949       } else {
 950         error = Status::FromErrorStringWithFormat("'%s' does not exist", path);
 951       }
 952       if (error.Fail())
 953         module_sp.reset();
 954       return error;
 955     }
 956
 957     // Make sure no one else can try and get or create a module while this
 958     // function is actively working on it by doing an extra lock on the global
 959     // mutex list.
 960     ModuleSpec platform_module_spec(module_spec);
 961     platform_module_spec.GetFileSpec() =
 962         located_binary_modulespec.GetFileSpec();
 963     platform_module_spec.GetPlatformFileSpec() =
 964         located_binary_modulespec.GetFileSpec();
 965     platform_module_spec.GetSymbolFileSpec() =
 966         located_binary_modulespec.GetSymbolFileSpec();
 967     ModuleList matching_module_list;
 968     shared_module_list.FindModules(platform_module_spec, matching_module_list);
 969     if (!matching_module_list.IsEmpty()) {
 970       module_sp = matching_module_list.GetModuleAtIndex(0);
 971
 972       // If we didn't have a UUID in mind when looking for the object file,
 973       // then we should make sure the modification time hasn't changed!
 974       if (platform_module_spec.GetUUIDPtr() == nullptr) {
 975         auto file_spec_mod_time = FileSystem::Instance().GetModificationTime(
 976             located_binary_modulespec.GetFileSpec());
 977         if (file_spec_mod_time != llvm::sys::TimePoint<>()) {
 978           if (file_spec_mod_time != module_sp->GetModificationTime()) {
 979             if (old_modules)
 980               old_modules->push_back(module_sp);
 981             shared_module_list.Remove(module_sp);
 982             module_sp.reset();
 983           }
 984         }
 985       }
 986     }
 987
 988     if (!module_sp) {
 989       module_sp = std::make_shared<Module>(platform_module_spec);
 990       // Make sure there are a module and an object file since we can specify a
 991       // valid file path with an architecture that might not be in that file.
 992       // By getting the object file we can guarantee that the architecture
 993       // matches
 994       if (module_sp && module_sp->GetObjectFile()) {
 995         if (module_sp->GetObjectFile()->GetType() ==
 996             ObjectFile::eTypeStubLibrary) {
 997           module_sp.reset();
 998         } else {
 999           if (did_create_ptr)
1000             *did_create_ptr = true;
1001
1002           shared_module_list.ReplaceEquivalent(module_sp, old_modules);
1003         }
1004       } else {
1005         located_binary_modulespec.GetFileSpec().GetPath(path, sizeof(path));
1006
1007         if (located_binary_modulespec.GetFileSpec()) {
1008           if (arch.IsValid())
1009             error = Status::FromErrorStringWithFormat(
1010                 "unable to open %s architecture in '%s'",
1011                 arch.GetArchitectureName(), path);
1012           else
1013             error =
1014                 Status::FromErrorStringWithFormat("unable to open '%s'", path);
1015         } else {
1016           std::string uuid_str;
1017           if (uuid_ptr && uuid_ptr->IsValid())
1018             uuid_str = uuid_ptr->GetAsString();
1019
1020           if (!uuid_str.empty())
1021             error = Status::FromErrorStringWithFormat(
1022                 "cannot locate a module for UUID '%s'", uuid_str.c_str());
1023           else
1024             error = Status::FromErrorString("cannot locate a module");
1025         }
1026       }
1027     }
1028   }
1029
1030   return error;
1031 }
1032
1033 bool ModuleList::RemoveSharedModule(lldb::ModuleSP &module_sp) {
1034   return GetSharedModuleList().Remove(module_sp);
1035 }
1036
1037 bool ModuleList::RemoveSharedModuleIfOrphaned(const Module *module_ptr) {
1038   return GetSharedModuleList().RemoveIfOrphaned(module_ptr);
1039 }
1040
1041 bool ModuleList::LoadScriptingResourcesInTarget(Target *target,
1042                                                 std::list<Status> &errors,
1043                                                 Stream &feedback_stream,
1044                                                 bool continue_on_error) {
1045   if (!target)
1046     return false;
1047   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
1048   for (auto module : m_modules) {
1049     if (module) {
1050       Status error;
1051       if (!module->LoadScriptingResourceInTarget(target, error,
1052                                                  feedback_stream)) {
1053         if (error.Fail() && error.AsCString()) {
1054           error = Status::FromErrorStringWithFormat(
1055               "unable to load scripting data for "
1056               "module %s - error reported was %s",
1057               module->GetFileSpec()
1058                   .GetFileNameStrippingExtension()
1059                   .GetCString(),
1060               error.AsCString());
1061           errors.push_back(std::move(error));
1062           if (!continue_on_error)
1063             return false;
1064         }
1065       }
1066     }
1067   }
1068   return errors.empty();
1069 }
1070
1071 void ModuleList::ForEach(
1072     std::function<bool(const ModuleSP &module_sp)> const &callback) const {
1073   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
1074   for (const auto &module_sp : m_modules) {
1075     assert(module_sp != nullptr);
1076     // If the callback returns false, then stop iterating and break out
1077     if (!callback(module_sp))
1078       break;
1079   }
1080 }
1081
1082 bool ModuleList::AnyOf(
1083     std::function<bool(lldb_private::Module &module_sp)> const &callback)
1084     const {
1085   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
1086   for (const auto &module_sp : m_modules) {
1087     assert(module_sp != nullptr);
1088     if (callback(*module_sp))
1089       return true;
1090   }
1091
1092   return false;
1093 }
1094
1095
1096 void ModuleList::Swap(ModuleList &other) {
1097   // scoped_lock locks both mutexes at once.
1098   std::scoped_lock<std::recursive_mutex, std::recursive_mutex> lock(
1099       m_modules_mutex, other.m_modules_mutex);
1100   m_modules.swap(other.m_modules);
1101 }