Deserialize Clang module search path from DWARF

[aprantl]

Summary

This is an unfinished patch I'm working on that Raphael may find interesting. Posting to get early feedback and to avoid stepping on each others' toes.

rdar://problem/47970144

[teemperor]

+1. That's a cleaner version of what I had to do in D58125, so feel free to commit when done. The code is similar enough that rebasing my patch on top shouldn't take too much time.

include/lldb/Symbol/SourceModule.h

14

Should also include lldb/Utility/ConstString.h otherwise this breaks the module build.

source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

332–333

path is unused.

[JDevlieghere]

The change itself looks fine, just a few nits inline.

include/lldb/Symbol/SourceModule.h

25

Can you run clang-format on this? (It will add // namespace lldb_private here.)

source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

282–283

Can we make this i?

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

941

Can we use a StringRef here?

[shafik]

source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

282–283

Or perhaps path_index

[aprantl]

Almost final version. There's a silly bug that prevents the C Darwin module to be loaded now that I haven't been able to track down yet.

[aprantl]

I think the problem was that I had an incompletely built libcxx in my build directory.

[stella.stamenova]

This looks to have broken the windows build:

http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/1665

[aprantl]

I attempted to fix it in r353971, but I'm not sure.

include/lldb/Symbol/CompileUnit.h

public:
   /// Get the compile unit's imported module list.
   ///
   /// This reports all the imports that the compile unit made, including the
   /// current module.
   ///
   /// @return
   ///     A list of imported module names.
   //------------------------------------------------------------------
-  const std::vector<ConstString> &GetImportedModules();
+  const std::vector<SourceModule> &GetImportedModules();
 
   //------------------------------------------------------------------
   /// 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
public:
   bool GetIsOptimized();
 
   //------------------------------------------------------------------
   /// Returns the number of functions in this compile unit
   //------------------------------------------------------------------
   size_t GetNumFunctions() const { return m_functions_by_uid.size(); }
 
 protected:
-  void *m_user_data; ///< User data for the SymbolFile parser to store
-                     ///information into.
-  lldb::LanguageType
-      m_language; ///< The programming language enumeration value.
-  Flags m_flags;  ///< Compile unit flags that help with partial parsing.
-
+  /// User data for the SymbolFile parser to store information into.
+  void *m_user_data;
+  /// The programming language enumeration value.
+  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;
-  std::vector<ConstString> m_imported_modules; ///< All modules, including the
-                                               ///current module, imported by
-                                               ///this
-                                               ///< compile unit.
-  FileSpecList m_support_files; ///< Files associated with this compile unit's
-                                ///line table and declarations.
-  std::unique_ptr<LineTable>
-      m_line_table_up; ///< Line table that will get parsed on demand.
-  DebugMacrosSP
-      m_debug_macros_sp; ///< Debug macros that will get parsed on demand.
-  lldb::VariableListSP m_variables; ///< Global and static variable list that
-                                    ///will get parsed on demand.
-  lldb_private::LazyBool m_is_optimized; /// eLazyBoolYes if this compile unit
-                                         /// was compiled with optimization.
+  /// All modules, including the current module, imported by this
+  /// compile unit.
+  std::vector<SourceModule> m_imported_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

include/lldb/Symbol/SourceModule.h

+//===-- SourceModule.h ------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_SourceModule_h_
+#define liblldb_SourceModule_h_
+
+#include "lldb/Utility/ConstString.h"
+#include <vector>
+
+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;
+};
+
+}; // namespace lldb_private
+
+#endif

include/lldb/Symbol/SymbolFile.h

 //===-- SymbolFile.h --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_SymbolFile_h_
 #define liblldb_SymbolFile_h_
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Function.h"
+#include "lldb/Symbol/SourceModule.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/DenseSet.h"
 
 #include <mutex>
 
 #if defined(LLDB_CONFIGURATION_DEBUG)
public:
   virtual bool ParseDebugMacros(CompileUnit &comp_unit) = 0;
   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<ConstString> &imported_modules) = 0;
+                       std::vector<SourceModule> &imported_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;

