Use target triple for “universal” modules

When loading a module supporting multiple targets, the module loader now looks for a file named with a normalized version of the target triple first, and only falls back to the architecture name if the normalized triple is not found.

Author: beccadax

include/swift/Basic/Platform.h

@@ -74,6 +74,17 @@ namespace swift {
   ///
   /// This is a stop-gap until full Triple support (ala Clang) exists within swiftc.
   StringRef getMajorArchitectureName(const llvm::Triple &triple);
+
+  /// Computes the normalized target triple used as the most preferred name for
+  /// module loading.
+  ///
+  /// For platforms with module stability, this canonicalizes architecture,
+  /// vendor, and OS names, strips OS versions, and makes inferred environments
+  /// explicit. For other platforms, it returns the unmodified triple.
+  ///
+  /// The input triple should already be "normalized" in the sense that
+  /// llvm::Triple::normalize() would not affect it.
+  llvm::Triple getTargetSpecificModuleTriple(const llvm::Triple &triple);
 } // end namespace swift
 
 #endif // SWIFT_BASIC_PLATFORM_H

lib/Basic/Platform.cpp

@@ -12,6 +12,8 @@
 
 #include "swift/Basic/Platform.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/StringExtras.h"
 
 using namespace swift;
 
@@ -188,3 +190,78 @@ StringRef swift::getMajorArchitectureName(const llvm::Triple &Triple) {
     return Triple.getArchName();
   }
 }
+
+static StringRef
+getArchForAppleTargetSpecificModuleTriple(const llvm::Triple &triple) {
+  auto tripleArchName = triple.getArchName();
+
+  return llvm::StringSwitch<StringRef>(tripleArchName)
+              .Cases("arm64", "aarch64", "arm64")
+              .Case ("armv7s", "armv7s")
+              .Case ("armv7k", "armv7k")
+              .Case ("armv7", "armv7")
+              .Case ("x86_64h", "x86_64h")
+              .Cases("x86_64", "amd64", "x86_64")
+              .Cases("i386", "i486", "i586", "i686", "i786", "i886", "i986",
+                     "i386")
+              .Cases("unknown", "", "unknown")
+              .Default(tripleArchName);
+}
+
+static StringRef
+getVendorForAppleTargetSpecificModuleTriple(const llvm::Triple &triple) {
+  return "apple";
+}
+
+static StringRef
+getOSForAppleTargetSpecificModuleTriple(const llvm::Triple &triple) {
+  auto tripleOSName = triple.getOSName();
+
+  // Truncate the OS name before the first digit.
+  auto tripleOSNameNoVersion = tripleOSName.take_until(llvm::isDigit);
+
+  return llvm::StringSwitch<StringRef>(tripleOSNameNoVersion)
+              .Cases("macos", "macosx", "darwin", "macos")
+              .Case ("ios", "ios")
+              .Case ("tvos", "tvos")
+              .Cases("unknown", "", "unknown")
+              .Default(tripleOSNameNoVersion);
+}
+
+static Optional<StringRef>
+getEnvironmentForAppleTargetSpecificModuleTriple(const llvm::Triple &triple) {
+  auto tripleEnvironment = triple.getEnvironmentName();
+
+  if (tripleEnvironment == "") {
+    if (swift::tripleIsAnySimulator(triple))
+      return StringRef("simulator");
+    else
+      return None;
+  }
+
+  return llvm::StringSwitch<Optional<StringRef>>(tripleEnvironment)
+              .Case("simulator", StringRef("simulator"))
+              .Case("unknown", None)
+              .Default(tripleEnvironment);
+}
+
+llvm::Triple swift::getTargetSpecificModuleTriple(const llvm::Triple &triple) {
+  if (triple.isOSDarwin()) {
+    StringRef newArch = getArchForAppleTargetSpecificModuleTriple(triple);
+
+    StringRef newVendor = getVendorForAppleTargetSpecificModuleTriple(triple);
+
+    StringRef newOS = getOSForAppleTargetSpecificModuleTriple(triple);
+
+    Optional<StringRef> newEnvironment =
+        getEnvironmentForAppleTargetSpecificModuleTriple(triple);
+
+    if (newEnvironment)
+      return llvm::Triple(newArch, newVendor, newOS, *newEnvironment);
+    else
+      return llvm::Triple(newArch, newVendor, newOS);
+  } else {
+    return triple;
+  }
+}
+

lib/Serialization/SerializedModuleLoader.cpp

@@ -16,6 +16,7 @@
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/FileTypes.h"
+#include "swift/Basic/Platform.h"
 #include "swift/Basic/STLExtras.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Version.h"
