Bless miri tests

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/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 `start`

src/tools/miri/tests/fail/alloc/deallocate-bad-alignment.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: memory access failed: ALLOC has been freed, so this pointer is dangling
-  --> tests/fail/alloc/deallocate-twice.rs:LL:CC
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL |         dealloc(x, Layout::from_size_align_unchecked(1, 1));
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: ALLOC has been freed, so this pointer is dangling
+LL |         unsafe { libc::free(ptr as *mut libc::c_void) }
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: ALLOC has been freed, so this pointer is dangling
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
@@ -17,7 +17,13 @@ help: ALLOC was deallocated here:
 LL |         dealloc(x, Layout::from_size_align_unchecked(1, 1));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: BACKTRACE (of the first span):
-   = note: inside `main` at tests/fail/alloc/deallocate-twice.rs:LL:CC
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_dealloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside `main`
+  --> tests/fail/alloc/deallocate-twice.rs:LL:CC
+   |
+LL |         dealloc(x, Layout::from_size_align_unchecked(1, 1));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

src/tools/miri/tests/fail/alloc/deallocate-bad-size.stderr

@@ -1,15 +1,21 @@
-error: Undefined Behavior: incorrect layout on deallocation: ALLOC has size 1 and alignment ALIGN, but gave size 2 and alignment ALIGN
-  --> tests/fail/alloc/reallocate-bad-size.rs:LL:CC
+error: memory leaked: ALLOC (C heap, size: 1, align: 1), allocated here:
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL |         let _y = realloc(x, Layout::from_size_align_unchecked(2, 1), 1);
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ incorrect layout on deallocation: ALLOC has size 1 and alignment ALIGN, but gave size 2 and alignment ALIGN
+LL |             unsafe { libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8 }
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
-   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = note: BACKTRACE:
-   = note: inside `main` at tests/fail/alloc/reallocate-bad-size.rs:LL:CC
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::realloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_realloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside `main`
+  --> tests/fail/alloc/reallocate-bad-size.rs:LL:CC
+   |
+LL | ...   let _y = realloc(x, Layout::from_size_align_unchecked(2, 1), 1);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
+note: set `MIRIFLAGS=-Zmiri-ignore-leaks` to disable this check
+
 error: aborting due to 1 previous error
 

src/tools/miri/tests/fail/alloc/deallocate-twice.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: memory access failed: ALLOC has been freed, so this pointer is dangling
-  --> tests/fail/alloc/reallocate-dangling.rs:LL:CC
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL |         let _z = realloc(x, Layout::from_size_align_unchecked(1, 1), 1);
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: ALLOC has been freed, so this pointer is dangling
+LL |             unsafe { libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8 }
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: ALLOC has been freed, so this pointer is dangling
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
@@ -17,7 +17,13 @@ help: ALLOC was deallocated here:
 LL |         dealloc(x, Layout::from_size_align_unchecked(1, 1));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: BACKTRACE (of the first span):
-   = note: inside `main` at tests/fail/alloc/reallocate-dangling.rs:LL:CC
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::realloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_realloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside `main`
+  --> tests/fail/alloc/reallocate-dangling.rs:LL:CC
+   |
+LL |         let _z = realloc(x, Layout::from_size_align_unchecked(1, 1), 1);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

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

