From 0e4c96953bf12ce8b9bedb8b62ad88187871ec36 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Wed, 17 Apr 2024 09:25:26 +0200 Subject: [PATCH 1/3] alloc_error_handler tests: directly call handle_alloc_error; test more codepaths --- tests/fail/alloc/alloc_error_handler.rs | 17 +----- tests/fail/alloc/alloc_error_handler.stderr | 4 +- .../fail/alloc/alloc_error_handler_custom.rs | 52 +++++++++++++++++++ .../alloc/alloc_error_handler_custom.stderr | 27 ++++++++++ .../fail/alloc/alloc_error_handler_no_std.rs | 34 +++--------- .../alloc/alloc_error_handler_no_std.stderr | 21 +++----- tests/panic/alloc_error_handler_hook.rs | 20 +++++++ tests/panic/alloc_error_handler_hook.stderr | 4 ++ tests/panic/alloc_error_handler_panic.rs | 18 +------ 9 files changed, 122 insertions(+), 75 deletions(-) create mode 100644 tests/fail/alloc/alloc_error_handler_custom.rs create mode 100644 tests/fail/alloc/alloc_error_handler_custom.stderr create mode 100644 tests/panic/alloc_error_handler_hook.rs create mode 100644 tests/panic/alloc_error_handler_hook.stderr diff --git a/tests/fail/alloc/alloc_error_handler.rs b/tests/fail/alloc/alloc_error_handler.rs index dc8e8c7380..2097126e16 100644 --- a/tests/fail/alloc/alloc_error_handler.rs +++ b/tests/fail/alloc/alloc_error_handler.rs @@ -4,22 +4,7 @@ #![feature(allocator_api)] use std::alloc::*; -use std::ptr::NonNull; - -struct BadAlloc; - -// Create a failing allocator; Miri's native allocator never fails so this is the only way to -// actually call the alloc error handler. -unsafe impl Allocator for BadAlloc { - fn allocate(&self, _l: Layout) -> Result, AllocError> { - Err(AllocError) - } - - unsafe fn deallocate(&self, _ptr: NonNull, _layout: Layout) { - unreachable!(); - } -} fn main() { - let _b = Box::new_in(0, BadAlloc); + handle_alloc_error(Layout::for_value(&0)); } diff --git a/tests/fail/alloc/alloc_error_handler.stderr b/tests/fail/alloc/alloc_error_handler.stderr index f9d8e80c0f..d1731a0f42 100644 --- a/tests/fail/alloc/alloc_error_handler.stderr +++ b/tests/fail/alloc/alloc_error_handler.stderr @@ -12,12 +12,10 @@ LL | ABORT(); = note: inside `std::alloc::_::__rg_oom` 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 `std::boxed::Box::::new_uninit_in` at RUSTLIB/alloc/src/boxed.rs:LL:CC - = note: inside `std::boxed::Box::::new_in` at RUSTLIB/alloc/src/boxed.rs:LL:CC note: inside `main` --> $DIR/alloc_error_handler.rs:LL:CC | -LL | let _b = Box::new_in(0, BadAlloc); +LL | handle_alloc_error(Layout::for_value(&0)); | ^ note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace diff --git a/tests/fail/alloc/alloc_error_handler_custom.rs b/tests/fail/alloc/alloc_error_handler_custom.rs new file mode 100644 index 0000000000..9f8837a626 --- /dev/null +++ b/tests/fail/alloc/alloc_error_handler_custom.rs @@ -0,0 +1,52 @@ +//@compile-flags: -Cpanic=abort +#![feature(start, core_intrinsics)] +#![feature(alloc_error_handler)] +#![feature(allocator_api)] +#![no_std] + +extern crate alloc; + +use alloc::alloc::*; + +extern "Rust" { + fn miri_write_to_stderr(bytes: &[u8]); +} + +#[alloc_error_handler] +fn alloc_error_handler(_: Layout) -> ! { + let msg = "custom alloc error handler called!\n"; + unsafe { miri_write_to_stderr(msg.as_bytes()) }; + core::intrinsics::abort(); //~ERROR: aborted +} + +// rustc requires us to provide some more things that aren't actually used by this test +mod plumbing { + use super::*; + + #[panic_handler] + fn panic_handler(_: &core::panic::PanicInfo) -> ! { + let msg = "custom panic handler called!\n"; + unsafe { miri_write_to_stderr(msg.as_bytes()) }; + core::intrinsics::abort(); + } + + struct NoAlloc; + + unsafe impl GlobalAlloc for NoAlloc { + unsafe fn alloc(&self, _: Layout) -> *mut u8 { + unreachable!(); + } + + unsafe fn dealloc(&self, _: *mut u8, _: Layout) { + unreachable!(); + } + } + + #[global_allocator] + static GLOBAL: NoAlloc = NoAlloc; +} + +#[start] +fn start(_: isize, _: *const *const u8) -> isize { + handle_alloc_error(Layout::for_value(&0)); +} diff --git a/tests/fail/alloc/alloc_error_handler_custom.stderr b/tests/fail/alloc/alloc_error_handler_custom.stderr new file mode 100644 index 0000000000..cdd666e5e0 --- /dev/null +++ b/tests/fail/alloc/alloc_error_handler_custom.stderr @@ -0,0 +1,27 @@ +custom alloc error handler called! +error: abnormal termination: the program aborted execution + --> $DIR/alloc_error_handler_custom.rs:LL:CC + | +LL | core::intrinsics::abort(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ the program aborted execution + | + = note: BACKTRACE: + = note: inside `alloc_error_handler` at $DIR/alloc_error_handler_custom.rs:LL:CC +note: inside `_::__rg_oom` + --> $DIR/alloc_error_handler_custom.rs:LL:CC + | +LL | #[alloc_error_handler] + | ---------------------- in this procedural macro expansion +LL | fn alloc_error_handler(_: Layout) -> ! { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + = 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` + --> $DIR/alloc_error_handler_custom.rs:LL:CC + | +LL | handle_alloc_error(Layout::for_value(&0)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + = note: this error originates in the attribute macro `alloc_error_handler` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: aborting due to 1 previous error + diff --git a/tests/fail/alloc/alloc_error_handler_no_std.rs b/tests/fail/alloc/alloc_error_handler_no_std.rs index 8103296f47..e3949b889f 100644 --- a/tests/fail/alloc/alloc_error_handler_no_std.rs +++ b/tests/fail/alloc/alloc_error_handler_no_std.rs @@ -7,28 +7,16 @@ extern crate alloc; use alloc::alloc::*; -use alloc::boxed::Box; -use core::ptr::NonNull; -struct BadAlloc; - -// Create a failing allocator; that is the only way to actually call the alloc error handler. -unsafe impl Allocator for BadAlloc { - fn allocate(&self, _l: Layout) -> Result, AllocError> { - Err(AllocError) - } - - unsafe fn deallocate(&self, _ptr: NonNull, _layout: Layout) { - unreachable!(); - } +extern "Rust" { + fn miri_write_to_stderr(bytes: &[u8]); } -#[alloc_error_handler] -fn alloc_error_handler(_: Layout) -> ! { - extern "Rust" { - fn miri_write_to_stderr(bytes: &[u8]); - } - let msg = "custom alloc error handler called!\n"; +// The default no_std alloc_error_handler is a panic. + +#[panic_handler] +fn panic_handler(_panic_info: &core::panic::PanicInfo) -> ! { + let msg = "custom panic handler called!\n"; unsafe { miri_write_to_stderr(msg.as_bytes()) }; core::intrinsics::abort(); //~ERROR: aborted } @@ -37,11 +25,6 @@ fn alloc_error_handler(_: Layout) -> ! { mod plumbing { use super::*; - #[panic_handler] - fn panic_handler(_: &core::panic::PanicInfo) -> ! { - core::intrinsics::abort(); - } - struct NoAlloc; unsafe impl GlobalAlloc for NoAlloc { @@ -60,6 +43,5 @@ mod plumbing { #[start] fn start(_: isize, _: *const *const u8) -> isize { - let _b = Box::new_in(0, BadAlloc); - 0 + handle_alloc_error(Layout::for_value(&0)); } diff --git a/tests/fail/alloc/alloc_error_handler_no_std.stderr b/tests/fail/alloc/alloc_error_handler_no_std.stderr index b40ffb7012..906c51be8b 100644 --- a/tests/fail/alloc/alloc_error_handler_no_std.stderr +++ b/tests/fail/alloc/alloc_error_handler_no_std.stderr @@ -1,4 +1,4 @@ -custom alloc error handler called! +custom panic handler called! error: abnormal termination: the program aborted execution --> $DIR/alloc_error_handler_no_std.rs:LL:CC | @@ -6,24 +6,17 @@ LL | core::intrinsics::abort(); | ^^^^^^^^^^^^^^^^^^^^^^^^^ the program aborted execution | = note: BACKTRACE: - = note: inside `alloc_error_handler` at $DIR/alloc_error_handler_no_std.rs:LL:CC -note: inside `_::__rg_oom` - --> $DIR/alloc_error_handler_no_std.rs:LL:CC - | -LL | #[alloc_error_handler] - | ---------------------- in this procedural macro expansion -LL | fn alloc_error_handler(_: Layout) -> ! { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + = note: inside `panic_handler` at $DIR/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::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 `alloc::boxed::Box::::new_uninit_in` at RUSTLIB/alloc/src/boxed.rs:LL:CC - = note: inside `alloc::boxed::Box::::new_in` at RUSTLIB/alloc/src/boxed.rs:LL:CC note: inside `start` --> $DIR/alloc_error_handler_no_std.rs:LL:CC | -LL | let _b = Box::new_in(0, BadAlloc); - | ^^^^^^^^^^^^^^^^^^^^^^^^ - = note: this error originates in the attribute macro `alloc_error_handler` (in Nightly builds, run with -Z macro-backtrace for more info) +LL | handle_alloc_error(Layout::for_value(&0)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace error: aborting due to 1 previous error diff --git a/tests/panic/alloc_error_handler_hook.rs b/tests/panic/alloc_error_handler_hook.rs new file mode 100644 index 0000000000..a1eadb45fd --- /dev/null +++ b/tests/panic/alloc_error_handler_hook.rs @@ -0,0 +1,20 @@ +#![feature(allocator_api, alloc_error_hook)] + +use std::alloc::*; + +struct Bomb; +impl Drop for Bomb { + fn drop(&mut self) { + eprintln!("yes we are unwinding!"); + } +} + +#[allow(unreachable_code, unused_variables)] +fn main() { + // This is a particularly tricky hook, since it unwinds, which the default one does not. + set_alloc_error_hook(|_layout| panic!("alloc error hook called")); + + let bomb = Bomb; + handle_alloc_error(Layout::for_value(&0)); + std::mem::forget(bomb); // defuse unwinding bomb +} diff --git a/tests/panic/alloc_error_handler_hook.stderr b/tests/panic/alloc_error_handler_hook.stderr new file mode 100644 index 0000000000..01c286fe3d --- /dev/null +++ b/tests/panic/alloc_error_handler_hook.stderr @@ -0,0 +1,4 @@ +thread 'main' panicked at $DIR/alloc_error_handler_hook.rs:LL:CC: +alloc error hook called +note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace +yes we are unwinding! diff --git a/tests/panic/alloc_error_handler_panic.rs b/tests/panic/alloc_error_handler_panic.rs index 186c9667a9..c434e8d322 100644 --- a/tests/panic/alloc_error_handler_panic.rs +++ b/tests/panic/alloc_error_handler_panic.rs @@ -2,21 +2,6 @@ #![feature(allocator_api)] use std::alloc::*; -use std::ptr::NonNull; - -struct BadAlloc; - -// Create a failing allocator; Miri's native allocator never fails so this is the only way to -// actually call the alloc error handler. -unsafe impl Allocator for BadAlloc { - fn allocate(&self, _l: Layout) -> Result, AllocError> { - Err(AllocError) - } - - unsafe fn deallocate(&self, _ptr: NonNull, _layout: Layout) { - unreachable!(); - } -} struct Bomb; impl Drop for Bomb { @@ -25,8 +10,9 @@ impl Drop for Bomb { } } +#[allow(unreachable_code, unused_variables)] fn main() { let bomb = Bomb; - let _b = Box::new_in(0, BadAlloc); + handle_alloc_error(Layout::for_value(&0)); std::mem::forget(bomb); // defuse unwinding bomb } From 5aad4fb1ab1ddb19dcc1e15767c4f136f831c13f Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Wed, 17 Apr 2024 09:40:53 +0200 Subject: [PATCH 2/3] tests/utils: add fmt::Write implementations for miri's native stdout/stderr --- .../fail/alloc/alloc_error_handler_custom.rs | 15 +++++------ .../alloc/alloc_error_handler_custom.stderr | 6 ++--- .../fail/alloc/alloc_error_handler_no_std.rs | 12 ++++----- .../alloc/alloc_error_handler_no_std.stderr | 2 ++ tests/fail/panic/no_std.rs | 24 +++--------------- tests/pass/no_std.rs | 22 +++------------- tests/utils/io.rs | 25 +++++++++++++++++++ tests/utils/miri_extern.rs | 4 +-- tests/utils/mod.no_std.rs | 11 ++++++++ tests/utils/mod.rs | 2 ++ 10 files changed, 64 insertions(+), 59 deletions(-) create mode 100644 tests/utils/io.rs create mode 100644 tests/utils/mod.no_std.rs diff --git a/tests/fail/alloc/alloc_error_handler_custom.rs b/tests/fail/alloc/alloc_error_handler_custom.rs index 9f8837a626..babdb73f09 100644 --- a/tests/fail/alloc/alloc_error_handler_custom.rs +++ b/tests/fail/alloc/alloc_error_handler_custom.rs @@ -7,15 +7,14 @@ extern crate alloc; use alloc::alloc::*; +use core::fmt::Write; -extern "Rust" { - fn miri_write_to_stderr(bytes: &[u8]); -} +#[path = "../../utils/mod.no_std.rs"] +mod utils; #[alloc_error_handler] -fn alloc_error_handler(_: Layout) -> ! { - let msg = "custom alloc error handler called!\n"; - unsafe { miri_write_to_stderr(msg.as_bytes()) }; +fn alloc_error_handler(layout: Layout) -> ! { + let _ = writeln!(utils::MiriStderr, "custom alloc error handler: {layout:?}"); core::intrinsics::abort(); //~ERROR: aborted } @@ -25,9 +24,7 @@ mod plumbing { #[panic_handler] fn panic_handler(_: &core::panic::PanicInfo) -> ! { - let msg = "custom panic handler called!\n"; - unsafe { miri_write_to_stderr(msg.as_bytes()) }; - core::intrinsics::abort(); + loop {} } struct NoAlloc; diff --git a/tests/fail/alloc/alloc_error_handler_custom.stderr b/tests/fail/alloc/alloc_error_handler_custom.stderr index cdd666e5e0..5d9c2e2fb4 100644 --- a/tests/fail/alloc/alloc_error_handler_custom.stderr +++ b/tests/fail/alloc/alloc_error_handler_custom.stderr @@ -1,4 +1,4 @@ -custom alloc error handler called! +custom alloc error handler: Layout { size: 4, align: 4 (1 << 2) } error: abnormal termination: the program aborted execution --> $DIR/alloc_error_handler_custom.rs:LL:CC | @@ -12,8 +12,8 @@ note: inside `_::__rg_oom` | LL | #[alloc_error_handler] | ---------------------- in this procedural macro expansion -LL | fn alloc_error_handler(_: Layout) -> ! { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | fn alloc_error_handler(layout: Layout) -> ! { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = 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` diff --git a/tests/fail/alloc/alloc_error_handler_no_std.rs b/tests/fail/alloc/alloc_error_handler_no_std.rs index e3949b889f..18a8a61f22 100644 --- a/tests/fail/alloc/alloc_error_handler_no_std.rs +++ b/tests/fail/alloc/alloc_error_handler_no_std.rs @@ -7,17 +7,17 @@ extern crate alloc; use alloc::alloc::*; +use core::fmt::Write; -extern "Rust" { - fn miri_write_to_stderr(bytes: &[u8]); -} +#[path = "../../utils/mod.no_std.rs"] +mod utils; // The default no_std alloc_error_handler is a panic. #[panic_handler] -fn panic_handler(_panic_info: &core::panic::PanicInfo) -> ! { - let msg = "custom panic handler called!\n"; - unsafe { miri_write_to_stderr(msg.as_bytes()) }; +fn panic_handler(panic_info: &core::panic::PanicInfo) -> ! { + let _ = writeln!(utils::MiriStderr, "custom panic handler called!"); + let _ = writeln!(utils::MiriStderr, "{panic_info}"); core::intrinsics::abort(); //~ERROR: aborted } diff --git a/tests/fail/alloc/alloc_error_handler_no_std.stderr b/tests/fail/alloc/alloc_error_handler_no_std.stderr index 906c51be8b..6b98f6f75d 100644 --- a/tests/fail/alloc/alloc_error_handler_no_std.stderr +++ b/tests/fail/alloc/alloc_error_handler_no_std.stderr @@ -1,4 +1,6 @@ custom panic handler called! +panicked at RUSTLIB/alloc/src/alloc.rs:LL:CC: +memory allocation of 4 bytes failed error: abnormal termination: the program aborted execution --> $DIR/alloc_error_handler_no_std.rs:LL:CC | diff --git a/tests/fail/panic/no_std.rs b/tests/fail/panic/no_std.rs index 26cc0b2782..4d32b6d746 100644 --- a/tests/fail/panic/no_std.rs +++ b/tests/fail/panic/no_std.rs @@ -1,27 +1,11 @@ +//@compile-flags: -Cpanic=abort #![feature(start, core_intrinsics)] #![no_std] -//@compile-flags: -Cpanic=abort - -// Plumbing to let us use `writeln!` to host stderr: - -extern "Rust" { - fn miri_write_to_stderr(bytes: &[u8]); -} - -struct HostErr; use core::fmt::Write; -impl Write for HostErr { - fn write_str(&mut self, s: &str) -> core::fmt::Result { - unsafe { - miri_write_to_stderr(s.as_bytes()); - } - Ok(()) - } -} - -// Aaaand the test: +#[path = "../../utils/mod.no_std.rs"] +mod utils; #[start] fn start(_: isize, _: *const *const u8) -> isize { @@ -30,6 +14,6 @@ fn start(_: isize, _: *const *const u8) -> isize { #[panic_handler] fn panic_handler(panic_info: &core::panic::PanicInfo) -> ! { - writeln!(HostErr, "{panic_info}").ok(); + writeln!(utils::MiriStderr, "{panic_info}").ok(); core::intrinsics::abort(); //~ ERROR: the program aborted execution } diff --git a/tests/pass/no_std.rs b/tests/pass/no_std.rs index 3c98ee50aa..fc1c16f5fb 100644 --- a/tests/pass/no_std.rs +++ b/tests/pass/no_std.rs @@ -2,30 +2,14 @@ #![feature(start)] #![no_std] -// Plumbing to let us use `writeln!` to host stdout: - -extern "Rust" { - fn miri_write_to_stdout(bytes: &[u8]); -} - -struct Host; - use core::fmt::Write; -impl Write for Host { - fn write_str(&mut self, s: &str) -> core::fmt::Result { - unsafe { - miri_write_to_stdout(s.as_bytes()); - } - Ok(()) - } -} - -// Aaaand the test: +#[path = "../utils/mod.no_std.rs"] +mod utils; #[start] fn start(_: isize, _: *const *const u8) -> isize { - writeln!(Host, "hello, world!").unwrap(); + writeln!(utils::MiriStdout, "hello, world!").unwrap(); 0 } diff --git a/tests/utils/io.rs b/tests/utils/io.rs new file mode 100644 index 0000000000..e3eaa6c468 --- /dev/null +++ b/tests/utils/io.rs @@ -0,0 +1,25 @@ +use core::fmt::{self, Write}; + +use super::miri_extern; + +pub struct MiriStderr; + +impl Write for MiriStderr { + fn write_str(&mut self, s: &str) -> fmt::Result { + unsafe { + miri_extern::miri_write_to_stderr(s.as_bytes()); + } + Ok(()) + } +} + +pub struct MiriStdout; + +impl Write for MiriStdout { + fn write_str(&mut self, s: &str) -> fmt::Result { + unsafe { + miri_extern::miri_write_to_stdout(s.as_bytes()); + } + Ok(()) + } +} diff --git a/tests/utils/miri_extern.rs b/tests/utils/miri_extern.rs index e2983f6c71..d6c43b1882 100644 --- a/tests/utils/miri_extern.rs +++ b/tests/utils/miri_extern.rs @@ -133,8 +133,8 @@ extern "Rust" { /// with a null terminator. /// Returns 0 if the `out` buffer was large enough, and the required size otherwise. pub fn miri_host_to_target_path( - path: *const std::ffi::c_char, - out: *mut std::ffi::c_char, + path: *const core::ffi::c_char, + out: *mut core::ffi::c_char, out_size: usize, ) -> usize; diff --git a/tests/utils/mod.no_std.rs b/tests/utils/mod.no_std.rs new file mode 100644 index 0000000000..aaf2bf50c4 --- /dev/null +++ b/tests/utils/mod.no_std.rs @@ -0,0 +1,11 @@ +#![allow(dead_code)] +#![allow(unused_imports)] + +#[macro_use] +mod macros; + +mod io; +mod miri_extern; + +pub use self::io::*; +pub use self::miri_extern::*; diff --git a/tests/utils/mod.rs b/tests/utils/mod.rs index cb9380f575..138ada4e20 100644 --- a/tests/utils/mod.rs +++ b/tests/utils/mod.rs @@ -5,9 +5,11 @@ mod macros; mod fs; +mod io; mod miri_extern; pub use self::fs::*; +pub use self::io::*; pub use self::miri_extern::*; pub fn run_provenance_gc() { From 1f1f613ba49a6ed8b69d222db4270358080b2fc1 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Wed, 17 Apr 2024 09:44:28 +0200 Subject: [PATCH 3/3] no need to use miri's native stderr here --- tests/pass/tree_borrows/reserved.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/tests/pass/tree_borrows/reserved.rs b/tests/pass/tree_borrows/reserved.rs index 87ce91a809..f93cac8361 100644 --- a/tests/pass/tree_borrows/reserved.rs +++ b/tests/pass/tree_borrows/reserved.rs @@ -27,9 +27,8 @@ fn main() { } } -unsafe fn print(msg: &str) { - utils::miri_write_to_stderr(msg.as_bytes()); - utils::miri_write_to_stderr("\n".as_bytes()); +fn print(msg: &str) { + eprintln!("{msg}"); } unsafe fn read_second(x: &mut T, y: *mut u8) {