Explicitly pass a module to register Xcode SDKs with to ParseXcodeSDK. Was: Add an API that allows iterating over a debug map's OSO's Modules

[aprantl]

Summary

Based on Pavel's feedback, here is a different approach, where the "master" debug map module is passed in explicitly to ParseXcodeSDK(). This allows updating both the source remapping dictionary of the OSO (needed for source listings) and the debug map (needed to remap Clang compiler options in swift-lldb).

For Swift LLDB (but potentially also for module support in Clang-land) I need a way to accumulate the path remappings produced by Module::RegisterXcodeSDK(). Unfortunately there is no way to go from an executable's Module to the auxiliary modules that represent the individual OSO object files of a SymbolFileDWARFDebugMap.

Here is a proposed API that would allow me to do this. Does this look reasonable?

[labath]

My understanding is that these OSO modules are supposed to be a hidden implementation detail of SymbolFileDWARF(DebugMap) and that they should not leak out the main module. For example, we make sure to always rewrite any addresses that come out of the oso modules to be in terms of the main module, and ensure that parsed dwarf compile units are assigned to the CompileUnits belonging to the main module, etc.

In that world, the right thing to do would be to ensure that SymbolFileDWARF(DebugMap) accumulates the appropriate sdk information in the main module.

[aprantl]

Completely different implementation :-)

[labath]

Well... this is closer, but we should get rid of the Module argument. It's not consistent with the other SymbolFile functions, and also not necessary...

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

784–793 ↗

(On Diff #262208)

I don't think you need to pass thread the Module argument everywhere. The module you want should be available as comp_unit.GetModule(). SymbolFileDWARFDebugMap::ParseCompileUnitAtIndex ensures that the CUs are created pointing to the "main" module.

[aprantl]

Thanks, Pavel that was really helpful! Using cu->GetModule() indeed works, and is of course much cleaner.

lldb/include/lldb/Symbol/SymbolFile.h

public:
   ///     If the lambda early-exited, this function returns true to
   ///     propagate the early exit.
   virtual bool ForEachExternalModule(
       lldb_private::CompileUnit &comp_unit,
       llvm::DenseSet<lldb_private::SymbolFile *> &visited_symbol_files,
       llvm::function_ref<bool(Module &)> lambda) {
     return false;
   }
+
+  /// Apply a lambda to each auxiliary lldb::Module referenced by this
+  /// \p comp_unit.
+  ///
+  /// This function can be used to traverse all OSO modules in a
+  /// SymbolFileDWARFDebugMap.
+  ///
+  /// \param[in] lambda
+  ///     The lambda that should be applied to every function. The lambda can
+  ///     return true if the iteration should be aborted earlier.
+  ///
+  /// \return
+  ///     If the lambda early-exited, this function returns true to
+  ///     propagate the early exit.
+  virtual bool
+  ForEachAuxiliaryModule(llvm::function_ref<bool(Module &)> lambda) {
+    return false;
+  }
+
   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;

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

public:
 
   bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
 
   bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;
 
   bool ForEachExternalModule(
       lldb_private::CompileUnit &, llvm::DenseSet<lldb_private::SymbolFile *> &,
       llvm::function_ref<bool(lldb_private::Module &)>) override;
+  bool ForEachAuxiliaryModule(
+      llvm::function_ref<bool(lldb_private::Module &)>) override;
 
   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;
 

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

bool SymbolFileDWARFDebugMap::ForEachExternalModule(
     llvm::function_ref<bool(Module &)> f) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ForEachExternalModule(comp_unit, visited_symbol_files, f);
   return false;
 }
 
+bool SymbolFileDWARFDebugMap::ForEachAuxiliaryModule(
+    llvm::function_ref<bool(Module &)> f) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
+  ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
+    if (oso_dwarf)
+      if (auto *obj = oso_dwarf->GetObjectFile())
+        if (ModuleSP module_sp = obj->GetModule())
+          return f(*module_sp);
+    return false;
+  });
+  return false;
+}
+
 bool SymbolFileDWARFDebugMap::ParseSupportFiles(CompileUnit &comp_unit,
                                                 FileSpecList &support_files) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
   if (oso_dwarf)
     return oso_dwarf->ParseSupportFiles(comp_unit, support_files);
   return false;
 }