Default to using libgc alloc instead of system alloc

Previously users had to ensure they set the #[global_allocator] in order
to use Alloy. This was never ideal, but it was necessary because it was
too difficult to implement when we statically linked libgc. We've
changed this to use dynamic linkage now, and I also know my way around
the bootstrap process, so I've fixed this long standing annoyance.

In addition, this is also needed for more precise metric tracking in our
benchmarks, where we use different allocators depending whether we're
constructing an `Rc` / `Arc` etc. Now, these will always correctly
resolve to the libgc allocator.

Author: jacob-hughes

library/alloc/src/bdwgc.rs

@@ -19,6 +19,7 @@ use crate::alloc::{AllocError, Allocator, GlobalAlloc, Layout};
 pub fn init(finalizer_thread: extern "C" fn()) {
     unsafe {
         api::GC_set_finalize_on_demand(1);
+        api::GC_set_warn_proc(Some(api::GC_ignore_warn_proc));
         api::GC_set_finalizer_notifier(Some(finalizer_thread));
         #[cfg(feature = "gc-disable")]
         api::GC_disable();
@@ -53,7 +54,7 @@ unsafe impl GlobalAlloc for GcAllocator {
 }
 
 #[inline]
-unsafe fn gc_malloc(layout: Layout) -> *mut u8 {
+pub unsafe fn gc_malloc(layout: Layout) -> *mut u8 {
     if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
         unsafe { api::GC_malloc(layout.size()) as *mut u8 }
     } else {
@@ -69,7 +70,7 @@ unsafe fn gc_malloc(layout: Layout) -> *mut u8 {
 }
 
 #[inline]
-unsafe fn gc_realloc(ptr: *mut u8, old_layout: Layout, new_size: usize) -> *mut u8 {
+pub unsafe fn gc_realloc(ptr: *mut u8, old_layout: Layout, new_size: usize) -> *mut u8 {
     if old_layout.align() <= MIN_ALIGN && old_layout.align() <= new_size {
         unsafe { api::GC_realloc(ptr as *mut c_void, new_size) as *mut u8 }
     } else {
@@ -88,7 +89,7 @@ unsafe fn gc_realloc(ptr: *mut u8, old_layout: Layout, new_size: usize) -> *mut
 }
 
 #[inline]
-unsafe fn gc_free(ptr: *mut u8, _: Layout) {
+pub unsafe fn gc_free(ptr: *mut u8, _: Layout) {
     unsafe {
         api::GC_free(ptr as *mut c_void);
     }

library/std/src/sys/alloc/unix.rs

@@ -1,89 +1,24 @@
-use super::{MIN_ALIGN, realloc_fallback};
 use crate::alloc::{GlobalAlloc, Layout, System};
-use crate::ptr;
 
 #[stable(feature = "alloc_system_type", since = "1.28.0")]
 unsafe impl GlobalAlloc for System {
     #[inline]
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        // jemalloc provides alignment less than MIN_ALIGN for small allocations.
-        // So only rely on MIN_ALIGN if size >= align.
-        // Also see <https://github.com/rust-lang/rust/issues/45955> and
-        // <https://github.com/rust-lang/rust/issues/62251#issuecomment-507580914>.
-        if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
-            unsafe { libc::malloc(layout.size()) as *mut u8 }
-        } else {
-            // `posix_memalign` returns a non-aligned value if supplied a very
-            // large alignment on older versions of Apple's platforms (unknown
-            // exactly which version range, but the issue is definitely
-            // present in macOS 10.14 and iOS 13.3).
-            //
-            // <https://github.com/rust-lang/rust/issues/30170>
-            #[cfg(target_vendor = "apple")]
-            {
-                if layout.align() > (1 << 31) {
-                    return ptr::null_mut();
-                }
-            }
-            unsafe { aligned_malloc(&layout) }
-        }
+        unsafe { crate::bdwgc::gc_malloc(layout) }
     }
 
     #[inline]
     unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        // See the comment above in `alloc` for why this check looks the way it does.
-        if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
-            unsafe { libc::calloc(layout.size(), 1) as *mut u8 }
-        } else {
-            let ptr = unsafe { self.alloc(layout) };
-            if !ptr.is_null() {
-                unsafe { ptr::write_bytes(ptr, 0, layout.size()) };
-            }
-            ptr
-        }
+        unsafe { crate::bdwgc::gc_malloc(layout) }
     }
 
     #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
-        unsafe { libc::free(ptr as *mut libc::c_void) }
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        unsafe { crate::bdwgc::gc_free(ptr, layout) }
     }
 
     #[inline]
     unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        if layout.align() <= MIN_ALIGN && layout.align() <= new_size {
-            unsafe { libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8 }
-        } else {
-            unsafe { realloc_fallback(self, ptr, layout, new_size) }
-        }
-    }
-}
-
-cfg_if::cfg_if! {
-    // We use posix_memalign wherever possible, but some targets have very incomplete POSIX coverage
-    // so we need a fallback for those.
-    if #[cfg(any(
-        target_os = "horizon",
-        target_os = "vita",
-    ))] {
-        #[inline]
-        unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {
-            unsafe { libc::memalign(layout.align(), layout.size()) as *mut u8 }
-        }
-    } else {
-        #[inline]
-        #[cfg_attr(target_os = "vxworks", allow(unused_unsafe))]
-        unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {
-            let mut out = ptr::null_mut();
-            // We prefer posix_memalign over aligned_alloc since it is more widely available, and
-            // since with aligned_alloc, implementations are making almost arbitrary choices for
-            // which alignments are "supported", making it hard to use. For instance, some
-            // implementations require the size to be a multiple of the alignment (wasi emmalloc),
-            // while others require the alignment to be at least the pointer size (Illumos, macOS).
-            // posix_memalign only has one, clear requirement: that the alignment be a multiple of
-            // `sizeof(void*)`. Since these are all powers of 2, we can just use max.
-            let align = layout.align().max(crate::mem::size_of::<usize>());
-            let ret = unsafe { libc::posix_memalign(&mut out, align, layout.size()) };
-            if ret != 0 { ptr::null_mut() } else { out as *mut u8 }
-        }
+        unsafe { crate::bdwgc::gc_realloc(ptr, layout, new_size) }
     }
 }

