From e9b0eeb99de66a2b85ecda546362b1dce9e7c9ba Mon Sep 17 00:00:00 2001 From: Trevor Gross Date: Wed, 30 Sep 2026 17:07:09 -0500 Subject: [PATCH] intrinsics: Rename `abort` to `abort_immediate` The semantics of `intrinsics::abort()` are closer to what we have unstably as `abort_immediate()` than to `process::abort()` or `libc::abort()`. Rename it to make more clear that the intrinsic is more of an intentional crash with platform-specific behavior than what `libc::abort()` tries to be (i.e. raising `SIGABRT`). --- .../example/mini_core.rs | 8 +++---- .../example/mini_core_hello_world.rs | 4 ++-- .../src/intrinsics/mod.rs | 2 +- .../build_system/src/fuzz/reduce.rs | 2 +- .../example/alloc_example.rs | 4 ++-- .../rustc_codegen_gcc/example/mini_core.rs | 10 ++++----- .../example/mini_core_hello_world.rs | 4 ++-- .../rustc_codegen_gcc/src/intrinsic/mod.rs | 2 +- .../rustc_codegen_gcc/tests/run/abort1.rs | 2 +- .../rustc_codegen_gcc/tests/run/abort2.rs | 2 +- .../tests/run/always_inline.rs | 2 +- compiler/rustc_codegen_llvm/src/builder.rs | 2 +- compiler/rustc_codegen_llvm/src/intrinsic.rs | 2 +- compiler/rustc_codegen_ssa/src/mir/block.rs | 8 +++---- .../rustc_codegen_ssa/src/mir/intrinsic.rs | 6 +++--- compiler/rustc_codegen_ssa/src/mir/place.rs | 2 +- compiler/rustc_codegen_ssa/src/mir/rvalue.rs | 4 ++-- .../rustc_codegen_ssa/src/traits/intrinsic.rs | 3 ++- .../src/const_eval/machine.rs | 4 ++-- .../rustc_hir_analysis/src/check/intrinsic.rs | 4 ++-- compiler/rustc_span/src/symbol.rs | 1 + library/alloc/src/collections/btree/mem.rs | 2 +- library/alloc/src/collections/btree/split.rs | 2 +- library/alloc/src/rcs/arc.rs | 9 ++++---- library/alloc/src/rcs/rc.rs | 11 +++++----- library/core/src/intrinsics/mod.rs | 21 ++++++++----------- library/core/src/panicking.rs | 14 ++++++------- library/core/src/process.rs | 2 +- library/core/src/slice/sort/shared/pivot.rs | 2 +- .../core/src/slice/sort/shared/smallsort.rs | 10 ++++----- .../core/src/slice/sort/stable/quicksort.rs | 2 +- .../core/src/slice/sort/unstable/quicksort.rs | 4 ++-- library/std/src/panicking.rs | 4 ++-- library/std/src/sys/exit.rs | 4 ++-- library/std/src/sys/pal/uefi/mod.rs | 4 ++-- library/std/src/sys/pal/unix/mod.rs | 4 ++-- library/std/src/sys/pal/unsupported/common.rs | 2 +- library/std/src/sys/pal/windows/mod.rs | 4 ++-- library/std/src/sys/pal/zkvm/mod.rs | 2 +- library/std/src/sys/personality/mod.rs | 2 +- .../stdarch/crates/core_arch/src/mips/mod.rs | 2 +- .../stdarch/crates/core_arch/src/nvptx/mod.rs | 2 +- .../crates/core_arch/src/powerpc/mod.rs | 2 +- .../crates/core_arch/src/wasm32/mod.rs | 2 +- .../src/language-features/intrinsics.md | 2 +- .../src/language-features/lang-items.md | 4 ++-- src/tools/miri/src/intrinsics/mod.rs | 4 ++-- .../fail/alloc/alloc_error_handler_custom.rs | 2 +- .../alloc/alloc_error_handler_custom.stderr | 4 ++-- .../fail/alloc/alloc_error_handler_no_std.rs | 2 +- .../alloc/alloc_error_handler_no_std.stderr | 4 ++-- src/tools/miri/tests/fail/panic/no_std.rs | 2 +- src/tools/miri/tests/fail/panic/no_std.stderr | 4 ++-- src/tools/rustfmt/tests/source/match.rs | 2 +- src/tools/rustfmt/tests/target/match.rs | 2 +- tests/assembly-llvm/mips-div-no-trap.rs | 6 +++--- tests/rustdoc-html/safe-intrinsic.rs | 6 +++--- tests/ui/consts/const-eval/const_panic.stderr | 2 +- .../proc-macro/auxiliary/derive-unstable.rs | 3 +-- tests/ui/process/signal-exit-status.rs | 2 +- 60 files changed, 119 insertions(+), 123 deletions(-) diff --git a/compiler/rustc_codegen_cranelift/example/mini_core.rs b/compiler/rustc_codegen_cranelift/example/mini_core.rs index 08adec96a079b..d6d82a9d2af69 100644 --- a/compiler/rustc_codegen_cranelift/example/mini_core.rs +++ b/compiler/rustc_codegen_cranelift/example/mini_core.rs @@ -497,7 +497,7 @@ pub trait FnMut: FnOnce { pub fn panic(_msg: &'static str) -> ! { unsafe { libc::puts("Panicking\n\0" as *const str as *const i8); - intrinsics::abort(); + intrinsics::abort_immediate(); } } @@ -539,7 +539,7 @@ fn panic_bounds_check(index: usize, len: usize) -> ! { len, index, ); - intrinsics::abort(); + intrinsics::abort_immediate(); } } @@ -548,7 +548,7 @@ fn panic_bounds_check(index: usize, len: usize) -> ! { fn panic_cannot_unwind() -> ! { unsafe { libc::puts("panic in a function that cannot unwind\n\0" as *const str as *const i8); - intrinsics::abort(); + intrinsics::abort_immediate(); } } @@ -688,7 +688,7 @@ pub union MaybeUninit { pub mod intrinsics { #[rustc_intrinsic] - pub fn abort() -> !; + pub fn abort_immediate() -> !; #[rustc_intrinsic] pub const fn size_of() -> usize; #[rustc_intrinsic] diff --git a/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs b/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs index 9a710caae9cd1..c53ec2ec6710d 100644 --- a/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs +++ b/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs @@ -602,11 +602,11 @@ pub enum E2 { #[allow(unreachable_patterns)] fn check_niche_behavior() { if let E1::V2 { .. } = (E1::V1 { f: true }) { - intrinsics::abort(); + intrinsics::abort_immediate(); } if let E2::V1 { .. } = E2::V3:: { - intrinsics::abort(); + intrinsics::abort_immediate(); } } diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs index cf1c1f027e7f5..9c3182c944dc6 100644 --- a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs +++ b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs @@ -469,7 +469,7 @@ fn codegen_regular_intrinsic_call<'tcx>( let usize_layout = fx.layout_of(fx.tcx.types.usize); match intrinsic { - sym::abort => { + sym::abort_immediate => { fx.bcx.set_cold_block(fx.bcx.current_block().unwrap()); fx.bcx.ins().trap(TrapCode::user(2).unwrap()); return Ok(()); diff --git a/compiler/rustc_codegen_gcc/build_system/src/fuzz/reduce.rs b/compiler/rustc_codegen_gcc/build_system/src/fuzz/reduce.rs index 20715ab0e7c48..d1ed8fabbaf11 100644 --- a/compiler/rustc_codegen_gcc/build_system/src/fuzz/reduce.rs +++ b/compiler/rustc_codegen_gcc/build_system/src/fuzz/reduce.rs @@ -203,7 +203,7 @@ fn block_abort(file: &mut Vec, path: &PathBuf, cache: &mut ResultCache) // ..and insert an unconditional call to abort. file_copy.insert( block_starts, - "Call(tmp = core::intrinsics::abort(), ReturnTo(bb1), UnwindUnreachable())\n" + "Call(tmp = core::intrinsics::abort_immediate(), ReturnTo(bb1), UnwindUnreachable())\n" .to_string(), ); file_copy.insert(block_starts, "let tmp = ();\n".to_string()); diff --git a/compiler/rustc_codegen_gcc/example/alloc_example.rs b/compiler/rustc_codegen_gcc/example/alloc_example.rs index 9a0b46d5b221a..338057e1fcb87 100644 --- a/compiler/rustc_codegen_gcc/example/alloc_example.rs +++ b/compiler/rustc_codegen_gcc/example/alloc_example.rs @@ -20,12 +20,12 @@ extern "C" { #[panic_handler] fn panic_handler(_: &core::panic::PanicInfo<'_>) -> ! { - core::intrinsics::abort(); + core::intrinsics::abort_immediate(); } #[alloc_error_handler] fn alloc_error_handler(_: alloc::alloc::Layout) -> ! { - core::intrinsics::abort(); + core::intrinsics::abort_immediate(); } #[lang = "eh_personality"] diff --git a/compiler/rustc_codegen_gcc/example/mini_core.rs b/compiler/rustc_codegen_gcc/example/mini_core.rs index 2d5a29ceb8191..efc3e169678dc 100644 --- a/compiler/rustc_codegen_gcc/example/mini_core.rs +++ b/compiler/rustc_codegen_gcc/example/mini_core.rs @@ -509,7 +509,7 @@ pub trait FnMut: FnOnce { pub fn panic(_msg: &'static str) -> ! { unsafe { libc::puts("Panicking\n\0" as *const str as *const u8); - intrinsics::abort(); + intrinsics::abort_immediate(); } } @@ -546,7 +546,7 @@ panic_const! { fn panic_cannot_unwind() -> ! { unsafe { libc::puts("Panicking\n\0" as *const str as *const u8); - intrinsics::abort(); + intrinsics::abort_immediate(); } } @@ -555,7 +555,7 @@ fn panic_cannot_unwind() -> ! { fn panic_in_cleanup() -> ! { unsafe { libc::printf("panic in a destructor during cleanup\n\0" as *const str as *const i8); - intrinsics::abort(); + intrinsics::abort_immediate(); } } @@ -568,7 +568,7 @@ fn panic_bounds_check(index: usize, len: usize) -> ! { len, index, ); - intrinsics::abort(); + intrinsics::abort_immediate(); } } @@ -698,7 +698,7 @@ pub mod intrinsics { #[rustc_intrinsic] pub const fn black_box(_dummy: T) -> T; #[rustc_intrinsic] - pub fn abort() -> !; + pub fn abort_immediate() -> !; #[rustc_intrinsic] pub const fn size_of() -> usize; #[rustc_intrinsic] diff --git a/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs b/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs index ab841d51a7f53..a630c33e086d3 100644 --- a/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs +++ b/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs @@ -438,10 +438,10 @@ pub enum E2 { #[allow(unreachable_patterns)] fn check_niche_behavior () { if let E1::V2 { .. } = (E1::V1 { f: true }) { - intrinsics::abort(); + intrinsics::abort_immediate(); } if let E2::V1 { .. } = E2::V3:: { - intrinsics::abort(); + intrinsics::abort_immediate(); } } diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs index 4d2590ac81e41..0f735172667ab 100644 --- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs +++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs @@ -661,7 +661,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc llret } - fn abort(&mut self) { + fn abort_immediate(&mut self) { let func = self.context.get_builtin_function("__builtin_trap"); self.block.add_eval(self.location, self.context.new_call(self.location, func, &[])); } diff --git a/compiler/rustc_codegen_gcc/tests/run/abort1.rs b/compiler/rustc_codegen_gcc/tests/run/abort1.rs index ff2bb75ece22a..c9e3c27a0791d 100644 --- a/compiler/rustc_codegen_gcc/tests/run/abort1.rs +++ b/compiler/rustc_codegen_gcc/tests/run/abort1.rs @@ -12,7 +12,7 @@ extern crate mini_core; use mini_core::*; fn test_fail() -> ! { - unsafe { intrinsics::abort() }; + unsafe { intrinsics::abort_immediate() }; } #[no_mangle] diff --git a/compiler/rustc_codegen_gcc/tests/run/abort2.rs b/compiler/rustc_codegen_gcc/tests/run/abort2.rs index 781f518e0b222..51f55e9404c1f 100644 --- a/compiler/rustc_codegen_gcc/tests/run/abort2.rs +++ b/compiler/rustc_codegen_gcc/tests/run/abort2.rs @@ -12,7 +12,7 @@ extern crate mini_core; use mini_core::*; fn fail() -> i32 { - unsafe { intrinsics::abort() }; + unsafe { intrinsics::abort_immediate() }; 0 } diff --git a/compiler/rustc_codegen_gcc/tests/run/always_inline.rs b/compiler/rustc_codegen_gcc/tests/run/always_inline.rs index ebd741ee090c8..2a580fe79acaf 100644 --- a/compiler/rustc_codegen_gcc/tests/run/always_inline.rs +++ b/compiler/rustc_codegen_gcc/tests/run/always_inline.rs @@ -47,7 +47,7 @@ fn fib_a(n: u8) -> u8 { #[no_mangle] extern "C" fn main(argc: i32, _argv: *const *const u8) -> i32 { if fib(2) != fib_a(2) { - intrinsics::abort(); + intrinsics::abort_immediate(); } 0 } diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs index dc89414940620..d7470be0046d4 100644 --- a/compiler/rustc_codegen_llvm/src/builder.rs +++ b/compiler/rustc_codegen_llvm/src/builder.rs @@ -2129,7 +2129,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> { self.unreachable(); } } else { - self.abort(); + self.abort_immediate(); self.unreachable(); } diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs index 3163139ba1f04..cfc880ca92827 100644 --- a/compiler/rustc_codegen_llvm/src/intrinsic.rs +++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs @@ -1040,7 +1040,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> { autocast(self, llret, src_ty, dest_ty) } - fn abort(&mut self) { + fn abort_immediate(&mut self) { self.call_intrinsic("llvm.trap", &[], &[]); } diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs index 8fa044a45de22..9db1dd700e95e 100644 --- a/compiler/rustc_codegen_ssa/src/mir/block.rs +++ b/compiler/rustc_codegen_ssa/src/mir/block.rs @@ -199,7 +199,7 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> { "compiler_builtins call to diverging function {:?} replaced with abort", instance.def_id() ); - bx.abort(); + bx.abort_immediate(); bx.unreachable(); return MergingSucc::False; } @@ -587,7 +587,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { // so we should make sure that we never actually do. // We play it safe by using a well-defined `abort`, but we could go for immediate UB // if that turns out to be helpful. - bx.abort(); + bx.abort_immediate(); // `abort` does not terminate the block, so we still need to generate // an `unreachable` terminator after it. bx.unreachable(); @@ -1099,7 +1099,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { } // Also we need to terminate the block to avoid an LLVM assertion, // even though we're not going to actually use the IR. - bx.abort(); + bx.abort_immediate(); return MergingSucc::False; } IntrinsicResult::Fallback(instance) => { @@ -2398,7 +2398,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { let (fn_abi, fn_ptr, instance) = common::build_langcall(&bx, self.mir.span, reason.lang_item()); if is_call_from_compiler_builtins_to_upstream_monomorphization(bx.tcx(), instance) { - bx.abort(); + bx.abort_immediate(); } else { let fn_ty = bx.fn_decl_backend_type(fn_abi); diff --git a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs index e6b70ce2ca77b..650b21bf78a9c 100644 --- a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs +++ b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs @@ -121,7 +121,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { if args.is_empty() { match name { - sym::abort + sym::abort_immediate | sym::unreachable | sym::cold_path | sym::gpu_launch_sized_workgroup_mem @@ -152,8 +152,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { } let op_val: OperandValue<_> = match name { - sym::abort => { - bx.abort(); + sym::abort_immediate => { + bx.abort_immediate(); OperandValue::ZeroSized } diff --git a/compiler/rustc_codegen_ssa/src/mir/place.rs b/compiler/rustc_codegen_ssa/src/mir/place.rs index 02e125fd31717..c74a5e788689f 100644 --- a/compiler/rustc_codegen_ssa/src/mir/place.rs +++ b/compiler/rustc_codegen_ssa/src/mir/place.rs @@ -264,7 +264,7 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> { Err(UninhabitedVariantError) => { // We play it safe by using a well-defined `abort`, but we could go for immediate UB // if that turns out to be helpful. - bx.abort(); + bx.abort_immediate(); } Ok(Some((tag_field, imm))) => { let tag_place = self.project_field(bx, tag_field.as_usize()); diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs index 3b33cf5a17602..6391fcd58f4bb 100644 --- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs +++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs @@ -834,8 +834,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { Err(super::place::UninhabitedVariantError) => { // Like codegen_set_discr we use a sound abort, but could // potentially `unreachable` or just return the poison for - // more optimizability, if that turns out to be helpful. - bx.abort(); + // optimizability, if that turns out to be helpful. + bx.abort_immediate(); let val = OperandValue::poison(bx, layout); OperandRef { val, layout, move_annotation: None } } diff --git a/compiler/rustc_codegen_ssa/src/traits/intrinsic.rs b/compiler/rustc_codegen_ssa/src/traits/intrinsic.rs index 47144834b5072..0aacbb3b5f7fb 100644 --- a/compiler/rustc_codegen_ssa/src/traits/intrinsic.rs +++ b/compiler/rustc_codegen_ssa/src/traits/intrinsic.rs @@ -38,7 +38,8 @@ pub trait IntrinsicCallBuilderMethods<'tcx>: BackendTypes { is_cleanup: bool, ) -> Self::Value; - fn abort(&mut self); + /// Ungracefully stop execution in the simplest way possible. + fn abort_immediate(&mut self); fn assume(&mut self, val: Self::Value); fn expect(&mut self, cond: Self::Value, expected: bool) -> Self::Value; /// Trait method used to load a function while testing if it is associated with a type diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs index 3f7731ce95583..7ee3d2f7826dd 100644 --- a/compiler/rustc_const_eval/src/const_eval/machine.rs +++ b/compiler/rustc_const_eval/src/const_eval/machine.rs @@ -484,8 +484,8 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> { // CTFE-specific intrinsics. match intrinsic_name { - sym::abort => { - // Note that `abort` is also hooked separately in Miri. + sym::abort_immediate => { + // Note that `abort_immediate` is also hooked separately in Miri. throw_machine_stop!(ConstEvalErrKind::Abort); } sym::ptr_guaranteed_cmp => { diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs index bcab1457e0655..3ababc644ddc1 100644 --- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs +++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs @@ -67,7 +67,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi // safe extern fns are otherwise unprecedented. // tidy-alphabetical-start - | sym::abort + | sym::abort_immediate | sym::add_with_overflow | sym::aggregate_raw_ptr | sym::align_of @@ -289,7 +289,7 @@ pub(crate) fn check_intrinsic_type( let n_lts = 0; let (n_tps, n_cts, inputs, output) = match intrinsic_name { sym::autodiff => (4, 0, vec![param(0), param(1), param(2)], param(3)), - sym::abort => (0, 0, vec![], tcx.types.never), + sym::abort_immediate => (0, 0, vec![], tcx.types.never), sym::amdgpu_dispatch_ptr => (0, 0, vec![], Ty::new_imm_ptr(tcx, tcx.types.unit)), sym::unreachable => (0, 0, vec![], tcx.types.never), sym::breakpoint => (0, 0, vec![], tcx.types.unit), diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index a003f20e3512d..dbd7cf40061f0 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -398,6 +398,7 @@ symbols! { abi_vectorcall, abi_x86_interrupt, abort, + abort_immediate, add, add_assign, add_with_overflow, diff --git a/library/alloc/src/collections/btree/mem.rs b/library/alloc/src/collections/btree/mem.rs index ad86e9422d974..c9a1ec8ca63c6 100644 --- a/library/alloc/src/collections/btree/mem.rs +++ b/library/alloc/src/collections/btree/mem.rs @@ -19,7 +19,7 @@ pub(super) fn replace(v: &mut T, change: impl FnOnce(T) -> (T, R)) -> R { struct PanicGuard; impl Drop for PanicGuard { fn drop(&mut self) { - intrinsics::abort() + intrinsics::abort_immediate() } } let guard = PanicGuard; diff --git a/library/alloc/src/collections/btree/split.rs b/library/alloc/src/collections/btree/split.rs index 388f41cc1c646..fde6810ed4143 100644 --- a/library/alloc/src/collections/btree/split.rs +++ b/library/alloc/src/collections/btree/split.rs @@ -61,7 +61,7 @@ impl Root { // A panic from a later `search_node` comparison would unwind out of // that state and double-free the shared values (#158165), so abort // instead of exposing it. - let guard = mem::DropGuard::new((), |()| intrinsics::abort()); + let guard = mem::DropGuard::new((), |()| intrinsics::abort_immediate()); loop { split_edge.move_suffix(&mut right_node); diff --git a/library/alloc/src/rcs/arc.rs b/library/alloc/src/rcs/arc.rs index 5b42173da5a3a..ffa848998e9a2 100644 --- a/library/alloc/src/rcs/arc.rs +++ b/library/alloc/src/rcs/arc.rs @@ -5,7 +5,6 @@ use core::clone::TrivialClone; use core::clone::{CloneToUninit, Share, UseCloned}; use core::cmp::Ordering; use core::hash::{Hash, Hasher}; -use core::intrinsics::abort; #[cfg(not(no_global_oom_handling))] use core::iter; use core::marker::{PhantomData, Unsize}; @@ -21,7 +20,7 @@ use core::ptr::{self, NonNull}; use core::slice::from_raw_parts_mut; use core::sync::atomic::Ordering::{Acquire, Relaxed, Release}; use core::sync::atomic::{self, Atomic}; -use core::{borrow, fmt, hint}; +use core::{borrow, fmt, hint, intrinsics}; #[cfg(not(no_global_oom_handling))] use crate::alloc::handle_alloc_error; @@ -2539,7 +2538,7 @@ impl Clone for Arc { // Otherwise, the counter could be brought to an almost-overflow using a compare-exchange loop, // and then overflow using a few `fetch_add`s. if old_size > MAX_REFCOUNT { - abort(); + intrinsics::abort_immediate(); } // SAFETY: Pointer is valid & allocator corresponds to the one used to allocate it. @@ -3587,7 +3586,7 @@ impl Clone for Weak { // See comments in Arc::clone() for why we do this (for mem::forget). if old_size > MAX_REFCOUNT { - abort(); + intrinsics::abort_immediate(); } } @@ -5065,7 +5064,7 @@ impl UniqueArc { // See comments in Arc::clone() for why we do this (for mem::forget). if old_size > MAX_REFCOUNT { - abort(); + intrinsics::abort_immediate(); } Weak { ptr: this.ptr, alloc: this.alloc.clone() } diff --git a/library/alloc/src/rcs/rc.rs b/library/alloc/src/rcs/rc.rs index d928e42f71e20..0666995ffe94a 100644 --- a/library/alloc/src/rcs/rc.rs +++ b/library/alloc/src/rcs/rc.rs @@ -248,7 +248,6 @@ use core::clone::TrivialClone; use core::clone::{CloneToUninit, Share, UseCloned}; use core::cmp::Ordering; use core::hash::{Hash, Hasher}; -use core::intrinsics::abort; #[cfg(not(no_global_oom_handling))] use core::iter; use core::marker::{PhantomData, Unsize}; @@ -264,7 +263,7 @@ use core::pin::PinSafePointer; use core::ptr::{self, NonNull, drop_in_place}; #[cfg(not(no_global_oom_handling))] use core::slice::from_raw_parts_mut; -use core::{borrow, fmt, hint}; +use core::{borrow, fmt, hint, intrinsics}; #[cfg(not(no_global_oom_handling))] use crate::alloc::handle_alloc_error; @@ -3939,8 +3938,8 @@ trait RcInnerPtr { // We want to abort on overflow instead of dropping the value. // Checking for overflow after the store instead of before // allows for slightly better code generation. - if core::intrinsics::unlikely(strong == 0) { - abort(); + if intrinsics::unlikely(strong == 0) { + intrinsics::abort_immediate(); } } @@ -3972,8 +3971,8 @@ trait RcInnerPtr { // We want to abort on overflow instead of dropping the value. // Checking for overflow after the store instead of before // allows for slightly better code generation. - if core::intrinsics::unlikely(weak == 0) { - abort(); + if intrinsics::unlikely(weak == 0) { + intrinsics::abort_immediate(); } } diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs index f44da9840b8e5..ee25326631107 100644 --- a/library/core/src/intrinsics/mod.rs +++ b/library/core/src/intrinsics/mod.rs @@ -425,26 +425,23 @@ pub fn breakpoint(); #[rustc_intrinsic] pub fn rustc_peek(_: T) -> T; -/// Aborts the execution of the process. +/// Ungracefully aborts the execution of the process. /// -/// Note that, unlike most intrinsics, this is safe to call; -/// it does not require an `unsafe` block. -/// Therefore, implementations must not require the user to uphold -/// any safety invariants. +/// This is the intrinsic for directly implementing [`core::process::abort_immediate`] which, on +/// most platforms, will invoke an invalid instruction. On Unix, the process will probably +/// terminate with a signal like `SIGABRT`, `SIGILL`, `SIGTRAP`, `SIGSEGV` or `SIGBUS`. The +/// precise behavior is not guaranteed and not stable. /// /// [`std::process::abort`](../../std/process/fn.abort.html) is to be preferred if possible, /// as its behavior is more user-friendly and more stable. /// -/// The current implementation of `intrinsics::abort` is to invoke an invalid instruction, -/// on most platforms. -/// On Unix, the -/// process will probably terminate with a signal like `SIGABRT`, `SIGILL`, `SIGTRAP`, `SIGSEGV` or -/// `SIGBUS`. The precise behavior is not guaranteed and not stable. +/// Note that, unlike most intrinsics, this is safe to call; it does not require an `unsafe` block. +/// Therefore, implementations must not require the user to uphold any safety invariants. /// -/// The stabilization-track version of this intrinsic is [`core::process::abort_immediate`]. +/// The stabilized version of this intrinsic is [`core::process::abort_immediate`]. #[rustc_nounwind] #[rustc_intrinsic] -pub const fn abort() -> !; +pub const fn abort_immediate() -> !; /// Informs the optimizer that this point in the code is not reachable, /// enabling further optimizations. diff --git a/library/core/src/panicking.rs b/library/core/src/panicking.rs index 04722e4e2fc10..bd4fbcf68b256 100644 --- a/library/core/src/panicking.rs +++ b/library/core/src/panicking.rs @@ -59,7 +59,7 @@ compile_error!( #[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable pub const fn panic_fmt(fmt: fmt::Arguments<'_>) -> ! { if cfg!(panic = "immediate-abort") { - super::intrinsics::abort() + super::intrinsics::abort_immediate() } // NOTE This function never crosses the FFI boundary; it's a Rust-to-Rust call @@ -100,7 +100,7 @@ pub const fn panic_nounwind_fmt(fmt: fmt::Arguments<'_>, force_no_backtrace: boo panic_fmt(fmt) } else #[track_caller] { if cfg!(panic = "immediate-abort") { - super::intrinsics::abort() + super::intrinsics::abort_immediate() } // NOTE This function never crosses the FFI boundary; it's a Rust-to-Rust call @@ -265,7 +265,7 @@ pub const fn panic_display(x: &T) -> ! { #[lang = "panic_bounds_check"] // needed by codegen for panic on OOB array/slice access fn panic_bounds_check(index: usize, len: usize) -> ! { if cfg!(panic = "immediate-abort") { - super::intrinsics::abort() + super::intrinsics::abort_immediate() } panic!("index out of bounds: the len is {len} but the index is {index}") @@ -278,7 +278,7 @@ fn panic_bounds_check(index: usize, len: usize) -> ! { #[rustc_nounwind] // `CheckAlignment` MIR pass requires this function to never unwind fn panic_misaligned_pointer_dereference(required: usize, found: usize) -> ! { if cfg!(panic = "immediate-abort") { - super::intrinsics::abort() + super::intrinsics::abort_immediate() } panic_nounwind_fmt( @@ -296,7 +296,7 @@ fn panic_misaligned_pointer_dereference(required: usize, found: usize) -> ! { #[rustc_nounwind] // `CheckNull` MIR pass requires this function to never unwind fn panic_null_pointer_dereference() -> ! { if cfg!(panic = "immediate-abort") { - super::intrinsics::abort() + super::intrinsics::abort_immediate() } panic_nounwind_fmt( @@ -312,7 +312,7 @@ fn panic_null_pointer_dereference() -> ! { #[rustc_nounwind] // `CheckNull` MIR pass requires this function to never unwind fn panic_null_reference_constructed() -> ! { if cfg!(panic = "immediate-abort") { - super::intrinsics::abort() + super::intrinsics::abort_immediate() } panic_nounwind_fmt(format_args!("null reference produced"), /* force_no_backtrace */ false) @@ -325,7 +325,7 @@ fn panic_null_reference_constructed() -> ! { #[rustc_nounwind] // `CheckEnums` MIR pass requires this function to never unwind fn panic_invalid_enum_construction(source: u128) -> ! { if cfg!(panic = "immediate-abort") { - super::intrinsics::abort() + super::intrinsics::abort_immediate() } panic_nounwind_fmt( diff --git a/library/core/src/process.rs b/library/core/src/process.rs index 2da752b42ee85..1c2769f07895b 100644 --- a/library/core/src/process.rs +++ b/library/core/src/process.rs @@ -40,5 +40,5 @@ #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces #[doc(alias = "halt")] pub const fn abort_immediate() -> ! { - crate::intrinsics::abort() + crate::intrinsics::abort_immediate() } diff --git a/library/core/src/slice/sort/shared/pivot.rs b/library/core/src/slice/sort/shared/pivot.rs index 9eb60f854ce21..878ec27419fc2 100644 --- a/library/core/src/slice/sort/shared/pivot.rs +++ b/library/core/src/slice/sort/shared/pivot.rs @@ -17,7 +17,7 @@ pub fn choose_pivot bool>(v: &[T], is_less: &mut F) -> us let len = v.len(); if len < 8 { - intrinsics::abort(); + intrinsics::abort_immediate(); } // SAFETY: a, b, c point to initialized regions of len_div_8 elements, diff --git a/library/core/src/slice/sort/shared/smallsort.rs b/library/core/src/slice/sort/shared/smallsort.rs index 40939f922bcb6..1510c3d6d8d6c 100644 --- a/library/core/src/slice/sort/shared/smallsort.rs +++ b/library/core/src/slice/sort/shared/smallsort.rs @@ -228,7 +228,7 @@ fn small_sort_general_with_scratch bool>( } if scratch.len() < len + 16 { - intrinsics::abort(); + intrinsics::abort_immediate(); } let v_base = v.as_mut_ptr(); @@ -321,7 +321,7 @@ where } if len > SMALL_SORT_NETWORK_SCRATCH_LEN { - intrinsics::abort(); + intrinsics::abort_immediate(); } let mut stack_array = MaybeUninit::<[T; SMALL_SORT_NETWORK_SCRATCH_LEN]>::uninit(); @@ -422,7 +422,7 @@ where F: FnMut(&T, &T) -> bool, { if v.len() < 9 { - intrinsics::abort(); + intrinsics::abort_immediate(); } let v_base = v.as_mut_ptr(); @@ -471,7 +471,7 @@ where F: FnMut(&T, &T) -> bool, { if v.len() < 13 { - intrinsics::abort(); + intrinsics::abort_immediate(); } let v_base = v.as_mut_ptr(); @@ -578,7 +578,7 @@ pub fn insertion_sort_shift_left bool>( ) { let len = v.len(); if offset == 0 || offset > len { - intrinsics::abort(); + intrinsics::abort_immediate(); } // SAFETY: see individual comments. diff --git a/library/core/src/slice/sort/stable/quicksort.rs b/library/core/src/slice/sort/stable/quicksort.rs index acc8a5e838e12..1696a5e3c0277 100644 --- a/library/core/src/slice/sort/stable/quicksort.rs +++ b/library/core/src/slice/sort/stable/quicksort.rs @@ -96,7 +96,7 @@ fn stable_partition bool>( let len = v.len(); if intrinsics::unlikely(scratch.len() < len || pivot_pos >= len) { - core::intrinsics::abort() + core::intrinsics::abort_immediate() } let v_base = v.as_ptr(); diff --git a/library/core/src/slice/sort/unstable/quicksort.rs b/library/core/src/slice/sort/unstable/quicksort.rs index 5f2991ee722d2..58a9aae7c7afa 100644 --- a/library/core/src/slice/sort/unstable/quicksort.rs +++ b/library/core/src/slice/sort/unstable/quicksort.rs @@ -102,7 +102,7 @@ where } if pivot >= len { - intrinsics::abort(); + intrinsics::abort_immediate(); } // SAFETY: We checked that `pivot` is in-bounds. @@ -124,7 +124,7 @@ where let num_lt = (const { inst_partition::() })(v_without_pivot, pivot, is_less); if num_lt >= len { - intrinsics::abort(); + intrinsics::abort_immediate(); } // SAFETY: We checked that `num_lt` is in-bounds. diff --git a/library/std/src/panicking.rs b/library/std/src/panicking.rs index f69e0a749f579..4a66d2c1d55f5 100644 --- a/library/std/src/panicking.rs +++ b/library/std/src/panicking.rs @@ -706,7 +706,7 @@ pub(crate) fn panic_handler(info: &core::panic::PanicInfo<'_>) -> ! { #[rustc_do_not_const_check] // hooked by const-eval pub const fn begin_panic(msg: M) -> ! { if cfg!(panic = "immediate-abort") { - intrinsics::abort() + intrinsics::abort_immediate() } struct Payload { @@ -887,5 +887,5 @@ fn rust_panic(msg: &mut dyn PanicPayload) -> ! { #[cfg_attr(not(test), rustc_std_internal_symbol)] #[cfg(panic = "immediate-abort")] fn rust_panic(_: &mut dyn PanicPayload) -> ! { - crate::intrinsics::abort(); + crate::intrinsics::abort_immediate(); } diff --git a/library/std/src/sys/exit.rs b/library/std/src/sys/exit.rs index b9ebe2d974fec..1ca2bd8f6b514 100644 --- a/library/std/src/sys/exit.rs +++ b/library/std/src/sys/exit.rs @@ -127,7 +127,7 @@ pub fn exit(code: i32) -> ! { ) }; } - crate::intrinsics::abort() + crate::intrinsics::abort_immediate() } any(target_family = "unix", target_os = "wasi") => unsafe { libc::exit(code as crate::ffi::c_int) @@ -147,7 +147,7 @@ pub fn exit(code: i32) -> ! { target_os = "xous" => crate::os::xous::ffi::exit(code as u32), _ => { let _ = code; - crate::intrinsics::abort() + crate::intrinsics::abort_immediate() } } } diff --git a/library/std/src/sys/pal/uefi/mod.rs b/library/std/src/sys/pal/uefi/mod.rs index 67499d2c6f17c..bb771c232f2de 100644 --- a/library/std/src/sys/pal/uefi/mod.rs +++ b/library/std/src/sys/pal/uefi/mod.rs @@ -103,8 +103,8 @@ pub fn abort_internal() -> ! { }; } - // In case SystemTable and ImageHandle cannot be reached, use `core::intrinsics::abort` - core::intrinsics::abort(); + // In case SystemTable and ImageHandle cannot be reached, use `abort_immediate` + core::intrinsics::abort_immediate(); } /// Disable access to BootServices if `EVT_SIGNAL_EXIT_BOOT_SERVICES` is signaled diff --git a/library/std/src/sys/pal/unix/mod.rs b/library/std/src/sys/pal/unix/mod.rs index e4a18794f7823..292c02f3d1f3e 100644 --- a/library/std/src/sys/pal/unix/mod.rs +++ b/library/std/src/sys/pal/unix/mod.rs @@ -267,8 +267,8 @@ pub fn cvt_nz(error: libc::c_int) -> io::Result<()> { // Current glibc's abort() function unblocks SIGABRT, raises SIGABRT, clears the // SIGABRT handler and raises it again, and then starts to get creative. // -// See the public documentation for `intrinsics::abort()` and `process::abort()` -// for further discussion. +// See the public documentation for `intrinsics::abort_immediate()` and +// `process::abort()` for further discussion. // // There is confusion about whether libc::abort() flushes stdio streams. // libc::abort() is required by ISO C 99 (7.14.1.1p5) to be async-signal-safe, diff --git a/library/std/src/sys/pal/unsupported/common.rs b/library/std/src/sys/pal/unsupported/common.rs index d94b9015d0f5f..8e53c3212b64b 100644 --- a/library/std/src/sys/pal/unsupported/common.rs +++ b/library/std/src/sys/pal/unsupported/common.rs @@ -17,5 +17,5 @@ pub fn unsupported_err() -> std_io::Error { } pub fn abort_internal() -> ! { - core::intrinsics::abort(); + core::intrinsics::abort_immediate(); } diff --git a/library/std/src/sys/pal/windows/mod.rs b/library/std/src/sys/pal/windows/mod.rs index 2a8ffaa0baab8..a9f3cdbdd9d3e 100644 --- a/library/std/src/sys/pal/windows/mod.rs +++ b/library/std/src/sys/pal/windows/mod.rs @@ -275,7 +275,7 @@ pub fn abort_internal() -> ! { core::arch::asm!("brk 0xF003", in("x0") c::FAST_FAIL_FATAL_APP_EXIT, options(noreturn, nostack)); } _ => { - core::intrinsics::abort(); + core::intrinsics::abort_immediate(); } } } @@ -284,7 +284,7 @@ pub fn abort_internal() -> ! { #[cfg(miri)] #[track_caller] // even without panics, this helps for Miri backtraces pub fn abort_internal() -> ! { - crate::intrinsics::abort(); + crate::intrinsics::abort_immediate(); } /// Align the inner value to 8 bytes. diff --git a/library/std/src/sys/pal/zkvm/mod.rs b/library/std/src/sys/pal/zkvm/mod.rs index 1a64d3c93d701..3a21e6f66c4e2 100644 --- a/library/std/src/sys/pal/zkvm/mod.rs +++ b/library/std/src/sys/pal/zkvm/mod.rs @@ -31,5 +31,5 @@ pub fn unsupported_err() -> std_io::Error { } pub fn abort_internal() -> ! { - core::intrinsics::abort(); + core::intrinsics::abort_immediate(); } diff --git a/library/std/src/sys/personality/mod.rs b/library/std/src/sys/personality/mod.rs index 31bd457adbe6b..be79643bdf846 100644 --- a/library/std/src/sys/personality/mod.rs +++ b/library/std/src/sys/personality/mod.rs @@ -22,7 +22,7 @@ cfg_select! { // aborting stub. #[lang = "eh_personality"] fn rust_eh_personality() { - core::intrinsics::abort() + core::intrinsics::abort_immediate() } } any( diff --git a/library/stdarch/crates/core_arch/src/mips/mod.rs b/library/stdarch/crates/core_arch/src/mips/mod.rs index 1de3ffd03d1f0..84bfd1585e89b 100644 --- a/library/stdarch/crates/core_arch/src/mips/mod.rs +++ b/library/stdarch/crates/core_arch/src/mips/mod.rs @@ -16,5 +16,5 @@ use stdarch_test::assert_instr; #[inline] #[unstable(feature = "stdarch_mips", issue = "111198")] pub unsafe fn break_() -> ! { - crate::intrinsics::abort() + crate::intrinsics::abort_immediate() } diff --git a/library/stdarch/crates/core_arch/src/nvptx/mod.rs b/library/stdarch/crates/core_arch/src/nvptx/mod.rs index d382aff41f4bf..ea6fffee3897f 100644 --- a/library/stdarch/crates/core_arch/src/nvptx/mod.rs +++ b/library/stdarch/crates/core_arch/src/nvptx/mod.rs @@ -145,7 +145,7 @@ pub unsafe fn _thread_idx_z() -> u32 { #[inline] #[unstable(feature = "stdarch_nvptx", issue = "111199")] pub unsafe fn trap() -> ! { - crate::intrinsics::abort() + crate::intrinsics::abort_immediate() } // Basic CUDA syscall declarations. diff --git a/library/stdarch/crates/core_arch/src/powerpc/mod.rs b/library/stdarch/crates/core_arch/src/powerpc/mod.rs index 53227215d946c..9bb1bf22434dc 100644 --- a/library/stdarch/crates/core_arch/src/powerpc/mod.rs +++ b/library/stdarch/crates/core_arch/src/powerpc/mod.rs @@ -18,5 +18,5 @@ use stdarch_test::assert_instr; #[inline] #[unstable(feature = "stdarch_powerpc", issue = "111145")] pub unsafe fn trap() -> ! { - crate::intrinsics::abort() + crate::intrinsics::abort_immediate() } diff --git a/library/stdarch/crates/core_arch/src/wasm32/mod.rs b/library/stdarch/crates/core_arch/src/wasm32/mod.rs index 57c9157bede89..03986e7e08ec7 100644 --- a/library/stdarch/crates/core_arch/src/wasm32/mod.rs +++ b/library/stdarch/crates/core_arch/src/wasm32/mod.rs @@ -29,7 +29,7 @@ pub use self::memory::*; #[inline] #[stable(feature = "unreachable_wasm32", since = "1.37.0")] pub fn unreachable() -> ! { - crate::intrinsics::abort() + crate::intrinsics::abort_immediate() } /// Generates the [`f32.ceil`] instruction, returning the smallest integer greater than or equal to `a`. diff --git a/src/doc/unstable-book/src/language-features/intrinsics.md b/src/doc/unstable-book/src/language-features/intrinsics.md index 9e59dd889985c..c662e5831d3a0 100644 --- a/src/doc/unstable-book/src/language-features/intrinsics.md +++ b/src/doc/unstable-book/src/language-features/intrinsics.md @@ -68,5 +68,5 @@ These are written without a body: #![allow(internal_features)] #[rustc_intrinsic] -pub fn abort() -> !; +pub fn abort_immediate() -> !; ``` diff --git a/src/doc/unstable-book/src/language-features/lang-items.md b/src/doc/unstable-book/src/language-features/lang-items.md index ccc973d013e44..c88f0cb859877 100644 --- a/src/doc/unstable-book/src/language-features/lang-items.md +++ b/src/doc/unstable-book/src/language-features/lang-items.md @@ -85,7 +85,7 @@ unsafe fn allocate(size: usize, _align: usize) -> *mut u8 { // Check if `malloc` failed: if p.is_null() { - intrinsics::abort(); + intrinsics::abort_immediate(); } p @@ -102,7 +102,7 @@ extern "C" fn main(_argc: c_int, _argv: *const *const u8) -> c_int { fn rust_eh_personality() {} #[panic_handler] -fn panic_handler(_info: &PanicInfo) -> ! { intrinsics::abort() } +fn panic_handler(_info: &PanicInfo) -> ! { intrinsics::abort_immediate() } ``` Note the use of `abort`: the `exchange_malloc` lang item is assumed to diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs index 997339f66a51c..aa93632b78470 100644 --- a/src/tools/miri/src/intrinsics/mod.rs +++ b/src/tools/miri/src/intrinsics/mod.rs @@ -95,8 +95,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> { match intrinsic_name { // Basic control flow - "abort" => { - // Note that `abort` is also hooked separately in CTFE. + "abort_immediate" => { + // Note that `abort_immediate` is also hooked separately in CTFE. throw_machine_stop!(TerminationInfo::Abort( "the program aborted execution".to_owned() )); diff --git a/src/tools/miri/tests/fail/alloc/alloc_error_handler_custom.rs b/src/tools/miri/tests/fail/alloc/alloc_error_handler_custom.rs index 72f45be61b299..cb11c4ac22776 100644 --- a/src/tools/miri/tests/fail/alloc/alloc_error_handler_custom.rs +++ b/src/tools/miri/tests/fail/alloc/alloc_error_handler_custom.rs @@ -16,7 +16,7 @@ mod utils; #[alloc_error_handler] fn alloc_error_handler(layout: Layout) -> ! { let _ = writeln!(utils::MiriStderr, "custom alloc error handler: {layout:?}"); - core::intrinsics::abort(); //~ERROR: aborted + core::intrinsics::abort_immediate(); //~ERROR: aborted } // rustc requires us to provide some more things that aren't actually used by this test diff --git a/src/tools/miri/tests/fail/alloc/alloc_error_handler_custom.stderr b/src/tools/miri/tests/fail/alloc/alloc_error_handler_custom.stderr index 677fa1b1bb9c0..4e6bdd2d82296 100644 --- a/src/tools/miri/tests/fail/alloc/alloc_error_handler_custom.stderr +++ b/src/tools/miri/tests/fail/alloc/alloc_error_handler_custom.stderr @@ -2,8 +2,8 @@ custom alloc error handler: Layout { size: 4, align: 4 (1 << 2) } error: abnormal termination: the program aborted execution --> tests/fail/alloc/alloc_error_handler_custom.rs:LL:CC | -LL | core::intrinsics::abort(); - | ^^^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here +LL | core::intrinsics::abort_immediate(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here | = note: stack backtrace: 0: alloc_error_handler diff --git a/src/tools/miri/tests/fail/alloc/alloc_error_handler_no_std.rs b/src/tools/miri/tests/fail/alloc/alloc_error_handler_no_std.rs index c7c51c95e9c26..d88c8b27e3c94 100644 --- a/src/tools/miri/tests/fail/alloc/alloc_error_handler_no_std.rs +++ b/src/tools/miri/tests/fail/alloc/alloc_error_handler_no_std.rs @@ -19,7 +19,7 @@ mod utils; 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 + core::intrinsics::abort_immediate(); //~ERROR: aborted } // rustc requires us to provide some more things that aren't actually used by this test diff --git a/src/tools/miri/tests/fail/alloc/alloc_error_handler_no_std.stderr b/src/tools/miri/tests/fail/alloc/alloc_error_handler_no_std.stderr index 386e7cdc2bd81..b93848eef5274 100644 --- a/src/tools/miri/tests/fail/alloc/alloc_error_handler_no_std.stderr +++ b/src/tools/miri/tests/fail/alloc/alloc_error_handler_no_std.stderr @@ -4,8 +4,8 @@ memory allocation of 4 bytes failed error: abnormal termination: the program aborted execution --> tests/fail/alloc/alloc_error_handler_no_std.rs:LL:CC | -LL | core::intrinsics::abort(); - | ^^^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here +LL | core::intrinsics::abort_immediate(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here | = note: stack backtrace: 0: panic_handler diff --git a/src/tools/miri/tests/fail/panic/no_std.rs b/src/tools/miri/tests/fail/panic/no_std.rs index cd8a3251fef20..e4b212104ede2 100644 --- a/src/tools/miri/tests/fail/panic/no_std.rs +++ b/src/tools/miri/tests/fail/panic/no_std.rs @@ -16,5 +16,5 @@ fn miri_start(_argc: isize, _argv: *const *const u8) -> isize { #[panic_handler] fn panic_handler(panic_info: &core::panic::PanicInfo) -> ! { writeln!(utils::MiriStderr, "{panic_info}").ok(); - core::intrinsics::abort(); //~ ERROR: the program aborted execution + core::intrinsics::abort_immediate(); //~ ERROR: the program aborted execution } diff --git a/src/tools/miri/tests/fail/panic/no_std.stderr b/src/tools/miri/tests/fail/panic/no_std.stderr index 87adb18a7ab90..493ed858c3234 100644 --- a/src/tools/miri/tests/fail/panic/no_std.stderr +++ b/src/tools/miri/tests/fail/panic/no_std.stderr @@ -3,8 +3,8 @@ blarg I am dead error: abnormal termination: the program aborted execution --> tests/fail/panic/no_std.rs:LL:CC | -LL | core::intrinsics::abort(); - | ^^^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here +LL | core::intrinsics::abort_immediate(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here | = note: stack backtrace: 0: panic_handler diff --git a/src/tools/rustfmt/tests/source/match.rs b/src/tools/rustfmt/tests/source/match.rs index d1d8d7f2c3665..c171244271f45 100644 --- a/src/tools/rustfmt/tests/source/match.rs +++ b/src/tools/rustfmt/tests/source/match.rs @@ -240,7 +240,7 @@ fn issue383() { fn issue507() { match 1 { - 1 => unsafe { std::intrinsics::abort() }, + 1 => unsafe { std::intrinsics::abort_immediate() }, _ => (), } } diff --git a/src/tools/rustfmt/tests/target/match.rs b/src/tools/rustfmt/tests/target/match.rs index 0e7815a814da2..f751aea547af6 100644 --- a/src/tools/rustfmt/tests/target/match.rs +++ b/src/tools/rustfmt/tests/target/match.rs @@ -249,7 +249,7 @@ fn issue383() { fn issue507() { match 1 { - 1 => unsafe { std::intrinsics::abort() }, + 1 => unsafe { std::intrinsics::abort_immediate() }, _ => (), } } diff --git a/tests/assembly-llvm/mips-div-no-trap.rs b/tests/assembly-llvm/mips-div-no-trap.rs index d2baff77d3070..1088cce4ef26b 100644 --- a/tests/assembly-llvm/mips-div-no-trap.rs +++ b/tests/assembly-llvm/mips-div-no-trap.rs @@ -107,16 +107,16 @@ extern crate minicore; pub unsafe fn unchecked_div(x: T, y: T) -> T; #[rustc_intrinsic] -pub fn abort() -> !; +pub fn abort_immediate() -> !; // NOTRAP-NOT: teq // TRAP: teq #[no_mangle] pub fn div_i32(a: i32, b: i32) -> i32 { match a { - 0 => abort(), + 0 => abort_immediate(), -1 => match b { - -2147483648 => abort(), + -2147483648 => abort_immediate(), _ => unsafe { unchecked_div(a, b) }, }, _ => unsafe { unchecked_div(a, b) }, diff --git a/tests/rustdoc-html/safe-intrinsic.rs b/tests/rustdoc-html/safe-intrinsic.rs index a40116894a84a..1a38a4f5f1c15 100644 --- a/tests/rustdoc-html/safe-intrinsic.rs +++ b/tests/rustdoc-html/safe-intrinsic.rs @@ -14,10 +14,10 @@ pub trait MetaSized: PointeeSized {} #[lang = "sized"] pub trait Sized: MetaSized {} -//@ has 'foo/fn.abort.html' -//@ has - '//pre[@class="rust item-decl"]' 'pub fn abort() -> !' +//@ has 'foo/fn.abort_immediate.html' +//@ has - '//pre[@class="rust item-decl"]' 'pub fn abort_immediate() -> !' #[rustc_intrinsic] -pub fn abort() -> !; +pub fn abort_immediate() -> !; //@ has 'foo/fn.unreachable.html' //@ has - '//pre[@class="rust item-decl"]' 'pub unsafe fn unreachable() -> !' #[rustc_intrinsic] diff --git a/tests/ui/consts/const-eval/const_panic.stderr b/tests/ui/consts/const-eval/const_panic.stderr index 19d8f3ae1c106..c91151b137fbe 100644 --- a/tests/ui/consts/const-eval/const_panic.stderr +++ b/tests/ui/consts/const-eval/const_panic.stderr @@ -76,7 +76,7 @@ error[E0080]: the program aborted execution LL | const ABORT: () = core::process::abort_immediate(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `ABORT` failed inside this call | -note: inside `abort_immediate` +note: inside `std::process::abort_immediate` --> $SRC_DIR/core/src/process.rs:LL:COL error: aborting due to 13 previous errors diff --git a/tests/ui/proc-macro/auxiliary/derive-unstable.rs b/tests/ui/proc-macro/auxiliary/derive-unstable.rs index 8ba3a06e3549e..c7e34db900042 100644 --- a/tests/ui/proc-macro/auxiliary/derive-unstable.rs +++ b/tests/ui/proc-macro/auxiliary/derive-unstable.rs @@ -4,6 +4,5 @@ use proc_macro::TokenStream; #[proc_macro_derive(Unstable)] pub fn derive(_input: TokenStream) -> TokenStream { - - "unsafe fn foo() -> u32 { ::std::intrinsics::abort() }".parse().unwrap() + "unsafe fn foo() -> u32 { ::std::intrinsics::abort_immediate() }".parse().unwrap() } diff --git a/tests/ui/process/signal-exit-status.rs b/tests/ui/process/signal-exit-status.rs index 33aa83abfc377..1a7836b171a81 100644 --- a/tests/ui/process/signal-exit-status.rs +++ b/tests/ui/process/signal-exit-status.rs @@ -12,7 +12,7 @@ pub fn main() { let args: Vec = env::args().collect(); if args.len() >= 2 && args[1] == "signal" { // Raise an aborting signal without UB - core::intrinsics::abort(); + core::intrinsics::abort_immediate(); } else { let status = Command::new(&args[0]).arg("signal").status().unwrap(); assert!(status.code().is_none());