Add support for catalyst

C++ implementation: swiftlang/swift#29017

Also fixes test/Driver/print_target_info.swift

Author: cltnschlosser

Sources/SwiftDriver/Driver/Driver.swift

@@ -59,6 +59,9 @@ public struct Driver {
   /// The target triple.
   public let targetTriple: Triple
 
+  /// The variant target triple.
+  public let targetVariantTriple: Triple?
+
   /// The toolchain to use for resolution.
   public let toolchain: Toolchain
 
@@ -220,6 +223,7 @@ public struct Driver {
         Triple($0, normalizing: true)
       }
     (self.toolchain, self.targetTriple) = try Self.computeToolchain(explicitTarget, diagnosticsEngine: diagnosticEngine, env: env)
+    self.targetVariantTriple = self.parsedOptions.getLastArgument(.targetVariant).map { Triple($0.asSingle, normalizing: true) }
 
     // Find the Swift compiler executable.
     if let frontendPath = self.parsedOptions.getLastArgument(.driverUseFrontendPath) {

Sources/SwiftDriver/Jobs/DarwinToolchain+LinkerSupport.swift

@@ -113,7 +113,8 @@ extension DarwinToolchain {
 
   private func addDeploymentTargetArgs(
     to commandLine: inout [Job.ArgTemplate],
-    targetTriple: Triple
+    targetTriple: Triple,
+    targetVariantTriple: Triple?
   ) {
     // FIXME: Properly handle deployment targets.
 
@@ -124,6 +125,8 @@ extension DarwinToolchain {
       flag = "-iphoneos_version_min"
     case .iOS(.simulator):
       flag = "-ios_simulator_version_min"
+    case .iOS(.catalyst):
+      flag = "-maccatalyst_version_min"
     case .macOS:
       flag = "-macosx_version_min"
     case .tvOS(.device):
@@ -138,6 +141,20 @@ extension DarwinToolchain {
 
     commandLine.appendFlag(flag)
     commandLine.appendFlag(targetTriple.version().description)
+
+    if let variant = targetVariantTriple {
+      if targetTriple.isiOS {
+        assert(targetTriple.isValidForZipperingWithTriple(variant))
+        assert(variant.isMacOSX)
+        commandLine.appendFlag("-macosx_version_min")
+        commandLine.appendFlag(variant.version().description)
+      } else {
+        assert(targetTriple.isValidForZipperingWithTriple(variant))
+        assert(variant.isMacCatalyst)
+        commandLine.appendFlag("-maccatalyst_version_min")
+        commandLine.appendFlag(variant.version().description)
+      }
+    }
   }
 
   private func addArgsToLinkARCLite(
@@ -178,7 +195,8 @@ extension DarwinToolchain {
     outputFile: VirtualPath,
     sdkPath: String?,
     sanitizers: Set<Sanitizer>,
-    targetTriple: Triple
+    targetTriple: Triple,
+    targetVariantTriple: Triple?
   ) throws -> AbsolutePath {
 
     // FIXME: If we used Clang as a linker instead of going straight to ld,
@@ -262,7 +280,8 @@ extension DarwinToolchain {
     )
     addDeploymentTargetArgs(
       to: &commandLine,
-      targetTriple: targetTriple
+      targetTriple: targetTriple,
+      targetVariantTriple: targetVariantTriple
     )
     try addProfileGenerationArgs(
       to: &commandLine,

Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift

@@ -54,6 +54,11 @@ extension Driver {
       }
     }
 
+    if let variant = parsedOptions.getLastArgument(.targetVariant)?.asSingle {
+      commandLine.appendFlag(.targetVariant)
+      commandLine.appendFlag(Triple(variant, normalizing: true).triple)
+    }
+
     // Enable address top-byte ignored in the ARM64 backend.
     if (targetTriple.arch == .aarch64) {
       commandLine.appendFlag(.Xllvm)

Sources/SwiftDriver/Jobs/GenericUnixToolchain+LinkerSupport.swift

@@ -50,7 +50,8 @@ extension GenericUnixToolchain {
     outputFile: VirtualPath,
     sdkPath: String?,
     sanitizers: Set<Sanitizer>,
-    targetTriple: Triple
+    targetTriple: Triple,
+    targetVariantTriple: Triple?
   ) throws -> AbsolutePath {
     switch linkerOutputType {
     case .dynamicLibrary:

Sources/SwiftDriver/Jobs/LinkJob.swift

@@ -48,7 +48,8 @@ extension Driver {
       outputFile: outputFile,
       sdkPath: sdkPath,
       sanitizers: enabledSanitizers,
-      targetTriple: targetTriple
+      targetTriple: targetTriple,
+      targetVariantTriple: targetVariantTriple
     )
 
     // TODO: some, but not all, linkers support response files.

Sources/SwiftDriver/Jobs/Planning.swift

@@ -172,6 +172,7 @@ extension Driver {
       var commandLine: [Job.ArgTemplate] = [.flag("-frontend"),
                                             .flag("-print-target-info")]
       try commandLine.appendLast(.target, from: &parsedOptions)
+      try commandLine.appendLast(.targetVariant, from: &parsedOptions)
       try commandLine.appendLast(.sdk, from: &parsedOptions)
       try commandLine.appendLast(.resourceDir, from: &parsedOptions)
       return Job(kind: .printTargetInfo,

Sources/SwiftDriver/Jobs/Toolchain+LinkerSupport.swift

@@ -37,6 +37,11 @@ extension Toolchain {
     return resourceDirBase.appending(components: triple.platformName() ?? "")
   }
 
+  func computeSecondaryResourceDirPath(for triple: Triple, primaryPath: AbsolutePath) -> AbsolutePath? {
+    guard triple.isMacCatalyst else { return nil }
+    return primaryPath.parentDirectory.appending(component: "macosx")
+  }
+
   func clangLibraryPath(
     for triple: Triple,
     parsedOptions: inout ParsedOptions
@@ -55,13 +60,25 @@ extension Toolchain {
     sdkPath: String?,
     isShared: Bool
   ) throws -> [AbsolutePath] {
-    var result = [try computeResourceDirPath(
+    let resourceDirPath = try computeResourceDirPath(
       for: triple,
       parsedOptions: &parsedOptions,
-      isShared: isShared)]
+      isShared: isShared)
+    var result = [resourceDirPath]
+
+    let secondaryResourceDir = computeSecondaryResourceDirPath(for: triple, primaryPath: resourceDirPath)
+    if let path = secondaryResourceDir {
+      result.append(path)
+    }
 
     if let path = sdkPath {
-      result.append(AbsolutePath(path).appending(RelativePath("usr/lib/swift")))
+      let sdkPath = AbsolutePath(path)
+      // If we added the secondary resource dir, we also need the iOSSupport directory.
+      if secondaryResourceDir != nil {
+        result.append(sdkPath.appending(components: "System", "iOSSupport", "usr", "lib", "swift"))
+      }
+
+      result.append(sdkPath.appending(RelativePath("usr/lib/swift")))
     }
 
     return result