include/lldb/Symbol/SymbolVendor.h

 //===-- SymbolVendor.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_SymbolVendor_h_
 #define liblldb_SymbolVendor_h_
 
 #include <vector>
 
 #include "lldb/Core/ModuleChild.h"
 #include "lldb/Core/PluginInterface.h"
+#include "lldb/Symbol/SourceModule.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/lldb-private.h"
 #include "llvm/ADT/DenseSet.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
public:
 
   virtual bool ParseSupportFiles(CompileUnit &comp_unit,
                                  FileSpecList &support_files);
 
   virtual bool ParseIsOptimized(CompileUnit &comp_unit);
 
   virtual size_t ParseTypes(CompileUnit &comp_unit);
 
-  virtual bool ParseImportedModules(const SymbolContext &sc,
-                                    std::vector<ConstString> &imported_modules);
+  virtual bool
+  ParseImportedModules(const SymbolContext &sc,
+                       std::vector<SourceModule> &imported_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,

packages/Python/lldbsuite/test/lang/cpp/modules-import/Bar.h

+struct Bar { int success; };

packages/Python/lldbsuite/test/lang/cpp/modules-import/Foo.h

+struct Foo {};

packages/Python/lldbsuite/test/lang/cpp/modules-import/Makefile

+LEVEL = ../../../make
+CXX_SOURCES := main.cpp
+
+CFLAGS += $(MANDATORY_MODULE_BUILD_CFLAGS)
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/lang/cpp/modules-import/TestCXXModulesImport.py

+"""Test that importing modules in C++ works as expected."""
+
+from __future__ import print_function
+
+
+from distutils.version import StrictVersion
+import unittest2
+import os
+import time
+import lldb
+import platform
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class CXXModulesImportTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipUnlessDarwin
+    @skipIf(macos_version=["<", "10.12"])
+    def test_expr(self):
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
+            self, 'break here', lldb.SBFileSpec('main.cpp'))
+
+        self.expect("expr -- @import Bar")
+        self.expect("expr -- Bar()", substrs = ["success"])

packages/Python/lldbsuite/test/lang/cpp/modules-import/main.cpp

+#include "Foo.h"
+
+int main(int argc, char **argv) {
+  Foo foo;
+  // break here.
+  return 0;
+}

packages/Python/lldbsuite/test/lang/cpp/modules-import/module.modulemap

