Merge pull request #65725 from adrian-prantl/107869141

[Serialization] Teach ASTSectionImporter to filter by triple.

Author: adrian-prantl

include/swift/ASTSectionImporter/ASTSectionImporter.h

@@ -20,6 +20,9 @@
 #include "swift/Basic/LLVM.h"
 #include <string>
 
+namespace llvm {
+class Triple;
+}
 namespace swift {
   class MemoryBufferSerializedModuleLoader;
 
@@ -28,9 +31,10 @@ namespace swift {
   /// registers them using registerMemoryBuffer() so they can be found by
   /// loadModule(). The access path of all modules found in the section is
   /// appended to the vector foundModules.
+  /// \param filter  If fully specified, only matching modules are registered.
   /// \return true if successful.
   bool parseASTSection(MemoryBufferSerializedModuleLoader &Loader,
-                       StringRef Data,
+                       StringRef Data, const llvm::Triple &filter,
                        SmallVectorImpl<std::string> &foundModules);
 }
 #endif

include/swift/Serialization/Validation.h

@@ -19,6 +19,10 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 
+namespace llvm {
+class Triple;
+}
+
 namespace swift {
 
 class ModuleFile;
@@ -302,6 +306,11 @@ void diagnoseSerializedASTLoadFailureTransitive(
     ASTContext &Ctx, SourceLoc diagLoc, const serialization::Status status,
     ModuleFile *loadedModuleFile, Identifier ModuleName, bool forTestable);
 
+/// Determine whether two triples are considered to be compatible for module
+/// serialization purposes.
+bool areCompatible(const llvm::Triple &moduleTarget,
+                   const llvm::Triple &ctxTarget);
+
 } // end namespace serialization
 } // end namespace swift
 

lib/ASTSectionImporter/ASTSectionImporter.cpp

@@ -28,10 +28,13 @@ using namespace swift;
 
 bool swift::parseASTSection(MemoryBufferSerializedModuleLoader &Loader,
                             StringRef buf,
+                            const llvm::Triple &filter,
                             SmallVectorImpl<std::string> &foundModules) {
   if (!serialization::isSerializedAST(buf))
     return false;
 
+  bool haveFilter = filter.getOS() != llvm::Triple::UnknownOS &&
+                   filter.getArch() != llvm::Triple::UnknownArch;
   // An AST section consists of one or more AST modules, optionally with
   // headers. Iterate over all AST modules.
   while (!buf.empty()) {
@@ -43,10 +46,15 @@ bool swift::parseASTSection(MemoryBufferSerializedModuleLoader &Loader,
 
     if (info.status == serialization::Status::Valid) {
       assert(info.bytes != 0);
-      if (!info.name.empty()) {
+      bool selected = true;
+      if (haveFilter) {
+        llvm::Triple moduleTriple(info.targetTriple);
+        selected = serialization::areCompatible(moduleTriple, filter);
+      }
+      if (!info.name.empty() && selected) {
         StringRef moduleData = buf.substr(0, info.bytes);
         std::unique_ptr<llvm::MemoryBuffer> bitstream(
-          llvm::MemoryBuffer::getMemBuffer(moduleData, info.name, false));
+            llvm::MemoryBuffer::getMemBuffer(moduleData, info.name, false));
 
         // Register the memory buffer.
         Loader.registerMemoryBuffer(info.name, std::move(bitstream),

lib/Serialization/ModuleFile.cpp

@@ -91,6 +91,16 @@ static bool isTargetTooNew(const llvm::Triple &moduleTarget,
   return ctxTarget.isOSVersionLT(moduleTarget);
 }
 
+namespace swift {
+namespace serialization {
+bool areCompatible(const llvm::Triple &moduleTarget,
+                   const llvm::Triple &ctxTarget) {
+  return areCompatibleArchitectures(moduleTarget, ctxTarget) &&
+         areCompatibleOSs(moduleTarget, ctxTarget);
+}
+} // namespace serialization
+} // namespace swift
+
 ModuleFile::ModuleFile(std::shared_ptr<const ModuleFileSharedCore> core)
     : Core(core) {
   assert(!core->hasError());
@@ -249,8 +259,7 @@ Status ModuleFile::associateWithFileContext(FileUnit *file, SourceLoc diagLoc,
   ASTContext &ctx = getContext();
 
   llvm::Triple moduleTarget(llvm::Triple::normalize(Core->TargetTriple));
-  if (!areCompatibleArchitectures(moduleTarget, ctx.LangOpts.Target) ||
-      !areCompatibleOSs(moduleTarget, ctx.LangOpts.Target)) {
+  if (!areCompatible(moduleTarget, ctx.LangOpts.Target)) {
     status = Status::TargetIncompatible;
     if (!recoverFromIncompatibility)
       return error(status);

test/DebugInfo/ASTSection.swift

@@ -2,6 +2,7 @@
 
 // RUN: %target-build-swift -emit-executable %s -g -o %t/ASTSection -emit-module
 // RUN: %lldb-moduleimport-test -verbose %t/ASTSection | %FileCheck %s
+// RUN: %lldb-moduleimport-test -filter mips64-unknown-hurd -verbose %t/ASTSection | %FileCheck %s --check-prefix=LINETABLE-CHECK
 
 // REQUIRES: executable_test
 // REQUIRES: swift_tools_extra

tools/lldb-moduleimport-test/lldb-moduleimport-test.cpp

@@ -239,6 +239,9 @@ int main(int argc, char **argv) {
   opt<bool> Verbose("verbose", desc("Dump informations on the loaded module"),
                     cat(Visible));
 
+  opt<std::string> Filter("filter", desc("triple for filtering modules"),
+                          cat(Visible));
+
   opt<std::string> ModuleCachePath(
       "module-cache-path", desc("Clang module cache path"), cat(Visible));
 
@@ -351,9 +354,11 @@ int main(int argc, char **argv) {
     ClangImporter->setDWARFImporterDelegate(dummyDWARFImporter);
   }
 
+  llvm::Triple filter(Filter);
   for (auto &Module : Modules)
     if (!parseASTSection(*CI.getMemoryBufferSerializedModuleLoader(),
-                         StringRef(Module.first, Module.second), modules)) {
+                         StringRef(Module.first, Module.second), filter,
+                         modules)) {
       llvm::errs() << "error: Failed to parse AST section!\n";
       return 1;
     }