Auto merge of rust-lang#129642 - workingjubilee:bump-backtrace-fc37b22, r=<try>

Bump backtrace to rust-lang/backtrace-rs@fc37b22

It should be 0.3.74~ish.

This should help with backtraces on Android, QNX NTO 7.0, and Windows.

try-job: arm-android

Author: bors

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -790,13 +790,15 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let (fn_abi, llfn, instance) =
                     common::build_langcall(bx, Some(source_info.span), LangItem::PanicNounwind);
 
+                let location = self.get_caller_location(bx, source_info).immediate();
+
                 // Codegen the actual panic invoke/call.
                 helper.do_call(
                     self,
                     bx,
                     fn_abi,
                     llfn,
-                    &[msg.0, msg.1],
+                    &[msg.0, msg.1, location],
                     target.as_ref().map(|bb| (ReturnDest::Nothing, *bb)),
                     unwind,
                     &[],

compiler/rustc_codegen_ssa/src/size_of_val.rs

@@ -72,12 +72,20 @@ pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
             // (But we are in good company, this code is duplicated plenty of times.)
             let fn_ty = bx.fn_decl_backend_type(fn_abi);
 
+            let const_loc = bx.tcx().span_as_caller_location(rustc_span::DUMMY_SP);
+            let location = crate::mir::operand::OperandRef::from_const(
+                bx,
+                const_loc,
+                bx.tcx().caller_location_ty(),
+            )
+            .immediate();
+
             bx.call(
                 fn_ty,
                 /* fn_attrs */ None,
                 Some(fn_abi),
                 llfn,
-                &[msg.0, msg.1],
+                &[msg.0, msg.1, location],
                 None,
                 None,
             );

library/backtrace

@@ -212,6 +212,7 @@ panic_const! {
 
 /// Like `panic`, but without unwinding and track_caller to reduce the impact on codesize on the caller.
 /// If you want `#[track_caller]` for nicer errors, call `panic_nounwind_fmt` directly.
+#[track_caller]
 #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
 #[cfg_attr(feature = "panic_immediate_abort", inline)]
 #[lang = "panic_nounwind"] // needed by codegen for non-unwinding panics
@@ -222,6 +223,7 @@ pub const fn panic_nounwind(expr: &'static str) -> ! {
 }
 
 /// Like `panic_nounwind`, but also inhibits showing a backtrace.
+#[track_caller]
 #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
 #[cfg_attr(feature = "panic_immediate_abort", inline)]
 #[rustc_nounwind]

library/core/src/panicking.rs

@@ -65,6 +65,7 @@ macro_rules! assert_unsafe_precondition {
             #[inline]
             #[rustc_nounwind]
             #[rustc_const_unstable(feature = "const_ub_checks", issue = "none")]
+            #[track_caller]
             const fn precondition_check($($name:$ty),*) {
                 if !$e {
                     ::core::panicking::panic_nounwind(
@@ -92,8 +93,10 @@ pub use intrinsics::ub_checks as check_library_ub;
 /// language UB checks which generally produce better errors.
 #[rustc_const_unstable(feature = "const_ub_checks", issue = "none")]
 #[inline]
+#[track_caller]
 pub(crate) const fn check_language_ub() -> bool {
     #[inline]
+    #[track_caller]
     fn runtime() -> bool {
         // Disable UB checks in Miri.
         !cfg!(miri)
@@ -116,11 +119,13 @@ pub(crate) const fn check_language_ub() -> bool {
 /// for `assert_unsafe_precondition!` with `check_language_ub`, in which case the
 /// check is anyway not executed in `const`.
 #[inline]
+#[track_caller]
 pub(crate) const fn is_aligned_and_not_null(ptr: *const (), align: usize) -> bool {
     !ptr.is_null() && ptr.is_aligned_to(align)
 }
 
 #[inline]
+#[track_caller]
 pub(crate) const fn is_valid_allocation_size(size: usize, len: usize) -> bool {
     let max_len = if size == 0 { usize::MAX } else { isize::MAX as usize / size };
     len <= max_len
@@ -132,13 +137,15 @@ pub(crate) const fn is_valid_allocation_size(size: usize, len: usize) -> bool {
 /// Note that in const-eval this function just returns `true` and therefore must
 /// only be used with `assert_unsafe_precondition!`, similar to `is_aligned_and_not_null`.
 #[inline]
+#[track_caller]
 pub(crate) const fn is_nonoverlapping(
     src: *const (),
     dst: *const (),
     size: usize,
     count: usize,
 ) -> bool {
     #[inline]
+    #[track_caller]
     fn runtime(src: *const (), dst: *const (), size: usize, count: usize) -> bool {
         let src_usize = src.addr();
         let dst_usize = dst.addr();

library/core/src/ub_checks.rs

@@ -1,4 +1,4 @@
-thread 'main' panicked at core/src/panicking.rs:$LINE:$COL:
+thread 'main' panicked at $DIR/extern-types-field-offset.rs:1:1:
 attempted to compute the size or alignment of extern type `Opaque`
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 thread caused non-unwinding panic. aborting.

tests/ui/extern/extern-types-field-offset.run.stderr

@@ -1,4 +1,4 @@
-thread 'main' panicked at core/src/panicking.rs:$LINE:$COL:
+thread 'main' panicked at $DIR/extern-types-size_of_val.rs:1:1:
 attempted to compute the size or alignment of extern type `A`
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 thread caused non-unwinding panic. aborting.

tests/ui/extern/extern-types-size_of_val.align.run.stderr

@@ -1,4 +1,4 @@
-thread 'main' panicked at core/src/panicking.rs:$LINE:$COL:
+thread 'main' panicked at $DIR/extern-types-size_of_val.rs:1:1:
 attempted to compute the size or alignment of extern type `A`
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 thread caused non-unwinding panic. aborting.