[LLDB] Support importing modules from llvmcas:// URLs

This patch creates a wrapper LLDB Swft module loader that owns both an
ESML (explicit Swift module loader) and a CAS explicit module loader,
dispatches module discovery calls to both, and tries to find each
module in the CAS first, before trying the ESML.

rdar://166576110

Author: adrian-prantl

lldb/include/lldb/Core/ModuleList.h

@@ -33,6 +33,14 @@
 #include <cstddef>
 #include <cstdint>
 
+namespace llvm {
+namespace cas {
+class CASConfiguration;
+class ObjectStore;
+class ActionCache;
+} // namespace cas
+} // namespace llvm
+
 namespace lldb_private {
 class ConstString;
 class FileSpecList;
@@ -106,6 +114,7 @@ class ModuleListProperties : public Properties {
   // START CAS
   /// Get CASPath set via properties.
   FileSpec GetCASOnDiskPath() const;
+  bool SetCASOnDiskPath(const FileSpec &);
 
   /// Get CASPluginPath set via properties.
   FileSpec GetCASPluginPath() const;
@@ -538,10 +547,14 @@ class ModuleList {
 
   // START CAS
 
-  /// Get CAS configuration using global module properties or from candidate
-  /// search path.
-  static std::optional<llvm::cas::CASConfiguration>
-  GetCASConfiguration(FileSpec CandidateConfigSearchPath);
+  struct CAS {
+    std::shared_ptr<llvm::cas::CASConfiguration> configuration;
+    std::shared_ptr<llvm::cas::ObjectStore> object_store;
+    std::shared_ptr<llvm::cas::ActionCache> action_cache;
+  };
+  /// Search for a CAS configuration file near this module. This
+  /// operation does a lot of file system stat calls.
+  static llvm::Expected<CAS> GetOrCreateCAS(const lldb::ModuleSP &module_sp);
 
   /// Gets the shared module from CAS. It works the same as `GetSharedModule`
   /// but the lookup is done inside the CAS.
@@ -550,11 +563,9 @@ class ModuleList {
   ///    true if module is successfully loaded, false if module is not found
   ///    in the CAS, error if there are any errors happened during the loading
   ///    process.
-  static llvm::Expected<bool> GetSharedModuleFromCAS(ConstString module_name,
-                                                     llvm::StringRef cas_id,
-                                                     FileSpec cu_path,
-                                                     ModuleSpec &module_spec,
-                                                     lldb::ModuleSP &module_sp);
+  static llvm::Expected<bool>
+  GetSharedModuleFromCAS(llvm::StringRef cas_id, const lldb::ModuleSP &nearby,
+                         ModuleSpec &module_spec, lldb::ModuleSP &module_sp);
   // END CAS
 
   static bool RemoveSharedModule(lldb::ModuleSP &module_sp);

lldb/source/Core/ModuleList.cpp

@@ -17,6 +17,7 @@
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Utility/ArchSpec.h"
@@ -28,6 +29,7 @@
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-defines.h"
 #include "llvm/ADT/ScopeExit.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/FileUtilities.h"
 
 #if defined(_WIN32)
@@ -304,6 +306,11 @@ FileSpec ModuleListProperties::GetCASOnDiskPath() const {
   return GetPropertyAtIndexAs<FileSpec>(idx, {});
 }
 
+bool ModuleListProperties::SetCASOnDiskPath(const FileSpec &path) {
+  const uint32_t idx = ePropertyCASOnDiskPath;
+  return SetPropertyAtIndex(idx, path);
+}
+
 FileSpec ModuleListProperties::GetCASPluginPath() const {
   const uint32_t idx = ePropertyCASPluginPath;
   return GetPropertyAtIndexAs<FileSpec>(idx, {});
@@ -1299,7 +1306,8 @@ class SharedModuleList {
 struct SharedModuleListInfo {
   SharedModuleList module_list;
   ModuleListProperties module_list_properties;
-  std::shared_ptr<llvm::cas::ObjectStore> cas_object_store;
+  // TODO: This should be an LRU cache of multiple CAS.
+  ModuleList::CAS cas = {};
   std::mutex shared_lock;
 };
 }
@@ -1322,8 +1330,8 @@ static SharedModuleList &GetSharedModuleList() {
   return GetSharedModuleListInfo().module_list;
 }
 
-std::optional<llvm::cas::CASConfiguration>
-ModuleList::GetCASConfiguration(FileSpec CandidateConfigSearchPath) {
+static std::optional<llvm::cas::CASConfiguration>
+GetCASConfiguration(FileSpec CandidateConfigSearchPath) {
   // Config CAS from properties.
   llvm::cas::CASConfiguration cas_config;
   cas_config.CASPath =
@@ -1344,25 +1352,6 @@ ModuleList::GetCASConfiguration(FileSpec CandidateConfigSearchPath) {
   return std::nullopt;
 }
 
-static llvm::Expected<std::shared_ptr<llvm::cas::ObjectStore>>
-GetOrCreateCASStorage(FileSpec CandidateConfigSearchPath) {
-  auto &shared_module_list = GetSharedModuleListInfo();
-  if (shared_module_list.cas_object_store)
-    return shared_module_list.cas_object_store;
-
-  auto config = ModuleList::GetCASConfiguration(CandidateConfigSearchPath);
-  if (!config)
-    return nullptr;
-
-  auto cas = config->createDatabases();
-  if (!cas)
-    return cas.takeError();
-
-  std::scoped_lock<std::mutex> lock(shared_module_list.shared_lock);
-  shared_module_list.cas_object_store = std::move(cas->first);
-  return shared_module_list.cas_object_store;
-}
-
 ModuleListProperties &ModuleList::GetGlobalModuleListProperties() {
   return GetSharedModuleListInfo().module_list_properties;
 }
@@ -1634,19 +1623,18 @@ ModuleList::GetSharedModule(const ModuleSpec &module_spec, ModuleSP &module_sp,
   return error;
 }
 
-static llvm::Expected<bool> loadModuleFromCAS(ConstString module_name,
-                                              llvm::StringRef cas_id,
-                                              FileSpec cu_path,
-                                              ModuleSpec &module_spec) {
-  auto maybe_cas = GetOrCreateCASStorage(cu_path);
+static llvm::Expected<bool> loadModuleFromCASImpl(llvm::StringRef cas_id,
+                                                  const lldb::ModuleSP &nearby,
+                                                  ModuleSpec &module_spec) {
+  auto maybe_cas = ModuleList::GetOrCreateCAS(nearby);
   if (!maybe_cas)
     return maybe_cas.takeError();
 
-  auto cas = std::move(*maybe_cas);
+  auto cas = std::move(maybe_cas->object_store);
   if (!cas) {
     LLDB_LOG(GetLog(LLDBLog::Modules),
              "skip loading module '{0}' from CAS: CAS is not available",
-             module_name);
+             cas_id);
     return false;
   }
 
@@ -1670,15 +1658,96 @@ static llvm::Expected<bool> loadModuleFromCAS(ConstString module_name,
   loaded.GetArchitecture() = module_spec.GetArchitecture();
   module_spec = loaded;
 
-  LLDB_LOG(GetLog(LLDBLog::Modules), "loading module '{0}' using CASID '{1}'",
-           module_name, cas_id);
+  LLDB_LOG(GetLog(LLDBLog::Modules), "loading module using CASID '{0}'",
+           cas_id);
   return true;
 }
 
+/// Load the module referenced by \c cas_id from a CAS located
+/// near \c nearby.
+static llvm::Expected<bool> loadModuleFromCAS(llvm::StringRef cas_id,
+                                              const lldb::ModuleSP &nearby,
+                                              ModuleSpec &module_spec) {
+  static llvm::StringMap<bool> g_cache;
+  static std::recursive_mutex g_cache_lock;
+  std::scoped_lock<std::recursive_mutex> lock(g_cache_lock);
+  auto cached = g_cache.find(cas_id);
+  if (cached != g_cache.end())
+    return cached->second;
+  auto result = loadModuleFromCASImpl(cas_id, nearby, module_spec);
+  // Errors are only returned the first time.
+  g_cache.insert({cas_id, result ? *result : false});
+  return result;
+}
+
+llvm::Expected<ModuleList::CAS>
+ModuleList::GetOrCreateCAS(const ModuleSP &module_sp) {
+  if (!module_sp)
+    return llvm::createStringError("no lldb::Module available");
+
+  auto &shared_module_list = GetSharedModuleListInfo();
+  std::scoped_lock<std::mutex> lock(shared_module_list.shared_lock);
+  if (shared_module_list.cas.object_store)
+    return shared_module_list.cas;
+
+  std::set<FileSpec> unique_paths;
+  auto insert_module_path = [&](const ModuleSP &m) -> IterationAction {
+    if (m) {
+      FileSpec path = m->GetFileSpec();
+      path.ClearFilename();
+      unique_paths.insert(path);
+    }
+    return IterationAction::Continue;
+  };
+  insert_module_path(module_sp);
+
+  std::optional<llvm::cas::CASConfiguration> cas_config;
+  for (auto &path : unique_paths)
+    cas_config = GetCASConfiguration(path);
+  if (!cas_config) {
+    unique_paths.clear();
+    insert_module_path(module_sp);
+    if (SymbolFile *sf = module_sp->GetSymbolFile()) {
+      sf->GetDebugInfoModules().ForEach(insert_module_path);
+      for (auto &path : unique_paths)
+        if ((cas_config = GetCASConfiguration(path)))
+          break;
+    }
+  }
+  if (!cas_config &&
+      !ModuleList::GetGlobalModuleListProperties().GetCASOnDiskPath())
+    for (auto &path : unique_paths) {
+      llvm::StringRef parent = path.GetDirectory().GetStringRef();
+      while (!parent.empty() &&
+             llvm::sys::path::filename(parent) != "DerivedData")
+        parent = llvm::sys::path::parent_path(parent);
+      if (parent.empty())
+        continue;
+      llvm::SmallString<256> cas_path(parent);
+      llvm::sys::path::append(cas_path, "CompilationCache.noindex", "builtin");
+      FileSpec fs = FileSpec(cas_path);
+      ModuleList::GetGlobalModuleListProperties().SetCASOnDiskPath(fs);
+      cas_config = GetCASConfiguration(fs);
+      if (cas_config)
+        break;
+    }
+
+  if (!cas_config)
+    return llvm::createStringError("no CAS available");
+  auto cas = cas_config->createDatabases();
+  if (!cas)
+    return cas.takeError();
+
+  shared_module_list.cas = {
+      std::make_shared<llvm::cas::CASConfiguration>(*cas_config),
+      std::move(cas->first), std::move(cas->second)};
+  return shared_module_list.cas;
+}
+
 llvm::Expected<bool> ModuleList::GetSharedModuleFromCAS(
-    ConstString module_name, llvm::StringRef cas_id, FileSpec cu_path,
+    llvm::StringRef cas_id, const lldb::ModuleSP &nearby,
     ModuleSpec &module_spec, lldb::ModuleSP &module_sp) {
-  auto loaded = loadModuleFromCAS(module_name, cas_id, cu_path, module_spec);
+  auto loaded = loadModuleFromCAS(cas_id, nearby, module_spec);
   if (!loaded)
     return loaded.takeError();
 

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

@@ -2006,21 +2006,25 @@ void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
 
     dwo_module_spec.GetArchitecture() =
         m_objfile_sp->GetModule()->GetArchitecture();
+    dwo_module_spec.GetFileSpec().SetFile(dwo_path, FileSpec::Style::native);
 
-    // Try load from CAS, if loaded, continue to next one.
-    auto loaded = ModuleList::GetSharedModuleFromCAS(
-        const_name, dwo_path, GetObjectFile()->GetFileSpec(), dwo_module_spec,
-        module_sp);
-    if (!loaded)
-      GetObjectFile()->GetModule()->ReportWarning(
-          "Failed to load module '{0}' from CAS: {1}", const_name,
-          toString(loaded.takeError()));
-
-    // succeed, loaded next module.
-    if (*loaded)
-      continue;
+    // BEGIN CAS
+    llvm::StringRef url(dwo_path);
+    if (url.starts_with("llvmcas://")) {
+      LLDB_LOG(GetLog(LLDBLog::Symbols|LLDBLog::Modules),
+               "Loading module '{0}' from CAS at {1}...", const_name, url);
+      auto loaded = ModuleList::GetSharedModuleFromCAS(
+          url, GetObjectFile()->GetModule(), dwo_module_spec, module_sp);
+      if (!loaded)
+        GetObjectFile()->GetModule()->ReportWarning(
+            "Failed to load module '{0}' from CAS: {1}", const_name,
+            toString(loaded.takeError()));
+      else if (*loaded)
+        // Succeed, load next module.
+        continue;
+    }
+    // END CAS
 
-    dwo_module_spec.GetFileSpec().SetFile(dwo_path, FileSpec::Style::native);
     if (dwo_module_spec.GetFileSpec().IsRelative()) {
       const char *comp_dir =
           die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr);

lldb/source/Plugins/TypeSystem/Swift/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_lldb_library(lldbPluginTypeSystemSwift PLUGIN
+  LLDBExplicitModuleLoader.cpp
   SwiftDWARFImporterForClangTypes.cpp
   TypeSystemSwift.cpp
   TypeSystemSwiftTypeRef.cpp