Merge pull request #129 from owenv/compat-libs

owenv · web-flow · commit 64f3fcbcce01 · 2020-06-17T22:12:04.000-07:00
Link runtime compatibility libs on darwin if needed
diff --git a/Sources/SwiftDriver/Jobs/DarwinToolchain+LinkerSupport.swift b/Sources/SwiftDriver/Jobs/DarwinToolchain+LinkerSupport.swift
@@ -258,7 +258,9 @@ extension DarwinToolchain {
         to: &commandLine,
         parsedOptions: &parsedOptions,
         sdkPath: sdkPath,
-        targetTriple: targetTriple
+        targetTriple: targetTriple,
+        linkerOutputType: linkerOutputType,
+        fileSystem: fileSystem
       )
 
       // These custom arguments should be right before the object file at the
diff --git a/Sources/SwiftDriver/Jobs/Toolchain+LinkerSupport.swift b/Sources/SwiftDriver/Jobs/Toolchain+LinkerSupport.swift
@@ -24,7 +24,8 @@ extension Toolchain {
     let resourceDirBase: AbsolutePath
     if let resourceDir = parsedOptions.getLastArgument(.resourceDir) {
       resourceDirBase = try AbsolutePath(validating: resourceDir.asSingle)
-    } else if let sdk = parsedOptions.getLastArgument(.sdk),
+    } else if !triple.isDarwin,
+      let sdk = parsedOptions.getLastArgument(.sdk),
       let sdkPath = try? AbsolutePath(validating: sdk.asSingle) {
       resourceDirBase = sdkPath
         .appending(components: "usr", "lib",
@@ -120,87 +121,130 @@ extension Toolchain {
 // MARK: - Common argument routines
 
 extension DarwinToolchain {
-    func addArgsToLinkStdlib(
-      to commandLine: inout [Job.ArgTemplate],
-      parsedOptions: inout ParsedOptions,
-      sdkPath: String?,
-      targetTriple: Triple
-    ) throws {
+  func getSwiftRuntimeCompatibilityVersion(for targetTriple: Triple) -> (Int, Int)? {
+    // FIXME: Add arm64e to Triple.swift
+    if targetTriple.archName == "arm64e" {
+      return (5, 3)
+    }
 
-      // Link compatibility libraries, if we're deploying back to OSes that
-      // have an older Swift runtime.
-  //    let sharedResourceDirPath = try computeResourceDirPath(for: targetTriple,
-  //                                                           isShared: true)
-  //    Optional<llvm::VersionTuple> runtimeCompatibilityVersion;
-  //
-  //    if (context.Args.hasArg(options::OPT_runtime_compatibility_version)) {
-  //      auto value = context.Args.getLastArgValue(
-  //                                      options::OPT_runtime_compatibility_version);
-  //      if (value.equals("5.0")) {
-  //        runtimeCompatibilityVersion = llvm::VersionTuple(5, 0);
-  //      } else if (value.equals("none")) {
-  //        runtimeCompatibilityVersion = None;
-  //      } else {
-  //        // TODO: diagnose unknown runtime compatibility version?
-  //      }
-  //    } else if (job.getKind() == LinkKind::Executable) {
-  //      runtimeCompatibilityVersion
-  //                     = getSwiftRuntimeCompatibilityVersionForTarget(getTriple());
-  //    }
-  //
-  //    if (runtimeCompatibilityVersion) {
-  //      if (*runtimeCompatibilityVersion <= llvm::VersionTuple(5, 0)) {
-  //        // Swift 5.0 compatibility library
-  //        SmallString<128> BackDeployLib;
-  //        BackDeployLib.append(SharedResourceDirPath);
-  //        llvm::sys::path::append(BackDeployLib, "libswiftCompatibility50.a");
-  //
-  //        if (llvm::sys::fs::exists(BackDeployLib)) {
-  //          Arguments.push_back("-force_load");
-  //          Arguments.push_back(context.Args.MakeArgString(BackDeployLib));
-  //        }
-  //      }
-  //    }
-  //
-  //    if (job.getKind() == LinkKind::Executable) {
-  //      if (runtimeCompatibilityVersion)
-  //        if (*runtimeCompatibilityVersion <= llvm::VersionTuple(5, 0)) {
-  //          // Swift 5.0 dynamic replacement compatibility library.
-  //          SmallString<128> BackDeployLib;
-  //          BackDeployLib.append(SharedResourceDirPath);
-  //          llvm::sys::path::append(BackDeployLib,
-  //                                  "libswiftCompatibilityDynamicReplacements.a");
-  //
-  //          if (llvm::sys::fs::exists(BackDeployLib)) {
-  //            Arguments.push_back("-force_load");
-  //            Arguments.push_back(context.Args.MakeArgString(BackDeployLib));
-  //          }
-  //        }
-  //    }
+    if targetTriple.isMacOSX {
+      let macOSVersion = targetTriple.version(for: .macOS)
+      switch (macOSVersion.major, macOSVersion.minor, macOSVersion.micro) {
+      case (10, ...14, _):
+        return (5, 0)
+      case (10, ...15, ...3):
+        return (5, 1)
+      case (10, ...15, _):
+        return (5, 2)
+      default:
+        break
+      }
+    } else if targetTriple.isiOS { // includes tvOS
+      let iOSVersion = targetTriple.version(for: .iOS(.device))
+      switch (iOSVersion.major, iOSVersion.minor, iOSVersion.micro) {
+      case (...12, _, _):
+        return (5, 0)
+      case (13, ...3, _):
+        return (5, 1)
+      case (13, _, _):
+        return (5, 2)
+      default:
+        break
+      }
+    } else if targetTriple.isWatchOS {
+      let watchOSVersion = targetTriple.version(for: .watchOS(.device))
+      switch (watchOSVersion.major, watchOSVersion.minor, watchOSVersion.micro) {
+      case (...5, _, _):
+        return (5, 0)
+      case (6, ...1, _):
+        return (5, 1)
+      case (6, _, _):
+        return (5, 2)
+      default:
+        break
+      }
+    }
+    return nil
+  }
 
-      // Add the runtime library link path, which is platform-specific and found
-      // relative to the compiler.
-      let runtimePaths = try runtimeLibraryPaths(
-        for: targetTriple,
-        parsedOptions: &parsedOptions,
-        sdkPath: sdkPath,
-        isShared: true
-      )
-      for path in runtimePaths {
-        commandLine.appendFlag(.L)
-        commandLine.appendPath(path)
+  func addArgsToLinkStdlib(
+    to commandLine: inout [Job.ArgTemplate],
+    parsedOptions: inout ParsedOptions,
+    sdkPath: String?,
+    targetTriple: Triple,
+    linkerOutputType: LinkOutputType,
+    fileSystem: FileSystem
+  ) throws {
+    // Link compatibility libraries, if we're deploying back to OSes that
+    // have an older Swift runtime.
+    var runtimeCompatibilityVersion: (Int, Int)? = nil
+    let resourceDirPath = try computeResourceDirPath(for: targetTriple,
+                                                     parsedOptions: &parsedOptions,
+                                                     isShared: true)
+    if let version = parsedOptions.getLastArgument(.runtimeCompatibilityVersion)?.asSingle {
+      switch version {
+      case "5.0":
+        runtimeCompatibilityVersion = (5, 0)
+      case "5.1":
+        runtimeCompatibilityVersion = (5, 1)
+      case "none":
+        runtimeCompatibilityVersion = nil
+      default:
+        // TODO: diagnose unknown runtime compatibility version?
+        break
       }
+    } else if linkerOutputType == .executable {
+      runtimeCompatibilityVersion = getSwiftRuntimeCompatibilityVersion(for: targetTriple)
+    }
 
-      let rpaths = StdlibRpathRule(
-        parsedOptions: &parsedOptions,
-        targetTriple: targetTriple
-      )
-      for path in rpaths.paths(runtimeLibraryPaths: runtimePaths) {
-        commandLine.appendFlag("-rpath")
-        commandLine.appendPath(path)
+    func addArgsForBackDeployLib(_ libName: String) {
+      let backDeployLibPath = resourceDirPath.appending(component: libName)
+      if fileSystem.exists(backDeployLibPath) {
+        commandLine.append(.flag("-force_load"))
+        commandLine.appendPath(backDeployLibPath)
       }
     }
 
+    if let compatibilityVersion = runtimeCompatibilityVersion {
+      if compatibilityVersion <= (5, 0) {
+        // Swift 5.0 compatibility library
+        addArgsForBackDeployLib("libswiftCompatibility50.a")
+      }
+
+      if compatibilityVersion <= (5, 1) {
+        // Swift 5.1 compatibility library
+        addArgsForBackDeployLib("libswiftCompatibility51.a")
+      }
+
+      if linkerOutputType == .executable && compatibilityVersion <= (5, 0) {
+        // Swift 5.0 dynamic replacement compatibility library.
+        addArgsForBackDeployLib("libswiftCompatibilityDynamicReplacements.a")
+      }
+    }
+
+    // Add the runtime library link path, which is platform-specific and found
+    // relative to the compiler.
+    let runtimePaths = try runtimeLibraryPaths(
+      for: targetTriple,
+      parsedOptions: &parsedOptions,
+      sdkPath: sdkPath,
+      isShared: true
+    )
+    for path in runtimePaths {
+      commandLine.appendFlag(.L)
+      commandLine.appendPath(path)
+    }
+
+    let rpaths = StdlibRpathRule(
+      parsedOptions: &parsedOptions,
+      targetTriple: targetTriple
+    )
+    for path in rpaths.paths(runtimeLibraryPaths: runtimePaths) {
+      commandLine.appendFlag("-rpath")
+      commandLine.appendPath(path)
+    }
+  }
+
   /// Represents the rpaths we need to add in order to find the
   /// desired standard library at runtime.
   fileprivate enum StdlibRpathRule {
@@ -221,7 +265,7 @@ extension DarwinToolchain {
         positive: .toolchainStdlibRpath,
         negative: .noToolchainStdlibRpath,
         default: false
-      ) {
+        ) {
         // If the user has explicitly asked for a toolchain stdlib, we should
         // provide one using -rpath. This used to be the default behaviour but it
         // was considered annoying in at least the SwiftPM scenario (see
@@ -232,7 +276,7 @@ extension DarwinToolchain {
         self = .toolchain
       }
       else if targetTriple.supports(.swiftInTheOS) ||
-          parsedOptions.hasArgument(.noStdlibRpath) {
+        parsedOptions.hasArgument(.noStdlibRpath) {
         // If targeting an OS with Swift in /usr/lib/swift, the LC_ID_DYLIB
         // install_name the stdlib will be an absolute path like
         // /usr/lib/swift/libswiftCore.dylib, and we do not need to provide an rpath
diff --git a/Tests/SwiftDriverTests/SwiftDriverTests.swift b/Tests/SwiftDriverTests/SwiftDriverTests.swift
@@ -903,6 +903,110 @@ final class SwiftDriverTests: XCTestCase {
     #endif
   }
 
+  func testCompatibilityLibs() throws {
+    var env = ProcessEnv.vars
+    env["SWIFT_DRIVER_TESTS_ENABLE_EXEC_PATH_FALLBACK"] = "1"
+    try withTemporaryDirectory { path in
+      let path5_0Mac = path.appending(components: "macosx", "libswiftCompatibility50.a")
+      let path5_1Mac = path.appending(components: "macosx", "libswiftCompatibility51.a")
+      let pathDynamicReplacementsMac = path.appending(components: "macosx", "libswiftCompatibilityDynamicReplacements.a")
+      let path5_0iOS = path.appending(components: "iphoneos", "libswiftCompatibility50.a")
+      let path5_1iOS = path.appending(components: "iphoneos", "libswiftCompatibility51.a")
+      let pathDynamicReplacementsiOS = path.appending(components: "iphoneos", "libswiftCompatibilityDynamicReplacements.a")
+
+      for compatibilityLibPath in [path5_0Mac, path5_1Mac,
+                                   pathDynamicReplacementsMac, path5_0iOS,
+                                   path5_1iOS, pathDynamicReplacementsiOS] {
+        try localFileSystem.writeFileContents(compatibilityLibPath) { $0 <<< "Empty" }
+      }
+      let commonArgs = ["swiftc", "foo.swift", "bar.swift",  "-module-name", "Test", "-resource-dir", path.pathString]
+
+      do {
+        var driver = try Driver(args: commonArgs + ["-target", "x86_64-apple-macosx10.14"], env: env)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(3, plannedJobs.count)
+        let linkJob = plannedJobs[2]
+        XCTAssertEqual(linkJob.kind, .link)
+        let cmd = linkJob.commandLine
+
+        XCTAssertTrue(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(path5_0Mac))]))
+        XCTAssertTrue(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(path5_1Mac))]))
+        XCTAssertTrue(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(pathDynamicReplacementsMac))]))
+      }
+
+      do {
+        var driver = try Driver(args: commonArgs + ["-target", "x86_64-apple-macosx10.15.1"], env: env)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(3, plannedJobs.count)
+        let linkJob = plannedJobs[2]
+        XCTAssertEqual(linkJob.kind, .link)
+        let cmd = linkJob.commandLine
+
+        XCTAssertFalse(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(path5_0Mac))]))
+        XCTAssertTrue(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(path5_1Mac))]))
+        XCTAssertFalse(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(pathDynamicReplacementsMac))]))
+      }
+
+      do {
+        var driver = try Driver(args: commonArgs + ["-target", "x86_64-apple-macosx10.15.4"], env: env)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(3, plannedJobs.count)
+        let linkJob = plannedJobs[2]
+        XCTAssertEqual(linkJob.kind, .link)
+        let cmd = linkJob.commandLine
+
+        XCTAssertFalse(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(path5_0Mac))]))
+        XCTAssertFalse(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(path5_1Mac))]))
+        XCTAssertFalse(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(pathDynamicReplacementsMac))]))
+      }
+
+      do {
+        var driver = try Driver(args: commonArgs + ["-target", "x86_64-apple-macosx10.15.4", "-runtime-compatibility-version", "5.0"], env: env)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(3, plannedJobs.count)
+        let linkJob = plannedJobs[2]
+        XCTAssertEqual(linkJob.kind, .link)
+        let cmd = linkJob.commandLine
+
+        XCTAssertTrue(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(path5_0Mac))]))
+        XCTAssertTrue(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(path5_1Mac))]))
+        XCTAssertTrue(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(pathDynamicReplacementsMac))]))
+      }
+
+      do {
+        var driver = try Driver(args: commonArgs + ["-target", "arm64-apple-ios13.0"], env: env)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(3, plannedJobs.count)
+        let linkJob = plannedJobs[2]
+        XCTAssertEqual(linkJob.kind, .link)
+        let cmd = linkJob.commandLine
+
+        XCTAssertFalse(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(path5_0iOS))]))
+        XCTAssertTrue(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(path5_1iOS))]))
+        XCTAssertFalse(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(pathDynamicReplacementsiOS))]))
+      }
+
+      do {
+        var driver = try Driver(args: commonArgs + ["-target", "arm64-apple-ios12.0"], env: env)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(3, plannedJobs.count)
+        let linkJob = plannedJobs[2]
+        XCTAssertEqual(linkJob.kind, .link)
+        let cmd = linkJob.commandLine
+
+        XCTAssertTrue(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(path5_0iOS))]))
+        XCTAssertTrue(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(path5_1iOS))]))
+        XCTAssertTrue(cmd.contains(subsequence: [.flag("-force_load"), .path(.absolute(pathDynamicReplacementsiOS))]))
+      }
+    }
+  }
+
   func testSanitizerArgs() throws {
   // FIXME: This doesn't work on Linux.
   #if os(macOS)
