Reland "Use #[global_allocator] to provide Rust allocator implementation"

This is a reland of commit cfa3bee

Original was reverted due to a cronet gn2bp failure. The script
filtered out GN rules in //build/rust/std, but this caused an exception
when //build/rust/std:allocator was referenced later.

Moving the rules to //build/rust/allocator sidesteps the issue.

Original change's description:
> Use #[global_allocator] to provide Rust allocator implementation
>
> The allocator shim hack we have been using no longer works with
> upstream Rust. Replace it with a less-unsupported method: provide a
> rust-lang/rust#123015, which still requires
> us to provide a few symbol definitions.
>
> Bug: 408221149, 407024458
> Change-Id: If1808ca24b12dc80ead35a25521313a3d2e148d5
>
> Cq-Include-Trybots: luci.chromium.try:android-rust-arm32-rel,android-rust-arm64-dbg,android-rust-arm64-rel,linux-rust-x64-dbg,linux-rust-x64-rel,mac-rust-x64-dbg,win-rust-x64-dbg,win-rust-x64-rel
> Change-Id: If1808ca24b12dc80ead35a25521313a3d2e148d5
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6427855
> Reviewed-by: Alan Zhao <[email protected]>
> Reviewed-by: Lei Zhang <[email protected]>
> Reviewed-by: Łukasz Anforowicz <[email protected]>
> Commit-Queue: Collin Baker <[email protected]>
> Auto-Submit: Collin Baker <[email protected]>
> Cr-Commit-Position: refs/heads/main@{#1442472}

Bug: 408221149, 407024458
Cq-Include-Trybots: luci.chromium.try:android-rust-arm32-rel,android-rust-arm64-dbg,android-rust-arm64-rel,linux-rust-x64-dbg,linux-rust-x64-rel,mac-rust-x64-dbg,win-rust-x64-dbg,win-rust-x64-rel
Change-Id: I36fef217297bfe64ae81519be24b8c653f6fdfa1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6432410
Reviewed-by: Mohannad Farrag <[email protected]>
Reviewed-by: Łukasz Anforowicz <[email protected]>
Auto-Submit: Collin Baker <[email protected]>
Commit-Queue: Łukasz Anforowicz <[email protected]>
Cr-Commit-Position: refs/heads/main@{#1442922}

Author: chbaker0

build/rust/allocator/BUILD.gn

@@ -0,0 +1,90 @@
+# Copyright 2025 The Chromium Authors
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/buildflag_header.gni")
+import("//build/config/rust.gni")
+import("//build/rust/rust_static_library.gni")
+
+rust_allocator_uses_partition_alloc = false
+if (build_with_chromium) {
+  import("//base/allocator/partition_allocator/partition_alloc.gni")
+  rust_allocator_uses_partition_alloc = use_partition_alloc_as_malloc
+}
+
+buildflag_header("buildflags") {
+  header = "buildflags.h"
+  flags = [
+    "RUST_ALLOCATOR_USES_PARTITION_ALLOC=$rust_allocator_uses_partition_alloc",
+  ]
+  visibility = [ ":*" ]
+}
+
+if (toolchain_has_rust) {
+  # All targets which depend on Rust code but are not linked by rustc must
+  # depend on this. Usually, this dependency will come from the rust_target() GN
+  # template. However, cargo_crate() does *not* include this dependency so any
+  # C++ targets which directly depend on a cargo_crate() must depend on this.
+  rust_static_library("allocator") {
+    sources = [ "lib.rs" ]
+    crate_root = "lib.rs"
+    cxx_bindings = [ "lib.rs" ]
+
+    deps = [
+      ":allocator_impls",
+      ":allocator_shim_definitions",
+    ]
+
+    no_chromium_prelude = true
+    no_allocator_crate = true
+    allow_unsafe = true
+  }
+
+  static_library("allocator_impls") {
+    public_deps = []
+    if (rust_allocator_uses_partition_alloc) {
+      public_deps += [ "//base/allocator/partition_allocator:partition_alloc" ]
+    }
+
+    sources = [
+      "allocator_impls.cc",
+      "allocator_impls.h",
+    ]
+
+    deps = [
+      ":allocator_cpp_shared",
+      ":buildflags",
+
+      # TODO(crbug.com/408221149): remove the C++ -> Rust dependency for the
+      # default allocator.
+      "//build/rust/std",
+    ]
+
+    visibility = [ ":*" ]
+  }
+
+  source_set("allocator_shim_definitions") {
+    sources = [ "allocator_shim_definitions.cc" ]
+
+    deps = [ ":allocator_cpp_shared" ]
+
+    visibility = [ ":*" ]
+  }
+
+  source_set("allocator_cpp_shared") {
+    sources = [
+      # `alias.*`, `compiler_specific.h`, and `immediate_crash.*` have been
+      # copied from `//base`.
+      # TODO(crbug.com/40279749): Avoid duplication / reuse code.
+      "alias.cc",
+      "alias.h",
+      "compiler_specific.h",
+      "immediate_crash.h",
+    ]
+
+    visibility = [
+      ":allocator_impls",
+      ":allocator_shim_definitions",
+    ]
+  }
+}

build/rust/std/alias.cc renamed to build/rust/allocator/alias.cc

@@ -7,9 +7,9 @@
 //
 // TODO(crbug.com/40279749): Avoid code duplication / reuse code.
 
-#include "build/rust/std/alias.h"
+#include "build/rust/allocator/alias.h"
 
-#include "build/rust/std/compiler_specific.h"
+#include "build/rust/allocator/compiler_specific.h"
 
 namespace build_rust_std {
 namespace debug {

build/rust/std/alias.h renamed to build/rust/allocator/alias.h

@@ -8,8 +8,8 @@
 //
 // TODO(crbug.com/40279749): Avoid code duplication / reuse code.
 
-#ifndef BUILD_RUST_STD_ALIAS_H_
-#define BUILD_RUST_STD_ALIAS_H_
+#ifndef BUILD_RUST_ALLOCATOR_ALIAS_H_
+#define BUILD_RUST_ALLOCATOR_ALIAS_H_
 
 #include <stddef.h>
 
@@ -34,4 +34,4 @@ void Alias(const void* var);
   const int line_number = __LINE__; \
   build_rust_std::debug::Alias(&line_number)
 
-#endif  // BUILD_RUST_STD_ALIAS_H_
+#endif  // BUILD_RUST_ALLOCATOR_ALIAS_H_

build/rust/std/remap_alloc.cc renamed to build/rust/allocator/allocator_impls.cc

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "build/rust/allocator/allocator_impls.h"
+
 #ifdef UNSAFE_BUFFERS_BUILD
 // TODO(crbug.com/390223051): Remove C-library calls to fix the errors.
 #pragma allow_unsafe_libc_calls
@@ -11,9 +13,9 @@
 #include <cstring>
 
 #include "build/build_config.h"
-#include "build/rust/std/alias.h"
-#include "build/rust/std/buildflags.h"
-#include "build/rust/std/immediate_crash.h"
+#include "build/rust/allocator/alias.h"
+#include "build/rust/allocator/buildflags.h"
+#include "build/rust/allocator/immediate_crash.h"
 
 #if BUILDFLAG(RUST_ALLOCATOR_USES_PARTITION_ALLOC)
 #include "partition_alloc/partition_alloc_constants.h"  // nogncheck
@@ -22,6 +24,11 @@
 #include <cstdlib>
 #endif
 
+// NOTE: this documentation is outdated.
+//
+// TODO(crbug.com/408221149): update this documentation, or replace it with docs
+// in the Rust allocator implementation.
+//
 // When linking a final binary, rustc has to pick between either:
 // * The default Rust allocator
 // * Any #[global_allocator] defined in *any rlib in its dependency tree*
@@ -87,57 +94,46 @@
 // enabling it breaks Win32 APIs like CreateProcess:
 // https://issues.chromium.org/u/1/issues/368070343#comment29
 
-extern "C" {
-
-#ifdef COMPONENT_BUILD
-#if BUILDFLAG(IS_WIN)
-#define REMAP_ALLOC_ATTRIBUTES __declspec(dllexport) __attribute__((weak))
-#else
-#define REMAP_ALLOC_ATTRIBUTES \
-  __attribute__((visibility("default"))) __attribute__((weak))
-#endif
-#else
-#define REMAP_ALLOC_ATTRIBUTES __attribute__((weak))
-#endif  // COMPONENT_BUILD
-
 #if !BUILDFLAG(RUST_ALLOCATOR_USES_PARTITION_ALLOC) && BUILDFLAG(IS_WIN) && \
     defined(ADDRESS_SANITIZER)
 #define USE_WIN_ALIGNED_MALLOC 1
 #else
 #define USE_WIN_ALIGNED_MALLOC 0
 #endif
 
-// This must exist as the stdlib depends on it to prove that we know the
-// alloc shims below are unstable. In the future we may be required to replace
-// them with a #[global_allocator] crate (see file comment above for more).
-//
-// Marked as weak as when Rust drives linking it includes this symbol itself,
-// and we don't want a collision due to C++ being in the same link target, where
-// C++ causes us to explicitly link in the stdlib and this symbol here.
-[[maybe_unused]]
-__attribute__((weak)) unsigned char __rust_no_alloc_shim_is_unstable;
+// The default allocator functions provided by the Rust standard library.
+extern "C" void* __rdl_alloc(size_t size, size_t align);
+extern "C" void __rdl_dealloc(void* p, size_t size, size_t align);
+extern "C" void* __rdl_realloc(void* p,
+                               size_t old_size,
+                               size_t align,
+                               size_t new_size);
+
+extern "C" void* __rdl_alloc_zeroed(size_t size, size_t align);
+
+namespace rust_allocator_internal {
 
-REMAP_ALLOC_ATTRIBUTES void* __rust_alloc(size_t size, size_t align) {
+unsigned char* alloc(size_t size, size_t align) {
 #if BUILDFLAG(RUST_ALLOCATOR_USES_PARTITION_ALLOC)
   // PartitionAlloc will crash if given an alignment larger than this.
   if (align > partition_alloc::internal::kMaxSupportedAlignment) {
     return nullptr;
   }
 
   if (align <= alignof(std::max_align_t)) {
-    return allocator_shim::UncheckedAlloc(size);
+    return static_cast<unsigned char*>(allocator_shim::UncheckedAlloc(size));
   } else {
-    return allocator_shim::UncheckedAlignedAlloc(size, align);
+    return static_cast<unsigned char*>(
+        allocator_shim::UncheckedAlignedAlloc(size, align));
   }
 #elif USE_WIN_ALIGNED_MALLOC
-  return _aligned_malloc(size, align);
+  return static_cast<unsigned char*>(_aligned_malloc(size, align));
 #else
-  extern void* __rdl_alloc(size_t size, size_t align);
-  return __rdl_alloc(size, align);
+  return static_cast<unsigned char*>(__rdl_alloc(size, align));
 #endif
 }
 
-REMAP_ALLOC_ATTRIBUTES void __rust_dealloc(void* p, size_t size, size_t align) {
+void dealloc(unsigned char* p, size_t size, size_t align) {
 #if BUILDFLAG(RUST_ALLOCATOR_USES_PARTITION_ALLOC)
   if (align <= alignof(std::max_align_t)) {
     allocator_shim::UncheckedFree(p);
@@ -147,54 +143,44 @@ REMAP_ALLOC_ATTRIBUTES void __rust_dealloc(void* p, size_t size, size_t align) {
 #elif USE_WIN_ALIGNED_MALLOC
   return _aligned_free(p);
 #else
-  extern void __rdl_dealloc(void* p, size_t size, size_t align);
   __rdl_dealloc(p, size, align);
 #endif
 }
 
-REMAP_ALLOC_ATTRIBUTES void* __rust_realloc(void* p,
-                                            size_t old_size,
-                                            size_t align,
-                                            size_t new_size) {
+unsigned char* realloc(unsigned char* p,
+                       size_t old_size,
+                       size_t align,
+                       size_t new_size) {
 #if BUILDFLAG(RUST_ALLOCATOR_USES_PARTITION_ALLOC)
   if (align <= alignof(std::max_align_t)) {
-    return allocator_shim::UncheckedRealloc(p, new_size);
+    return static_cast<unsigned char*>(
+        allocator_shim::UncheckedRealloc(p, new_size));
   } else {
-    return allocator_shim::UncheckedAlignedRealloc(p, new_size, align);
+    return static_cast<unsigned char*>(
+        allocator_shim::UncheckedAlignedRealloc(p, new_size, align));
   }
 #elif USE_WIN_ALIGNED_MALLOC
-  return _aligned_realloc(p, new_size, align);
+  return static_cast<unsigned char*>(_aligned_realloc(p, new_size, align));
 #else
-  extern void* __rdl_realloc(void* p, size_t old_size, size_t align,
-                             size_t new_size);
-  return __rdl_realloc(p, old_size, align, new_size);
+  return static_cast<unsigned char*>(
+      __rdl_realloc(p, old_size, align, new_size));
 #endif
 }
 
-REMAP_ALLOC_ATTRIBUTES void* __rust_alloc_zeroed(size_t size, size_t align) {
+unsigned char* alloc_zeroed(size_t size, size_t align) {
 #if BUILDFLAG(RUST_ALLOCATOR_USES_PARTITION_ALLOC) || USE_WIN_ALIGNED_MALLOC
   // TODO(danakj): When RUST_ALLOCATOR_USES_PARTITION_ALLOC is true, it's
   // possible that a partition_alloc::UncheckedAllocZeroed() call would perform
   // better than partition_alloc::UncheckedAlloc() + memset. But there is no
   // such API today. See b/342251590.
-  void* p = __rust_alloc(size, align);
+  unsigned char* p = alloc(size, align);
   if (p) {
     memset(p, 0, size);
   }
   return p;
 #else
-  extern void* __rdl_alloc_zeroed(size_t size, size_t align);
-  return __rdl_alloc_zeroed(size, align);
+  return static_cast<unsigned char*>(__rdl_alloc_zeroed(size, align));
 #endif
 }
 
-REMAP_ALLOC_ATTRIBUTES void __rust_alloc_error_handler(size_t size,
-                                                       size_t align) {
-  NO_CODE_FOLDING();
-  IMMEDIATE_CRASH();
-}
-
-REMAP_ALLOC_ATTRIBUTES extern const unsigned char
-    __rust_alloc_error_handler_should_panic = 0;
-
-}  // extern "C"
+}  // namespace rust_allocator_internal

build/rust/allocator/allocator_impls.h

@@ -0,0 +1,25 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BUILD_RUST_ALLOCATOR_ALLOCATOR_IMPLS_H_
+#define BUILD_RUST_ALLOCATOR_ALLOCATOR_IMPLS_H_
+
+#include <cstddef>
+
+#include "build/build_config.h"
+#include "build/rust/allocator/buildflags.h"
+
+namespace rust_allocator_internal {
+
+unsigned char* alloc(size_t size, size_t align);
+void dealloc(unsigned char* p, size_t size, size_t align);
+unsigned char* realloc(unsigned char* p,
+                       size_t old_size,
+                       size_t align,
+                       size_t new_size);
+unsigned char* alloc_zeroed(size_t size, size_t align);
+
+}  // namespace rust_allocator_internal
+
+#endif  // BUILD_RUST_ALLOCATOR_ALLOCATOR_IMPLS_H_

build/rust/allocator/allocator_shim_definitions.cc

@@ -0,0 +1,30 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <cstddef>
+
+#include "build/rust/allocator/alias.h"
+#include "build/rust/allocator/immediate_crash.h"
+
+extern "C" {
+
+// As part of rustc's contract for using `#[global_allocator]` without
+// rustc-generated shims we must define this symbol, since we are opting in to
+// unstable functionality. See https://github.com./rust-lang/rust/issues/123015
+//
+// Mark it weak since rustc will generate it when it drives linking.
+[[maybe_unused]]
+__attribute__((weak)) unsigned char __rust_no_alloc_shim_is_unstable;
+
+__attribute__((weak)) void __rust_alloc_error_handler(size_t size,
+                                                      size_t align) {
+  NO_CODE_FOLDING();
+  IMMEDIATE_CRASH();
+}
+
+__attribute__((
+    weak)) extern const unsigned char __rust_alloc_error_handler_should_panic =
+    0;
+
+}  // extern "C"

build/rust/std/compiler_specific.h renamed to build/rust/allocator/compiler_specific.h

@@ -7,8 +7,8 @@
 //
 // TODO(crbug.com/40279749): Avoid code duplication / reuse code.
 
-#ifndef BUILD_RUST_STD_COMPILER_SPECIFIC_H_
-#define BUILD_RUST_STD_COMPILER_SPECIFIC_H_
+#ifndef BUILD_RUST_ALLOCATOR_COMPILER_SPECIFIC_H_
+#define BUILD_RUST_ALLOCATOR_COMPILER_SPECIFIC_H_
 
 #include "build/build_config.h"
 
@@ -35,4 +35,4 @@
 #define NOINLINE
 #endif
 
-#endif  // BUILD_RUST_STD_COMPILER_SPECIFIC_H_
+#endif  // BUILD_RUST_ALLOCATOR_COMPILER_SPECIFIC_H_

build/rust/std/immediate_crash.h renamed to build/rust/allocator/immediate_crash.h

@@ -5,8 +5,8 @@
 // This file has been copied from //base/immediate_crash.h.
 // TODO(crbug.com/40279749): Avoid code duplication / reuse code.
 
-#ifndef BUILD_RUST_STD_IMMEDIATE_CRASH_H_
-#define BUILD_RUST_STD_IMMEDIATE_CRASH_H_
+#ifndef BUILD_RUST_ALLOCATOR_IMMEDIATE_CRASH_H_
+#define BUILD_RUST_ALLOCATOR_IMMEDIATE_CRASH_H_
 
 #include "build/build_config.h"
 
@@ -168,4 +168,4 @@
 
 #endif  // defined(__clang__) || defined(COMPILER_GCC)
 
-#endif  // BUILD_RUST_STD_IMMEDIATE_CRASH_H_
+#endif  // BUILD_RUST_ALLOCATOR_IMMEDIATE_CRASH_H_