+module Foo {
+  header "Foo.h"
+}
+
+module Bar {
+  header "Bar.h"
+}

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

 
 public:
   LLDBPreprocessorCallbacks(ClangModulesDeclVendor &decl_vendor,
                             ClangPersistentVariables &persistent_vars)
       : m_decl_vendor(decl_vendor), m_persistent_vars(persistent_vars) {}
 
   void moduleImport(SourceLocation import_location, clang::ModuleIdPath path,
                     const clang::Module * /*null*/) override {
-    std::vector<ConstString> string_path;
+    SourceModule module;
 
-    for (const std::pair<IdentifierInfo *, SourceLocation> &component : path) {
-      string_path.push_back(ConstString(component.first->getName()));
-    }
+    for (const std::pair<IdentifierInfo *, SourceLocation> &component : path)
+      module.path.push_back(ConstString(component.first->getName()));
 
     StreamString error_stream;
 
     ClangModulesDeclVendor::ModuleVector exported_modules;
-
-    if (!m_decl_vendor.AddModule(string_path, &exported_modules,
-                                 m_error_stream)) {
+    if (!m_decl_vendor.AddModule(module, &exported_modules, m_error_stream))
       m_has_errors = true;
-    }
 
-    for (ClangModulesDeclVendor::ModuleID module : exported_modules) {
+    for (ClangModulesDeclVendor::ModuleID module : exported_modules)
       m_persistent_vars.AddHandLoadedClangModule(module);
-    }
-  }
 
   bool hasErrors() { return m_has_errors; }
 
   llvm::StringRef getErrorString() { return m_error_stream.GetString(); }
 };
 
 class ClangDiagnosticManagerAdapter : public clang::DiagnosticConsumer {
 public:

source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h

public:
 
   typedef std::vector<ConstString> ModulePath;
   typedef uintptr_t ModuleID;
   typedef std::vector<ModuleID> ModuleVector;
 
   //------------------------------------------------------------------
   /// Add a module to the list of modules to search.
   ///
-  /// @param[in] path
+  /// @param[in] module
   ///     The path to the exact module to be loaded.  E.g., if the desired
   ///     module is std.io, then this should be { "std", "io" }.
   ///
   /// @param[in] exported_modules
   ///     If non-NULL, a pointer to a vector to populate with the ID of every
   ///     module that is re-exported by the specified module.
   ///
   /// @param[in] error_stream
   ///     A stream to populate with the output of the Clang parser when
   ///     it tries to load the module.
   ///
   /// @return
   ///     True if the module could be loaded; false if not.  If the
   ///     compiler encountered a fatal error during a previous module
   ///     load, then this will always return false for this ModuleImporter.
   //------------------------------------------------------------------
-  virtual bool AddModule(ModulePath &path, ModuleVector *exported_modules,
+  virtual bool AddModule(const SourceModule &module,
+                         ModuleVector *exported_modules,
                          Stream &error_stream) = 0;
 
   //------------------------------------------------------------------
   /// Add all modules referred to in a given compilation unit to the list
   /// of modules to search.
   ///
   /// @param[in] cu
   ///     The compilation unit to scan for imported modules.

source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

 #include "ClangHost.h"
 #include "ClangModulesDeclVendor.h"
 #include "ModuleDependencyCollector.h"
 
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/CompileUnit.h"
+#include "lldb/Symbol/SourceModule.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb_private;
public:
   ClangModulesDeclVendorImpl(
       llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine,
       std::shared_ptr<clang::CompilerInvocation> compiler_invocation,
       std::unique_ptr<clang::CompilerInstance> compiler_instance,
       std::unique_ptr<clang::Parser> parser);
 
   ~ClangModulesDeclVendorImpl() override = default;
 
-  bool AddModule(ModulePath &path, ModuleVector *exported_modules,
+  bool AddModule(const SourceModule &module, ModuleVector *exported_modules,
                  Stream &error_stream) override;
 
   bool AddModulesForCompileUnit(CompileUnit &cu, ModuleVector &exported_modules,
                                 Stream &error_stream) override;
 
   uint32_t FindDecls(const ConstString &name, bool append, uint32_t max_matches,
                      std::vector<clang::NamedDecl *> &decls) override;
 
void ClangModulesDeclVendorImpl::ReportModuleExports(
 
   ReportModuleExportsHelper(exports_set, module);
 
   for (ModuleID module : exports_set) {
     exports.push_back(module);
   }
 }
 
-bool ClangModulesDeclVendorImpl::AddModule(ModulePath &path,
+bool ClangModulesDeclVendorImpl::AddModule(const SourceModule &module,
                                            ModuleVector *exported_modules,
                                            Stream &error_stream) {
   // Fail early.
 
   if (m_compiler_instance->hadModuleLoaderFatalFailure()) {
     error_stream.PutCString("error: Couldn't load a module because the module "
                             "loader is in a fatal state.\n");
     return false;
   }
 
   // Check if we've already imported this module.
 
   std::vector<ConstString> imported_module;
 
-  for (ConstString path_component : path) {
+  for (ConstString path_component : module.path) {
     imported_module.push_back(path_component);
   }
 
   {
     ImportedModuleMap::iterator mi = m_imported_modules.find(imported_module);
 
     if (mi != m_imported_modules.end()) {
       if (exported_modules) {
         ReportModuleExports(*exported_modules, mi->second);
       }
       return true;
     }
   }
 
-  if (!m_compiler_instance->getPreprocessor()
-           .getHeaderSearchInfo()
-           .lookupModule(path[0].GetStringRef())) {
+  clang::HeaderSearch &HS =
+    m_compiler_instance->getPreprocessor().getHeaderSearchInfo();
+
+  if (module.search_path) {
+    auto path_begin = llvm::sys::path::begin(module.search_path.GetStringRef());
+    auto path_end = llvm::sys::path::end(module.search_path.GetStringRef());
+    auto sysroot_begin = llvm::sys::path::begin(module.sysroot.GetStringRef());
+    auto sysroot_end = llvm::sys::path::end(module.sysroot.GetStringRef());
+    // FIXME: Use C++14 std::equal(it, it, it, it) variant once it's available.
+    bool is_system_module = (std::distance(path_begin, path_end) >=
+                             std::distance(sysroot_begin, sysroot_end)) &&
+                            std::equal(sysroot_begin, sysroot_end, path_begin);
+    // No need to inject search paths to modules in the sysroot.
+    if (!is_system_module) {
+      bool is_system = true;
+      bool is_framework = false;
+      auto *dir =
+          HS.getFileMgr().getDirectory(module.search_path.GetStringRef());
+      auto *file = HS.lookupModuleMapFile(dir, is_framework);
+      if (!HS.loadModuleMapFile(file, is_system))
+        error_stream.Printf("error: No module map file in %s\n",
+                            module.search_path.AsCString());
+      return false;
+    }
+  }
+  if (!HS.lookupModule(module.path.front().GetStringRef())) {
     error_stream.Printf("error: Header search couldn't locate module %s\n",
-                        path[0].AsCString());
+                        module.path.front().AsCString());
     return false;
   }
 
   llvm::SmallVector<std::pair<clang::IdentifierInfo *, clang::SourceLocation>,
                     4>
       clang_path;
 
   {
     clang::SourceManager &source_manager =
         m_compiler_instance->getASTContext().getSourceManager();
 
-    for (ConstString path_component : path) {
+    for (ConstString path_component : module.path) {
       clang_path.push_back(std::make_pair(
           &m_compiler_instance->getASTContext().Idents.get(
               path_component.GetStringRef()),
           source_manager.getLocForStartOfFile(source_manager.getMainFileID())
               .getLocWithOffset(m_source_location_index++)));
     }
   }
 
   StoringDiagnosticConsumer *diagnostic_consumer =
       static_cast<StoringDiagnosticConsumer *>(
           m_compiler_instance->getDiagnostics().getClient());
 
   diagnostic_consumer->ClearDiagnostics();
 
   clang::Module *top_level_module = DoGetModule(clang_path.front(), false);
 
   if (!top_level_module) {
     diagnostic_consumer->DumpDiagnostics(error_stream);
     error_stream.Printf("error: Couldn't load top-level module %s\n",
-                        path[0].AsCString());
+                        module.path.front().AsCString());
     return false;
   }
 
   clang::Module *submodule = top_level_module;
 
-  for (size_t ci = 1; ci < path.size(); ++ci) {
-    llvm::StringRef component = path[ci].GetStringRef();
-    submodule = submodule->findSubmodule(component.str());
+  for (auto &component : llvm::ArrayRef<ConstString>(module.path).drop_front()) {
+    submodule = submodule->findSubmodule(component.GetStringRef());
     if (!submodule) {
       diagnostic_consumer->DumpDiagnostics(error_stream);
       error_stream.Printf("error: Couldn't load submodule %s\n",
-                          component.str().c_str());
+                          component.GetCString());
       return false;
     }
   }
 
   clang::Module *requested_module = DoGetModule(clang_path, true);
 
   if (requested_module != nullptr) {
     if (exported_modules) {
bool ClangModulesDeclVendorImpl::AddModule(const SourceModule &module,
   return false;
 }
 
 bool ClangModulesDeclVendor::LanguageSupportsClangModules(
     lldb::LanguageType language) {
   switch (language) {
   default:
     return false;
-  // C++ and friends to be added
   case lldb::LanguageType::eLanguageTypeC:
   case lldb::LanguageType::eLanguageTypeC11:
   case lldb::LanguageType::eLanguageTypeC89:
   case lldb::LanguageType::eLanguageTypeC99:
+  case lldb::LanguageType::eLanguageTypeC_plus_plus:
+  case lldb::LanguageType::eLanguageTypeC_plus_plus_03:
+  case lldb::LanguageType::eLanguageTypeC_plus_plus_11:
+  case lldb::LanguageType::eLanguageTypeC_plus_plus_14:
   case lldb::LanguageType::eLanguageTypeObjC:
+  case lldb::LanguageType::eLanguageTypeObjC_plus_plus:
     return true;
   }
 }
 
 bool ClangModulesDeclVendorImpl::AddModulesForCompileUnit(
     CompileUnit &cu, ClangModulesDeclVendor::ModuleVector &exported_modules,
     Stream &error_stream) {
   if (LanguageSupportsClangModules(cu.GetLanguage())) {
-    std::vector<ConstString> imported_modules = cu.GetImportedModules();
-
-    for (ConstString imported_module : imported_modules) {
-      std::vector<ConstString> path;
-
-      path.push_back(imported_module);
-
-      if (!AddModule(path, &exported_modules, error_stream)) {
+    for (auto &imported_module : cu.GetImportedModules())
+      if (!AddModule(imported_module, &exported_modules, error_stream))
         return false;
-      }
-    }
-
-    return true;
-  }
-
   return true;
 }
 
 // ClangImporter::lookupValue
 
 uint32_t
 ClangModulesDeclVendorImpl::FindDecls(const ConstString &name, bool append,
                                       uint32_t max_matches,

source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

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

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
                          lldb_private::FileSpecList &support_files) override;
 
   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::ConstString> &imported_modules) override;
+      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(

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 #include "LogChannelDWARF.h"
 #include "ManualDWARFIndex.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDwp.h"
 
 #include "llvm/Support/FileSystem.h"
 
+#include <algorithm>
 #include <map>
 #include <memory>
 
 #include <ctype.h>
 #include <string.h>
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
 
bool SymbolFileDWARF::ParseIsOptimized(CompileUnit &comp_unit) {
   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<lldb_private::ConstString> &imported_modules) {
+    std::vector<SourceModule> &imported_modules) {
   ASSERT_MODULE_LOCK(this);
   assert(sc.comp_unit);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
-  if (dwarf_cu) {
-    if (ClangModulesDeclVendor::LanguageSupportsClangModules(
-            sc.comp_unit->GetLanguage())) {
-      UpdateExternalModuleListIfNeeded();
+  if (!dwarf_cu)
+    return false;
+  if (!ClangModulesDeclVendor::LanguageSupportsClangModules(
+          sc.comp_unit->GetLanguage()))
+    return false;
 
-      if (sc.comp_unit) {
-        const DWARFDIE die = dwarf_cu->DIE();
+  if (!sc.comp_unit)
+    return false;
+
+  if (!die)
+    return false;
 
-        if (die) {
-          for (DWARFDIE child_die = die.GetFirstChild(); child_die;
-               child_die = child_die.GetSibling()) {
-            if (child_die.Tag() == DW_TAG_imported_declaration) {
-              if (DWARFDIE module_die =
-                      child_die.GetReferencedDIE(DW_AT_import)) {
-                if (module_die.Tag() == DW_TAG_module) {
-                  if (const char *name = module_die.GetAttributeValueAsString(
-                          DW_AT_name, nullptr)) {
-                    ConstString const_name(name);
-                    imported_modules.push_back(const_name);
-                  }
-                }
-              }
-            }
-          }
-        }
-      } else {
-        for (const auto &pair : m_external_type_modules) {
-          imported_modules.push_back(pair.first);
-        }
-      }
+    if (child_die.Tag() != DW_TAG_imported_declaration)
+      continue;
+
+    DWARFDIE module_die = child_die.GetReferencedDIE(DW_AT_import);
+    if (module_die.Tag() != DW_TAG_module)
+      continue;
+
+    if (const char *name =
+            module_die.GetAttributeValueAsString(DW_AT_name, nullptr)) {
+      SourceModule module;
+      module.path.push_back(ConstString(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);
     }
   }
-  return false;
+  return true;
 }
 
 struct ParseDWARFLineTableCallbackInfo {
   LineTable *line_table;
   std::unique_ptr<LineSequence> sequence_up;
   lldb::addr_t addr_mask;
 };
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
                          lldb_private::FileSpecList &support_files) override;
 
   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::ConstString> &imported_modules) override;
+      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;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

 bool SymbolFileDWARFDebugMap::ParseIsOptimized(CompileUnit &comp_unit) {
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseIsOptimized(comp_unit);
   return false;
 }
 
 bool SymbolFileDWARFDebugMap::ParseImportedModules(
-    const SymbolContext &sc, std::vector<ConstString> &imported_modules) {
+    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;
 }
 
 size_t SymbolFileDWARFDebugMap::ParseBlocksRecursive(Function &func) {
   CompileUnit *comp_unit = func.GetCompileUnit();

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

public:
   bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;
 
   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<ConstString> &imported_modules) override;
+  bool ParseImportedModules(
+      const SymbolContext &sc,
+      std::vector<lldb_private::SourceModule> &imported_modules) override;
 
   size_t ParseBlocksRecursive(Function &func) override;
 
   uint32_t FindGlobalVariables(const ConstString &name,
                                const CompilerDeclContext *parent_decl_ctx,
                                uint32_t max_matches,
                                VariableList &variables) override;
 

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

FileSpec::Style style = main_source_file.startswith("/")
                               ? FileSpec::Style::posix
                               : FileSpec::Style::windows;
   FileSpec spec(main_source_file, style);
   support_files.Insert(0, spec);
   return true;
 }
 
 bool SymbolFileNativePDB::ParseImportedModules(
-    const SymbolContext &sc, std::vector<ConstString> &imported_modules) {
+    const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
   // PDB does not yet support module debug info
   return false;
 }
 
 size_t SymbolFileNativePDB::ParseBlocksRecursive(Function &func) {
   GetOrCreateBlock(PdbSymUid(func.GetID()).asCompilandSym());
   // FIXME: Parse child blocks
   return 1;

source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

public:
 
   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::ConstString> &imported_modules) override;
+      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(

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

bool SymbolFilePDB::ParseSupportFiles(
   // the zeroth file is the compile unit itself
   support_files.Insert(0, comp_unit);
 
   return true;
 }
 
 bool SymbolFilePDB::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
-    std::vector<lldb_private::ConstString> &imported_modules) {
+    std::vector<SourceModule> &imported_modules) {
   // PDB does not yet support module debug info
   return false;
 }
 
 static size_t ParseFunctionBlocksForPDBSymbol(
     uint64_t func_file_vm_addr, const llvm::pdb::PDBSymbol *pdb_symbol,
     lldb_private::Block *parent_block, bool is_top_parent) {
   assert(pdb_symbol && parent_block);

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

public:
 
   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::ConstString> &imported_modules) override;
+      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(

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

 }
 
 bool SymbolFileSymtab::ParseSupportFiles(CompileUnit &comp_unit,
                                          FileSpecList &support_files) {
   return false;
 }
 
 bool SymbolFileSymtab::ParseImportedModules(
-    const SymbolContext &sc, std::vector<ConstString> &imported_modules) {
+    const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
   return false;
 }
 
 size_t SymbolFileSymtab::ParseBlocksRecursive(Function &func) { return 0; }
 
 size_t SymbolFileSymtab::ParseVariablesForContext(const SymbolContext &sc) {
   return 0;
 }

source/Symbol/CompileUnit.cpp

bool CompileUnit::GetIsOptimized() {
   }
   return m_is_optimized;
 }
 
 void CompileUnit::SetVariableList(VariableListSP &variables) {
   m_variables = variables;
 }
 
-const std::vector<ConstString> &CompileUnit::GetImportedModules() {
+const std::vector<SourceModule> &CompileUnit::GetImportedModules() {
   if (m_imported_modules.empty() &&
       m_flags.IsClear(flagsParsedImportedModules)) {
     m_flags.Set(flagsParsedImportedModules);
     if (SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor()) {
       SymbolContext sc;
       CalculateSymbolContext(&sc);
       symbol_vendor->ParseImportedModules(sc, m_imported_modules);
     }

source/Symbol/SymbolVendor.cpp

if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_up)
       return m_sym_file_up->ParseIsOptimized(comp_unit);
   }
   return false;
 }
 
 bool SymbolVendor::ParseImportedModules(
-    const SymbolContext &sc, std::vector<ConstString> &imported_modules) {
+    const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_sym_file_up)
       return m_sym_file_up->ParseImportedModules(sc, imported_modules);
   }
   return false;
 }