`std::thread::panicking()` doesn't simplify to `false` when compiled with `panic=abort`

[gendx]

I tried compiling this code with -C panic=abort:

std::thread::panicking()

I expected to see this happen: this should simplify to false because the documentation of panicking() says "Determines whether the current thread is unwinding because of panic", but the current thread cannot be unwinding when we are in panic=abort mode.

Instead, this happened: a dozen instructions are generated, referring to GLOBAL_PANIC_COUNT, etc. See https://rust.godbolt.org/z/93Yax7rT9.

Can the implementation be changed to something like this? Due to constant folding, this could potentially automatically optimize away a lot of code referring to std::thread::panicking() when compiled in panic=abort mode.

fn panicking() -> bool {
    if cfg!(panic = "abort") {
        false
    } else {
        panicking::panicking()
    }
}

Meta

Rust version 1.92.0 on https://rust.godbolt.org/

[eggyal]

cfg! is evaluated at compile time - in this case when the std library was compiled; so that proposal won't work... but perhaps there's another way.

[SpriteOvO]

Try cargo +nightly build --release -Zbuild-std -Zpanic-immediate-abort with cargo profile

[profile.release]
panic = "immediate-abort"

fn panicking has a no-op alternative impl for cfg(panic = "immediate-abort") not cfg(panic = "abort") because panic hooks still work in "abort".

rust/library/std/src/panicking.rs

Lines 323 to 361 in b765963

	#[cfg(not(test))]
	#[doc(hidden)]
	#[cfg(panic = "immediate-abort")]
	#[unstable(feature = "update_panic_count", issue = "none")]
	pub mod panic_count {
	/// A reason for forcing an immediate abort on panic.
	#[derive(Debug)]
	pub enum MustAbort {
	AlwaysAbort,
	PanicInHook,
	}
	#[inline]
	pub fn increase(run_panic_hook: bool) -> Option<MustAbort> {
	None
	}
	#[inline]
	pub fn finished_panic_hook() {}
	#[inline]
	pub fn decrease() {}
	#[inline]
	pub fn set_always_abort() {}
	// Disregards ALWAYS_ABORT_FLAG
	#[inline]
	#[must_use]
	pub fn get_count() -> usize {
	0
	}
	#[must_use]
	#[inline]
	pub fn count_is_zero() -> bool {
	true
	}
	}

As mentioned above, stdlib is pre-built and shipped with "unwind", so you need -Zbuild-std option to build stdlib with "immediate-abort" yourself.

/tmp/temp> cargo +nightly build --release -Zbuild-std -Z panic-immediate-abort
    Finished `release` profile [optimized] target(s) in 0.02s
/tmp/temp> objdump --disassemble=current_panicking ./target/release/libtemp.rlib
In archive ./target/release/libtemp.rlib:

lib.rmeta:     file format elf64-x86-64


temp-3f2e16a7c6c0be9d.temp.76320231b5fb0a73-cgu.0.rcgu.o:     file format elf64-x86-64


Disassembly of section .text.current_panicking:

0000000000000000 <current_panicking>:
   0:   31 c0                   xor    %eax,%eax
   2:   c3                      ret

[gendx]

Thanks for the clarification, indeed I hadn't thought about the prebuilt stdlib situation.

I'm still wondering whether std::thread::panicking() could return anything other than false in the cfg(panic = "abort") case (assuming the stdlib has been built with that). Yes a panic hook will still run, but what are the semantics of that? The only way to observe std::thread::panicking() == true would be if the panic hook itself invokes (directly or indirectly) std::thread::panicking(), is that correct? Even from within the panic hook, would returning true be correct, given that the thread isn't really unwinding (in the sense that it's not dropping all the objects along the call stack).

[SpriteOvO]

Determines whether the current thread is unwinding because of panic.

The fn panicking docs (its first sentence) has remained unchanged since it's stabilized in v1.0. Panic hooks were introduced since v1.10. Prior to that, the only case where it could return true was unwinding I guess. So the documentation might need some updates, like

Determines whether the current thread is unwinding or aborting because of panic.