Merge pull request #211 from owenv/linker-deployment-target

Use platform_version to pass deployment target information to the linker

Author: owenv

Sources/SwiftDriver/Jobs/DarwinToolchain+LinkerSupport.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 import TSCBasic
+import TSCUtility
 import SwiftOptions
 
 extension DarwinToolchain {
@@ -112,49 +113,36 @@ extension DarwinToolchain {
     commandLine.appendPath(clangRTPath)
   }
 
+  private func addPlatformVersionArg(to commandLine: inout [Job.ArgTemplate],
+                                     for triple: Triple, sdkPath: VirtualPath?) {
+    assert(triple.isDarwin)
+    let platformName = triple.darwinPlatform!.linkerPlatformName
+    let platformVersion = triple.darwinLinkerPlatformVersion
+    let sdkVersion: Version
+    if let sdkPath = sdkPath,
+       let sdkInfo = getTargetSDKInfo(sdkPath: sdkPath) {
+      sdkVersion = sdkInfo.sdkVersion(for: triple)
+    } else {
+      sdkVersion = Version(0, 0, 0)
+    }
+
+    commandLine.append(.flag("-platform_version"))
+    commandLine.append(.flag(platformName))
+    commandLine.append(.flag(platformVersion.description))
+    commandLine.append(.flag(sdkVersion.description))
+  }
+
   private func addDeploymentTargetArgs(
     to commandLine: inout [Job.ArgTemplate],
     targetTriple: Triple,
-    targetVariantTriple: Triple?
+    targetVariantTriple: Triple?,
+    sdkPath: VirtualPath?
   ) {
-    // FIXME: Properly handle deployment targets.
-
-    let flag: String
-
-    switch targetTriple.darwinPlatform! {
-    case .iOS(.device):
-      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):
-      flag = "-tvos_version_min"
-    case .tvOS(.simulator):
-      flag = "-tvos_simulator_version_min"
-    case .watchOS(.device):
-      flag = "-watchos_version_min"
-    case .watchOS(.simulator):
-      flag = "-watchos_simulator_version_min"
-    }
-
-    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)
-      }
+    addPlatformVersionArg(to: &commandLine, for: targetTriple, sdkPath: sdkPath)
+    if let variantTriple = targetVariantTriple {
+      assert(targetTriple.isValidForZipperingWithTriple(variantTriple))
+      addPlatformVersionArg(to: &commandLine, for: variantTriple,
+                            sdkPath: sdkPath)
     }
   }
 