@@ -1,12 +1,14 @@
-error: Undefined Behavior: deallocating ALLOC, which is stack variable memory, using Rust heap deallocation operation
-  --> RUSTLIB/alloc/src/boxed.rs:LL:CC
+error: Undefined Behavior: deallocating ALLOC, which is stack variable memory, using C heap deallocation operation
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL |                 self.1.deallocate(From::from(ptr.cast()), layout);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocating ALLOC, which is stack variable memory, using Rust heap deallocation operation
+LL |         unsafe { libc::free(ptr as *mut libc::c_void) }
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocating ALLOC, which is stack variable memory, using C heap deallocation operation
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = note: BACKTRACE:
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_dealloc` at RUSTLIB/std/src/alloc.rs:LL:CC
    = note: inside `<std::boxed::Box<i32> as std::ops::Drop>::drop` at RUSTLIB/alloc/src/boxed.rs:LL:CC
    = note: inside `std::ptr::drop_in_place::<std::boxed::Box<i32>> - shim(Some(std::boxed::Box<i32>))` at RUSTLIB/core/src/ptr/mod.rs:LL:CC
    = note: inside `std::mem::drop::<std::boxed::Box<i32>>` at RUSTLIB/core/src/mem/mod.rs:LL:CC

src/tools/miri/tests/fail/alloc/reallocate-bad-size.stderr

@@ -1,13 +1,29 @@
-error: Undefined Behavior: creating an allocation larger than half the address space
-  --> tests/fail/alloc/too_large.rs:LL:CC
+thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
+unsafe precondition(s) violated: Layout::from_size_align_unchecked requires that align is a power of 2 and the rounded-up allocation size does not exceed isize::MAX
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+thread caused non-unwinding panic. aborting.
+error: abnormal termination: the program aborted execution
+  --> RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
    |
-LL |         __rust_alloc(bytes, 1);
-   |         ^^^^^^^^^^^^^^^^^^^^^^ creating an allocation larger than half the address space
+LL |     unsafe { libc::abort() }
+   |              ^^^^^^^^^^^^^ the program aborted execution
    |
-   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
-   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = note: BACKTRACE:
-   = note: inside `main` at tests/fail/alloc/too_large.rs:LL:CC
+   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+   = note: inside `std::panicking::rust_panic_with_hook` at RUSTLIB/std/src/panicking.rs:LL:CC
+   = note: inside closure at RUSTLIB/std/src/panicking.rs:LL:CC
+   = note: inside `std::sys::backtrace::__rust_end_short_backtrace::<{closure@std::panicking::begin_panic_handler::{closure#0}}, !>` at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
+   = note: inside `std::panicking::begin_panic_handler` at RUSTLIB/std/src/panicking.rs:LL:CC
+   = note: inside `core::panicking::panic_nounwind` at RUSTLIB/core/src/panicking.rs:LL:CC
+   = note: inside `std::alloc::Layout::from_size_align_unchecked::precondition_check` at RUSTLIB/core/src/ub_checks.rs:LL:CC
+   = note: inside `std::alloc::Layout::from_size_align_unchecked` at RUSTLIB/core/src/ub_checks.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_alloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside `main`
+  --> tests/fail/alloc/too_large.rs:LL:CC
+   |
+LL |         __rust_alloc(bytes, 1);
+   |         ^^^^^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

src/tools/miri/tests/fail/alloc/reallocate-dangling.stderr

@@ -1,14 +1,138 @@
-error: unsupported operation: creating allocation with alignment ALIGN exceeding rustc's maximum supported value
-  --> tests/fail/alloc/unsupported_big_alignment.rs:LL:CC
+thread 'rustc' panicked at src/tools/miri/src/shims/alloc.rs:LL:CC:
+called `Result::unwrap()` on an `Err` value: `1073741824` is too large
+stack backtrace:
+   0: rust_begin_unwind
+ at RUSTLIB/std/src/panicking.rs:LL:CC
+   1: core::panicking::panic_fmt
+ at RUSTLIB/core/src/panicking.rs:LL:CC
+   2: core::result::unwrap_failed
+ at RUSTLIB/core/src/result.rs:LL:CC
+   3: <core::result::Result<rustc_abi::Align, rustc_abi::AlignFromBytesError>>::unwrap
+ at RUSTLIB/core/src/result.rs:LL:CC
+   4: <rustc_const_eval::interpret::eval_context::InterpCx<miri::machine::MiriMachine> as miri::shims::alloc::EvalContextExt>::posix_memalign
+ at ./src/shims/alloc.rs:LL:CC
+   5: <rustc_const_eval::interpret::eval_context::InterpCx<miri::machine::MiriMachine> as miri::shims::unix::foreign_items::EvalContextExt>::emulate_foreign_item_inner
+ at ./src/shims/unix/foreign_items.rs:LL:CC
+   6: <rustc_const_eval::interpret::eval_context::InterpCx<miri::machine::MiriMachine> as miri::shims::foreign_items::EvalContextExtPriv>::emulate_foreign_item_inner
+ at ./src/shims/foreign_items.rs:LL:CC
+   7: <rustc_const_eval::interpret::eval_context::InterpCx<miri::machine::MiriMachine> as miri::shims::foreign_items::EvalContextExt>::emulate_foreign_item
+ at ./src/shims/foreign_items.rs:LL:CC
+   8: <miri::machine::MiriMachine as rustc_const_eval::interpret::machine::Machine>::find_mir_or_eval_fn
+ at ./src/machine.rs:LL:CC
+   9: <rustc_const_eval::interpret::eval_context::InterpCx<miri::machine::MiriMachine>>::init_fn_call
+ at /home/gh-bjorn3/rust/compiler/rustc_const_eval/src/interpret/call.rs:LL:CC
+  10: <rustc_const_eval::interpret::eval_context::InterpCx<miri::machine::MiriMachine>>::eval_terminator
+ at /home/gh-bjorn3/rust/compiler/rustc_const_eval/src/interpret/step.rs:LL:CC
+  11: <rustc_const_eval::interpret::eval_context::InterpCx<miri::machine::MiriMachine>>::step
+ at /home/gh-bjorn3/rust/compiler/rustc_const_eval/src/interpret/step.rs:LL:CC
+  12: <rustc_const_eval::interpret::eval_context::InterpCx<miri::machine::MiriMachine> as miri::concurrency::thread::EvalContextExt>::run_threads
+ at ./src/concurrency/thread.rs:LL:CC
+  13: miri::eval::eval_entry::{closure#0}
+ at ./src/eval.rs:LL:CC
+  14: <miri::eval::eval_entry::{closure#0} as core::ops::function::FnOnce<()>>::call_once
+ at RUSTLIB/core/src/ops/function.rs:LL:CC
+  15: <core::panic::unwind_safe::AssertUnwindSafe<miri::eval::eval_entry::{closure#0}> as core::ops::function::FnOnce<()>>::call_once
+ at RUSTLIB/core/src/panic/unwind_safe.rs:LL:CC
+  16: std::panicking::try::do_call
+ at RUSTLIB/std/src/panicking.rs:LL:CC
+  17: std::panicking::try
+ at RUSTLIB/std/src/panicking.rs:LL:CC
+  18: std::panic::catch_unwind
+ at RUSTLIB/std/src/panic.rs:LL:CC
+  19: miri::eval::eval_entry
+ at ./src/eval.rs:LL:CC
+  20: <miri::MiriCompilerCalls as rustc_driver_impl::Callbacks>::after_analysis
+ at ./src/bin/miri.rs:LL:CC
+  21: rustc_driver_impl::run_compiler::{closure#0}::{closure#2}
+ at /home/gh-bjorn3/rust/compiler/rustc_driver_impl/src/lib.rs:LL:CC
+  22: rustc_interface::passes::create_and_enter_global_ctxt::{closure#2}::{closure#0}
+ at /home/gh-bjorn3/rust/compiler/rustc_interface/src/passes.rs:LL:CC
+  23: <rustc_middle::ty::context::TyCtxt>::create_global_ctxt::{closure#3}
+ at /home/gh-bjorn3/rust/compiler/rustc_middle/src/ty/context.rs:LL:CC
+  24: rustc_middle::ty::context::tls::enter_context::{closure#0}
+ at /home/gh-bjorn3/rust/compiler/rustc_middle/src/ty/context/tls.rs:LL:CC
+  25: <std::thread::local::LocalKey<core::cell::Cell<*const ()>>>::try_with
+ at RUSTLIB/std/src/thread/local.rs:LL:CC
+  26: <std::thread::local::LocalKey<core::cell::Cell<*const ()>>>::with
+ at RUSTLIB/std/src/thread/local.rs:LL:CC
+  27: rustc_middle::ty::context::tls::enter_context
+ at /home/gh-bjorn3/rust/compiler/rustc_middle/src/ty/context/tls.rs:LL:CC
+  28: <rustc_middle::ty::context::TyCtxt>::create_global_ctxt
+ at /home/gh-bjorn3/rust/compiler/rustc_middle/src/ty/context.rs:LL:CC
+  29: rustc_interface::passes::create_and_enter_global_ctxt::{closure#2}
+ at /home/gh-bjorn3/rust/compiler/rustc_interface/src/passes.rs:LL:CC
+  30: <rustc_interface::passes::create_and_enter_global_ctxt<core::option::Option<rustc_interface::queries::Linker>, rustc_driver_impl::run_compiler::{closure#0}::{closure#2}>::{closure#2} as core::ops::function::FnOnce<(&rustc_interface::interface::Compiler, &std::sync::once_lock::OnceLock<rustc_middle::ty::context::GlobalCtxt>, &rustc_data_structures::sync::worker_local::WorkerLocal<rustc_middle::arena::Arena>, &rustc_data_structures::sync::worker_local::WorkerLocal<rustc_hir::Arena>, rustc_driver_impl::run_compiler::{closure#0}::{closure#2})>>::call_once::{shim:vtable#0}
+ at RUSTLIB/core/src/ops/function.rs:LL:CC
+  31: <alloc::boxed::Box<dyn for<'a> core::ops::function::FnOnce<(&'a rustc_interface::interface::Compiler, &'a std::sync::once_lock::OnceLock<rustc_middle::ty::context::GlobalCtxt<'a>>, &'a rustc_data_structures::sync::worker_local::WorkerLocal<rustc_middle::arena::Arena<'a>>, &'a rustc_data_structures::sync::worker_local::WorkerLocal<rustc_hir::Arena<'a>>, rustc_driver_impl::run_compiler::{closure#0}::{closure#2}), Output = core::option::Option<rustc_interface::queries::Linker>>> as core::ops::function::FnOnce<(&rustc_interface::interface::Compiler, &std::sync::once_lock::OnceLock<rustc_middle::ty::context::GlobalCtxt>, &rustc_data_structures::sync::worker_local::WorkerLocal<rustc_middle::arena::Arena>, &rustc_data_structures::sync::worker_local::WorkerLocal<rustc_hir::Arena>, rustc_driver_impl::run_compiler::{closure#0}::{closure#2})>>::call_once
+ at RUSTLIB/alloc/src/boxed.rs:LL:CC
+  32: rustc_interface::passes::create_and_enter_global_ctxt
+ at /home/gh-bjorn3/rust/compiler/rustc_interface/src/passes.rs:LL:CC
+  33: rustc_driver_impl::run_compiler::{closure#0}
+ at /home/gh-bjorn3/rust/compiler/rustc_driver_impl/src/lib.rs:LL:CC
+  34: rustc_interface::interface::run_compiler::{closure#1}::{closure#0}
+ at /home/gh-bjorn3/rust/compiler/rustc_interface/src/interface.rs:LL:CC
+  35: <core::panic::unwind_safe::AssertUnwindSafe<rustc_interface::interface::run_compiler<(), rustc_driver_impl::run_compiler::{closure#0}>::{closure#1}::{closure#0}> as core::ops::function::FnOnce<()>>::call_once
+ at RUSTLIB/core/src/panic/unwind_safe.rs:LL:CC
+  36: std::panicking::try::do_call
+ at RUSTLIB/std/src/panicking.rs:LL:CC
+  37: std::panicking::try
+ at RUSTLIB/std/src/panicking.rs:LL:CC
+  38: std::panic::catch_unwind
+ at RUSTLIB/std/src/panic.rs:LL:CC
+  39: rustc_interface::interface::run_compiler::{closure#1}
+ at /home/gh-bjorn3/rust/compiler/rustc_interface/src/interface.rs:LL:CC
+  40: rustc_interface::util::run_in_thread_pool_with_globals::{closure#0}
+ at /home/gh-bjorn3/rust/compiler/rustc_interface/src/util.rs:LL:CC
+  41: rustc_interface::util::run_in_thread_with_globals::{closure#0}::{closure#0}::{closure#0}
+ at /home/gh-bjorn3/rust/compiler/rustc_interface/src/util.rs:LL:CC
+  42: <scoped_tls::ScopedKey<rustc_span::SessionGlobals>>::set
+ at CARGO_REGISTRY/.../lib.rs:LL:CC
+  43: rustc_span::create_session_globals_then
+ at /home/gh-bjorn3/rust/compiler/rustc_span/src/lib.rs:LL:CC
+  44: rustc_interface::util::run_in_thread_with_globals::{closure#0}::{closure#0}
+ at /home/gh-bjorn3/rust/compiler/rustc_interface/src/util.rs:LL:CC
+note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
+
+error: the compiler unexpectedly panicked. this is a bug.
+
+note: we would appreciate a bug report: https://github.com/rust-lang/miri/issues/new
+
+note: please make sure that you have updated to the latest nightly
+
+note: please attach the file at `/home/gh-bjorn3/rust/src/tools/miri/rustc-ice-2024-12-20T10_31_46-710436.txt` to your bug report
+
+note: compiler flags: -Z ui-testing
+
+query stack during panic:
+end of query stack
+
+Miri caused an ICE during evaluation. Here's the interpreter backtrace at the time of the panic:
+note: the place in the program where the ICE was triggered
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL |         __rust_alloc(1, 1 << 30);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^ creating allocation with alignment ALIGN exceeding rustc's maximum supported value
+LL |             let ret = unsafe { libc::posix_memalign(&mut out, align, layout.size()) };
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
    = note: BACKTRACE:
-   = note: inside `main` at tests/fail/alloc/unsupported_big_alignment.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
+   = note: inside `std::sys::alloc::unix::aligned_malloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::alloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_alloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside `main`
+  --> tests/fail/alloc/unsupported_big_alignment.rs:LL:CC
+   |
+LL |         __rust_alloc(1, 1 << 30);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: inside `<fn() as std::ops::FnOnce<()>>::call_once - shim(fn())` at RUSTLIB/core/src/ops/function.rs:LL:CC
+   = note: inside `std::sys::backtrace::__rust_begin_short_backtrace::<fn(), ()>` at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
+   = note: inside closure at RUSTLIB/std/src/rt.rs:LL:CC
+   = note: inside `std::ops::function::impls::<impl std::ops::FnOnce<()> for &dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe>::call_once` at RUSTLIB/core/src/ops/function.rs:LL:CC
+   = note: inside `std::panicking::r#try::do_call::<&dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe, i32>` at RUSTLIB/std/src/panicking.rs:LL:CC
+   = note: inside `std::panicking::r#try::<i32, &dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe>` at RUSTLIB/std/src/panicking.rs:LL:CC
+   = note: inside `std::panic::catch_unwind::<&dyn std::ops::Fn() -> i32 + std::marker::Sync + std::panic::RefUnwindSafe, i32>` at RUSTLIB/std/src/panic.rs:LL:CC
+   = note: inside closure at RUSTLIB/std/src/rt.rs:LL:CC
+   = note: inside `std::panicking::r#try::do_call::<{closure@std::rt::lang_start_internal::{closure#1}}, isize>` at RUSTLIB/std/src/panicking.rs:LL:CC
+   = note: inside `std::panicking::r#try::<isize, {closure@std::rt::lang_start_internal::{closure#1}}>` at RUSTLIB/std/src/panicking.rs:LL:CC
+   = note: inside `std::panic::catch_unwind::<{closure@std::rt::lang_start_internal::{closure#1}}, isize>` at RUSTLIB/std/src/panic.rs:LL:CC
+   = note: inside `std::rt::lang_start_internal` at RUSTLIB/std/src/rt.rs:LL:CC
+   = note: inside `std::rt::lang_start::<()>` at RUSTLIB/std/src/rt.rs:LL:CC
 

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

@@ -1,13 +1,29 @@
-error: Undefined Behavior: creating allocation with non-power-of-two alignment ALIGN
-  --> tests/fail/alloc/unsupported_non_power_two_alignment.rs:LL:CC
+thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
+unsafe precondition(s) violated: Layout::from_size_align_unchecked requires that align is a power of 2 and the rounded-up allocation size does not exceed isize::MAX
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+thread caused non-unwinding panic. aborting.
+error: abnormal termination: the program aborted execution
+  --> RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
    |
-LL |         __rust_alloc(1, 3);
-   |         ^^^^^^^^^^^^^^^^^^ creating allocation with non-power-of-two alignment ALIGN
+LL |     unsafe { libc::abort() }
+   |              ^^^^^^^^^^^^^ the program aborted execution
    |
-   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
-   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = note: BACKTRACE:
-   = note: inside `main` at tests/fail/alloc/unsupported_non_power_two_alignment.rs:LL:CC
+   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+   = note: inside `std::panicking::rust_panic_with_hook` at RUSTLIB/std/src/panicking.rs:LL:CC
+   = note: inside closure at RUSTLIB/std/src/panicking.rs:LL:CC
+   = note: inside `std::sys::backtrace::__rust_end_short_backtrace::<{closure@std::panicking::begin_panic_handler::{closure#0}}, !>` at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
+   = note: inside `std::panicking::begin_panic_handler` at RUSTLIB/std/src/panicking.rs:LL:CC
+   = note: inside `core::panicking::panic_nounwind` at RUSTLIB/core/src/panicking.rs:LL:CC
+   = note: inside `std::alloc::Layout::from_size_align_unchecked::precondition_check` at RUSTLIB/core/src/ub_checks.rs:LL:CC
+   = note: inside `std::alloc::Layout::from_size_align_unchecked` at RUSTLIB/core/src/ub_checks.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_alloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside `main`
+  --> tests/fail/alloc/unsupported_non_power_two_alignment.rs:LL:CC
+   |
+LL |         __rust_alloc(1, 3);
+   |         ^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

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

@@ -1,8 +1,8 @@
 error: Undefined Behavior: deallocation through <TAG> at ALLOC[0x0] is forbidden
-  --> RUSTLIB/alloc/src/boxed.rs:LL:CC
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL |                 self.1.deallocate(From::from(ptr.cast()), layout);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocation through <TAG> at ALLOC[0x0] is forbidden
+LL |         unsafe { libc::free(ptr as *mut libc::c_void) }
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocation through <TAG> at ALLOC[0x0] is forbidden
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Tree Borrows rules it violated are still experimental
    = help: the accessed tag <TAG> is foreign to the protected tag <TAG> (i.e., it is not a child)
@@ -25,6 +25,8 @@ LL |             || drop(Box::from_raw(ptr)),
    |                     ^^^^^^^^^^^^^^^^^^
    = help: this transition corresponds to a temporary loss of write permissions until function exit
    = note: BACKTRACE (of the first span):
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_dealloc` at RUSTLIB/std/src/alloc.rs:LL:CC
    = note: inside `<std::boxed::Box<i32> as std::ops::Drop>::drop` at RUSTLIB/alloc/src/boxed.rs:LL:CC
    = note: inside `std::ptr::drop_in_place::<std::boxed::Box<i32>> - shim(Some(std::boxed::Box<i32>))` at RUSTLIB/core/src/ptr/mod.rs:LL:CC
    = note: inside `std::mem::drop::<std::boxed::Box<i32>>` at RUSTLIB/core/src/mem/mod.rs:LL:CC

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

@@ -1,8 +1,8 @@
 error: Undefined Behavior: deallocation through <TAG> at ALLOC[0x0] is forbidden
-  --> RUSTLIB/alloc/src/boxed.rs:LL:CC
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL |                 self.1.deallocate(From::from(ptr.cast()), layout);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocation through <TAG> at ALLOC[0x0] is forbidden
+LL |         unsafe { libc::free(ptr as *mut libc::c_void) }
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocation through <TAG> at ALLOC[0x0] is forbidden
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Tree Borrows rules it violated are still experimental
    = help: the accessed tag <TAG> is foreign to the protected tag <TAG> (i.e., it is not a child)
@@ -25,6 +25,8 @@ LL |             || drop(Box::from_raw(ptr)),
    |                     ^^^^^^^^^^^^^^^^^^
    = help: this transition corresponds to a temporary loss of write permissions until function exit
    = note: BACKTRACE (of the first span):
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_dealloc` at RUSTLIB/std/src/alloc.rs:LL:CC
    = note: inside `<std::boxed::Box<i32> as std::ops::Drop>::drop` at RUSTLIB/alloc/src/boxed.rs:LL:CC
    = note: inside `std::ptr::drop_in_place::<std::boxed::Box<i32>> - shim(Some(std::boxed::Box<i32>))` at RUSTLIB/core/src/ptr/mod.rs:LL:CC
    = note: inside `std::mem::drop::<std::boxed::Box<i32>>` at RUSTLIB/core/src/mem/mod.rs:LL:CC

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

@@ -1,8 +1,8 @@
 error: Undefined Behavior: deallocation through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
-  --> tests/fail/both_borrows/zero-sized-protected.rs:LL:CC
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL |     unsafe { dealloc(ptr, l) };
-   |              ^^^^^^^^^^^^^^^ deallocation through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
+LL |         unsafe { libc::free(ptr as *mut libc::c_void) }
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocation through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Tree Borrows rules it violated are still experimental
    = help: the allocation of the accessed tag <TAG> (root of the allocation) also contains the strongly protected tag <TAG>
@@ -18,7 +18,13 @@ help: the strongly protected tag <TAG> was created here, in the initial state Re
 LL | fn test(_x: &mut (), ptr: *mut u8, l: Layout) {
    |         ^^
    = note: BACKTRACE (of the first span):
-   = note: inside `test` at tests/fail/both_borrows/zero-sized-protected.rs:LL:CC
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_dealloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside `test`
+  --> tests/fail/both_borrows/zero-sized-protected.rs:LL:CC
+   |
+LL |     unsafe { dealloc(ptr, l) };
+   |              ^^^^^^^^^^^^^^^
 note: inside `main`
   --> tests/fail/both_borrows/zero-sized-protected.rs:LL:CC
    |

src/tools/miri/tests/fail/both_borrows/newtype_pair_retagging.tree.stderr

@@ -1,13 +1,8 @@
 error: Undefined Behavior: Data race detected between (1) non-atomic read on thread `unnamed-ID` and (2) deallocation on thread `unnamed-ID` at ALLOC. (2) just happened here
-  --> tests/fail/data_race/dealloc_read_race1.rs:LL:CC
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL | /             __rust_dealloc(
-LL | |
-LL | |                 ptr.0 as *mut _,
-LL | |                 std::mem::size_of::<usize>(),
-LL | |                 std::mem::align_of::<usize>(),
-LL | |             );
-   | |_____________^ Data race detected between (1) non-atomic read on thread `unnamed-ID` and (2) deallocation on thread `unnamed-ID` at ALLOC. (2) just happened here
+LL |         unsafe { libc::free(ptr as *mut libc::c_void) }
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Data race detected between (1) non-atomic read on thread `unnamed-ID` and (2) deallocation on thread `unnamed-ID` at ALLOC. (2) just happened here
    |
 help: and (1) occurred earlier here
   --> tests/fail/data_race/dealloc_read_race1.rs:LL:CC
@@ -17,7 +12,18 @@ LL |             let _val = *ptr.0;
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = note: BACKTRACE (of the first span) on thread `unnamed-ID`:
-   = note: inside closure at tests/fail/data_race/dealloc_read_race1.rs:LL:CC
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_dealloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside closure
+  --> tests/fail/data_race/dealloc_read_race1.rs:LL:CC
+   |
+LL | /             __rust_dealloc(
+LL | |
+LL | |                 ptr.0 as *mut _,
+LL | |                 std::mem::size_of::<usize>(),
+LL | |                 std::mem::align_of::<usize>(),
+LL | |             );
+   | |_____________^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

src/tools/miri/tests/fail/both_borrows/newtype_retagging.tree.stderr

@@ -1,13 +1,8 @@
 error: Undefined Behavior: Data race detected between (1) non-atomic write on thread `unnamed-ID` and (2) deallocation on thread `unnamed-ID` at ALLOC. (2) just happened here
-  --> tests/fail/data_race/dealloc_write_race1.rs:LL:CC
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL | /             __rust_dealloc(
-LL | |
-LL | |                 ptr.0 as *mut _,
-LL | |                 std::mem::size_of::<usize>(),
-LL | |                 std::mem::align_of::<usize>(),
-LL | |             );
-   | |_____________^ Data race detected between (1) non-atomic write on thread `unnamed-ID` and (2) deallocation on thread `unnamed-ID` at ALLOC. (2) just happened here
+LL |         unsafe { libc::free(ptr as *mut libc::c_void) }
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Data race detected between (1) non-atomic write on thread `unnamed-ID` and (2) deallocation on thread `unnamed-ID` at ALLOC. (2) just happened here
    |
 help: and (1) occurred earlier here
   --> tests/fail/data_race/dealloc_write_race1.rs:LL:CC
@@ -17,7 +12,18 @@ LL |             *ptr.0 = 2;
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = note: BACKTRACE (of the first span) on thread `unnamed-ID`:
-   = note: inside closure at tests/fail/data_race/dealloc_write_race1.rs:LL:CC
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_dealloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside closure
+  --> tests/fail/data_race/dealloc_write_race1.rs:LL:CC
+   |
+LL | /             __rust_dealloc(
+LL | |
+LL | |                 ptr.0 as *mut _,
+LL | |                 std::mem::size_of::<usize>(),
+LL | |                 std::mem::align_of::<usize>(),
+LL | |             );
+   | |_____________^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

src/tools/miri/tests/fail/both_borrows/zero-sized-protected.tree.stderr

@@ -1,11 +1,17 @@
-error: memory leaked: ALLOC (Rust heap, size: 4, align: 4), allocated here:
+error: memory leaked: ALLOC (C heap, size: 4, align: 4), allocated here:
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   |
+LL |             unsafe { libc::malloc(layout.size()) as *mut u8 }
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: BACKTRACE:
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::alloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_alloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside `main`
   --> tests/fail/memleak.rs:LL:CC
    |
 LL |     std::mem::forget(Box::new(42));
    |                      ^^^^^^^^^^^^
-   |
-   = note: BACKTRACE:
-   = note: inside `main` at tests/fail/memleak.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

src/tools/miri/tests/fail/data_race/dealloc_read_race1.stderr

@@ -1,4 +1,4 @@
-error: memory leaked: ALLOC (Rust heap, size: 4, align: 4)
+error: memory leaked: ALLOC (C heap, size: 4, align: 4)
 
 note: set `MIRIFLAGS=-Zmiri-ignore-leaks` to disable this check
 

src/tools/miri/tests/fail/data_race/dealloc_write_race1.stderr

@@ -1,10 +1,12 @@
-error: memory leaked: ALLOC (Rust heap, SIZE, ALIGN), allocated here:
-  --> RUSTLIB/alloc/src/rc.rs:LL:CC
+error: memory leaked: ALLOC (C heap, size: 32, align: 16), allocated here:
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL |                 Box::leak(Box::new(RcInner { strong: Cell::new(1), weak: Cell::new(1), value }))
-   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |             unsafe { libc::malloc(layout.size()) as *mut u8 }
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: BACKTRACE:
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::alloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_alloc` at RUSTLIB/std/src/alloc.rs:LL:CC
    = note: inside `std::rc::Rc::<std::cell::RefCell<std::option::Option<Dummy>>>::new` at RUSTLIB/alloc/src/rc.rs:LL:CC
 note: inside `main`
   --> tests/fail/memleak_rc.rs:LL:CC

src/tools/miri/tests/fail/memleak.stderr

@@ -1,12 +1,14 @@
 error: Undefined Behavior: deallocating while item [Unique for <TAG>] is strongly protected
-  --> RUSTLIB/alloc/src/boxed.rs:LL:CC
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL |                 self.1.deallocate(From::from(ptr.cast()), layout);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocating while item [Unique for <TAG>] is strongly protected
+LL |         unsafe { libc::free(ptr as *mut libc::c_void) }
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocating while item [Unique for <TAG>] is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
    = note: BACKTRACE:
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_dealloc` at RUSTLIB/std/src/alloc.rs:LL:CC
    = note: inside `<std::boxed::Box<i32> as std::ops::Drop>::drop` at RUSTLIB/alloc/src/boxed.rs:LL:CC
    = note: inside `std::ptr::drop_in_place::<std::boxed::Box<i32>> - shim(Some(std::boxed::Box<i32>))` at RUSTLIB/core/src/ptr/mod.rs:LL:CC
    = note: inside `std::mem::drop::<std::boxed::Box<i32>>` at RUSTLIB/core/src/mem/mod.rs:LL:CC

src/tools/miri/tests/fail/memleak_no_backtrace.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: attempting deallocation using <TAG> at ALLOC, but that tag does not exist in the borrow stack for this location
-  --> tests/fail/stacked_borrows/illegal_deALLOC.rs:LL:CC
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL |         dealloc(ptr2, Layout::from_size_align_unchecked(1, 1));
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempting deallocation using <TAG> at ALLOC, but that tag does not exist in the borrow stack for this location
+LL |         unsafe { libc::free(ptr as *mut libc::c_void) }
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempting deallocation using <TAG> at ALLOC, but that tag does not exist in the borrow stack for this location
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
@@ -17,7 +17,13 @@ help: <TAG> was later invalidated at offsets [0x0..0x1] by a write access
 LL |         ptr1.write(0);
    |         ^^^^^^^^^^^^^
    = note: BACKTRACE (of the first span):
-   = note: inside `main` at tests/fail/stacked_borrows/illegal_deALLOC.rs:LL:CC
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_dealloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside `main`
+  --> tests/fail/stacked_borrows/illegal_deALLOC.rs:LL:CC
+   |
+LL |         dealloc(ptr2, Layout::from_size_align_unchecked(1, 1));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

src/tools/miri/tests/fail/memleak_rc.stderr

@@ -1,11 +1,17 @@
-error: memory leaked: ALLOC (Rust heap, size: 4, align: 4), allocated here:
+error: memory leaked: ALLOC (C heap, size: 4, align: 4), allocated here:
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   |
+LL |             unsafe { libc::malloc(layout.size()) as *mut u8 }
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: BACKTRACE:
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::alloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_alloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside closure
   --> tests/fail/tls_macro_leak.rs:LL:CC
    |
 LL |             cell.set(Some(Box::leak(Box::new(123))));
    |                                     ^^^^^^^^^^^^^
-   |
-   = note: BACKTRACE:
-   = note: inside closure at tests/fail/tls_macro_leak.rs:LL:CC
    = note: inside `std::thread::LocalKey::<std::cell::Cell<std::option::Option<&i32>>>::try_with::<{closure@tests/fail/tls_macro_leak.rs:LL:CC}, ()>` at RUSTLIB/std/src/thread/local.rs:LL:CC
    = note: inside `std::thread::LocalKey::<std::cell::Cell<std::option::Option<&i32>>>::with::<{closure@tests/fail/tls_macro_leak.rs:LL:CC}, ()>` at RUSTLIB/std/src/thread/local.rs:LL:CC
 note: inside closure

src/tools/miri/tests/fail/stacked_borrows/deallocate_against_protector1.stderr

@@ -1,11 +1,17 @@
-error: memory leaked: ALLOC (Rust heap, size: 4, align: 4), allocated here:
+error: memory leaked: ALLOC (C heap, size: 4, align: 4), allocated here:
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   |
+LL |             unsafe { libc::malloc(layout.size()) as *mut u8 }
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: BACKTRACE:
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::alloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_alloc` at RUSTLIB/std/src/alloc.rs:LL:CC
+note: inside closure
   --> tests/fail/tls_static_leak.rs:LL:CC
    |
 LL |         TLS.set(Some(Box::leak(Box::new(123))));
    |                                ^^^^^^^^^^^^^
-   |
-   = note: BACKTRACE:
-   = note: inside closure at tests/fail/tls_static_leak.rs:LL:CC
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

src/tools/miri/tests/fail/stacked_borrows/illegal_dealloc1.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: deallocation through <TAG> at ALLOC[0x0] is forbidden
-  --> RUSTLIB/alloc/src/boxed.rs:LL:CC
+  --> RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
    |
-LL |                 self.1.deallocate(From::from(ptr.cast()), layout);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocation through <TAG> at ALLOC[0x0] is forbidden
+LL |         unsafe { libc::free(ptr as *mut libc::c_void) }
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocation through <TAG> at ALLOC[0x0] is forbidden
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Tree Borrows rules it violated are still experimental
    = help: the allocation of the accessed tag <TAG> also contains the strongly protected tag <TAG>
@@ -18,6 +18,8 @@ help: the strongly protected tag <TAG> was created here, in the initial state Re
 LL | fn inner(x: &mut i32, f: fn(*mut i32)) {
    |          ^
    = note: BACKTRACE (of the first span):
+   = note: inside `std::sys::alloc::unix::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc` at RUSTLIB/std/src/sys/alloc/unix.rs:LL:CC
+   = note: inside `std::alloc::__default_lib_allocator::__rust_dealloc` at RUSTLIB/std/src/alloc.rs:LL:CC
    = note: inside `<std::boxed::Box<i32> as std::ops::Drop>::drop` at RUSTLIB/alloc/src/boxed.rs:LL:CC
    = note: inside `std::ptr::drop_in_place::<std::boxed::Box<i32>> - shim(Some(std::boxed::Box<i32>))` at RUSTLIB/core/src/ptr/mod.rs:LL:CC
    = note: inside `std::mem::drop::<std::boxed::Box<i32>>` at RUSTLIB/core/src/mem/mod.rs:LL:CC

src/tools/miri/tests/fail/tls_macro_leak.stderr

@@ -16,7 +16,7 @@ LL |         drop(slice1.cmp(slice2));
    |              ^^^^^^^^^^^^^^^^^^
 
 Uninitialized memory occurred at ALLOC[0x4..0x10], in this allocation:
-ALLOC (Rust heap, size: 32, align: 8) {
+ALLOC (C heap, size: 32, align: 16) {
     0x00 │ 41 42 43 44 __ __ __ __ __ __ __ __ __ __ __ __ │ ABCD░░░░░░░░░░░░
     0x10 │ 00 __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ .░░░░░░░░░░░░░░░
 }

src/tools/miri/tests/fail/tls_static_leak.stderr

@@ -16,7 +16,7 @@ LL |         drop(slice1.cmp(slice2));
    |              ^^^^^^^^^^^^^^^^^^
 
 Uninitialized memory occurred at ALLOC[0x4..0x8], in this allocation:
-ALLOC (Rust heap, size: 16, align: 8) {
+ALLOC (C heap, size: 16, align: 16) {
     ╾42[ALLOC]<TAG> (1 ptr byte)╼ 12 13 ╾43[ALLOC]<TAG> (1 ptr byte)╼ __ __ __ __ __ __ __ __ __ __ __ __ │ ━..━░░░░░░░░░░░░
 }
 ALLOC (global (static or const), size: 1, align: 1) {