Integrated libc constraints from @platforms_contrib

MODULE.bazel

@@ -12,11 +12,18 @@ module(
 bazel_dep(name = "bazel_features", version = "1.32.0")
 bazel_dep(name = "bazel_skylib", version = "1.8.2")
 bazel_dep(name = "platforms", version = "1.0.0")
+bazel_dep(name = "platforms_contrib", version = "0.3.0")
 bazel_dep(name = "rules_cc", version = "0.2.4")
 bazel_dep(name = "rules_license", version = "1.0.0")
 bazel_dep(name = "rules_shell", version = "0.6.1")
 bazel_dep(name = "apple_support", version = "1.24.1", repo_name = "build_bazel_apple_support")
 
+git_override(
+    module_name = "platforms_contrib",
+    branch = "fmeum/libc",
+    remote = "https://github.com/bazel-contrib/platforms_contrib.git",
+)
+
 internal_deps = use_extension("//rust/private:internal_extensions.bzl", "i")
 use_repo(
     internal_deps,

crate_universe/private/crates_repository.bzl

@@ -29,10 +29,12 @@ load("//rust/platform:triple.bzl", "get_host_triple")
 SUPPORTED_PLATFORM_TRIPLES = [
     "aarch64-apple-darwin",
     "aarch64-unknown-linux-gnu",
+    "aarch64-unknown-linux-musl",
     "wasm32-unknown-unknown",
     "wasm32-wasip1",
     "x86_64-pc-windows-msvc",
     "x86_64-unknown-linux-gnu",
+    "x86_64-unknown-linux-musl",
     "x86_64-unknown-nixos-gnu",
 ]
 

examples/cross_compile_musl/MODULE.bazel

@@ -10,9 +10,16 @@ local_path_override(
 )
 
 bazel_dep(name = "platforms", version = "1.0.0")
+bazel_dep(name = "platforms_contrib", version = "0.3.0")
 bazel_dep(name = "rules_shell", version = "0.6.1")
 bazel_dep(name = "bazel_skylib", version = "1.8.2")
 
+git_override(
+    module_name = "platforms_contrib",
+    branch = "fmeum/libc",
+    remote = "https://github.com/bazel-contrib/platforms_contrib.git",
+)
+
 RUST_EDITION = "2021"
 
 RUST_VERSION = "1.80.0"
@@ -23,84 +30,41 @@ rust.toolchain(
     versions = [RUST_VERSION],
 )
 
-# This overrides a default rust_repository_set created by rust_register_toolchain.
-# It must be named exactly this.
-# Each exec triple needs one of these calls per target triple it supports.
-# The first call needs all of the attrs, the subsequent calls should only set name, target_triple, and target_compatible_with.
+# Register musl target triples for each exec host.
+# target_compatible_with is not needed here because triple_to_constraint_set
+# now emits @platforms_contrib//libc:musl for musl triples (and glibc for gnu)
+# which is sufficient to distinguish the toolchains.
 rust.repository_set(
     name = "rust_linux_x86_64",
     edition = RUST_EDITION,
     exec_triple = "x86_64-unknown-linux-gnu",
-    target_compatible_with = [
-        "@//linker_config:unknown",
-        "@platforms//cpu:x86_64",
-        "@platforms//os:linux",
-    ],
-    target_triple = "x86_64-unknown-linux-gnu",
-    versions = [RUST_VERSION],
-)
-rust.repository_set(
-    name = "rust_linux_x86_64",
-    target_compatible_with = [
-        "@//linker_config:musl",
-        "@platforms//cpu:arm64",
-        "@platforms//os:linux",
-    ],
     target_triple = "aarch64-unknown-linux-musl",
+    versions = [RUST_VERSION],
 )
 rust.repository_set(
     name = "rust_linux_x86_64",
-    target_compatible_with = [
-        "@//linker_config:musl",
-        "@platforms//cpu:x86_64",
-        "@platforms//os:linux",
-    ],
     target_triple = "x86_64-unknown-linux-musl",
 )
-
-# We don't need to register a repository_set for exec_triple == target_triple if we're not customising it in any way:
-# one will get registered by default.
-# But we do for the Linux case above, because we want to add the "@//linker_config:unknown" constraint in that case.
 rust.repository_set(
     name = "rust_darwin_x86_64",
     edition = RUST_EDITION,
     exec_triple = "x86_64-apple-darwin",
-    target_compatible_with = [
-        "@//linker_config:musl",
-        "@platforms//cpu:x86_64",
-        "@platforms//os:linux",
-    ],
     target_triple = "x86_64-unknown-linux-musl",
     versions = [RUST_VERSION],
 )
 rust.repository_set(
     name = "rust_darwin_x86_64",
-    target_compatible_with = [
-        "@//linker_config:musl",
-        "@platforms//cpu:arm64",
-        "@platforms//os:linux",
-    ],
     target_triple = "aarch64-unknown-linux-musl",
 )
 rust.repository_set(
     name = "rust_darwin_aarch64",
     edition = RUST_EDITION,
     exec_triple = "aarch64-apple-darwin",
-    target_compatible_with = [
-        "@//linker_config:musl",
-        "@platforms//cpu:x86_64",
-        "@platforms//os:linux",
-    ],
     target_triple = "x86_64-unknown-linux-musl",
     versions = [RUST_VERSION],
 )
 rust.repository_set(
     name = "rust_darwin_aarch64",
-    target_compatible_with = [
-        "@//linker_config:musl",
-        "@platforms//cpu:arm64",
-        "@platforms//os:linux",
-    ],
     target_triple = "aarch64-unknown-linux-musl",
 )
 use_repo(rust, "rust_toolchains")
@@ -125,5 +89,5 @@ bazel_dep(name = "toolchains_musl", version = "0.1.20", dev_dependency = True)
 
 toolchains_musl = use_extension("@toolchains_musl//:toolchains_musl.bzl", "toolchains_musl", dev_dependency = True)
 toolchains_musl.config(
-    extra_target_compatible_with = ["@//linker_config:musl"],
+    extra_target_compatible_with = ["@platforms_contrib//libc:musl"],
 )

examples/cross_compile_musl/platforms/BUILD.bazel

@@ -1,19 +1,19 @@
 platform(
     name = "linux_x86_64_musl",
     constraint_values = [
-        "@//linker_config:musl",
         "@platforms//cpu:x86_64",
         "@platforms//os:linux",
+        "@platforms_contrib//libc:musl",
     ],
     visibility = ["//visibility:public"],
 )
 
 platform(
     name = "linux_arm64_musl",
     constraint_values = [
-        "@//linker_config:musl",
         "@platforms//cpu:arm64",
         "@platforms//os:linux",
+        "@platforms_contrib//libc:musl",
     ],
     visibility = ["//visibility:public"],
 )

examples/cross_compile_nix/MODULE.bazel

@@ -151,11 +151,13 @@ crates.from_specs(
         "aarch64-apple-ios",
         "aarch64-linux-android",
         "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
         "wasm32-unknown-unknown",
         "wasm32-wasip1",
         "x86_64-apple-darwin",
         "x86_64-pc-windows-msvc",
         "x86_64-unknown-linux-gnu",
+        "x86_64-unknown-linux-musl",
         "x86_64-unknown-nixos-gnu",
     ],
 )

rust/platform/triple_mappings.bzl

@@ -32,8 +32,8 @@ SUPPORTED_T1_PLATFORM_TRIPLES = {
     "x86_64-pc-windows-msvc": _support(std = True, host_tools = True),
     "x86_64-unknown-linux-gnu": _support(std = True, host_tools = True),
     "x86_64-unknown-nixos-gnu": _support(std = True, host_tools = True),  # Same as `x86_64-unknown-linux-gnu` but with `@platforms//os:nixos`.
-    # N.B. These "alternative" envs are not supported, as bazel cannot distinguish between them
-    # and others using existing @platforms// config_values
+    # N.B. These windows-gnu "alternative" envs are not supported, as bazel cannot
+    # distinguish between MSVC and MinGW using existing @platforms// config_values.
     #
     #"i686-pc-windows-gnu",
     #"x86_64-pc-windows-gnu",
@@ -48,18 +48,23 @@ SUPPORTED_T2_PLATFORM_TRIPLES = {
     "aarch64-linux-android": _support(std = True, host_tools = False),
     "aarch64-pc-windows-msvc": _support(std = True, host_tools = True),
     "aarch64-unknown-fuchsia": _support(std = True, host_tools = False),
+    "aarch64-unknown-linux-musl": _support(std = True, host_tools = True),
     "aarch64-unknown-uefi": _support(std = True, host_tools = False),
     "arm-unknown-linux-gnueabi": _support(std = True, host_tools = True),
     "arm-unknown-linux-musleabi": _support(std = True, host_tools = True),
     "armv7-linux-androideabi": _support(std = True, host_tools = False),
     "armv7-unknown-linux-gnueabi": _support(std = True, host_tools = True),
     "i686-linux-android": _support(std = True, host_tools = False),
     "i686-unknown-freebsd": _support(std = True, host_tools = False),
+    "i686-unknown-linux-musl": _support(std = True, host_tools = True),
     "powerpc-unknown-linux-gnu": _support(std = True, host_tools = True),
+    "powerpc-unknown-linux-musl": _support(std = True, host_tools = True),
     "riscv32imc-unknown-none-elf": _support(std = True, host_tools = False),
     "riscv64gc-unknown-linux-gnu": _support(std = True, host_tools = False),
+    "riscv64gc-unknown-linux-musl": _support(std = True, host_tools = False),
     "riscv64gc-unknown-none-elf": _support(std = True, host_tools = False),
     "s390x-unknown-linux-gnu": _support(std = True, host_tools = True),
+    "s390x-unknown-linux-musl": _support(std = True, host_tools = True),
     "thumbv6m-none-eabi": _support(std = True, host_tools = False),
     "thumbv7em-none-eabi": _support(std = True, host_tools = False),
     "thumbv7em-none-eabihf": _support(std = True, host_tools = False),
@@ -74,6 +79,7 @@ SUPPORTED_T2_PLATFORM_TRIPLES = {
     "x86_64-linux-android": _support(std = True, host_tools = False),
     "x86_64-unknown-freebsd": _support(std = True, host_tools = True),
     "x86_64-unknown-fuchsia": _support(std = True, host_tools = False),
+    "x86_64-unknown-linux-musl": _support(std = True, host_tools = True),
     "x86_64-unknown-none": _support(std = True, host_tools = False),
     "x86_64-unknown-uefi": _support(std = True, host_tools = False),
 }
@@ -268,8 +274,10 @@ _SYSTEM_TO_STDLIB_LINKFLAGS = {
     "fuchsia": ["-lzircon", "-lfdio"],
     "illumos": ["-lsocket", "-lposix4", "-lpthread", "-lresolv", "-lnsl", "-lumem"],
     "ios": ["-lSystem", "-lobjc", "-Wl,-framework,Security", "-Wl,-framework,Foundation", "-lresolv"],
-    # TODO: This ignores musl. Longer term what does Bazel think about musl?
-    "linux": ["-ldl", "-lpthread"],
+    "linux": {
+        None: ["-ldl", "-lpthread"],
+        "musl": [],
+    },
     "macos": ["-lSystem", "-lresolv"],
     "nacl": [],
     "netbsd": ["-lpthread", "-lrt"],
@@ -340,20 +348,18 @@ def abi_to_constraints(abi, *, arch = None, system = None):
 
     all_abi_constraints = []
 
-    # add constraints for MUSL static compilation and linking
-    # to separate the MUSL from the non-MUSL toolchain on x86_64
-    # if abi == "musl" and system == "linux" and arch == "x86_64":
-    # all_abi_constraints.append("//rust/platform/constraints:musl_on")
-
     # add constraints for iOS + watchOS simulator and device triples
     if system in ["ios", "watchos"]:
         if arch == "x86_64" or abi == "sim":
             all_abi_constraints.append("@build_bazel_apple_support//constraints:simulator")
         else:
             all_abi_constraints.append("@build_bazel_apple_support//constraints:device")
 
-    # TODO(bazelbuild/platforms#38): Implement when C++ toolchain is more mature and we
-    # figure out how they're doing this
+    if abi:
+        if abi.startswith("musl"):
+            all_abi_constraints.append("@platforms_contrib//libc:musl")
+        elif abi.startswith("gnu"):
+            all_abi_constraints.append("@platforms_contrib//libc:glibc")
     return all_abi_constraints
 
 def triple_to_system(target_triple):
@@ -410,8 +416,15 @@ def system_to_staticlib_ext(system):
 def system_to_binary_ext(system):
     return _SYSTEM_TO_BINARY_EXT[system]
 
-def system_to_stdlib_linkflags(system):
-    return _SYSTEM_TO_STDLIB_LINKFLAGS[system]
+def system_to_stdlib_linkflags(system, abi = None):
+    flags = _SYSTEM_TO_STDLIB_LINKFLAGS[system]
+    if type(flags) == "list":
+        return flags
+    if abi:
+        for prefix, abi_flags in flags.items():
+            if prefix and abi.startswith(prefix):
+                return abi_flags
+    return flags.get(None, [])
 
 def triple_to_constraint_set(target_triple):
     """Returns a set of constraints for a given platform triple

rust/private/repository_utils.bzl

@@ -417,7 +417,7 @@ def BUILD_for_rust_toolchain(
         str: A rendered template of a `rust_toolchain` declaration
     """
     if stdlib_linkflags == None:
-        stdlib_linkflags = ", ".join(['"%s"' % x for x in system_to_stdlib_linkflags(target_triple.system)])
+        stdlib_linkflags = ", ".join(['"%s"' % x for x in system_to_stdlib_linkflags(target_triple.system, target_triple.abi)])
 
     rustfmt_label = None
     if include_rustfmt:

tools/rust_analyzer/3rdparty/BUILD.bazel

@@ -57,6 +57,7 @@ crates_vendor(
         "aarch64-apple-darwin",
         "aarch64-pc-windows-msvc",
         "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
         "aarch64-unknown-nixos-gnu",
         "arm-unknown-linux-gnueabi",
         "armv7-linux-androideabi",
@@ -71,6 +72,7 @@ crates_vendor(
         "x86_64-pc-windows-msvc",
         "x86_64-unknown-freebsd",
         "x86_64-unknown-linux-gnu",
+        "x86_64-unknown-linux-musl",
         "x86_64-unknown-nixos-gnu",
     ],
     tags = ["manual"],