Update logic to find 'linker' executable.

* Update the logic to not use the running platform
  but rather use the commonly named ld.<ALTERNATE_LINKER>
  filename.
* Add a large comment with the various linker filenames
    for reference.
* Change the tests to locate the given linker first as linkers
  may or may not be present on host.
* Change the linker test properties to not throw but rather
  return an optional.

Author: kcieplak

Sources/SWBCore/Specs/Tools/LinkerTools.swift

@@ -1274,17 +1274,44 @@ public final class LdLinkerSpec : GenericLinkerSpec, SpecIdentifierType, @unchec
 
     override public func discoveredCommandLineToolSpecInfo(_ producer: any CommandProducer, _ scope: MacroEvaluationScope, _ delegate: any CoreClientTargetDiagnosticProducingDelegate) async -> (any DiscoveredCommandLineToolSpecInfo)? {
         let alternateLinker = scope.evaluate(BuiltinMacros.ALTERNATE_LINKER)
-
         // The ALTERNATE_LINKER is the 'name' of the linker not the executable name, clang will find the linker binary based on name passed via -fuse-ld, but we need to discover
-        // its properties by executing the actual binary. On unix based oses the linkers are installed as ld.<name> on windows its <name>.exe
+        // its properties by executing the actual binary. There is a common filename when the linker is not "ld" across all platforms using "ld.<ALTERNAME_LINKER>(.exe)"
+        // macOS (Xcode SDK)
+        // -----------------
+        // ld
+        // ld-classic
+        //
+        // macOS (Open Source)
+        // -----------
+        // ld.lld -> lld
+        // ld64.lld -> lld
+        // lld
+        // lld-link -> lld
+        //
+        // Linux
+        // ------
+        // /usr/bin/ld -> aarch64-linux-gnu-ld
+        // /usr/bin/ld.bfd -> aarch64-linux-gnu-ld.bfd
+        // /usr/bin/ld.gold -> aarch64-linux-gnu-ld.gold
+        // /usr/bin/ld.lld -> lld
+        // /usr/bin/ld64.lld -> lld
+        // /usr/bin/lld
+        // /usr/bin/lld-link -> lld
+        // /usr/bin/gold -> aarch64-linux-gnu-gold
+        //
+        // Windows
+        // -------
+        // ld.lld.exe
+        // ld64.lld.exe
+        // lld-link.exe
+        // lld.exe
+        // link.exe //In Visual Studio
+        //
+        // Note: On Linux you cannot invoke the llvm linker by the direct name for determining the version,
+        // you need to use ld.<ALTERNATE_LINKER>
         var linkerPath = Path("ld")
-        if alternateLinker != "" {
-            linkerPath =
-                switch producer.hostOperatingSystem {
-                        case .linux: Path("ld.\(alternateLinker)")
-                        case .windows: Path("\(alternateLinker).exe")
-                        default : Path("\(alternateLinker)")
-                }
+        if alternateLinker != "" && alternateLinker != "ld" {
+            linkerPath = Path(producer.hostOperatingSystem.imageFormat.executableName(basename: "ld.\(alternateLinker)"))
         }
         // Create the cache key.  This is just the path to the linker we would invoke if we were invoking the linker directly.
         guard let toolPath = producer.executableSearchPaths.lookup(linkerPath) else {

Sources/SWBTestSupport/CoreBasedTests.swift

@@ -258,31 +258,32 @@ extension CoreBasedTests {
     }
 
     // Linkers
-    package var ldPath: Path {
+    package var ldPath: Path? {
         get async throws {
             let (core, defaultToolchain) = try await coreAndToolchain()
-            return try #require(defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld"), "couldn't find ld in default toolchain")
+            return defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld")
         }
     }
-    package var linkPath: Path {
+    package var linkPath: Path? {
         get async throws {
             let (core, defaultToolchain) = try await coreAndToolchain()
-            return try #require(defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "link"), "couldn't find link in default toolchain")
+            if core.hostOperatingSystem != .windows {
+                // Most unixes have a link executable, but that is not a linker
+                return nil
+            }
+            return defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "link")
         }
     }
-    package var lldPath: Path {
+    package var lldPath: Path? {
         get async throws {
             let (core, defaultToolchain) = try await coreAndToolchain()
-            return try #require(
-                defaultToolchain.executableSearchPaths.findExecutable(
-                    operatingSystem: core.hostOperatingSystem,
-                    basename: core.hostOperatingSystem == .windows ? "lld-link" : "ld.lld"), "couldn't find ld.ldd in default toolchain")
+            return defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld.lld")
         }
     }
-    package var goldPath: Path {
+    package var goldPath: Path? {
         get async throws {
             let (core, defaultToolchain) = try await coreAndToolchain()
-            return try #require(defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld.gold"), "couldn't find ld.gold in default toolchain")
+            return defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld.gold")
         }
     }
 }

Tests/SWBBuildSystemTests/LinkerTests.swift

@@ -198,7 +198,7 @@ fileprivate struct LinkerTests: CoreBasedTests {
                         type: .commandLineTool,
                         buildPhases: [
                             TestSourcesBuildPhase(["main.swift"]),
-                            TestFrameworksBuildPhase([TestBuildFile(.target("Library"))])
+                            TestFrameworksBuildPhase([TestBuildFile(.target("Library"))]),
                         ],
                         dependencies: ["Library"]
                     ),
@@ -216,35 +216,45 @@ fileprivate struct LinkerTests: CoreBasedTests {
             let projectDir = tester.workspace.projects[0].sourceRoot
             try await tester.fs.writeFileContents(projectDir.join("main.swift")) { stream in
                 stream <<< """
-                import Library
+                    import Library
 
-                hello()
-                """
+                    hello()
+                    """
             }
             try await tester.fs.writeFileContents(projectDir.join("library.swift")) { stream in
                 stream <<< """
-                public func hello() {
-                    print(\"Hello World\")
-                }
-                """
+                    public func hello() {
+                        print(\"Hello World\")
+                    }
+                    """
+            }
+
+            // Try to find the installed linkers
+            let ldLinkerPath = try await self.ldPath
+            let lldLinkerPath = try await self.lldPath
+            let goldLinkerPath = try await self.goldPath
+            var linkLinkerPath = try await self.linkPath
+            if runDestination == .windows {
+                // Issue: Finding link.exe will fail until https://github.com/swiftlang/swift-build/pull/163 is merged. Clang will find it via PATH.
+                linkLinkerPath = Path("link.exe")
             }
+            let installedLinkerPaths = [lldLinkerPath, ldLinkerPath, goldLinkerPath, linkLinkerPath].compactMap { $0 }
 
             // Default Linker
-            var parameters = BuildParameters(configuration: "Debug")
-            let defaultLinker = try await runDestination == .windows ? self.lldPath : self.ldPath
+            var parameters = BuildParameters(configuration: "Debug", overrides: ["ALTERNATE_LINKER": ""])
             try await tester.checkBuild(parameters: parameters, runDestination: .host) { results in
                 results.checkTask(.matchRuleType("Ld")) { task in
                     results.checkTaskOutput(task) { taskOutput in
                         results.checkTaskOutput(task) { output in
-                            // Expect that the default linker is called by clang
-                            #expect(output.asString.contains(anyOf: defaultLinker.str))
+                            // Expect that one of the installed linkers is used, we are not sure which one.
+                            #expect(installedLinkerPaths.map { $0.str }.contains(where: output.asString.contains))
                         }
                     }
                 }
                 if runDestination == .windows {
                     // Issue: Linker cannot find dependent library
                     results.checkError(.contains("Linker command failed with exit code 1"))
-                    results.checkError(.contains("lld-link: error: could not open 'Library.lib'"))
+                    results.checkError(.contains("LNK1181: cannot open input file 'Library.lib'"))
                 }
                 results.checkNoDiagnostics()
             }
@@ -256,19 +266,17 @@ fileprivate struct LinkerTests: CoreBasedTests {
                     results.checkError(.contains("Invalid linker name in argument '-fuse-ld=not-a-linker'"))
                     results.checkError(.contains("invalid linker name in argument '-fuse-ld=not-a-linker'"))
                 } else {
-                    //Windows 'clang' does not check the linker in passed in via -fuse-ld and simply tries to execute it verbatim.
+                    // Windows 'clang' does not check the linker in passed in via -fuse-ld and simply tries to execute it verbatim.
                     results.checkError(.contains("Unable to execute command: program not executable"))
                     results.checkError(.contains("unable to execute command: program not executable"))
                     results.checkError(.contains("Linker command failed with exit code 1"))
                 }
                 results.checkNoDiagnostics()
             }
 
-
             // lld - llvm linker
-            if runDestination != .macOS {
-                parameters = BuildParameters(configuration: "Debug", overrides: ["ALTERNATE_LINKER": runDestination == .windows ? "lld-link": "lld"])
-                let linkerPath = try await self.lldPath
+            if let lldLinkerPath {
+                parameters = BuildParameters(configuration: "Debug", overrides: ["ALTERNATE_LINKER": "lld"])
                 try await tester.checkBuild(parameters: parameters, runDestination: .host) { results in
                     if runDestination == .windows {
                         // Issue: Linker cannot find dependent library
@@ -277,46 +285,46 @@ fileprivate struct LinkerTests: CoreBasedTests {
                     }
 
                     results.checkTask(.matchRuleType("Ld")) { task in
-                    task.checkCommandLineContains(["-fuse-ld=\(runDestination == .windows ? "lld-link" : "lld")"])
+                        task.checkCommandLineContains(["-fuse-ld=lld"])
                         results.checkTaskOutput(task) { output in
-                            //Expect that the default linker is called by clang
-                            #expect(output.asString.contains(anyOf: linkerPath.str))
+                            // Expect that the default linker is called by clang
+                            if runDestination == .windows {
+                                // clang will choose to run lld-link rather than ld.lld.exe.
+                                // clang output will have escaped slashes in stdout.
+                                #expect(output.asString.replacingOccurrences(of: "\\\\", with: "\\").contains(lldLinkerPath.dirname.join("lld-link").str))
+                            } else {
+                                #expect(output.asString.contains(lldLinkerPath.str))
+                            }
                         }
                     }
                     results.checkNoDiagnostics()
                 }
             }
 
             // gold
-            if runDestination == .linux {
+            if let goldLinkerPath {
                 parameters = BuildParameters(configuration: "Debug", overrides: ["ALTERNATE_LINKER": "gold"])
-                let linkerPath = try await self.goldPath
                 try await tester.checkBuild(parameters: parameters, runDestination: .host) { results in
                     results.checkTask(.matchRuleType("Ld")) { task in
-                    task.checkCommandLineContains(["-fuse-ld=gold"])
+                        task.checkCommandLineContains(["-fuse-ld=gold"])
                         results.checkTaskOutput(task) { output in
-                            //Expect that the default linker is called by clang
-                            #expect(output.asString.contains(anyOf: linkerPath.str))
+                            // Expect that the default linker is called by clang
+                            #expect(output.asString.contains(goldLinkerPath.str))
                         }
                     }
                     results.checkNoDiagnostics()
                 }
             }
 
             // link.exe
-            if runDestination == .windows {
+            if let linkLinkerPath {
                 parameters = BuildParameters(configuration: "Debug", overrides: ["ALTERNATE_LINKER": "link"])
-                // Issue: Finding link.exe will fail until https://github.com/swiftlang/swift-build/pull/163 is merged
-                // clang will find it via PATH.
-                // linkerPath = try await self.linkPath
-                let linkerPath = Path("link.exe")
-
                 try await tester.checkBuild(parameters: parameters, runDestination: .host) { results in
                     results.checkTask(.matchRuleType("Ld")) { task in
-                    task.checkCommandLineContains(["-fuse-ld=link"])
+                        task.checkCommandLineContains(["-fuse-ld=link"])
                         results.checkTaskOutput(task) { output in
-                            //Expect that the default linker is called by clang
-                            #expect(output.asString.contains(anyOf: linkerPath.str))
+                            // Expect that the default linker is called by clang
+                            #expect(output.asString.contains(linkLinkerPath.str))
                         }
                     }
                     //Issue: Linker cannot find dependent library