@@ -284,7 +272,8 @@ extension DarwinToolchain {
     addDeploymentTargetArgs(
       to: &commandLine,
       targetTriple: targetTriple,
-      targetVariantTriple: targetVariantTriple
+      targetVariantTriple: targetVariantTriple,
+      sdkPath: try sdkPath.map(VirtualPath.init(path:))
     )
     try addProfileGenerationArgs(
       to: &commandLine,

Sources/SwiftDriver/Toolchains/DarwinToolchain.swift

@@ -137,7 +137,7 @@ public final class DarwinToolchain: Toolchain {
       case .iOSVersionAboveMaximumDeploymentTarget(let version):
         return "iOS \(version) does not support 32-bit programs"
       case .unsupportedTargetVariant(variant: let variant):
-        return "unsupported '\(variant.isiOS ? "-target" : "-target-variant")' value '\(variant)'; use 'ios-macabi' instead"
+        return "unsupported '\(variant.isiOS ? "-target-variant" : "-target")' value '\(variant.triple)'; use 'ios-macabi' instead"
       case .argumentNotSupported(let argument):
         return "\(argument) is no longer supported for Apple platforms"
       case .darwinOnlySupportsLibCxx:
@@ -208,14 +208,14 @@ public final class DarwinToolchain: Toolchain {
     }
   }
 
-  private struct DarwinSDKInfo: Decodable {
-    enum CodingKeys: String, CodingKey {
+  struct DarwinSDKInfo: Decodable {
+    private enum CodingKeys: String, CodingKey {
       case version = "Version"
       case versionMap = "VersionMap"
     }
 
     struct VersionMap: Decodable {
-      enum CodingKeys: String, CodingKey {
+      private enum CodingKeys: String, CodingKey {
         case macOSToCatalystMapping = "macOS_iOSMac"
       }
 
@@ -242,8 +242,8 @@ public final class DarwinToolchain: Toolchain {
       }
     }
 
-    var version: Version
-    var versionMap: VersionMap
+    private var version: Version
+    private var versionMap: VersionMap
 
     init(from decoder: Decoder) throws {
       let keyedContainer = try decoder.container(keyedBy: CodingKeys.self)
@@ -272,7 +272,7 @@ public final class DarwinToolchain: Toolchain {
   // SDK info is computed lazily. This should not generally be accessed directly.
   private var _sdkInfo: DarwinSDKInfo? = nil
 
-  private func getTargetSDKInfo(sdkPath: VirtualPath) -> DarwinSDKInfo? {
+  func getTargetSDKInfo(sdkPath: VirtualPath) -> DarwinSDKInfo? {
     if let info = _sdkInfo {
       return info
     } else {

Sources/SwiftDriver/Utilities/Triple+Platforms.swift

@@ -102,6 +102,29 @@ public enum DarwinPlatform: Hashable {
     }
   }
 
+  /// The name the linker uses to identify this platform.
+  public var linkerPlatformName: String {
+    switch self {
+    case .macOS:
+      return "macos"
+    case .iOS(.device):
+      return "ios"
+    case .iOS(.simulator):
+      return "ios-simulator"
+    case .iOS(.catalyst):
+      return "mac-catalyst"
+    case .tvOS(.device):
+      return "tvos"
+    case .tvOS(.simulator):
+      return "tvos-simulator"
+    case .watchOS(.device):
+      return "watchos"
+    case .watchOS(.simulator):
+      return "watchos-simulator"
+    }
+  }
+
+
   /// The name used to identify this platform in compiler_rt file names.
   public var libraryNameSuffix: String {
     switch self {
@@ -184,6 +207,53 @@ extension Triple {
     }
   }
 
+  // The Darwin platform version used for linking.
+  public var darwinLinkerPlatformVersion: Version {
+    precondition(self.isDarwin)
+    switch darwinPlatform! {
+    case .macOS:
+      // The integrated driver falls back to `osVersion` for ivalid macOS
+      // versions, this decision might be worth revisiting.
+      let macVersion = _macOSVersion ?? osVersion
+      // The first deployment of arm64 for macOS is version 11
+      if macVersion.major < 11 && arch == .aarch64 {
+        return Version(11, 0, 0)
+      }
+
+      return macVersion
+    case .iOS(.catalyst):
+      // Mac Catalyst on arm was introduced with an iOS deployment target of
+      // 14.0; the linker doesn't want to see a deployment target before that.
+      if _iOSVersion.major < 14 && arch == .aarch64 {
+        return Version(14, 0, 0)
+      }
+
+      // Mac Catalyst was introduced with an iOS deployment target of 13.0;
+      // the linker doesn't want to see a deployment target before that.
+      if _iOSVersion.major < 13 {
+        return Version(13, 0, 0)
+      }
+
+      return _iOSVersion
+    case .iOS(.device), .iOS(.simulator), .tvOS(_):
+      // The first deployment of arm64 simulators is iOS/tvOS 14.0;
+      // the linker doesn't want to see a deployment target before that.
+      if _isSimulatorEnvironment && _iOSVersion.major < 14 && arch == .aarch64 {
+        return Version(14, 0, 0)
+      }
+
+      return _iOSVersion
+    case .watchOS(_):
+      // The first deployment of arm64 simulators is watchOS 7;
+      // the linker doesn't want to see a deployment target before that.
+      if _isSimulatorEnvironment && osVersion.major < 7 && arch == .aarch64 {
+        return Version(7, 0, 0)
+      }
+
+      return osVersion
+    }
+  }
+
   /// The platform name, i.e. the name clang uses to identify this target in its
   /// resource directory.
   ///