Fix platform-specific linker resolution (#872)

Allow one toolchain configuration to select catalogued linkers on some
target platforms and native or bundled linkers on others. This makes
configurations such as Linux mold plus macOS `auto` work as intended.

Fixes #871.

Details:
- preserve target keys while materializing catalogued linker
distributions;
- skip a catalogue artifact unavailable on the execution platform when
it belongs only to targets for another OS;
- omit those unusable cross-target toolchain configurations rather than
breaking valid native targets;
- apply `linker_version` requirements only to catalogue selections,
ignoring them for `auto`, absolute paths, and the LLVM-distribution
linker;
- document and test the inherited-version behavior.

Validation:
- `bazel test //...`
- `trunk check`
- xff macOS build with one toolchain selecting `auto` on Darwin and
latest mold on Linux

Author: helly25

README.md

@@ -578,6 +578,9 @@ map. Setting both `linker_version` and `linker_versions` is an error.
 catalogue. To use an already installed mold instead of downloading one, provide
 its absolute path, for example `linker = {"": "/usr/bin/mold"}`. The `auto`
 selection resolves the platform's native `ld`; it does not search for mold.
+Version requirements apply only to catalogue selections. They are ignored for
+`auto`, absolute paths, and the linker included in the LLVM distribution, so a
+default `linker_version` can be combined with platform-specific overrides.
 
 ##### Optional mold module version inference
 

toolchain/internal/configure.bzl

@@ -485,25 +485,22 @@ def _linker_descriptor(rctx, selection, version, linker_paths, exec_os, target_o
         )
 
     if selection == "auto":
-        if version:
-            fail("linker version '{}' cannot be used with linker selection 'auto'".format(version))
         if exec_os != target_os:
             fail("linker selection 'auto' requires matching execution and target operating systems, got {} -> {}".format(exec_os, target_os))
         selection = _native_linker(rctx, exec_os)
     elif not _is_absolute_path(selection):
         reference = "{}@{}".format(selection, version) if version else selection
         linker_info = linker_paths.get(reference)
         if not linker_info:
+            if exec_os != target_os:
+                return None
             fail("catalogued linker '{}' was not materialized".format(reference))
         return struct(
             file = linker_info.path,
             path = linker_info.path,
             supports_start_end_lib = "start_end_lib" in linker_info.features,
         )
 
-    if version:
-        fail("linker version '{}' cannot be used with absolute linker path '{}'".format(version, selection))
-
     linker_path = rctx.path(selection)
     if not linker_path.exists:
         fail("configured linker does not exist: {}".format(selection))
@@ -578,6 +575,8 @@ def _cc_toolchain_str(
         exec_os,
         target_os,
     )
+    if linker == None:
+        return ""
 
     extra_files_str = repr(":internal-use-tools" if bazel_features.rules.merkle_cache_v2 else ":internal-use-tools-legacy")
 

toolchain/internal/linker_distributions.bzl

@@ -18,15 +18,11 @@ load("//toolchain/internal:common.bzl", "is_absolute_path")
 load("//toolchain/internal:distributions_repo.bzl", "load_jsonc")
 load("//toolchain/internal:llvm_distributions.bzl", "resolve_version")
 
-def catalogued_linker_reference(selection, version, target = ""):
+def catalogued_linker_reference(selection, version):
     """Return the catalogue reference for a linker selection, or None."""
     if not selection:
-        if version:
-            fail("linker version '{}' has no linker selection for target '{}'".format(version, target))
         return None
     if selection == "auto" or is_absolute_path(selection):
-        if version:
-            fail("linker version '{}' cannot be used with linker selection '{}' for target '{}'".format(version, selection, target))
         return None
     return "{}@{}".format(selection, version) if version else selection
 
@@ -116,11 +112,27 @@ def _linker_distributions_repository_impl(rctx):
     platform = "{}-{}".format(_normalize_os(rctx), _normalize_arch(rctx))
     manifest = {}
 
-    for index, reference in enumerate(sorted(rctx.attr.linkers)):
+    references = {}
+    for target, reference in rctx.attr.linkers.items():
+        references.setdefault(reference, []).append(target)
+
+    for index, reference in enumerate(sorted(references.keys())):
         if reference == "mold":
             linker, version_selection = "mold", _mold_version(rctx)
         else:
             linker, version_selection = _parse_reference(reference)
+        versions = catalogue.get(linker)
+        if not versions:
+            fail("unknown linker '{}'; known linkers: {}".format(linker, ", ".join(sorted(catalogue.keys()))))
+        available_platforms = {
+            available_platform: True
+            for platforms in versions.values()
+            for available_platform in platforms.keys()
+        }
+        if platform not in available_platforms:
+            exec_os = platform.split("-")[0]
+            if all([target and target.split("-")[0] != exec_os for target in references[reference]]):
+                continue
         _, distribution = resolve_linker_distribution(catalogue, linker, version_selection, platform)
 
         extraction_dir = "_extract/{}".format(index)
@@ -159,7 +171,7 @@ linker_distributions_repository = repository_rule(
         "exec_arch": attr.string(),
         "exec_os": attr.string(),
         "extra_catalogues": attr.label_list(allow_files = [".json", ".jsonc"]),
-        "linkers": attr.string_list(mandatory = True),
+        "linkers": attr.string_dict(mandatory = True),
         "mold_source": attr.label(allow_single_file = True),
         "use_builtin_catalogue": attr.bool(default = True),
     },
@@ -186,8 +198,11 @@ def _linker_version_test_writer_impl(ctx):
             ("lld", "19.1.7"),
             ("mold", ""),
             ("auto", ""),
+            ("auto", "latest"),
             ("/usr/bin/ld", ""),
+            ("/usr/bin/ld", "latest"),
             ("", ""),
+            ("", "latest"),
         ]
     ]
     catalogue = {

toolchain/internal/linker_version_test.golden.txt

@@ -8,8 +8,11 @@ gold + 1.2.3 -> gold@1.2.3
 lld + 19.1.7 -> lld@19.1.7
 mold + <empty> -> mold
 auto + <empty> -> None
+auto + latest -> None
 /usr/bin/ld + <empty> -> None
+/usr/bin/ld + latest -> None
 <empty> + <empty> -> None
+<empty> + latest -> None
 latest linux-x86_64 -> 3.0.0 False
 latest darwin-aarch64 -> 2.0.0 True
 merged override -> override

toolchain/rules.bzl

@@ -70,18 +70,17 @@ def llvm_toolchain(name, **kwargs):
     for target in targets.keys():
         selection = linkers.get(target, linkers.get("", ""))
         version = linker_versions.get(target, linker_versions.get("", ""))
-        reference = catalogued_linker_reference(selection, version, target)
+        reference = catalogued_linker_reference(selection, version)
         if reference:
-            catalogued_linkers[reference] = True
-    catalogued_linkers = sorted(catalogued_linkers.keys())
+            catalogued_linkers[target] = reference
     if catalogued_linkers:
         linker_distributions_repository(
             name = name + "_linkers",
             exec_arch = kwargs.get("exec_arch", ""),
             exec_os = kwargs.get("exec_os", ""),
             extra_catalogues = kwargs.get("extra_linker_distribution_files", []),
             linkers = catalogued_linkers,
-            mold_source = "@mold//:src/entry.cc" if "mold" in catalogued_linkers else None,
+            mold_source = "@mold//:src/entry.cc" if "mold" in catalogued_linkers.values() else None,
             use_builtin_catalogue = kwargs.get("use_builtin_linker_distributions", True),
         )
         kwargs["linker_repository"] = "@{}_linkers//:linkers.json".format(name)