Fix short backtraces from stripped executables

[eggyal]

Locate the beginning and ending frames for short backtraces by address in addition to symbol name, so that they work even when symbols have been stripped from the executable.

We need to retain matching by symbol name for the time being, because rustc (and some associated ui tests) rely upon it to have ICE backtraces abbreviated. They can be updated once this commit lands in beta/stage0. (It is for this reason that the begin/end methods are being publicly exported from std::backtrace, albeit hidden from documentation and marked unstable).

Fixes #147846
r? libs

[rustbot]

The Miri subtree was changed

cc @rust-lang/miri

[jhpratt]

@rustbot reroll

[rustbot]

Reminder, once the PR becomes ready for a review, use @rustbot ready.

[saethlin]

You added a generic parameter to the backtrace markers which removes their address stability:

rust/src/tools/miri/src/machine.rs

Lines 1887 to 1926 in a33907a

	fn get_global_alloc_salt(
	ecx: &InterpCx<'tcx, Self>,
	instance: Option<ty::Instance<'tcx>>,
	) -> usize {
	let unique = if let Some(instance) = instance {
	// Functions cannot be identified by pointers, as asm-equal functions can get
	// deduplicated by the linker (we set the "unnamed_addr" attribute for LLVM) and
	// functions can be duplicated across crates. We thus generate a new `AllocId` for every
	// mention of a function. This means that `main as fn() == main as fn()` is false, while
	// `let x = main as fn(); x == x` is true. However, as a quality-of-life feature it can
	// be useful to identify certain functions uniquely, e.g. for backtraces. So we identify
	// whether codegen will actually emit duplicate functions. It does that when they have
	// non-lifetime generics, or when they can be inlined. All other functions are given a
	// unique address. This is not a stable guarantee! The `inline` attribute is a hint and
	// cannot be relied upon for anything. But if we don't do this, the
	// `__rust_begin_short_backtrace`/`__rust_end_short_backtrace` logic breaks and panic
	// backtraces look terrible.
	let is_generic = instance
	.args
	.into_iter()
	.any(|arg| !matches!(arg.kind(), ty::GenericArgKind::Lifetime(_)));
	let can_be_inlined = matches!(
	ecx.tcx.sess.opts.unstable_opts.cross_crate_inline_threshold,
	InliningThreshold::Always
	) || !matches!(
	ecx.tcx.codegen_instance_attrs(instance.def).inline,
	InlineAttr::Never
	);
	!is_generic && !can_be_inlined
	} else {
	// Non-functions are never unique.
	false
	};
	// Always use the same salt if the allocation is unique.
	if unique {
	CTFE_ALLOC_SALT
	} else {
	ecx.machine.rng.borrow_mut().random_range(0..ADDRS_PER_ANON_GLOBAL)
	}
	}

Miri explicitly tries to destabilize function pointer addresses in all cases where it would be plausible for an optimizer to do so.