Make linkers that do not support multiple targets discoverable.

The link.exe cannot link for multiple architectures there
is a distinct link.exe for arm86 and x86_64.

The path to the specific linkers should not be added to the
global search path, as when building a target we do not know
the architecture until task creation time.

* Only add up until the Host[x86|arm]/bin directory to the
  global search path.
* Let the LD spec determine the correct prefix directory
  to find the proper link.exe
* Introduce two build settings
    LD_MULTIARCH - A boolean indicator for multiple architecture support
    LD_MULTIARCH_PREFIX_MAP - A prefix directory map from architecture:prefix
* Add in specfic tests for discoveredLdLinkerSpecInfo for each linkers
* Add x86_64 as a supported architecture for windows. A seperate PR
  is inflight to add the true supported set.

Author: kcieplak

Sources/SWBCore/SDKRegistry.swift

@@ -646,6 +646,14 @@ public final class SDKRegistry: SDKRegistryLookup, CustomStringConvertible, Send
             tripleEnvironment = ""
         }
 
+        let archs: PropertyListItem =
+            switch operatingSystem {
+            case .windows:
+                .plArray([.plString("x86_64"), .plString("aarch64")])
+            default:
+                .plArray([.plString(Architecture.hostStringValue ?? "unknown")])
+            }
+
         return try [
             "Type": .plString("SDK"),
             "Version": .plString(Version(ProcessInfo.processInfo.operatingSystemVersion).zeroTrimmed.description),
@@ -656,7 +664,7 @@ public final class SDKRegistry: SDKRegistryLookup, CustomStringConvertible, Send
             ].merging(defaultProperties, uniquingKeysWith: { _, new in new })),
             "SupportedTargets": .plDict([
                 operatingSystem.xcodePlatformName: .plDict([
-                    "Archs": .plArray([.plString(Architecture.hostStringValue ?? "unknown")]),
+                    "Archs": archs,
                     "LLVMTargetTripleEnvironment": .plString(tripleEnvironment),
                     "LLVMTargetTripleSys": .plString(operatingSystem.xcodePlatformName),
                     "LLVMTargetTripleVendor": .plString("unknown"),

Sources/SWBCore/Settings/BuiltinMacros.swift

@@ -803,6 +803,8 @@ public final class BuiltinMacros {
     public static let LD_RUNPATH_SEARCH_PATHS = BuiltinMacros.declareStringListMacro("LD_RUNPATH_SEARCH_PATHS")
     public static let LD_SDK_IMPORTS_FILE = BuiltinMacros.declarePathMacro("LD_SDK_IMPORTS_FILE")
     public static let LD_WARN_UNUSED_DYLIBS = BuiltinMacros.declareBooleanMacro("LD_WARN_UNUSED_DYLIBS")
+    public static let LD_MULTIARCH = BuiltinMacros.declareBooleanMacro("LD_MULTIARCH")
+    public static let LD_MULTIARCH_PREFIX_MAP = BuiltinMacros.declareStringListMacro("LD_MULTIARCH_PREFIX_MAP")
     public static let LEX = BuiltinMacros.declarePathMacro("LEX")
     public static let LEXFLAGS = BuiltinMacros.declareStringListMacro("LEXFLAGS")
     public static let LIBRARIAN = BuiltinMacros.declareStringMacro("LIBRARIAN")
@@ -1858,6 +1860,8 @@ public final class BuiltinMacros {
         LD_RUNPATH_SEARCH_PATHS,
         LD_SDK_IMPORTS_FILE,
         LD_WARN_UNUSED_DYLIBS,
+        LD_MULTIARCH,
+        LD_MULTIARCH_PREFIX_MAP,
         LEGACY_DEVELOPER_DIR,
         LEX,
         LEXFLAGS,

Sources/SWBCore/SpecImplementations/Tools/LinkerTools.swift

@@ -1273,7 +1273,6 @@ 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. There is a common filename when the linker is not "ld" across all platforms using "ld.<ALTERNAME_LINKER>(.exe)"
         // macOS (Xcode SDK)
@@ -1309,9 +1308,43 @@ public final class LdLinkerSpec : GenericLinkerSpec, SpecIdentifierType, @unchec
         //
         // 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 = producer.hostOperatingSystem == .windows ? Path("link") : Path("ld")
-        if alternateLinker != "" && alternateLinker != "ld" {
+        let alternateLinker = scope.evaluate(BuiltinMacros.ALTERNATE_LINKER)
+        let isLinkerMultiarch = scope.evaluate(BuiltinMacros.LD_MULTIARCH)
+
+        var linkerPath = producer.hostOperatingSystem == .windows ? Path("ld.lld") : Path("ld")
+        if alternateLinker != "" && alternateLinker != "ld" && alternateLinker != "link" {
             linkerPath = Path(producer.hostOperatingSystem.imageFormat.executableName(basename: "ld.\(alternateLinker)"))
+        } else if alternateLinker != "" {
+            linkerPath =  Path(alternateLinker)
+        }
+        // If the linker does not support multiple architectures update the path to include a subfolder based on the prefix map
+        // to find the architecture specific executable.
+        if !isLinkerMultiarch {
+            let archMap = scope.evaluate(BuiltinMacros.LD_MULTIARCH_PREFIX_MAP)
+            let archMappings = archMap.reduce(into: [String: String]()) { mappings, map in
+                let split = map.components(separatedBy: ":")
+                if !split.isEmpty {
+                    return mappings[split[0]] = split[1]
+                }
+            }
+            if archMappings.isEmpty {
+                delegate.error("LD_MULTIARCH is 'false', but no prefix mappings are present in LD_MULTIARCH_PREFIX_MAP")
+                return nil
+            }
+            // Linkers that don't support multiple architectures cannot support universal binaries, so ARCHS will
+            // contain the target architecture and can only be a single value.
+            let arch = scope.evaluate(BuiltinMacros.ARCHS)
+            if arch.count > 1 {
+                delegate.error("LD_MULTIARCH is 'false', but multiple ARCHS have been given, this is invalid")
+                return nil
+            }
+            if let prefix = archMappings[arch[0]] {
+                // Add in the target architecture prefix directory to path for search.
+                linkerPath = Path(prefix).join(linkerPath)
+            } else {
+                delegate.error("Could not find prefix mapping for \(arch[0]) in LD_MULTIARCH_PREFIX_MAP")
+                return nil
+            }
         }
         guard let toolPath = producer.executableSearchPaths.findExecutable(operatingSystem: producer.hostOperatingSystem, basename: linkerPath.str) else {
             return nil

Sources/SWBCore/Specs/CoreBuildSystem.xcspec

@@ -1148,6 +1148,11 @@ When `GENERATE_INFOPLIST_FILE` is enabled, sets the value of the [CFBundleIdenti
                 DefaultValue = NO;
                 Category = "Linking - Warnings";
             },
+            {
+                Name = "LD_MULTIARCH";
+                Type = Boolean;
+                DefaultValue = YES;
+            },
             {
                 Name = "LIBRARY_SEARCH_PATHS";
                 Type = PathList;

Sources/SWBCore/Specs/en.lproj/CoreBuildSystem.strings

@@ -423,6 +423,13 @@ You cannot create a PIE from `.o` files compiled with `-mdynamic-no-pic`. Using
 "[LD_WARN_DUPLICATE_LIBRARIES]-name" = "Duplicate Libraries";
 "[LD_WARN_DUPLICATE_LIBRARIES]-description" = "Warn for linking the same library multiple times.";
 
+"[LD_MULTIARCH]-name" = "Multiple Architecture Supporte Linker";
+"[LD_MULTIARCH]-description" = "Linker supports linking multiple target architectures.";
+
+"[LD_MULTIARCH_PREFIX_MAP]-name" = "Linker subfolder architecture map";
+"[LD_MULTIARCH_PREFIX_MAP]-description" = "Mapping of architecture to subfolder. <arch>:<subfolder>";
+
+
 // Localization Settings
 
 "[Localization]-category" = "Localization";

Sources/SWBTestSupport/CoreBasedTests.swift

@@ -272,53 +272,55 @@ extension CoreBasedTests {
             return nil
         }
     }
-    package var linkPath: Path? {
+    package var lldPath: Path? {
         get async throws {
             let (core, defaultToolchain) = try await coreAndToolchain()
-            if core.hostOperatingSystem != .windows {
-                // Most unixes have a link executable, but that is not a linker
-                return nil
-            }
-            if let executable = defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "link") {
+            if let executable = defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld.lld") {
                 return executable
             }
             for platform in core.platformRegistry.platforms {
-                if let executable = platform.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "link") {
+                if let executable = platform.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld.lld") {
                     return executable
                 }
             }
             return nil
         }
     }
-
-    package var lldPath: Path? {
+    package var goldPath: Path? {
         get async throws {
             let (core, defaultToolchain) = try await coreAndToolchain()
-            if let executable = defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld.ld") {
+            if let executable = defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld.gold") {
                 return executable
             }
             for platform in core.platformRegistry.platforms {
-                if let executable = platform.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld.ld") {
+                if let executable = platform.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld.gold") {
                     return executable
                 }
             }
             return nil
         }
     }
+    package func linkPath(_ targetArchitecture: String) async throws -> Path? {
+        let (core, defaultToolchain) = try await self.coreAndToolchain()
+        let prefixMapping = [ "x86_64": "x64", "aarch64": "arm64", "arm64": "arm64" ]
 
-    package var goldPath: Path? {
-        get async throws {
-            let (core, defaultToolchain) = try await coreAndToolchain()
-            if let executable = defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld.gold") {
+        guard let prefix = prefixMapping[targetArchitecture] else {
+            return nil
+        }
+        let linkerPath = Path(prefix).join("link").str
+        if core.hostOperatingSystem != .windows {
+            // Most unixes have a link executable, but that is not a linker
+            return nil
+        }
+        if let executable = defaultToolchain.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: linkerPath) {
+            return executable
+        }
+        for platform in core.platformRegistry.platforms {
+            if let executable = platform.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: linkerPath) {
                 return executable
             }
-            for platform in core.platformRegistry.platforms {
-                if let executable = platform.executableSearchPaths.findExecutable(operatingSystem: core.hostOperatingSystem, basename: "ld.gold") {
-                    return executable
-                }
-            }
-            return nil
         }
+        return nil
     }
 }
 

Sources/SWBWindowsPlatform/Specs/WindowsLd.xcspec

@@ -52,6 +52,18 @@
                 CommandLineFlag = "--sysroot";
                 IsInputDependency = Yes;
             },
+            {
+                Name = LD_MULTIARCH;
+                Type = Boolean;
+                DefaultValue = NO;
+                Condition = "$(ALTERNATE_LINKER) == link";
+            },
+            {
+                Name = LD_MULTIARCH_PREFIX_MAP;
+                Type = StringList;
+                DefaultValue = "x86_64:x64 aarch64:arm64 arm64:arm64";
+                Condition = "$(ALTERNATE_LINKER) == link";
+            },
             {
                 // No such concept
                 Name = LD_DETERMINISTIC_MODE;

Tests/SWBBuildSystemTests/LinkerTests.swift

@@ -42,6 +42,7 @@ fileprivate struct LinkerTests: CoreBasedTests {
                                     "PRODUCT_NAME": "$(TARGET_NAME)",
                                     "SWIFT_VERSION": swiftVersion,
                                     "OTHER_LDFLAGS": "-not-a-real-flag",
+                                    "ARCHS" : "x86_64 aarch64"
                                 ])
                         ],
                         buildPhases: [
@@ -243,25 +244,22 @@ fileprivate struct LinkerTests: CoreBasedTests {
             let ldLinkerPath = try await self.ldPath
             let lldLinkerPath = try await self.lldPath
             let goldLinkerPath = try await self.goldPath
-            let linkLinkerPath = try await self.linkPath
-            let installedLinkerPaths = [lldLinkerPath, ldLinkerPath, goldLinkerPath, linkLinkerPath].compactMap { $0 }
+            let linkLinkerPathX86 = try await self.linkPath("x86_64")
+            let linkLinkerPathAarch64 = try await self.linkPath("aarch64")
+            var installedLinkerPaths = [ldLinkerPath, lldLinkerPath, goldLinkerPath, linkLinkerPathX86, linkLinkerPathAarch64].compactMap { $0 }
 
             // Default Linker
-            var parameters = BuildParameters(configuration: "Debug", overrides: ["ALTERNATE_LINKER": ""])
+            var parameters = BuildParameters(configuration: "Debug")
             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 one of the installed linkers is used, we are not sure which one.
-                            if runDestination == .windows && Architecture.hostStringValue == "aarch64" {
-                                withKnownIssue("'clang' picks the wrong binary for link.exe using x86 version") {
-                                    // On windows aarch64 'clang' picks the wrong host architecture for link.exe, choosing "MSVC\14.41.34120\bin\Hostx86\arm64\link.exe"
-                                    #expect(installedLinkerPaths.map { $0.str }.contains(where: output.asString.replacingOccurrences(of: "\\\\", with: "\\").contains))
-                                }
-                            } else {
-                                #expect(installedLinkerPaths.map { $0.str }.contains(where: output.asString.replacingOccurrences(of: "\\\\", with: "\\").contains))
+                    results.checkTaskOutput(task) { output in
+                        if runDestination == .windows {
+                            // clang will choose to run lld-link rather than ld.lld.exe.
+                            if let lldLinkerPath {
+                                installedLinkerPaths.append(lldLinkerPath.dirname.join("lld-link"))
                             }
                         }
+                        #expect(installedLinkerPaths.map { $0.str }.contains(where: output.asString.replacingOccurrences(of: "\\\\", with: "\\").contains))
                     }
                 }
                 results.checkNoDiagnostics()
@@ -286,12 +284,6 @@ fileprivate struct LinkerTests: CoreBasedTests {
             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
-                        results.checkError(.contains("Linker command failed with exit code 1"))
-                        results.checkError(.contains("lld-link: error: could not open 'Library.lib'"))
-                    }
-
                     results.checkTask(.matchRuleType("Ld")) { task in
                         task.checkCommandLineContains(["-fuse-ld=lld"])
                         results.checkTaskOutput(task) { output in
@@ -324,26 +316,46 @@ fileprivate struct LinkerTests: CoreBasedTests {
             }
 
             // link.exe
-            if let linkLinkerPath {
-                parameters = BuildParameters(configuration: "Debug", overrides: ["ALTERNATE_LINKER": "link"])
+            if let linkLinkerPathX86 {
+                parameters = BuildParameters(configuration: "Debug", overrides: ["ARCHS": "x86_64", "ALTERNATE_LINKER": "link"])
                 try await tester.checkBuild(parameters: parameters, runDestination: .host) { results in
                     results.checkTask(.matchRuleType("Ld")) { task in
                         task.checkCommandLineContains(["-fuse-ld=link"])
                         results.checkTaskOutput(task) { output in
                             // Expect that the 'link' linker is called by clang
                             if runDestination == .windows && Architecture.hostStringValue == "aarch64" {
-                                withKnownIssue("'clang' picks the wrong binary for link.exe using Hostx86 version") {
-                                    // On windows aarch64 'clang' picks the wrong host architecture for link.exe, choosing "MSVC\14.41.34120\bin\Hostx86\arm64\link.exe"
-                                    #expect(output.asString.replacingOccurrences(of: "Hostx86", with: "Hostarm64").contains(linkLinkerPath.str))
+                                // On windows aarch64 'clang' picks the wrong host architecture for link.exe, choosing "MSVC\14.41.34120\bin\Hostx86\x64\link.exe"
+                                withKnownIssue("'clang' picks the wrong binary for link.exe using the Hostx86 version") {
+                                    #expect(output.asString.replacingOccurrences(of: "\\\\", with: "\\").contains(linkLinkerPathX86.str))
                                 }
                             } else {
-                                #expect(output.asString.replacingOccurrences(of: "\\\\", with: "\\").contains(linkLinkerPath.str))
+                                #expect(output.asString.replacingOccurrences(of: "\\\\", with: "\\").contains(linkLinkerPathX86.str))
                             }
                         }
                     }
                     results.checkNoDiagnostics()
                 }
             }
+            if let linkLinkerPathAarch64 {
+                parameters = BuildParameters(configuration: "Debug", overrides: ["ARCHS": "aarch64", "ALTERNATE_LINKER": "link"])
+                try await tester.checkBuild(parameters: parameters, runDestination: .host) { results in
+                    results.checkTask(.matchRuleType("Ld")) { task in
+                        task.checkCommandLineContains(["-fuse-ld=link"])
+                         results.checkTaskOutput(task) { output in
+                            // Expect that the 'link' linker is called by clang
+                            if runDestination == .windows && Architecture.hostStringValue == "aarch64" {
+                                // On windows aarch64 'clang' picks the wrong host architecture for link.exe, choosing "MSVC\14.41.34120\bin\Hostx86\x64\link.exe"
+                                withKnownIssue("'clang' picks the wrong binary for link.exe using the Hostx86 version") {
+                                    #expect(output.asString.replacingOccurrences(of: "\\\\", with: "\\").contains(linkLinkerPathAarch64.str))
+                                }
+                            } else {
+                                #expect(output.asString.replacingOccurrences(of: "\\\\", with: "\\").contains(linkLinkerPathAarch64.str))
+                            }
+                         }
+                    }
+                    results.checkNoDiagnostics()
+                }
+            }
         }
     }
 }