Use cfg(bootstrap) as necessary

Author: bjorn3

library/alloc/src/alloc.rs

@@ -421,6 +421,7 @@ pub use std::alloc::handle_alloc_error;
 #[doc(hidden)]
 #[allow(unused_attributes)]
 #[unstable(feature = "alloc_internals", issue = "none")]
+#[cfg(not(bootstrap))]
 pub mod __alloc_error_handler {
     #[rustc_std_internal_symbol]
     #[linkage = "weak"]
@@ -444,3 +445,26 @@ pub mod __alloc_error_handler {
         }
     }
 }
+
+#[cfg(all(not(no_global_oom_handling), not(test)))]
+#[doc(hidden)]
+#[allow(unused_attributes)]
+#[unstable(feature = "alloc_internals", issue = "none")]
+#[cfg(bootstrap)]
+pub mod __alloc_error_handler {
+    #[rustc_std_internal_symbol]
+    pub unsafe fn __rdl_oom(size: usize, _align: usize) -> ! {
+        extern "Rust" {
+            static __rust_alloc_error_handler_should_panic: u8;
+        }
+
+        if unsafe { __rust_alloc_error_handler_should_panic != 0 } {
+            panic!("memory allocation of {size} bytes failed")
+        } else {
+            core::panicking::panic_nounwind_fmt(
+                format_args!("memory allocation of {size} bytes failed"),
+                /* force_no_backtrace */ false,
+            )
+        }
+    }
+}

library/std/src/alloc.rs

@@ -381,6 +381,7 @@ pub fn rust_oom(layout: Layout) -> ! {
 #[doc(hidden)]
 #[allow(unused_attributes)]
 #[unstable(feature = "alloc_internals", issue = "none")]
+#[cfg(not(bootstrap))]
 pub mod __default_lib_allocator {
     use super::{GlobalAlloc, Layout, System};
     // These are used as a fallback for implementing the `__rust_alloc`, etc symbols
@@ -437,3 +438,54 @@ pub mod __default_lib_allocator {
         }
     }
 }
+
+#[cfg(not(test))]
+#[doc(hidden)]
+#[allow(unused_attributes)]
+#[unstable(feature = "alloc_internals", issue = "none")]
+#[cfg(bootstrap)]
+pub mod __default_lib_allocator {
+    use super::{GlobalAlloc, Layout, System};
+
+    #[rustc_std_internal_symbol]
+    pub unsafe extern "C" fn __rdl_alloc(size: usize, align: usize) -> *mut u8 {
+        // SAFETY: see the guarantees expected by `Layout::from_size_align` and
+        // `GlobalAlloc::alloc`.
+        unsafe {
+            let layout = Layout::from_size_align_unchecked(size, align);
+            System.alloc(layout)
+        }
+    }
+
+    #[rustc_std_internal_symbol]
+    pub unsafe extern "C" fn __rdl_dealloc(ptr: *mut u8, size: usize, align: usize) {
+        // SAFETY: see the guarantees expected by `Layout::from_size_align` and
+        // `GlobalAlloc::dealloc`.
+        unsafe { System.dealloc(ptr, Layout::from_size_align_unchecked(size, align)) }
+    }
+
+    #[rustc_std_internal_symbol]
+    pub unsafe extern "C" fn __rdl_realloc(
+        ptr: *mut u8,
+        old_size: usize,
+        align: usize,
+        new_size: usize,
+    ) -> *mut u8 {
+        // SAFETY: see the guarantees expected by `Layout::from_size_align` and
+        // `GlobalAlloc::realloc`.
+        unsafe {
+            let old_layout = Layout::from_size_align_unchecked(old_size, align);
+            System.realloc(ptr, old_layout, new_size)
+        }
+    }
+
+    #[rustc_std_internal_symbol]
+    pub unsafe extern "C" fn __rdl_alloc_zeroed(size: usize, align: usize) -> *mut u8 {
+        // SAFETY: see the guarantees expected by `Layout::from_size_align` and
+        // `GlobalAlloc::alloc_zeroed`.
+        unsafe {
+            let layout = Layout::from_size_align_unchecked(size, align);
+            System.alloc_zeroed(layout)
+        }
+    }
+}