[lldb] Teach LLDB to load gmodules from CAS

Teach lldb to load clang modules when gmodule + clang caching is used.

Author: cachemeifyoucan

lldb/include/lldb/Core/ModuleList.h

@@ -100,6 +100,12 @@ class ModuleListProperties : public Properties {
   bool GetSwiftEnableASTContext() const;
   // END SWIFT
 
+  // START CAS
+  FileSpec GetCASOnDiskPath() const;
+  FileSpec GetCASPluginPath() const;
+  std::vector<std::pair<std::string, std::string>> GetCASPluginOptions() const;
+  // END CAS
+
   FileSpec GetClangModulesCachePath() const;
   bool SetClangModulesCachePath(const FileSpec &path);
   bool GetEnableExternalLookup() const;
@@ -522,6 +528,11 @@ class ModuleList {
                   llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules,
                   bool *did_create_ptr, bool always_create = false);
 
+  static Status GetSharedModuleFromCAS(ConstString module_name,
+                                       const char *cas_id, FileSpec cu_path,
+                                       ModuleSpec &module_spec,
+                                       lldb::ModuleSP &module_sp);
+
   static bool RemoveSharedModule(lldb::ModuleSP &module_sp);
 
   static void FindSharedModules(const ModuleSpec &module_spec,

lldb/scripts/clang-explicit-module-build.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Usage: clang-explicit-module-build.py [-cas-path CAS_PATH] -- CLANG_COMMAND
+
+The script builds with clang explicit module. If `-cas-path` is used, clang
+explicit module build is going to enable compilation caching.
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+
+
+def main():
+    argv = sys.argv[1:]
+    if "--" not in argv:
+        print("missing clang command")
+        exit(1)
+    dash_idx = argv.index("--")
+    clang_args = argv[dash_idx + 1:]
+    if len(clang_args) == 0:
+        print("empty clang command")
+        exit(1)
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-cas-path", required=False)
+    args = parser.parse_args(argv[:dash_idx])
+
+    clang_exe = clang_args[0]
+    clang_scan_deps = os.path.join(
+        os.path.dirname(clang_exe), "clang-scan-deps")
+
+    scan_cmd = [clang_scan_deps]
+    if args.cas_path is None:
+        scan_cmd.extend(["-format", "experimental-full", "-o", "-", "--"])
+    else:
+        scan_cmd.extend(["-format", "experimental-include-tree-full",
+                        "-cas-path", args.cas_path, "-o", "-", "--"])
+    scan_cmd.extend(clang_args)
+    scan_result = json.loads(subprocess.check_output(scan_cmd))
+
+    # build module: assuming modules in reverse dependency order.
+    for module in reversed(scan_result["modules"]):
+        cmd = [clang_exe] + module["command-line"]
+        print(*cmd)
+        subprocess.check_call(cmd)
+
+    # build tu: assuming only one TU.
+    tu_cmd = [clang_exe] + \
+        scan_result["translation-units"][0]["commands"][0]["command-line"]
+    print(*tu_cmd)
+    subprocess.check_call(tu_cmd)
+
+
+if __name__ == "__main__":
+    main()

lldb/source/Core/CoreProperties.td

@@ -74,6 +74,19 @@ let Definition = "modulelist" in {
     DefaultTrue,
     Desc<"Enable instantiating Swift AST contexts.">;
 // END SWIFT
+// BEGIN CAS
+  def CASOnDiskPath: Property<"cas-path", "FileSpec">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"The path for CAS storage">;
+  def CASPluginPath: Property<"cas-plugin-path", "FileSpec">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"The path for CAS plugin dynamic library">;
+  def CASPluginOptions: Property<"cas-plugin-options", "Array">,
+    ElementType<"String">,
+    Desc<"A list of options to be passed to CAS plugins">;
+// END CAS
   def SymLinkPaths: Property<"debug-info-symlink-paths", "FileSpecList">,
     Global,
     DefaultStringValue<"">,

lldb/source/Core/ModuleList.cpp

@@ -26,13 +26,17 @@
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-defines.h"
+#include "llvm/ADT/ScopeExit.h"
+#include "llvm/Support/FileUtilities.h"
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/PosixApi.h"
 #endif
 
 #include "clang/Driver/Driver.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/CAS/CASConfiguration.h"
+#include "llvm/CAS/ObjectStore.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
@@ -282,6 +286,32 @@ bool ModuleListProperties::GetSwiftEnableASTContext() const {
 }
 // END SWIFT
 
+// START CAS
+FileSpec ModuleListProperties::GetCASOnDiskPath() const {
+  const uint32_t idx = ePropertyCASOnDiskPath;
+  return GetPropertyAtIndexAs<FileSpec>(idx, {});
+}
+
+FileSpec ModuleListProperties::GetCASPluginPath() const {
+  const uint32_t idx = ePropertyCASPluginPath;
+  return GetPropertyAtIndexAs<FileSpec>(idx, {});
+}
+
+std::vector<std::pair<std::string, std::string>>
+ModuleListProperties::GetCASPluginOptions() const {
+  Args args;
+  const uint32_t idx = ePropertyCASPluginOptions;
+  m_collection_sp->GetPropertyAtIndexAsArgs(idx, args);
+  std::vector<std::pair<std::string, std::string>> options;
+  for (auto &arg : args) {
+    llvm::StringRef opt = arg.c_str();
+    auto splitted = opt.split("=");
+    options.emplace_back(splitted.first.str(), splitted.second.str());
+  }
+  return options;
+}
+// END CAS
+
 FileSpec ModuleListProperties::GetLLDBIndexCachePath() const {
   const uint32_t idx = ePropertyLLDBIndexCachePath;
   return GetPropertyAtIndexAs<FileSpec>(idx, {});
@@ -1253,8 +1283,11 @@ class SharedModuleList {
 struct SharedModuleListInfo {
   SharedModuleList module_list;
   ModuleListProperties module_list_properties;
+  std::shared_ptr<llvm::cas::ObjectStore> cas_object_store;
+  std::mutex shared_lock;
 };
 }
+
 static SharedModuleListInfo &GetSharedModuleListInfo()
 {
   static SharedModuleListInfo *g_shared_module_list_info = nullptr;
@@ -1273,6 +1306,45 @@ static SharedModuleList &GetSharedModuleList() {
   return GetSharedModuleListInfo().module_list;
 }
 
+static 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;
+
+  std::scoped_lock<std::mutex> lock(shared_module_list.shared_lock);
+  // Config CAS from properties.
+  llvm::cas::CASConfiguration cas_config;
+  cas_config.CASPath =
+      ModuleList::GetGlobalModuleListProperties().GetCASOnDiskPath().GetPath();
+  cas_config.PluginPath =
+      ModuleList::GetGlobalModuleListProperties().GetCASPluginPath().GetPath();
+  cas_config.PluginOptions =
+      ModuleList::GetGlobalModuleListProperties().GetCASPluginOptions();
+
+  if (!cas_config.CASPath.empty()) {
+    if (auto maybe_cas = cas_config.createDatabases()) {
+      shared_module_list.cas_object_store = std::move(maybe_cas->first);
+      return shared_module_list.cas_object_store;
+    } else
+      llvm::consumeError(maybe_cas.takeError());
+  }
+
+  // Try search from candidiate path.
+  auto search_config = llvm::cas::CASConfiguration::createFromSearchConfigFile(
+      CandidateConfigSearchPath.GetPath());
+  if (!search_config)
+    return nullptr;
+
+  if (auto maybe_cas = search_config->second.createDatabases()) {
+    shared_module_list.cas_object_store = std::move(maybe_cas->first);
+    return shared_module_list.cas_object_store;
+  } else
+    llvm::consumeError(maybe_cas.takeError());
+
+  return nullptr;
+}
+
 ModuleListProperties &ModuleList::GetGlobalModuleListProperties() {
   return GetSharedModuleListInfo().module_list_properties;
 }
@@ -1544,6 +1616,59 @@ ModuleList::GetSharedModule(const ModuleSpec &module_spec, ModuleSP &module_sp,
   return error;
 }
 
+static llvm::Error loadModuleFromCAS(ConstString module_name,
+                                     const char *cas_id, FileSpec cu_path,
+                                     ModuleSpec &module_spec) {
+  auto cas = GetOrCreateCASStorage(cu_path);
+  if (!cas)
+    return llvm::createStringError("CAS is not available");
+  auto id = cas->parseID(cas_id);
+  if (!id)
+    return id.takeError();
+
+  auto module_proxy = cas->getProxy(*id);
+  if (!module_proxy)
+    return module_proxy.takeError();
+
+  // Create a temporary file that holds the module info.
+  llvm::SmallString<0> name;
+  int fd;
+  auto ec =
+      llvm::sys::fs::createTemporaryFile("lldb-module-cas", "pcm", fd, name);
+  if (ec || fd <= 0)
+    return llvm::createStringError(
+        "could not create temporary file for module");
+
+  NativeFile file(fd, File::eOpenOptionWriteOnly, true);
+  size_t num_bytes = module_proxy->getData().size();
+  file.Write(module_proxy->getData().data(), num_bytes);
+
+  Log *log = GetLog(LLDBLog::Modules);
+  if (log != nullptr)
+    LLDB_LOGF(log, "loading module '%s' using CASID '%s' from temp file: %s",
+              module_name.AsCString(), cas_id, name.c_str());
+
+  module_spec.GetFileSpec().SetFile(name, FileSpec::Style::native);
+  return llvm::Error::success();
+}
+
+Status ModuleList::GetSharedModuleFromCAS(ConstString module_name,
+                                          const char *cas_id, FileSpec cu_path,
+                                          ModuleSpec &module_spec,
+                                          lldb::ModuleSP &module_sp) {
+  auto err = loadModuleFromCAS(module_name, cas_id, cu_path, module_spec);
+  if (err)
+    return Status::FromErrorString(llvm::toString(std::move(err)).c_str());
+
+  // Remove the temporary file created from CAS content after module is loaded.
+  auto cleanup_module = llvm::make_scope_exit([&]() {
+    llvm::sys::fs::remove(
+        module_spec.GetFileSpec().GetPathAsConstString().GetStringRef());
+  });
+
+  return GetSharedModule(module_spec, module_sp, nullptr, nullptr, nullptr);
+}
+
 bool ModuleList::RemoveSharedModule(lldb::ModuleSP &module_sp) {
   return GetSharedModuleList().Remove(module_sp);
 }

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

@@ -2004,6 +2004,17 @@ void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
       continue;
 
     ModuleSpec dwo_module_spec;
+
+    dwo_module_spec.GetArchitecture() =
+        m_objfile_sp->GetModule()->GetArchitecture();
+
+    // Try load from CAS, if loaded, continue to next one.
+    if (ModuleList::GetSharedModuleFromCAS(const_name, dwo_path,
+                                           GetObjectFile()->GetFileSpec(),
+                                           dwo_module_spec, module_sp)
+            .Success())
+      continue;
+
     dwo_module_spec.GetFileSpec().SetFile(dwo_path, FileSpec::Style::native);
     if (dwo_module_spec.GetFileSpec().IsRelative()) {
       const char *comp_dir =
@@ -2015,8 +2026,6 @@ void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
         dwo_module_spec.GetFileSpec().AppendPathComponent(dwo_path);
       }
     }
-    dwo_module_spec.GetArchitecture() =
-        m_objfile_sp->GetModule()->GetArchitecture();
 
     // When LLDB loads "external" modules it looks at the presence of
     // DW_AT_dwo_name. However, when the already created module

lldb/test/CMakeLists.txt

@@ -162,6 +162,8 @@ if(TARGET clang)
 
   # TestFullLtoStepping depends on LTO, and only runs when the compiler is clang.
   add_lldb_test_dependency(LTO)
+  # Clang explicit module build test requires clang-scan-deps
+  add_lldb_test_dependency(clang-scan-deps)
 
   if (TARGET libcxx OR ("libcxx" IN_LIST LLVM_ENABLE_RUNTIMES))
     set(LLDB_HAS_LIBCXX ON)

lldb/test/Shell/SymbolFile/cas-gmodule.test

@@ -0,0 +1,46 @@
+# REQUIRES: system-darwin
+# RUN: rm -rf %t
+# RUN: split-file %s %t
+# RUN: sed "s|DIR|%/t|g" %t/cas-config.template > %t/.cas-config
+
+# RUN: %python %S/../../../scripts/clang-explicit-module-build.py -cas-path %t/cas -- %clang_host -c -g -o %t/test.o %t/tu.c -fmodules -gmodules -fmodules-cache-path=%t/module-cache
+# RUN: %clang_host %t/test.o -o %t/main
+# RUN: %lldb %t/main -s %t/lldb.script 2>&1 | FileCheck %s
+# CHECK: loading module 'Bottom' using CASID
+# CHECK: loading module 'Top' using CASID
+# CHECK: top = (x = 1)
+
+//--- module.modulemap
+module Top { header "Top.h" export *}
+module Bottom { header "Bottom.h" export *}
+
+//--- Top.h
+#pragma once
+struct Top { int x; };
+
+//--- Bottom.h
+#pragma once
+#include "Top.h"
+struct Bottom { struct Top top; };
+
+//--- tu.c
+#include "Bottom.h"
+
+int main(void) {
+  struct Bottom _bottom;
+  _bottom.top.x = 1;
+
+  return 0; // BREAK HERE
+}
+
+//--- cas-config.template
+{
+  "CASPath": "DIR/cas"
+}
+
+//--- lldb.script
+log enable lldb module
+b tu.c:7
+run
+expr _bottom
+quit