@@ -166,18 +167,24 @@ SerializedModuleLoaderBase::findModule(AccessPathElem moduleID,
   llvm::SmallString<64> moduleName(moduleID.first.str());
   ModuleFilenamePair fileNames(moduleName);
 
-  StringRef archName = Ctx.LangOpts.Target.getArchName();
-
   SmallVector<ModuleFilenamePair, 4> targetFileNamePairs;
-  targetFileNamePairs.push_back(archName);
+
+  auto normalizedTarget = getTargetSpecificModuleTriple(Ctx.LangOpts.Target);
+  targetFileNamePairs.push_back(ModuleFilenamePair(normalizedTarget.str()));
+
+  // Before this, we used the un-normalized architecture as a target-specific
+  // module name. Fall back to that behavior.
+  targetFileNamePairs.push_back(
+    ModuleFilenamePair(Ctx.LangOpts.Target.getArchName())
+  );
 
   // FIXME: We used to use "major architecture" names for these files---the
   // names checked in "#if arch(...)". Fall back to that name in the one case
   // where it's different from what Swift 4.2 supported: 32-bit ARM platforms.
   // We should be able to drop this once there's an Xcode that supports the
   // new names.
   if (Ctx.LangOpts.Target.getArch() == llvm::Triple::ArchType::arm)
-    targetFileNamePairs.push_back(StringRef("arm"));
+    targetFileNamePairs.push_back(ModuleFilenamePair("arm"));
 
   auto &fs = *Ctx.SourceMgr.getFileSystem();
   isFramework = false;
@@ -202,7 +209,7 @@ SerializedModuleLoaderBase::findModule(AccessPathElem moduleID,
     // We can only get here if all targetFileNamePairs failed with
     // 'std::errc::no_such_file_or_directory'.
     if (maybeDiagnoseArchitectureMismatch(moduleID.second,
-                                          moduleName, archName, currPath)) {
+            moduleName, normalizedTarget.str(), currPath)) {
       return false;
     } else {
       return None;

test/ParseableInterface/ModuleCache/force-module-loading-mode-archs.swift

@@ -60,12 +60,12 @@
 // RUN: %empty-directory(%t/Lib.swiftmodule)
 // RUN: touch %t/Lib.swiftmodule/garbage.swiftmodule
 // RUN: touch %t/Lib.swiftmodule/garbage.swiftinterface
-// RUN: not env SWIFT_FORCE_MODULE_LOADING=prefer-parseable %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -I %t 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%target-cpu %s
-// RUN: not env SWIFT_FORCE_MODULE_LOADING=prefer-serialized %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -I %t 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%target-cpu %s
+// RUN: not env SWIFT_FORCE_MODULE_LOADING=prefer-parseable %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -I %t 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%module-target-triple %s
+// RUN: not env SWIFT_FORCE_MODULE_LOADING=prefer-serialized %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -I %t 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%module-target-triple %s
 // RUN: not env SWIFT_FORCE_MODULE_LOADING=only-parseable %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -I %t 2>&1 | %FileCheck -check-prefix=NO-SUCH-MODULE %s
-// RUN: not env SWIFT_FORCE_MODULE_LOADING=only-serialized %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -I %t 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%target-cpu %s
+// RUN: not env SWIFT_FORCE_MODULE_LOADING=only-serialized %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -I %t 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%module-target-triple %s
 // (default)
-// RUN: not %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP -I %t %s 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%target-cpu %s
+// RUN: not %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP -I %t %s 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%module-target-triple %s
 
 // 8. Only the interface is present but for the wrong architecture.
 // (Diagnostics for the module only are tested elsewhere.)

test/ParseableInterface/ModuleCache/force-module-loading-mode-framework.swift

@@ -60,12 +60,12 @@
 // RUN: %empty-directory(%t/Lib.framework/Modules/Lib.swiftmodule)
 // RUN: touch %t/Lib.framework/Modules/Lib.swiftmodule/garbage.swiftmodule
 // RUN: touch %t/Lib.framework/Modules/Lib.swiftmodule/garbage.swiftinterface
-// RUN: not env SWIFT_FORCE_MODULE_LOADING=prefer-parseable %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -F %t 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%target-cpu %s
-// RUN: not env SWIFT_FORCE_MODULE_LOADING=prefer-serialized %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -F %t 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%target-cpu %s
+// RUN: not env SWIFT_FORCE_MODULE_LOADING=prefer-parseable %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -F %t 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%module-target-triple %s
+// RUN: not env SWIFT_FORCE_MODULE_LOADING=prefer-serialized %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -F %t 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%module-target-triple %s
 // RUN: not env SWIFT_FORCE_MODULE_LOADING=only-parseable %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -F %t 2>&1 | %FileCheck -check-prefix=NO-SUCH-MODULE %s
-// RUN: not env SWIFT_FORCE_MODULE_LOADING=only-serialized %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -F %t 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%target-cpu %s
+// RUN: not env SWIFT_FORCE_MODULE_LOADING=only-serialized %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP %s -F %t 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%module-target-triple %s
 // (default)
-// RUN: not %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP -F %t %s 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%target-cpu %s
+// RUN: not %target-swift-frontend -typecheck -parse-stdlib -module-cache-path %t/MCP -F %t %s 2>&1 | %FileCheck -check-prefix=WRONG-ARCH -DARCH=%module-target-triple %s
 
 // 8. Only the interface is present but for the wrong architecture.
 // (Diagnostics for the module only are tested elsewhere.)

test/Serialization/load-invalid-arch.swift

@@ -5,13 +5,13 @@
 // RUN: touch %t/new_module.swiftmodule/ppc65.swiftmodule
 // RUN: touch %t/new_module.swiftmodule/i387.swiftdoc
 // RUN: touch %t/new_module.swiftmodule/ppc65.swiftdoc
-// RUN: not %target-swift-frontend %s -typecheck -I %t -show-diagnostics-after-fatal 2>&1 | %FileCheck %s -check-prefix=CHECK -check-prefix CHECK-ALL -DTARGET_ARCHITECTURE=%target-cpu
+// RUN: not %target-swift-frontend %s -typecheck -I %t -show-diagnostics-after-fatal 2>&1 | %FileCheck %s -check-prefix=CHECK -check-prefix CHECK-ALL -DTARGET_ARCHITECTURE=%module-target-triple
 
 // RUN: %empty-directory(%t)
 // RUN: mkdir -p %t/new_module.framework/Modules/new_module.swiftmodule/
 // RUN: touch %t/new_module.framework/Modules/new_module.swiftmodule/i387.swiftmodule
 // RUN: touch %t/new_module.framework/Modules/new_module.swiftmodule/ppc65.swiftmodule
-// RUN: not %target-swift-frontend %s -F %t -typecheck -show-diagnostics-after-fatal 2>&1 | %FileCheck %s -check-prefix=CHECK -check-prefix CHECK-ALL -DTARGET_ARCHITECTURE=%target-cpu
+// RUN: not %target-swift-frontend %s -F %t -typecheck -show-diagnostics-after-fatal 2>&1 | %FileCheck %s -check-prefix=CHECK -check-prefix CHECK-ALL -DTARGET_ARCHITECTURE=%module-target-triple
 
 // RUN: %empty-directory(%t)
 // RUN: mkdir %t/new_module.swiftmodule

test/Serialization/load-target-fallback.swift

@@ -0,0 +1,28 @@
+// RUN: %empty-directory(%t)
+
+// Tests that we prefer the normalized target triple name for a .swiftmodule,
+// but fall back to the legacy architecture name if necessary.
+
+// RUN: mkdir %t/TargetLibrary.swiftmodule
+// RUN: %target-swift-frontend -emit-module -o %t/TargetLibrary.swiftmodule/%module-target-triple.swiftmodule %S/Inputs/def_func.swift -module-name TargetLibrary
+// RUN: touch %t/TargetLibrary.swiftmodule/%target-cpu.swiftmodule
+
+import TargetLibrary
+
+// RUN: mkdir %t/ArchLibrary.swiftmodule
+// RUN: %target-swift-frontend -emit-module -o %t/ArchLibrary.swiftmodule/%target-cpu.swiftmodule %S/Inputs/def_func.swift -module-name ArchLibrary
+
+import ArchLibrary
+
+// RUN: mkdir -p %t/TargetModule.framework/Modules/TargetModule.swiftmodule
+// RUN: %target-swift-frontend -emit-module -o %t/TargetModule.framework/Modules/TargetModule.swiftmodule/%module-target-triple.swiftmodule %S/Inputs/def_func.swift -module-name TargetModule
+// RUN: touch %t/TargetModule.framework/Modules/TargetModule.swiftmodule/%target-cpu.swiftmodule
+
+import TargetModule
+
+// RUN: mkdir -p %t/ArchModule.framework/Modules/ArchModule.swiftmodule
+// RUN: %target-swift-frontend -emit-module -o %t/ArchModule.framework/Modules/ArchModule.swiftmodule/%target-cpu.swiftmodule %S/Inputs/def_func.swift -module-name ArchModule
+
+import ArchModule
+
+// RUN: %target-swift-frontend %s -typecheck -I %t -F %t