Add support for importing general C++ modules into the LLDB expression evaluator

[teemperor]

Summary

This patch adds basic support for importing C++ modules in general into the LLDB expression evaluator. It mostly reuses
the code we already use for the std module prototype for building/importing the modules, but is using a different logic
for querying the modules from the executable. The current functionality is limited - like the first std module patch - to
only reading module information but not merging or substituting debug information.

Unlike the std module prototype, this feature now requires that we compile with -gmodules, as this is the only way we
have all modules (even modules that were just imported but not actually used) in the debug information. Without this,
we run into frequent build errors as soon as some module includes another module without actually using it. This leads
to the situation where Clang will not emit the module in the debug information (as it's unused), but LLDB will fail to
compile the C++ module as it still needs the include paths of the unused module. This is why we now have a
GetAllUsedModules that works similar to GetImportedModules but actually creates a complete list of all modules we
have used in a given compilation unit. This allows LLDB to fully reconstruct the original include directories.

[aprantl]

lldb/include/lldb/Symbol/CompileUnit.h

397

All *Clang/Source* modules? Otherwise it sounds like lldb::Modules.

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

486

std::copy_if?

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

933

Is that a bug in Clang? Can you send me an example?

934

That is not the only valid name for module map files, we also support module.map, module.private.modulemap and possibly more. I feel like there should be a better solution to the underlying problem.

995

This sounds wrong for LTO binaries, which will contain many Clang CUs in one file.

lldb/include/lldb/Symbol/CompileUnit.h

public:
   ///
   /// This reports all the imports that the compile unit made, including the
   /// current module.
   ///
   /// \return
   ///     A list of imported modules.
   const std::vector<SourceModule> &GetImportedModules();
 
+  /// Get all modules used to compile this compile unit.
+  ///
+  /// This reports all modules used directly or indirectly by this compile unit.
+  /// For example, if this compile unit uses a module A which in turn uses a
+  /// module B, this function returns both A and B.
+  ///
+  /// \return
+  ///     A list of used modules.
+  const std::vector<SourceModule> &GetAllUsedModules();
+
   /// Get the SymbolFile plug-in user data.
   ///
   /// SymbolFile plug-ins can store user data to internal state or objects to
   /// quickly allow them to parse more information for a given object.
   ///
   /// \return
   ///     The user data stored with the CompileUnit when it was
   ///     constructed.
protected:
   lldb::LanguageType m_language;
   /// Compile unit flags that help with partial parsing.
   Flags m_flags;
   /// Maps UIDs to functions.
   llvm::DenseMap<lldb::user_id_t, lldb::FunctionSP> m_functions_by_uid;
   /// All modules, including the current module, imported by this
   /// compile unit.
   std::vector<SourceModule> m_imported_modules;
+  /// All modules, including the current module, used directly or indirectly
+  /// by this compile unit.
+  std::vector<SourceModule> m_all_used_modules;
   /// Files associated with this compile unit's line table and
   /// declarations.
   FileSpecList m_support_files;
   /// Line table that will get parsed on demand.
   std::unique_ptr<LineTable> m_line_table_up;
   /// Debug macros that will get parsed on demand.
   DebugMacrosSP m_debug_macros_sp;
   /// Global and static variable list that will get parsed on demand.
   lldb::VariableListSP m_variables;
   /// eLazyBoolYes if this compile unit was compiled with
   /// optimization.
   lldb_private::LazyBool m_is_optimized;
 
 private:
   enum {
     flagsParsedAllFunctions =
         (1u << 0), ///< Have we already parsed all our functions
     flagsParsedVariables =
         (1u << 1), ///< Have we already parsed globals and statics?
     flagsParsedSupportFiles = (1u << 2), ///< Have we already parsed the support
-                                         ///files for this compile unit?
+                                         /// files for this compile unit?
     flagsParsedLineTable =
         (1u << 3),                   ///< Have we parsed the line table already?
     flagsParsedLanguage = (1u << 4), ///< Have we parsed the language already?
     flagsParsedImportedModules =
         (1u << 5), ///< Have we parsed the imported modules already?
+    flagsParsedAllModules = (1u << 6), ///< Have we parsed all modules already?
     flagsParsedDebugMacros =
-        (1u << 6) ///< Have we parsed the debug macros already?
+        (1u << 7) ///< Have we parsed the debug macros already?
   };
 
   DISALLOW_COPY_AND_ASSIGN(CompileUnit);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_CompUnit_h_

lldb/include/lldb/Symbol/SourceModule.h

 namespace lldb_private {
 
 /// Information needed to import a source-language module.
 struct SourceModule {
   /// Something like "Module.Submodule".
   std::vector<ConstString> path;
   ConstString search_path;
   ConstString sysroot;
+
+  /// Comparison operator for two SourceModules. Only useful for imposing a
+  /// total order on list of SourceModules so that they can be std::sorted.
+  bool operator<(const SourceModule &o) const {
+    return std::tie(path, search_path, sysroot) <
+           std::tie(o.path, o.search_path, o.sysroot);
+  }
+
+  bool operator==(const SourceModule &o) const {
+    return std::tie(path, search_path, sysroot) ==
+           std::tie(o.path, o.search_path, o.sysroot);
+  }
 };
 
 } // namespace lldb_private
 
 #endif

lldb/include/lldb/Symbol/SymbolFile.h

public:
   virtual bool ParseSupportFiles(CompileUnit &comp_unit,
                                  FileSpecList &support_files) = 0;
   virtual size_t ParseTypes(CompileUnit &comp_unit) = 0;
   virtual bool ParseIsOptimized(CompileUnit &comp_unit) { return false; }
 
   virtual bool
   ParseImportedModules(const SymbolContext &sc,
                        std::vector<SourceModule> &imported_modules) = 0;
+  virtual bool ParseAllModules(const SymbolContext &sc,
+                               std::vector<SourceModule> &all_modules) = 0;
+
   virtual size_t ParseBlocksRecursive(Function &func) = 0;
   virtual size_t ParseVariablesForContext(const SymbolContext &sc) = 0;
   virtual Type *ResolveTypeUID(lldb::user_id_t type_uid) = 0;
 
 
   /// The characteristics of an array type.
   struct ArrayInfo {
     int64_t first_index = 0;

lldb/include/lldb/Symbol/SymbolVendor.h

public:
   virtual bool ParseIsOptimized(CompileUnit &comp_unit);
 
   virtual size_t ParseTypes(CompileUnit &comp_unit);
 
   virtual bool
   ParseImportedModules(const SymbolContext &sc,
                        std::vector<SourceModule> &imported_modules);
 
+  virtual bool ParseAllUsedModules(const SymbolContext &sc,
+                                   std::vector<SourceModule> &all_modules);
+
   virtual size_t ParseBlocksRecursive(Function &func);
 
   virtual size_t ParseVariablesForContext(const SymbolContext &sc);
 
   virtual Type *ResolveTypeUID(lldb::user_id_t type_uid);
 
   virtual uint32_t ResolveSymbolContext(const Address &so_addr,
                                         lldb::SymbolContextItem resolve_scope,

lldb/include/lldb/Target/Target.h

public:
   FileSpecList GetDebugFileSearchPaths();
 
   FileSpecList GetClangModuleSearchPaths();
 
   bool GetEnableAutoImportClangModules() const;
 
   bool GetEnableImportStdModule() const;
 
+  bool GetEnableImportCxxModules() const;
+
   bool GetEnableAutoApplyFixIts() const;
 
   bool GetEnableNotifyAboutFixIts() const;
 
   bool GetEnableSaveObjects() const;
 
   bool GetEnableSyntheticValue() const;
 

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/functions/Makefile

+LEVEL = ../../../make
+USE_LIBCPP := 1
+CXXFLAGS += $(MANDATORY_CXXMODULE_BUILD_CFLAGS)
+CXX_SOURCES := main.cpp
+include $(LEVEL)/Makefile.rules

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/functions/TestFunctionImportCxxModules.py

+"""
+Test importing a C++ module and using its functions.
+"""
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class ImportCxxModuleMacros(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @add_test_categories(["gmodules"])
+    def test(self):
+        self.build()
+
+        lldbutil.run_to_source_breakpoint(self,
+            "// Set break point at this line.", lldb.SBFileSpec("main.cpp"))
+
+        # Activate importing of std module.
+        self.runCmd("settings set target.import-c++-modules true")
+        # Call our functions.
+        self.expect("expr add(2, 3)", substrs=['(int)', '= 5'])

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/functions/foo.h

+#ifndef FOO_H
+#define FOO_H
+
+int add(int a, int b) {
+  return a + b;
+}
+
+#endif

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/functions/main.cpp

+#include "foo.h"
+
+int main(int argc, char **argv) {
+  // Set break point at this line.
+  return 0;
+}

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/functions/module.modulemap

+module Foo { header "foo.h" export * }

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/macro/Makefile

+LEVEL = ../../../make
+USE_LIBCPP := 1
+CXXFLAGS += $(MANDATORY_CXXMODULE_BUILD_CFLAGS)
+CXX_SOURCES := main.cpp
+include $(LEVEL)/Makefile.rules

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/macro/TestMacroImportCxxModules.py

+"""
+Test importing a C++ module and using its macros.
+"""
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class ImportCxxModuleMacros(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @add_test_categories(["gmodules"])
+    # As ASTReader's generations are currently out of sync when
+    # multiplexing ExternalASTSources (which is what we do in LLDB),
+    # this test currently fails.
+    @expectedFailureAll(bugnumber="reviews.llvm.org/D39714")
+    def test(self):
+        self.build()
+
+        lldbutil.run_to_source_breakpoint(self,
+            "// Set break point at this line.", lldb.SBFileSpec("main.cpp"))
+
+        # Activate importing of std module.
+        self.runCmd("settings set target.import-c++-modules true")
+        # Call our macro.
+        self.expect("expr my_abs(-42)", substrs=['(int) $0 = 42'])
+        # Call it again. The first macro may be defined from the module built
+        # process, but the second time we are reusing an on-disk module where
+        # we fail due to out of sync ASTReader generation.
+        self.expect("expr my_abs(-42)", substrs=['(int) $0 = 42'])

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/macro/foo.h

+#ifndef FOO_H
+#define FOO_H
+
+#define my_abs(x) (x)<0?-(x):(x)
+
+#endif

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/macro/main.cpp

+#include "foo.h"
+
+int main(int argc, char **argv) {
+  // Set break point at this line.
+  return 0;
+}

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/macro/module.modulemap

+module Foo { header "foo.h" export * }

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/multiple-include-dirs/Makefile

+LEVEL = ../../../make
+USE_LIBCPP := 1
+CXXFLAGS += $(MANDATORY_CXXMODULE_BUILD_CFLAGS) -I $(SRCDIR)/inc1 -I $(SRCDIR)/inc2
+CXX_SOURCES := main.cpp
+include $(LEVEL)/Makefile.rules

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/multiple-include-dirs/TestMultiIncDirImportCxxModules.py

+"""
+Test importing a C++ module with multiple include directories.
+"""
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class ImportCxxModuleMacros(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @add_test_categories(["gmodules"])
+    def test(self):
+        self.build()
+
+        lldbutil.run_to_source_breakpoint(self,
+            "// Set break point at this line.", lldb.SBFileSpec("main.cpp"))
+
+        # Activate importing of std module.
+        self.runCmd("settings set target.import-c++-modules true")
+        self.runCmd("log enable lldb expr")
+        # Call our function in the nested module.
+        self.expect("expr foo()", substrs=['(int)', '= 33'])

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/multiple-include-dirs/foo.h

+#ifndef FOO_H
+#define FOO_H
+#include "a.h"
+#endif

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/multiple-include-dirs/inc1/a.h

+#ifndef A_H
+#define A_H
+#include "b.h"
+#endif

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/multiple-include-dirs/inc1/module.modulemap

+module Inc1 { header "a.h" export * }

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/multiple-include-dirs/inc2/b.h

+#ifndef B_H
+#define B_H
+int foo() { return 33; }
+#endif

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/multiple-include-dirs/inc2/module.modulemap

+module Inc2 { header "b.h" export * }

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/multiple-include-dirs/main.cpp

+#include "foo.h"
+
+int main(int argc, char **argv) {
+  // Set break point at this line.
+  return 0;
+}

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/multiple-include-dirs/module.modulemap

+module Foo { header "foo.h" export * }

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/templates/Makefile

+LEVEL = ../../../make
+USE_LIBCPP := 1
+CXXFLAGS += $(MANDATORY_CXXMODULE_BUILD_CFLAGS)
+CXX_SOURCES := main.cpp
+include $(LEVEL)/Makefile.rules

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/templates/TestTemplateImportCxxModules.py

+"""
+Test importing a C++ module and using its templates.
+"""
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class ImportCxxModuleMacros(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @add_test_categories(["gmodules"])
+    def test(self):
+        self.build()
+
+        lldbutil.run_to_source_breakpoint(self,
+            "// Set break point at this line.", lldb.SBFileSpec("main.cpp"))
+
+        # Activate importing of std module.
+        self.runCmd("settings set target.import-c++-modules true")
+        # Call our template functions.
+        self.expect("expr add(2, 3)", substrs=['(int) $0 = 5'])
+        self.expect("expr Foo<42>::get()", substrs=['(unsigned int)', '= 42'])

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/templates/foo.h

+#ifndef FOO_H
+#define FOO_H
+
+template<typename T>
+int add(T a, T b) {
+  return a + b;
+}
+
+template<unsigned I>
+struct Foo {
+  static unsigned get() { return I; }
+};
+
+#endif

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/templates/main.cpp

+#include "foo.h"
+
+int main(int argc, char **argv) {
+  // Set break point at this line.
+  return 0;
+}

lldb/packages/Python/lldbsuite/test/expression_command/import-c++-modules/templates/module.modulemap

+module Foo { header "foo.h" export * }

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

 static void
 SetupModuleHeaderPaths(CompilerInstance *compiler,
                        std::vector<ConstString> include_directories,
                        lldb::TargetSP target_sp) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   HeaderSearchOptions &search_opts = compiler->getHeaderSearchOpts();
 
+  std::set<ConstString> added_inc_dirs;
   for (ConstString dir : include_directories) {
-    search_opts.AddPath(dir.AsCString(), frontend::System, false, true);
+    search_opts.AddPath(dir.AsCString(), frontend::IncludeDirGroup::Angled,
+                        false, true);
     LLDB_LOG(log, "Added user include dir: {0}", dir);
   }
 
   llvm::SmallString<128> module_cache;
   auto props = ModuleList::GetGlobalModuleListProperties();
   props.GetClangModulesCachePath().GetPath(module_cache);
   search_opts.ModuleCachePath = module_cache.str();
   LLDB_LOG(log, "Using module cache path: {0}", module_cache.c_str());

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

 std::vector<std::string>
 ClangUserExpression::GetModulesToImport(ExecutionContext &exe_ctx) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   if (!SupportsCxxModuleImport(Language()))
     return {};
 
   Target *target = exe_ctx.GetTargetPtr();
-  if (!target || !target->GetEnableImportStdModule())
+  if (!target)
+    return {};
+
+  if (!target->GetEnableImportStdModule() &&
+      !target->GetEnableImportCxxModules())
     return {};
 
   StackFrame *frame = exe_ctx.GetFramePtr();
   if (!frame)
     return {};
 
   Block *block = frame->GetFrameBlock();
   if (!block)
     return {};
 
   SymbolContext sc;
   block->CalculateSymbolContext(&sc);
   if (!sc.comp_unit)
     return {};
 
+  // Get the list of modules we need to to import. For the `std` module it's
+  // enough to search the list of directly imported modules, but for a general
+  // module import we need to get all used modules to reconstruct the relevant
+  // include directories.
+  const std::vector<SourceModule> &module_list =
+      target->GetEnableImportCxxModules() ? sc.comp_unit->GetAllUsedModules()
+                                          : sc.comp_unit->GetImportedModules();
+
   if (log) {
-    for (const SourceModule &m : sc.comp_unit->GetImportedModules()) {
+    for (const SourceModule &m : module_list) {
       LLDB_LOG(log, "Found module in compile unit: {0:$[.]} - include dir: {1}",
                   llvm::make_range(m.path.begin(), m.path.end()), m.search_path);
     }
   }
 
-  for (const SourceModule &m : sc.comp_unit->GetImportedModules())
+  // Build a list of include directories used by these modules.
+  for (const SourceModule &m : module_list) {
+    if (!m.search_path.IsEmpty())
       m_include_directories.push_back(m.search_path);
+  }
 
+  // If we only need the `std` module we can just iterate the list and check
+  // if `std` or any of its submodule was imported.
+  if (target->GetEnableImportStdModule()) {
     // Check if we imported 'std' or any of its submodules.
-  // We currently don't support importing any other modules in the expression
-  // parser.
-  for (const SourceModule &m : sc.comp_unit->GetImportedModules())
+    for (const SourceModule &m : module_list)
       if (!m.path.empty() && m.path.front() == "std")
         return {"std"};
-
     return {};
   }
 
+  // If we want to import all C++ modules we have to
+  assert(target->GetEnableImportCxxModules());
+  std::vector<std::string> result;
+  for (const SourceModule &m : module_list)
+    result.push_back(m.path.front().GetCString());
+
+  // Filter out any duplicates as importing a module once is enough.
+  std::sort(result.begin(), result.end());
+  result.erase(std::unique(result.begin(), result.end()), result.end());
+  return result;
+}
+
 bool ClangUserExpression::PrepareForParsing(
     DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
     bool for_completion) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   InstallContext(exe_ctx);
 
   if (!SetupPersistentState(diagnostic_manager, exe_ctx))

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

public:
   size_t ParseTypes(CompileUnit &cu) override { return 0; }
 
   bool ParseImportedModules(
       const SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override {
     return false;
   }
 
+  bool ParseAllModules(
+      const SymbolContext &sc,
+      std::vector<lldb_private::SourceModule> &imported_modules) override {
+    return false;
+  }
+
   size_t ParseBlocksRecursive(Function &func) override { return 0; }
 
   uint32_t FindGlobalVariables(ConstString name,
                                const CompilerDeclContext *parent_decl_ctx,
                                uint32_t max_matches,
                                VariableList &variables) override {
     return 0;
   }

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

public:
 
   bool ParseIsOptimized(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseImportedModules(
       const lldb_private::SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override;
+  bool ParseAllModules(
+      const lldb_private::SymbolContext &sc,
+      std::vector<lldb_private::SourceModule> &imported_modules) override;
 
   size_t ParseBlocksRecursive(lldb_private::Function &func) override;
 
   size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(

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

 bool SymbolFileDWARF::ParseIsOptimized(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
   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);
-  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();
-
+/// Parses the modules in the given DWARFUnit.
+/// \param dwarf_cu The DWARFUnit that should be searched for modules.
+/// \param only_imported_modules True if only modules that are imported should
+///                              be parsed. False if all modules should be
+///                              parsed.
+/// \param modules A list of SourceModules found in the DWARFUnit.
+/// \return True iff no error occurred while parsing the modules.
+static bool ParseModules(DWARFUnit *dwarf_cu, bool only_imported_modules,
+                         std::vector<SourceModule> &modules) {
   const DWARFDIE die = dwarf_cu->DIE();
   if (!die)
     return false;
 
   for (DWARFDIE child_die = die.GetFirstChild(); child_die;
        child_die = child_die.GetSibling()) {
+    DWARFDIE module_die;
+
+    if (only_imported_modules) {
       if (child_die.Tag() != DW_TAG_imported_declaration)
         continue;
 
-    DWARFDIE module_die = child_die.GetReferencedDIE(DW_AT_import);
+      module_die = child_die.GetReferencedDIE(DW_AT_import);
+    } else
+      module_die = child_die;
+
     if (module_die.Tag() != DW_TAG_module)
       continue;
 
-    if (const char *name =
+    if (const char *name_str =
             module_die.GetAttributeValueAsString(DW_AT_name, nullptr)) {
+
+      ConstString name(name_str);
+
+      // Clang emits some modulemap files as module tags, so we have to
+      // filter them out here as they are not actual SourceModules.
+      if (name == "module.modulemap")
+        continue;
+
       SourceModule module;
-      module.path.push_back(ConstString(name));
+      module.path.push_back(name);
 
       DWARFDIE parent_die = module_die;
       while ((parent_die = parent_die.GetParent())) {
         if (parent_die.Tag() != DW_TAG_module)
           break;
         if (const char *name =
                 parent_die.GetAttributeValueAsString(DW_AT_name, nullptr))
           module.path.push_back(ConstString(name));
       }
       std::reverse(module.path.begin(), module.path.end());
       if (const char *include_path = module_die.GetAttributeValueAsString(
               DW_AT_LLVM_include_path, nullptr))
         module.search_path = ConstString(include_path);
       if (const char *sysroot = module_die.GetAttributeValueAsString(
               DW_AT_LLVM_isysroot, nullptr))
         module.sysroot = ConstString(sysroot);
-      imported_modules.push_back(module);
+      modules.push_back(module);
     }
   }
   return true;
 }
 
+bool SymbolFileDWARF::ParseImportedModules(
+    const lldb_private::SymbolContext &sc,
+    std::vector<SourceModule> &imported_modules) {
+  ASSERT_MODULE_LOCK(this);
+  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();
+
+  return ParseModules(dwarf_cu, /*only_imported*/ true, imported_modules);
+}
+
+bool SymbolFileDWARF::ParseAllModules(const lldb_private::SymbolContext &sc,
+                                      std::vector<SourceModule> &all_modules) {
+  ASSERT_MODULE_LOCK(this);
+  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();
+
+  // Recursively descend into the referenced modules and add their used
+  // modules to our list.
+  for (auto &n : m_external_type_modules) {
+    ModuleSP module = n.second;
+
+    // The first compile unit should contain all used modules.
+    if (module->GetNumCompileUnits() == 0)
+      continue;
+    CompUnitSP comp_unit = module->GetCompileUnitAtIndex(0);
+
+    const std::vector<SourceModule> &m = comp_unit->GetAllUsedModules();
+    all_modules.insert(all_modules.end(), m.begin(), m.end());
+  }
+
+  // Parse all used modules in the current compile unit.
+  return ParseModules(dwarf_cu, /*only_imported*/ false, all_modules);
+}
+
 struct ParseDWARFLineTableCallbackInfo {
   LineTable *line_table;
   std::unique_ptr<LineSequence> sequence_up;
   lldb::addr_t addr_mask;
 };
 
 // ParseStatementTableCallback
 static void ParseDWARFLineTableCallback(dw_offset_t offset,

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

public:
 
   bool ParseIsOptimized(lldb_private::CompileUnit &comp_unit) override;
 
   size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseImportedModules(
       const lldb_private::SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override;
+  bool ParseAllModules(
+      const lldb_private::SymbolContext &sc,
+      std::vector<lldb_private::SourceModule> &imported_modules) override;
   size_t ParseBlocksRecursive(lldb_private::Function &func) override;
   size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
       lldb::user_id_t type_uid,
       const lldb_private::ExecutionContext *exe_ctx) override;

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

 bool SymbolFileDWARFDebugMap::ParseImportedModules(
     const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
   if (oso_dwarf)
     return oso_dwarf->ParseImportedModules(sc, imported_modules);
   return false;
 }
 
+bool SymbolFileDWARFDebugMap::ParseAllModules(
+    const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
+  SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
+  if (oso_dwarf)
+    return oso_dwarf->ParseAllModules(sc, imported_modules);
+  return false;
+}
+
 size_t SymbolFileDWARFDebugMap::ParseBlocksRecursive(Function &func) {
   CompileUnit *comp_unit = func.GetCompileUnit();
   if (!comp_unit)
     return 0;
 
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(*comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseBlocksRecursive(func);

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

public:
   bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
                          FileSpecList &support_files) override;
   size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseImportedModules(
       const SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override;
 
+  bool ParseAllModules(
+      const SymbolContext &sc,
+      std::vector<lldb_private::SourceModule> &imported_modules) override {
+    return false;
+  }
+
   size_t ParseBlocksRecursive(Function &func) override;
 
   uint32_t FindGlobalVariables(ConstString name,
                                const CompilerDeclContext *parent_decl_ctx,
                                uint32_t max_matches,
                                VariableList &variables) override;
 
   size_t ParseVariablesForContext(const SymbolContext &sc) override;

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
                          lldb_private::FileSpecList &support_files) override;
 
   size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseImportedModules(
       const lldb_private::SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override;
 
+  bool ParseAllModules(
+      const lldb_private::SymbolContext &sc,
+      std::vector<lldb_private::SourceModule> &imported_modules) override {
+    return false;
+  }
+
   size_t ParseBlocksRecursive(lldb_private::Function &func) override;
 
   size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
       lldb::user_id_t type_uid,

lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
                          lldb_private::FileSpecList &support_files) override;
 
   size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseImportedModules(
       const lldb_private::SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override;
 
+  bool ParseAllModules(
+      const lldb_private::SymbolContext &sc,
+      std::vector<lldb_private::SourceModule> &imported_modules) override {
+    return false;
+  }
+
   size_t ParseBlocksRecursive(lldb_private::Function &func) override;
 
   size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
       lldb::user_id_t type_uid,

lldb/source/Symbol/CompileUnit.cpp

if (SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor()) {
       SymbolContext sc;
       CalculateSymbolContext(&sc);
       symbol_vendor->ParseImportedModules(sc, m_imported_modules);
     }
   }
   return m_imported_modules;
 }
 
+const std::vector<SourceModule> &CompileUnit::GetAllUsedModules() {
+  if (m_all_used_modules.empty() && m_flags.IsClear(flagsParsedAllModules)) {
+    m_flags.Set(flagsParsedAllModules);
+    if (SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor()) {
+      SymbolContext sc;
+      CalculateSymbolContext(&sc);
+
+      symbol_vendor->ParseAllUsedModules(sc, m_all_used_modules);
+    }
+  }
+  return m_all_used_modules;
+}
+
 FileSpecList &CompileUnit::GetSupportFiles() {
   if (m_support_files.GetSize() == 0) {
     if (m_flags.IsClear(flagsParsedSupportFiles)) {
       m_flags.Set(flagsParsedSupportFiles);
       SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor();
       if (symbol_vendor) {
         symbol_vendor->ParseSupportFiles(*this, m_support_files);
       }
     }
   }
   return m_support_files;
 }
 
 void *CompileUnit::GetUserData() const { return m_user_data; }

lldb/source/Symbol/SymbolVendor.cpp

bool SymbolVendor::ParseImportedModules(
   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;
 }
 
+bool SymbolVendor::ParseAllUsedModules(const SymbolContext &sc,
+                                       std::vector<SourceModule> &all_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->ParseAllModules(sc, all_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;

lldb/source/Target/Target.cpp

static constexpr PropertyDefinition g_properties[] = {
      nullptr, {},
      "List of directories to be searched when locating modules for Clang."},
     {"auto-import-clang-modules", OptionValue::eTypeBoolean, false, true,
      nullptr, {},
      "Automatically load Clang modules referred to by the program."},
     {"import-std-module", OptionValue::eTypeBoolean, false, false,
      nullptr, {},
      "Import the C++ std module to improve debugging STL containers."},
+    {"import-c++-modules", OptionValue::eTypeBoolean, false, false,
+     nullptr, {},
+     "Import the executable's C++ modules to improve debugging."},
     {"auto-apply-fixits", OptionValue::eTypeBoolean, false, true, nullptr,
      {}, "Automatically apply fix-it hints to expressions."},
     {"notify-about-fixits", OptionValue::eTypeBoolean, false, true, nullptr,
      {}, "Print the fixed expression text."},
     {"save-jit-objects", OptionValue::eTypeBoolean, false, false, nullptr,
      {}, "Save intermediate object files generated by the LLVM JIT"},
     {"max-children-count", OptionValue::eTypeSInt64, false, 256, nullptr,
      {}, "Maximum number of children to expand in any level of depth."},
enum {
   ePropertyEnableSynthetic,
   ePropertySkipPrologue,
   ePropertySourceMap,
   ePropertyExecutableSearchPaths,
   ePropertyDebugFileSearchPaths,
   ePropertyClangModuleSearchPaths,
   ePropertyAutoImportClangModules,
   ePropertyImportStdModule,
+  ePropertyImportCxxModules,
   ePropertyAutoApplyFixIts,
   ePropertyNotifyAboutFixIts,
   ePropertySaveObjects,
   ePropertyMaxChildrenCount,
   ePropertyMaxSummaryLength,
   ePropertyMaxMemReadSize,
   ePropertyBreakpointUseAvoidList,
   ePropertyArg0,

 }
 
 bool TargetProperties::GetEnableImportStdModule() const {
   const uint32_t idx = ePropertyImportStdModule;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
+bool TargetProperties::GetEnableImportCxxModules() const {
+  const uint32_t idx = ePropertyImportCxxModules;
+  return m_collection_sp->GetPropertyAtIndexAsBoolean(
+      nullptr, idx, g_properties[idx].default_uint_value != 0);
+}
+
 bool TargetProperties::GetEnableAutoApplyFixIts() const {
   const uint32_t idx = ePropertyAutoApplyFixIts;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
 bool TargetProperties::GetEnableNotifyAboutFixIts() const {
   const uint32_t idx = ePropertyNotifyAboutFixIts;