src/bootstrap/src/core/build_steps/compile.rs

@@ -589,6 +589,9 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, stage: u32, car
     // about libgc.
     cargo.rustflag("-L").rustflag(builder.bdwgc_out(target).join("lib").to_str().unwrap());
 
+    // Don't run the GC when we're building rustc.
+    cargo.env("GC_DONT_GC", "true");
+
     // Determine if we're going to compile in optimized C intrinsics to
     // the `compiler-builtins` crate. These intrinsics live in LLVM's
     // `compiler-rt` repository.
@@ -1234,6 +1237,9 @@ pub fn rustc_cargo(
     let bindgen = builder.ensure(Bindgen { target });
     cargo.env("RUSTC_BINDGEN", &bindgen.tool_path);
 
+    // Don't run the GC when we're building rustc.
+    cargo.env("GC_DONT_GC", "true");
+
     // Building with protected visibility reduces the number of dynamic relocations needed, giving
     // us a faster startup time. However GNU ld < 2.40 will error if we try to link a shared object
     // with direct references to protected symbols, so for now we only use protected symbols if

src/bootstrap/src/core/build_steps/test.rs

@@ -262,6 +262,7 @@ impl Step for Cargotest {
             .args(builder.config.test_args())
             .env("RUSTC", builder.rustc(compiler))
             .env("RUSTDOC", builder.rustdoc(compiler))
+            .env("GC_DONT_GC", "true")
             .env("RUSTC_BINDGEN", &bindgen.tool_path);
         add_rustdoc_cargo_linker_args(
             &mut cmd,
@@ -849,7 +850,8 @@ impl Step for RustdocTheme {
             .env("RUSTDOC_LIBDIR", builder.sysroot_target_libdir(self.compiler, self.compiler.host))
             .env("CFG_RELEASE_CHANNEL", &builder.config.channel)
             .env("RUSTDOC_REAL", builder.rustdoc(self.compiler))
-            .env("RUSTC_BOOTSTRAP", "1");
+            .env("RUSTC_BOOTSTRAP", "1")
+            .env("GC_DONT_GC", "true");
         cmd.args(linker_args(builder, self.compiler.host, LldThreads::No, self.compiler.stage));
 
         cmd.delay_failure().run(builder);
@@ -880,6 +882,7 @@ impl Step for RustdocJSStd {
             builder.config.nodejs.as_ref().expect("need nodejs to run rustdoc-js-std tests");
         let mut command = command(nodejs);
         command
+            .env("GC_DONT_GC", "true")
             .arg(builder.src.join("src/tools/rustdoc-js/tester.js"))
             .arg("--crate-name")
             .arg("std")
@@ -1058,6 +1061,8 @@ impl Step for RustdocGUI {
             cmd.arg("--npm").arg(npm);
         }
 
+        cmd.env("GC_DONT_GC", "true");
+
         let _time = helpers::timeit(builder);
         let _guard = builder.msg_sysroot_tool(
             Kind::Test,
@@ -1646,6 +1651,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         }
 
         let mut cmd = builder.tool_cmd(Tool::Compiletest);
+        cmd.env("GC_DONT_GC", "true");
 
         if suite == "mir-opt" {
             builder.ensure(compile::Std::new(compiler, target).is_for_mir_opt_tests(true));
@@ -2517,6 +2523,7 @@ fn run_cargo_test<'a>(
 
     let bindgen = builder.ensure(Bindgen { target: compiler.host });
     cargo.env("RUSTC_BINDGEN", &bindgen.tool_path);
+    cargo.env("GC_DONT_GC", "true");
 
     #[cfg(feature = "build-metrics")]
     builder.metrics.begin_test_suite(

tests/ui/runtime/gc/disable.rs

@@ -7,6 +7,7 @@
 use std::gc::{disable, enable, is_enabled, try_enable};
 
 fn main() {
+    enable();
     assert!(is_enabled());
     disable();
     disable();