Switch to using clang as linker on darwin

keith · DougGregor · commit a557d591d7a2 · 2022-07-20T12:24:25.000-07:00
This allows us to remove lots of duplicated logic from the clang driver.
diff --git a/Sources/SwiftDriver/Jobs/DarwinToolchain+LinkerSupport.swift b/Sources/SwiftDriver/Jobs/DarwinToolchain+LinkerSupport.swift
@@ -47,153 +47,6 @@ extension DarwinToolchain {
     return try findXcodeClangLibPath("arc")
   }
 
-  internal func addLTOLibArgs(to commandLine: inout [Job.ArgTemplate]) throws {
-    if let path = try findXcodeClangLibPath("libLTO.dylib") {
-      commandLine.appendFlag("-lto_library")
-      commandLine.appendPath(path)
-    }
-  }
-
-  func addLinkRuntimeLibraryRPath(
-    to commandLine: inout [Job.ArgTemplate],
-    parsedOptions: inout ParsedOptions,
-    targetInfo: FrontendTargetInfo,
-    darwinLibName: String
-  ) throws {
-    // Adding the rpaths might negatively interact when other rpaths are involved,
-    // so we should make sure we add the rpaths last, after all user-specified
-    // rpaths. This is currently true from this place, but we need to be
-    // careful if this function is ever called before user's rpaths are emitted.
-    assert(darwinLibName.hasSuffix(".dylib"), "must be a dynamic library")
-
-    // Add @executable_path to rpath to support having the dylib copied with
-    // the executable.
-    commandLine.appendFlag("-rpath")
-    commandLine.appendFlag("@executable_path")
-
-    // Add the path to the resource dir to rpath to support using the dylib
-    // from the default location without copying.
-
-
-    let clangPath = try clangLibraryPath(
-      for: targetInfo,
-      parsedOptions: &parsedOptions)
-    commandLine.appendFlag("-rpath")
-    commandLine.appendPath(clangPath)
-  }
-
-  func addLinkSanitizerLibArgsForDarwin(
-    to commandLine: inout [Job.ArgTemplate],
-    parsedOptions: inout ParsedOptions,
-    targetInfo: FrontendTargetInfo,
-    sanitizer: Sanitizer,
-    isShared: Bool
-  ) throws {
-    // Sanitizer runtime libraries requires C++.
-    commandLine.appendFlag("-lc++")
-    // Add explicit dependency on -lc++abi, as -lc++ doesn't re-export
-    // all RTTI-related symbols that are used.
-    commandLine.appendFlag("-lc++abi")
-
-    let sanitizerName = try runtimeLibraryName(
-      for: sanitizer,
-      targetTriple: targetInfo.target.triple,
-      isShared: isShared
-    )
-    try addLinkRuntimeLibrary(
-      named: sanitizerName,
-      to: &commandLine,
-      for: targetInfo,
-      parsedOptions: &parsedOptions
-    )
-
-    if isShared {
-      try addLinkRuntimeLibraryRPath(
-        to: &commandLine,
-        parsedOptions: &parsedOptions,
-        targetInfo: targetInfo,
-        darwinLibName: sanitizerName
-      )
-    }
-  }
-
-  private func addProfileGenerationArgs(
-    to commandLine: inout [Job.ArgTemplate],
-    parsedOptions: inout ParsedOptions,
-    targetInfo: FrontendTargetInfo
-  ) throws {
-    guard parsedOptions.hasArgument(.profileGenerate) else { return }
-    let clangPath = try clangLibraryPath(for: targetInfo,
-                                         parsedOptions: &parsedOptions)
-
-    for runtime in targetInfo.target.triple.darwinPlatform!.profileLibraryNameSuffixes {
-      let clangRTPath = clangPath
-        .appending(component: "libclang_rt.profile_\(runtime).a")
-      commandLine.appendPath(clangRTPath)
-    }
-  }
-
-  private func addPlatformVersionArg(to commandLine: inout [Job.ArgTemplate],
-                                     for triple: Triple, sdkPath: VirtualPath.Handle?) {
-    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?,
-    sdkPath: VirtualPath.Handle?
-  ) {
-    addPlatformVersionArg(to: &commandLine, for: targetTriple, sdkPath: sdkPath)
-    if let variantTriple = targetVariantTriple {
-      assert(targetTriple.isValidForZipperingWithTriple(variantTriple))
-      addPlatformVersionArg(to: &commandLine, for: variantTriple,
-                            sdkPath: sdkPath)
-    }
-  }
-
-  private func addArgsToLinkARCLite(
-    to commandLine: inout [Job.ArgTemplate],
-    parsedOptions: inout ParsedOptions,
-    targetTriple: Triple
-  ) throws {
-    guard parsedOptions.hasFlag(
-      positive: .linkObjcRuntime,
-      negative: .noLinkObjcRuntime,
-      default: !targetTriple.supports(.nativeARC)
-    ) else {
-      return
-    }
-
-    guard let arcLiteLibPath = try findARCLiteLibPath(),
-      let platformName = targetTriple.platformName() else {
-        return
-    }
-    let fullLibPath = arcLiteLibPath
-      .appending(components: "libarclite_\(platformName).a")
-
-    commandLine.appendFlag("-force_load")
-    commandLine.appendPath(fullLibPath)
-
-    // Arclite depends on CoreFoundation.
-    commandLine.appendFlag(.framework)
-    commandLine.appendFlag("CoreFoundation")
-  }
-
   /// Adds the arguments necessary to link the files from the given set of
   /// options for a Darwin platform.
   public func addPlatformSpecificLinkerArgs(
@@ -213,7 +66,7 @@ extension DarwinToolchain {
     case .dynamicLibrary:
       // Same as an executable, but with the -dylib flag
       linkerTool = .dynamicLinker
-      commandLine.appendFlag("-dylib")
+      commandLine.appendFlag("-dynamiclib")
       addLinkInputs(shouldUseInputFileList: shouldUseInputFileList,
                     commandLine: &commandLine,
                     inputs: inputs,
@@ -280,8 +133,7 @@ extension DarwinToolchain {
       commandLine.appendPath(fileList)
       if linkerOutputType != .staticLibrary {
         for module in inputModules {
-          commandLine.append(.flag("-add_ast_path"))
-          commandLine.append(.path(module))
+          commandLine.append(.joinedOptionAndPath("-Wl,-add_ast_path,", module))
         }
       }
 
@@ -291,7 +143,7 @@ extension DarwinToolchain {
       commandLine.append(contentsOf: inputs.flatMap {
         (path: TypedVirtualPath) -> [Job.ArgTemplate] in
         if path.type == .swiftModule && linkerOutputType != .staticLibrary {
-          return [.flag("-add_ast_path"), .path(path.file)]
+          return [.joinedOptionAndPath("-Wl,-add_ast_path,", path.file)]
         } else if path.type == .object {
           return [.path(path.file)]
         } else if path.type == .tbd {
@@ -311,39 +163,16 @@ extension DarwinToolchain {
                                      sanitizers: Set<Sanitizer>,
                                      linkerOutputType: LinkOutputType,
                                      lto: LTOKind?) throws {
-    // FIXME: If we used Clang as a linker instead of going straight to ld,
-    // we wouldn't have to replicate a bunch of Clang's logic here.
-
-    // Always link the regular compiler_rt if it's present. Note that the
-    // regular libclang_rt.a uses a fat binary for device and simulator; this is
-    // not true for all compiler_rt build products.
-    //
-    // Note: Normally we'd just add this unconditionally, but it's valid to build
-    // Swift and use it as a linker without building compiler_rt.
-    let targetTriple = targetInfo.target.triple
-    let darwinPlatformSuffix =
-      targetTriple.darwinPlatform!.with(.device)!.libraryNameSuffix
-    let compilerRTPath =
-      try clangLibraryPath(
-        for: targetInfo,
-        parsedOptions: &parsedOptions)
-      .appending(component: "libclang_rt.\(darwinPlatformSuffix).a")
-    if try fileSystem.exists(compilerRTPath) {
-      commandLine.append(.path(compilerRTPath))
-    }
-
-    try addArgsToLinkARCLite(
-      to: &commandLine,
-      parsedOptions: &parsedOptions,
-      targetTriple: targetTriple
-    )
+    if let lto = lto {
+      switch lto {
+      case .llvmFull:
+        commandLine.appendFlag("-flto=full")
+      case .llvmThin:
+        commandLine.appendFlag("-flto=thin")
+      }
 
-    if lto != nil {
       if let arg = parsedOptions.getLastArgument(.ltoLibrary)?.asSingle {
-        commandLine.appendFlag("-lto_library")
-        commandLine.appendPath(try VirtualPath(path: arg))
-      } else {
-        try addLTOLibArgs(to: &commandLine)
+        commandLine.append(.joinedOptionAndPath("-Wl,-lto_library,", try VirtualPath(path: arg)))
       }
     }
 
@@ -354,43 +183,44 @@ extension DarwinToolchain {
     }
 
     if parsedOptions.contains(.enableAppExtension) {
-      commandLine.appendFlag("-application_extension")
+      commandLine.appendFlag("-fapplication-extension")
     }
 
     // Linking sanitizers will add rpaths, which might negatively interact when
     // other rpaths are involved, so we should make sure we add the rpaths after
     // all user-specified rpaths.
-    for sanitizer in sanitizers {
-      if sanitizer == .fuzzer {
-        guard linkerOutputType == .executable else { continue }
-      }
-      try addLinkSanitizerLibArgsForDarwin(
-        to: &commandLine,
-        parsedOptions: &parsedOptions,
-        targetInfo: targetInfo,
-        sanitizer: sanitizer,
-        isShared: sanitizer != .fuzzer
-      )
+    if linkerOutputType == .executable && !sanitizers.isEmpty {
+      let sanitizerNames = sanitizers
+        .map { $0.rawValue }
+        .sorted() // Sort so we get a stable, testable order
+        .joined(separator: ",")
+      commandLine.appendFlag("-fsanitize=\(sanitizerNames)")
     }
 
-    if parsedOptions.contains(.embedBitcode) ||
-        parsedOptions.contains(.embedBitcodeMarker) {
-      commandLine.appendFlag("-bitcode_bundle")
+    if parsedOptions.contains(.embedBitcode) {
+      commandLine.appendFlag("-fembed-bitcode")
+    } else if parsedOptions.contains(.embedBitcodeMarker) {
+      commandLine.appendFlag("-fembed-bitcode=marker")
     }
 
     // Add the SDK path
     if let sdkPath = targetInfo.sdkPath?.path {
-      commandLine.appendFlag("-syslibroot")
+      commandLine.appendFlag("--sysroot")
       commandLine.appendPath(VirtualPath.lookup(sdkPath))
     }
 
     commandLine.appendFlags(
+      "-fobjc-link-runtime",
       "-lobjc",
       "-lSystem"
     )
 
-    commandLine.appendFlag("-arch")
-    commandLine.appendFlag(targetTriple.archName)
+    let targetTriple = targetInfo.target.triple
+    commandLine.appendFlag("--target=\(targetTriple.triple)")
+    if let variantTriple = targetInfo.targetVariant?.triple {
+      assert(targetTriple.isValidForZipperingWithTriple(variantTriple))
+      commandLine.appendFlag("-darwin-target-variant=\(variantTriple.triple)")
+    }
 
     // On Darwin, we only support libc++.
     if parsedOptions.contains(.enableExperimentalCxxInterop) {
@@ -405,19 +235,9 @@ extension DarwinToolchain {
       fileSystem: fileSystem
     )
 
-    try addProfileGenerationArgs(
-      to: &commandLine,
-      parsedOptions: &parsedOptions,
-      targetInfo: targetInfo
-    )
-
-    let targetVariantTriple = targetInfo.targetVariant?.triple
-    addDeploymentTargetArgs(
-      to: &commandLine,
-      targetTriple: targetTriple,
-      targetVariantTriple: targetVariantTriple,
-      sdkPath: targetInfo.sdkPath?.path
-    )
+    if parsedOptions.hasArgument(.profileGenerate) {
+      commandLine.appendFlag("-fprofile-generate")
+    }
 
     // These custom arguments should be right before the object file at the
     // end.
@@ -427,7 +247,13 @@ extension DarwinToolchain {
       from: &parsedOptions
     )
     addLinkedLibArgs(to: &commandLine, parsedOptions: &parsedOptions)
-    try commandLine.appendAllArguments(.Xlinker, from: &parsedOptions)
+    // Because we invoke `clang` as the linker executable, we must still
+    // use `-Xlinker` for linker-specific arguments.
+    for linkerOpt in parsedOptions.arguments(for: .Xlinker) {
+      commandLine.appendFlag(.Xlinker)
+      commandLine.appendFlag(linkerOpt.argument.asSingle)
+    }
+    try commandLine.appendAllArguments(.XclangLinker, from: &parsedOptions)
   }
 }
 
diff --git a/Sources/SwiftDriver/Jobs/Toolchain+LinkerSupport.swift b/Sources/SwiftDriver/Jobs/Toolchain+LinkerSupport.swift
@@ -56,19 +56,6 @@ extension Toolchain {
     return result
   }
 
-  func addLinkRuntimeLibrary(
-    named name: String,
-    to commandLine: inout [Job.ArgTemplate],
-    for targetInfo: FrontendTargetInfo,
-    parsedOptions: inout ParsedOptions
-  ) throws {
-    let path = try clangLibraryPath(
-      for: targetInfo,
-      parsedOptions: &parsedOptions)
-      .appending(component: name)
-    commandLine.appendPath(path)
-  }
-
   func runtimeLibraryExists(
     for sanitizer: Sanitizer,
     targetInfo: FrontendTargetInfo,
diff --git a/Sources/SwiftDriver/Toolchains/DarwinToolchain.swift b/Sources/SwiftDriver/Toolchains/DarwinToolchain.swift
@@ -64,7 +64,7 @@ public final class DarwinToolchain: Toolchain {
     case .swiftCompiler:
       return try lookup(executable: "swift-frontend")
     case .dynamicLinker:
-      return try lookup(executable: "ld")
+      return try lookup(executable: "clang")
     case .staticLinker:
       return try lookup(executable: "libtool")
     case .dsymutil:
diff --git a/Tests/SwiftDriverTests/JobExecutorTests.swift b/Tests/SwiftDriverTests/JobExecutorTests.swift
@@ -179,11 +179,11 @@ final class JobExecutorTests: XCTestCase {
           .path(.temporary(RelativePath("foo.o"))),
           .path(.temporary(RelativePath("main.o"))),
           .path(.absolute(try toolchain.clangRT.get())),
-          "-syslibroot", .path(.absolute(try toolchain.sdk.get())),
-          "-lobjc", "-lSystem", "-arch", .flag(hostTriple.archName),
+          "--sysroot", .path(.absolute(try toolchain.sdk.get())),
+          "-lobjc", "-lSystem", .flag("--target=\(hostTriple.triple)"),
           "-L", .path(.absolute(try toolchain.resourcesDirectory.get())),
           "-L", .path(.absolute(try toolchain.sdkStdlib(sdk: toolchain.sdk.get()))),
-          "-rpath", "/usr/lib/swift", "-macosx_version_min", "10.14.0", "-o",
+          "-rpath", "/usr/lib/swift", "-o",
           .path(.relative(RelativePath("main"))),
         ],
         inputs: [
@@ -249,12 +249,10 @@ final class JobExecutorTests: XCTestCase {
         tool: try toolchain.resolvedTool(.dynamicLinker),
         commandLine: [
           .path(.temporary(RelativePath("main.o"))),
-          .path(.absolute(try toolchain.clangRT.get())),
-          "-syslibroot", .path(.absolute(try toolchain.sdk.get())),
-          "-lobjc", "-lSystem", "-arch", .flag(hostTriple.archName),
+          "--sysroot", .path(.absolute(try toolchain.sdk.get())),
+          "-lobjc", "-lSystem", .flag("--target=\(hostTriple.triple)"),
           "-L", .path(.absolute(try toolchain.resourcesDirectory.get())),
           "-L", .path(.absolute(try toolchain.sdkStdlib(sdk: toolchain.sdk.get()))),
-          "-rpath", "/usr/lib/swift", "-macosx_version_min", "10.14.0",
           "-o", .path(.absolute(exec)),
         ],
         inputs: [
diff --git a/Tests/SwiftDriverTests/SwiftDriverTests.swift b/Tests/SwiftDriverTests/SwiftDriverTests.swift
