Revert some miri changes

Author: bjorn3

library/alloc/src/alloc.rs

@@ -12,12 +12,12 @@ use core::ptr::{self, NonNull};
 
 extern "Rust" {
     // These are the magic symbols to call the global allocator. rustc generates
-    // them to call `__rg_alloc` etc. if there is a `#[global_allocator]` attribute
-    // (the code expanding that attribute macro generates those functions), or to call
+    // them to call `GLOBAL.alloc` etc. if there is a `#[global_allocator]` attribute
+    // (the code expanding that attribute macro generates those functions), or if not
     // the default implementations in std (weak symbols in `library/std/src/alloc.rs`)
-    // otherwise.
-    // The rustc fork of LLVM 14 and earlier also special-cases these function names to be able to optimize them
-    // like `malloc`, `realloc`, and `free`, respectively.
+    // is used otherwise.
+    // The rustc fork of LLVM 14 and earlier also special-cases these function names to
+    // be able to optimize them like `malloc`, `realloc`, and `free`, respectively.
     #[rustc_allocator]
     #[rustc_nounwind]
     fn __rust_alloc(size: usize, align: usize) -> *mut u8;

src/tools/miri/src/helpers.rs

@@ -980,6 +980,21 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 return interp_ok(());
             }
 
+            if ["__rust_alloc", "__rust_alloc_zeroed", "__rust_realloc", "__rust_dealloc"]
+                .contains(&link_name.as_str())
+            {
+                let attrs = self.eval_context_ref().tcx.codegen_fn_attrs(instance.def_id());
+                if attrs
+                    .linkage
+                    .map_or(false, |linkage| linkage == rustc_middle::mir::mono::Linkage::WeakAny)
+                    && attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL)
+                {
+                    // We intentionally intercept the allocator methods even though libstd provides
+                    // default implementations.
+                    return interp_ok(());
+                }
+            }
+
             throw_machine_stop!(TerminationInfo::SymbolShimClashing {
                 link_name,
                 span: body.span.data(),

src/tools/miri/src/shims/alloc.rs

@@ -1,4 +1,5 @@
 use rustc_abi::{Align, Size};
+use rustc_ast::expand::allocator::AllocatorKind;
 
 use crate::*;
 
@@ -49,6 +50,34 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         Align::from_bytes(prev_power_of_two(size)).unwrap()
     }
 
+    /// Emulates calling the internal __rust_* allocator functions
+    fn emulate_allocator(
+        &mut self,
+        default: impl FnOnce(&mut MiriInterpCx<'tcx>) -> InterpResult<'tcx>,
+    ) -> InterpResult<'tcx, EmulateItemResult> {
+        let this = self.eval_context_mut();
+
+        let Some(allocator_kind) = this.tcx.allocator_kind(()) else {
+            // in real code, this symbol does not exist without an allocator
+            return interp_ok(EmulateItemResult::NotSupported);
+        };
+
+        match allocator_kind {
+            AllocatorKind::Global => {
+                // When `#[global_allocator]` is used, `__rust_*` is defined by the macro expansion
+                // of this attribute. As such we have to call an exported Rust function,
+                // and not execute any Miri shim. Somewhat unintuitively doing so is done
+                // by returning `NotSupported`, which triggers the `lookup_exported_symbol`
+                // fallback case in `emulate_foreign_item`.
+                interp_ok(EmulateItemResult::NotSupported)
+            }
+            AllocatorKind::Default => {
+                default(this)?;
+                interp_ok(EmulateItemResult::NeedsReturn)
+            }
+        }
+    }
+
     fn malloc(&mut self, size: u64, init: AllocInit) -> InterpResult<'tcx, Pointer> {
         let this = self.eval_context_mut();
         let align = this.malloc_align(size);

src/tools/miri/src/shims/foreign_items.rs

@@ -1,5 +1,6 @@
 use std::collections::hash_map::Entry;
 use std::io::Write;
+use std::iter;
 use std::path::Path;
 
 use rustc_abi::{Align, AlignFromBytesError, Size};
@@ -502,34 +503,127 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
 
             // Rust allocation
-            "miri_alloc" => {
-                let [size, align] = this.check_shim(abi, Conv::Rust, link_name, args)?;
-                let size = this.read_target_usize(size)?;
-                let align = this.read_target_usize(align)?;
+            "__rust_alloc" | "miri_alloc" => {
+                let default = |ecx: &mut MiriInterpCx<'tcx>| {
+                    // Only call `check_shim` when `#[global_allocator]` isn't used. When that
+                    // macro is used, we act like no shim exists, so that the exported function can run.
+                    let [size, align] = ecx.check_shim(abi, Conv::Rust, link_name, args)?;
+                    let size = ecx.read_target_usize(size)?;
+                    let align = ecx.read_target_usize(align)?;
+
+                    ecx.check_rustc_alloc_request(size, align)?;
+
+                    let memory_kind = match link_name.as_str() {
+                        "__rust_alloc" => MiriMemoryKind::Rust,
+                        "miri_alloc" => MiriMemoryKind::Miri,
+                        _ => unreachable!(),
+                    };
 
-                this.check_rustc_alloc_request(size, align)?;
+                    let ptr = ecx.allocate_ptr(
+                        Size::from_bytes(size),
+                        Align::from_bytes(align).unwrap(),
+                        memory_kind.into(),
+                        AllocInit::Uninit,
+                    )?;
 
-                let ptr = this.allocate_ptr(
-                    Size::from_bytes(size),
-                    Align::from_bytes(align).unwrap(),
-                    MiriMemoryKind::Miri.into(),
-                    AllocInit::Uninit,
-                )?;
+                    ecx.write_pointer(ptr, dest)
+                };
 
-                this.write_pointer(ptr, dest)?;
+                match link_name.as_str() {
+                    "__rust_alloc" => return this.emulate_allocator(default),
+                    "miri_alloc" => {
+                        default(this)?;
+                        return interp_ok(EmulateItemResult::NeedsReturn);
+                    }
+                    _ => unreachable!(),
+                }
             }
-            "miri_dealloc" => {
-                let [ptr, old_size, align] = this.check_shim(abi, Conv::Rust, link_name, args)?;
-                let ptr = this.read_pointer(ptr)?;
-                let old_size = this.read_target_usize(old_size)?;
-                let align = this.read_target_usize(align)?;
+            "__rust_alloc_zeroed" => {
+                return this.emulate_allocator(|this| {
+                    // See the comment for `__rust_alloc` why `check_shim` is only called in the
+                    // default case.
+                    let [size, align] = this.check_shim(abi, Conv::Rust, link_name, args)?;
+                    let size = this.read_target_usize(size)?;
+                    let align = this.read_target_usize(align)?;
+
+                    this.check_rustc_alloc_request(size, align)?;
+
+                    let ptr = this.allocate_ptr(
+                        Size::from_bytes(size),
+                        Align::from_bytes(align).unwrap(),
+                        MiriMemoryKind::Rust.into(),
+                        AllocInit::Zero,
+                    )?;
 
-                // No need to check old_size/align; we anyway check that they match the allocation.
-                this.deallocate_ptr(
-                    ptr,
-                    Some((Size::from_bytes(old_size), Align::from_bytes(align).unwrap())),
-                    MiriMemoryKind::Miri.into(),
-                )?;
+                    // We just allocated this, the access is definitely in-bounds.
+                    this.write_bytes_ptr(
+                        ptr.into(),
+                        iter::repeat(0u8).take(usize::try_from(size).unwrap()),
+                    )
+                    .unwrap();
+                    this.write_pointer(ptr, dest)
+                });
+            }
+            "__rust_dealloc" | "miri_dealloc" => {
+                let default = |ecx: &mut MiriInterpCx<'tcx>| {
+                    // See the comment for `__rust_alloc` why `check_shim` is only called in the
+                    // default case.
+                    let [ptr, old_size, align] =
+                        ecx.check_shim(abi, Conv::Rust, link_name, args)?;
+                    let ptr = ecx.read_pointer(ptr)?;
+                    let old_size = ecx.read_target_usize(old_size)?;
+                    let align = ecx.read_target_usize(align)?;
+
+                    let memory_kind = match link_name.as_str() {
+                        "__rust_dealloc" => MiriMemoryKind::Rust,
+                        "miri_dealloc" => MiriMemoryKind::Miri,
+                        _ => unreachable!(),
+                    };
+
+                    // No need to check old_size/align; we anyway check that they match the allocation.
+                    ecx.deallocate_ptr(
+                        ptr,
+                        Some((Size::from_bytes(old_size), Align::from_bytes(align).unwrap())),
+                        memory_kind.into(),
+                    )
+                };
+
+                match link_name.as_str() {
+                    "__rust_dealloc" => {
+                        return this.emulate_allocator(default);
+                    }
+                    "miri_dealloc" => {
+                        default(this)?;
+                        return interp_ok(EmulateItemResult::NeedsReturn);
+                    }
+                    _ => unreachable!(),
+                }
+            }
+            "__rust_realloc" => {
+                return this.emulate_allocator(|this| {
+                    // See the comment for `__rust_alloc` why `check_shim` is only called in the
+                    // default case.
+                    let [ptr, old_size, align, new_size] =
+                        this.check_shim(abi, Conv::Rust, link_name, args)?;
+                    let ptr = this.read_pointer(ptr)?;
+                    let old_size = this.read_target_usize(old_size)?;
+                    let align = this.read_target_usize(align)?;
+                    let new_size = this.read_target_usize(new_size)?;
+                    // No need to check old_size; we anyway check that they match the allocation.
+
+                    this.check_rustc_alloc_request(new_size, align)?;
+
+                    let align = Align::from_bytes(align).unwrap();
+                    let new_ptr = this.reallocate_ptr(
+                        ptr,
+                        Some((Size::from_bytes(old_size), align)),
+                        Size::from_bytes(new_size),
+                        align,
+                        MiriMemoryKind::Rust.into(),
+                        AllocInit::Uninit,
+                    )?;
+                    this.write_pointer(new_ptr, dest)
+                });
             }
 
             // C memory handling functions

src/tools/miri/tests/fail/alloc/alloc_error_handler.stderr

@@ -9,7 +9,7 @@ LL |     ABORT();
    = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
    = note: inside `std::process::abort` at RUSTLIB/std/src/process.rs:LL:CC
    = note: inside `std::alloc::rust_oom` at RUSTLIB/std/src/alloc.rs:LL:CC
-   = note: inside `std::alloc::_::__rg_oom` at RUSTLIB/std/src/alloc.rs:LL:CC
+   = note: inside `std::alloc::_::__rust_alloc_error_handler` at RUSTLIB/std/src/alloc.rs:LL:CC
    = note: inside `std::alloc::handle_alloc_error::rt_error` at RUSTLIB/alloc/src/alloc.rs:LL:CC
    = note: inside `std::alloc::handle_alloc_error` at RUSTLIB/alloc/src/alloc.rs:LL:CC
 note: inside `main`

src/tools/miri/tests/fail/alloc/alloc_error_handler_custom.stderr

@@ -7,7 +7,7 @@ LL |     core::intrinsics::abort();
    |
    = note: BACKTRACE:
    = note: inside `alloc_error_handler` at tests/fail/alloc/alloc_error_handler_custom.rs:LL:CC
-note: inside `_::__rg_oom`
+note: inside `_::__rust_alloc_error_handler`
   --> tests/fail/alloc/alloc_error_handler_custom.rs:LL:CC
    |
 LL | #[alloc_error_handler]

src/tools/miri/tests/fail/alloc/alloc_error_handler_no_std.stderr

@@ -9,7 +9,7 @@ LL |     core::intrinsics::abort();
    |
    = note: BACKTRACE:
    = note: inside `panic_handler` at tests/fail/alloc/alloc_error_handler_no_std.rs:LL:CC
-   = note: inside `alloc::alloc::__alloc_error_handler::__rdl_oom` at RUSTLIB/alloc/src/alloc.rs:LL:CC
+   = note: inside `alloc::alloc::__alloc_error_handler::__rust_alloc_error_handler` at RUSTLIB/alloc/src/alloc.rs:LL:CC
    = note: inside `alloc::alloc::handle_alloc_error::rt_error` at RUSTLIB/alloc/src/alloc.rs:LL:CC
    = note: inside `alloc::alloc::handle_alloc_error` at RUSTLIB/alloc/src/alloc.rs:LL:CC
 note: inside `miri_start`