add allocator libraries compatible with the new rustc mangling (#3403)

This adds a version of the allocator support libraries implemented in
rust, to account for the new internal allocator symbol mangling applied
by rustc (rust-lang/rust#127173).

This mechanism relies on unstable language features and requires a
nightly rustc from 2025-04-05 or later. It is designed to be compatible
with:
* all allocator flavors (the default and global)
* all flavors of `no_std`
* both situations for when a `rust_library` is used as a dependency of a
`cc_binary` and when the `experimental_use_cc_common_link` setting is
used.

Rustc generates references to internal allocator symbols when building
rust libraries. At link time, rustc generates
the definitions of these symbols. When rustc is not used as the final
linker, we need to generate the definitions
ourselves. This happens for example when a `rust_library` is used as a
dependency of a `rust_binary`, or when the
`experimental_use_cc_common_link` setting is used.

For older versions of rustc, the allocator symbol definitions can be
provided via the `rust_toolchain`'s
`allocator_library` or `global_allocator_library` attributes, with
sample targets like
`//ffi/cc/allocator_library` and `//ffi/cc/global_allocator_library`.

Recent versions of rustc started mangling these allocator symbols
(rust-lang/rust#127173). The
mangling uses a scheme that is specific to the exact version of the
compiler. This makes the cc allocator library
definitions ineffective. To work around this, we provide rust versions
of the symbol definitions annotated with an
unstable language attribute that instructs rustc to mangle them
consistently. Because of the usage of unstable language features, this
is only compatible with nightly versions of the compiler.

Since the new symbol definitions are written in rust, we cannot just
attach them as attributes on the `rust_toolchain`
as the old cc versions, as that would create a build graph cycle: 
1. any `rust_library` depends on a `rust_toolchain`,
2. the `rust_toolchain` depends on the allocator library, 
3. so the allocator library cannot just be a `rust_library` directly.

The bootstrapping cycle can be avoided by defining a separate internal
"initial" rust toolchain specifically for
building the rust allocator libraries, and use a transition to attach
the generated allocator libraries to the "main" rust
toolchain. But that duplicates the whole subgraph of the build around
the rust toolchains, repository and supporting
tools used for them.

Instead, we define a new custom `rust_allocator_libraries` rule, which
builds the new rust allocator libraries and exposes them via a new
`AllocatorLibrariesInfo` provider. Since we cannot attach such a target
as an attribute to the `rust_toolchain`, we attach it as a new
`allocator_libraries` common attribute to the rust rules. We ported the
cc versions into the new rust implementations of the (default) allocator
and global allocator flavors in `//ffi/rs/allocator_library` and
`//ffi/rs/global_allocator_library`.

The rust standard libraries themselves have references to the allocator
libraries. For correct linking order of the standard libraries, we need
to establish the new rust allocator libraries as link-time dependencies
of the standard libraries. The specific set of linker inputs depends on
the no_std flavor and the choice of (default) allocator vs. global
allocator. We establish the linking dependencies by extending the
`rust_toolchain` `_make_libstd_and_allocator_ccinfo` feature to let us
inject a custom allocator library as a standard library dependency and
using that in the `rust_allocator_libraries` implementation to generate
the final standard libraries linker graph.

The new functionality is opt-in and gated via:
1. the new setting
`//rust/settings:experimental_use_allocator_libraries_with_mangled_symbols`,
which supplies the default value for the repository, and
2. the new `rust_toolchain` attribute
`experimental_use_allocator_libraries_with_mangled_symbols`, which lets
the user override the choice of using the new-style rust-based allocator
symbols, or the old-style cc-based ones for a specific toolchain.

For testing, I created variants for the cc_common.link / no_std /
global_allocator test matrix. I found it useful to be able to declare
`target_settings` via the `rust.repository_set` rule, similarly to the
`target_compatible_with`. This lets us include additional toolchains in
the same repository that are distinguished by the setting, like in:
https://github.com/bazelbuild/rules_rust/pull/3403/files#diff-164dd740b73baa94f9a84ed0d4a7ec29f8adeb34ff8430492747e2443f7f39d3

Author: krasimirgg

.bazelci/presubmit.yml

@@ -534,6 +534,18 @@ tasks:
       - "//..."
     test_targets:
       - "//..."
+  cc_common_link_and_mangling_ubuntu2004:
+    name: Build via cc_common.link with rustc mangling alloc symbols
+    platform: ubuntu2004
+    working_directory: test/integration/cc_common_link
+    build_targets:
+      - "//..."
+    test_targets:
+      - "//..."
+    build_flags:
+      - "--config=mangled_alloc_symbols"
+    test_flags:
+      - "--config=mangled_alloc_symbols"
   cc_common_link_with_global_alloc_ubuntu2004:
     name: Build via cc_common.link using a global allocator
     platform: ubuntu2004
@@ -550,6 +562,18 @@ tasks:
       - "//..."
     test_targets:
       - "//..."
+  cc_common_link_with_global_alloc_and_mangling_ubuntu2004:
+    name: Build via cc_common.link using a global allocator with rustc mangling alloc symbols
+    platform: ubuntu2004
+    working_directory: test/integration/cc_common_link_with_global_alloc
+    build_targets:
+      - "//..."
+    test_targets:
+      - "//..."
+    build_flags:
+      - "--config=mangled_alloc_symbols"
+    test_flags:
+      - "--config=mangled_alloc_symbols"
   cc_common_link_no_std_ubuntu2004:
     name: Build with no_std + alloc using cc_common.link infrastructure for linking
     platform: ubuntu2004
@@ -562,6 +586,18 @@ tasks:
       - "--config=no_std_alloc_using_cc_common_link"
     test_flags:
       - "--config=no_std_alloc_using_cc_common_link"
+  cc_common_link_no_std_and_mangling_ubuntu2004:
+    name: Build with no_std + alloc using cc_common.link infrastructure for linking with rust toolchain mangling alloc symbols
+    platform: ubuntu2004
+    working_directory: test/integration/no_std
+    build_targets:
+      - "//..."
+    test_targets:
+      - "//..."
+    build_flags:
+      - "--config=no_std_alloc_using_cc_common_link_and_mangled_alloc_symbols"
+    test_flags:
+      - "--config=no_std_alloc_using_cc_common_link_and_mangled_alloc_symbols"
   no_std_ubuntu2004:
     name: Build with no_std + alloc
     platform: ubuntu2004

ffi/rs/BUILD.bazel

@@ -0,0 +1,40 @@
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+
+# buildifier: disable=bzl-visibility
+load("@rules_rust//rust/private:rust.bzl", "rust_allocator_libraries")
+
+rust_allocator_libraries(
+    name = "allocator_libraries_with_mangling_support",
+    allocator_library = "@rules_rust//ffi/rs/allocator_library",
+    global_allocator_library = "@rules_rust//ffi/rs/global_allocator_library",
+    visibility = ["//visibility:public"],
+)
+
+rust_allocator_libraries(
+    name = "empty_allocator_libraries",
+    visibility = ["//visibility:public"],
+)
+
+alias(
+    name = "default_allocator_libraries",
+    actual = select({
+        "@rules_rust//rust/settings:experimental_use_allocator_libraries_with_mangled_symbols_on": ":allocator_libraries_with_mangling_support",
+        "//conditions:default": ":empty_allocator_libraries",
+    }),
+    visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "empty",
+    visibility = ["//visibility:public"],
+)
+
+# Allocator libraries used while bootstrapping the process wrapper.
+rust_allocator_libraries(
+    name = "allocator_libraries_with_mangling_support_without_process_wrapper",
+    allocator_library = "@rules_rust//ffi/rs/allocator_library:allocator_library_without_process_wrapper",
+    # no need for a global allocator library, since the process wrapper
+    # is always bootstrapped in exec mode, which always uses the default
+    # allocator.
+    visibility = ["@rules_rust//util/process_wrapper:__subpackages__"],
+)

ffi/rs/allocator_library/BUILD.bazel

@@ -0,0 +1,35 @@
+load("@rules_rust//rust:defs.bzl", "rust_library")
+
+# buildifier: disable=bzl-visibility
+load(
+    "@rules_rust//rust/private:rust.bzl",
+    "rust_library_without_process_wrapper",
+)
+
+package(
+    default_visibility = ["@rules_rust//ffi/rs:__subpackages__"],
+)
+
+srcs = select({
+    # Windows doesn't support weak symbol linkage.
+    # If someone can make this work on Windows, please do!
+    # For now we will silently not supply any symbols, because it would be very messy to conditionally define the default allocator library on toolchains depending on the platform.
+    "@platforms//os:windows": ["empty.rs"],
+    "//conditions:default": ["allocator_library.rs"],
+})
+
+rust_library(
+    name = "allocator_library",
+    srcs = srcs,
+    allocator_libraries = "@rules_rust//ffi/rs:empty_allocator_libraries",
+    edition = "2024",
+    tags = ["manual"],
+)
+
+rust_library_without_process_wrapper(
+    name = "allocator_library_without_process_wrapper",
+    srcs = srcs,
+    allocator_libraries = "@rules_rust//ffi/rs:empty_allocator_libraries",
+    edition = "2024",
+    tags = ["manual"],
+)

ffi/rs/allocator_library/allocator_library.rs

@@ -0,0 +1,86 @@
+// Workaround for Rust issue https://github.com/rust-lang/rust/issues/73632
+// We provide the allocator functions that rustc leaves in rlibs. These are
+// normally provided by rustc during the linking phase (since the allocator in
+// use can vary), but if rustc doesn't do the final link we have to provide
+// these manually. Hopefully we can make progress on the above bug and
+// eventually not need this kludge.
+//
+// Recently rustc started mangling these symbols, so we rewrote them in
+// rust.
+// https://github.com/rust-lang/rust/pull/127173
+//
+// This code uses unstable internal rustc features that are only available when
+// using a nightly toolchain. Also, it is only compatible with versions
+// of rustc that include the symbol mangling, such as nightly/2025-04-08 or
+// later.
+//
+// This has been translated from our c++ version
+// rules_rust/ffi/cc/allocator_library/allocator_library.cc.
+#![no_std]
+#![allow(warnings)]
+#![allow(internal_features)]
+#![feature(rustc_attrs)]
+#![feature(linkage)]
+
+unsafe extern "C" {
+    #[rustc_std_internal_symbol]
+    fn __rdl_alloc(size: usize, align: usize) -> *mut u8;
+
+    #[rustc_std_internal_symbol]
+    fn __rdl_dealloc(ptr: *mut u8, size: usize, align: usize);
+
+    #[rustc_std_internal_symbol]
+    fn __rdl_realloc(ptr: *mut u8, old_size: usize, align: usize, new_size: usize) -> *mut u8;
+
+    #[rustc_std_internal_symbol]
+    fn __rdl_alloc_zeroed(size: usize, align: usize) -> *mut u8;
+}
+
+#[linkage = "weak"]
+#[rustc_std_internal_symbol]
+fn __rust_alloc(size: usize, align: usize) -> *mut u8 {
+    unsafe {
+        return __rdl_alloc(size, align);
+    }
+}
+
+#[linkage = "weak"]
+#[rustc_std_internal_symbol]
+fn __rust_dealloc(ptr: *mut u8, size: usize, align: usize) {
+    unsafe {
+        return __rdl_dealloc(ptr, size, align);
+    }
+}
+
+#[linkage = "weak"]
+#[rustc_std_internal_symbol]
+fn __rust_realloc(ptr: *mut u8, old_size: usize, align: usize, new_size: usize) -> *mut u8 {
+    unsafe {
+        return __rdl_realloc(ptr, old_size, align, new_size);
+    }
+}
+
+#[linkage = "weak"]
+#[rustc_std_internal_symbol]
+fn __rust_alloc_zeroed(size: usize, align: usize) -> *mut u8 {
+    unsafe {
+        return __rdl_alloc_zeroed(size, align);
+    }
+}
+
+#[linkage = "weak"]
+#[rustc_std_internal_symbol]
+fn __rust_alloc_error_handler(size: usize, align: usize) {
+    panic!();
+}
+
+// New feature as of https://github.com/rust-lang/rust/pull/88098.
+// This symbol is normally emitted by rustc. 0 means OOMs should abort, 1 means OOMs should panic.
+#[linkage = "weak"]
+#[rustc_std_internal_symbol]
+static mut __rust_alloc_error_handler_should_panic: u8 = 1;
+
+// See https://github.com/rust-lang/rust/issues/73632#issuecomment-1563462239
+#[linkage = "weak"]
+#[rustc_std_internal_symbol]
+static mut __rust_no_alloc_shim_is_unstable: u8 = 0;

ffi/rs/allocator_library/empty.rs

@@ -0,0 +1,21 @@
+load("@rules_rust//rust:defs.bzl", "rust_library")
+
+package(
+    default_visibility = ["@rules_rust//ffi/rs:__subpackages__"],
+)
+
+srcs = select({
+    # Windows doesn't support weak symbol linkage.
+    # If someone can make this work on Windows, please do!
+    # For now we will silently not supply any symbols, because it would be very messy to conditionally define the global allocator library on toolchains depending on the platform.
+    "@platforms//os:windows": ["empty.rs"],
+    "//conditions:default": ["global_allocator_library.rs"],
+})
+
+rust_library(
+    name = "global_allocator_library",
+    srcs = srcs,
+    allocator_libraries = "@rules_rust//ffi/rs:empty_allocator_libraries",
+    edition = "2024",
+    tags = ["manual"],
+)

ffi/rs/global_allocator_library/BUILD.bazel

@@ -0,0 +1,48 @@
+// Workaround for Rust issue https://github.com/rust-lang/rust/issues/73632
+// We provide the allocator functions that rustc leaves in rlibs. These are
+// normally provided by rustc during the linking phase (since the allocator in
+// use can vary), but if rustc doesn't do the final link we have to provide
+// these manually. Hopefully we can make progress on the above bug and
+// eventually not need this kludge.
+//
+// Recently rustc started mangling these symbols, so we rewrote them in
+// rust.
+// https://github.com/rust-lang/rust/pull/127173
+//
+// This code uses unstable internal rustc features that are only available when
+// using a nightly toolchain. Also, it is only compatible with versions
+// of rustc that include the symbol mangling, such as nightly/2025-04-08 or
+// later.
+//
+// This has been translated from our c++ version
+// rules_rust/ffi/cc/global_allocator_library/global_allocator_library.cc.
+#![no_std]
+#![allow(warnings)]
+#![allow(internal_features)]
+#![feature(rustc_attrs)]
+#![feature(linkage)]
+
+unsafe extern "C" {
+    #[rustc_std_internal_symbol]
+    fn __rg_oom(size: usize, align: usize) -> *mut u8;
+}
+
+#[linkage = "weak"]
+#[rustc_std_internal_symbol]
+fn __rust_alloc_error_handler(size: usize, align: usize) {
+    unsafe {
+        __rg_oom(size, align);
+    }
+}
+
+
+// New feature as of https://github.com/rust-lang/rust/pull/88098.
+// This symbol is normally emitted by rustc. 0 means OOMs should abort, 1 means OOMs should panic.
+#[linkage = "weak"]
+#[rustc_std_internal_symbol]
+static mut __rust_alloc_error_handler_should_panic: u8 = 1;
+
+// See https://github.com/rust-lang/rust/issues/73632#issuecomment-1563462239
+#[linkage = "weak"]
+#[rustc_std_internal_symbol]
+static mut __rust_no_alloc_shim_is_unstable: u8 = 0;

ffi/rs/global_allocator_library/empty.rs

@@ -64,6 +64,7 @@ def _rust_impl(module_ctx):
                 "name": repository_set.name,
                 "rustfmt_version": repository_set.rustfmt_version,
                 "sha256s": repository_set.sha256s,
+                "target_settings": [str(v) for v in repository_set.target_settings],
                 "urls": repository_set.urls,
                 "versions": repository_set.versions,
             }
@@ -119,6 +120,7 @@ def _rust_impl(module_ctx):
                 register_toolchains = False,
                 aliases = toolchain.aliases,
                 toolchain_triples = toolchain_triples,
+                target_settings = [str(v) for v in toolchain.target_settings],
                 extra_toolchain_infos = extra_toolchain_infos,
             )
     metadata_kwargs = {}
@@ -170,6 +172,9 @@ _RUST_REPOSITORY_SET_TAG_ATTRS = {
     "target_compatible_with": attr.label_list(
         doc = "List of platform constraints this toolchain produces, for the particular target_triple this call is for.",
     ),
+    "target_settings": attr.label_list(
+        doc = "A list of `config_settings` that must be satisfied by the target configuration in order for this toolchain to be selected during toolchain resolution.",
+    ),
     "target_triple": attr.string(
         doc = "target_triple to configure.",
     ),
@@ -214,6 +219,9 @@ _RUST_TOOLCHAIN_TAG = tag_class(
         "rust_analyzer_version": attr.string(
             doc = "The version of Rustc to pair with rust-analyzer.",
         ),
+        "target_settings": attr.label_list(
+            doc = "A list of `config_settings` that must be satisfied by the target configuration in order for this toolchain to be selected during toolchain resolution.",
+        ),
         "versions": attr.string_list(
             doc = (
                 "A list of toolchain versions to download. This parameter only accepts one version " +

ffi/rs/global_allocator_library/global_allocator_library.rs

@@ -188,3 +188,21 @@ LintsInfo = provider(
         "rustdoc_lint_flags": "List[String]: rustc flags to specify when building rust_doc targets.",
     },
 )
+
+AllocatorLibrariesInfo = provider(
+    doc = "AllocatorLibrariesInfo provides allocator libraries for linking rust code with a non-rust linker.",
+    fields = {
+        "allocator_library": "Optional[CcInfo]: used when the default rust allocator is used",
+        "global_allocator_library": "Optional[CcInfo]: used when a global rust allocator is used",
+        "libstd_and_allocator_ccinfo": "Optional[CcInfo]: used when the default rust allocator is used",
+        "libstd_and_global_allocator_ccinfo": "Optional[CcInfo]: used when a global rust allocator is used",
+        "nostd_and_global_allocator_ccinfo": "Optional[CcInfo]: used when nostd with a global rust allocator is used",
+    },
+)
+
+AllocatorLibrariesImplInfo = provider(
+    doc = "AllocatorLibrariesImplInfo provides the rust-generated linker input for linking rust code with a non-rust linker.",
+    fields = {
+        "static_archive": "Optional[File]: the allocator library archive (typically .a file).",
+    },
+)