always show the origin_span of the failing thread

Author: RalfJung

src/diagnostics.rs

@@ -555,35 +555,24 @@ pub fn report_msg<'tcx>(
     thread: Option<ThreadId>,
     machine: &MiriMachine<'tcx>,
 ) {
-    let span = match stacktrace.first() {
-        Some(fi) => fi.span,
-        None =>
-            match thread {
-                Some(thread_id) => machine.threads.thread_ref(thread_id).origin_span,
-                // This fallback is super rare, but can happen e.g. when `main` has the wrong ABI
-                None => DUMMY_SP,
-            },
-    };
-    let sess = machine.tcx.sess;
+    let origin_span = thread.map(|t| machine.threads.thread_ref(t).origin_span).unwrap_or(DUMMY_SP);
+    let span = stacktrace.first().map(|fi| fi.span).unwrap_or(origin_span);
+    // The only time we do not have an origin span is for `main`, and there we check the signature
+    // upfront. So we should always have a span here.
+    assert!(!span.is_dummy());
+
+    let tcx = machine.tcx;
     let level = match diag_level {
         DiagLevel::Error => Level::Error,
         DiagLevel::Warning => Level::Warning,
         DiagLevel::Note => Level::Note,
     };
-    let mut err = Diag::<()>::new(sess.dcx(), level, title);
+    let mut err = Diag::<()>::new(tcx.sess.dcx(), level, title);
     err.span(span);
 
     // Show main message.
-    if !span.is_dummy() {
-        for line in span_msg {
-            err.span_label(span, line);
-        }
-    } else {
-        // Make sure we show the message even when it is a dummy span.
-        for line in span_msg {
-            err.note(line);
-        }
-        err.note("(no span available)");
+    for line in span_msg {
+        err.span_label(span, line);
     }
 
     // Show note and help messages.
@@ -621,7 +610,7 @@ pub fn report_msg<'tcx>(
             .unwrap();
         }
         // Only print function name if we show a backtrace
-        if rest.len() > 0 {
+        if rest.len() > 0 || !origin_span.is_dummy() {
             if !fn_and_thread.is_empty() {
                 fn_and_thread.push_str(", ");
             }
@@ -632,7 +621,7 @@ pub fn report_msg<'tcx>(
                 // Print a `span_note` as otherwise the backtrace looks attached to the last
                 // `span_help`. We somewhat arbitrarily use the span of the surrounding function.
                 err.span_note(
-                    machine.tcx.def_span(first.instance.def_id()),
+                    tcx.def_span(first.instance.def_id()),
                     format!("{level} occurred {fn_and_thread}"),
                 );
             } else {
@@ -646,11 +635,14 @@ pub fn report_msg<'tcx>(
             if is_local {
                 err.span_note(frame_info.span, format!("which got called {frame_info}"));
             } else {
-                let sm = sess.source_map();
+                let sm = tcx.sess.source_map();
                 let span = sm.span_to_embeddable_string(frame_info.span);
                 err.note(format!("which got called {frame_info} (at {span})"));
             }
         }
+        if !origin_span.is_dummy() {
+            err.span_note(origin_span, format!("which got called indirectly due to this code"));
+        }
     } else if !span.is_dummy() {
         err.note(format!("this {level} occurred while pushing a call frame onto an empty stack"));
         err.note("the span indicates which code caused the function to be called, but may not be the literal call site");

tests/fail-dep/concurrency/apple_os_unfair_lock_move_with_queue.stderr

@@ -6,7 +6,15 @@ LL |             let _val = atomic_ref.load(Ordering::Relaxed);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-   = note: this is on thread `unnamed-ID`
+   = note: this is on thread `unnamed-ID`, inside closure
+note: which got called indirectly due to this code
+  --> tests/fail-dep/concurrency/apple_os_unfair_lock_move_with_queue.rs:LL:CC
+   |
+LL | / ...   s.spawn(|| {
+LL | | ...       let atomic_ref = unsafe { &*lock.get().cast::<AtomicU32>() };
+LL | | ...       let _val = atomic_ref.load(Ordering::Relaxed);
+LL | | ...   });
+   | |________^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_join_main.stderr

@@ -6,7 +6,17 @@ LL | ...   assert_eq!(libc::pthread_join(thread_id, ptr::null_mut()), 0);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-   = note: this is on thread `unnamed-ID`
+   = note: this is on thread `unnamed-ID`, inside closure
+note: which got called indirectly due to this code
+  --> tests/fail-dep/concurrency/libc_pthread_join_main.rs:LL:CC
+   |
+LL |       let handle = thread::spawn(move || {
+   |  __________________^
+LL | |         unsafe {
+LL | |             assert_eq!(libc::pthread_join(thread_id, ptr::null_mut()), 0);
+LL | |         }
+LL | |     });
+   | |______^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_join_multiple.stderr

@@ -6,7 +6,15 @@ LL | ...   assert_eq!(libc::pthread_join(native_copy, ptr::null_mut()), 0);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-   = note: this is on thread `unnamed-ID`
+   = note: this is on thread `unnamed-ID`, inside closure
+note: which got called indirectly due to this code
+  --> tests/fail-dep/concurrency/libc_pthread_join_multiple.rs:LL:CC
+   |
+LL |   ...   let handle = thread::spawn(move || {
+   |  ____________________^
+LL | | ...       assert_eq!(libc::pthread_join(native_copy, ptr::null_mut()), 0);
+LL | | ...   });
+   | |________^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_join_self.stderr

@@ -6,7 +6,18 @@ LL |             assert_eq!(libc::pthread_join(native, ptr::null_mut()), 0);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-   = note: this is on thread `unnamed-ID`
+   = note: this is on thread `unnamed-ID`, inside closure
+note: which got called indirectly due to this code
+  --> tests/fail-dep/concurrency/libc_pthread_join_self.rs:LL:CC
+   |
+LL |       let handle = thread::spawn(|| {
+   |  __________________^
+LL | |         unsafe {
+LL | |             let native: libc::pthread_t = libc::pthread_self();
+LL | |             assert_eq!(libc::pthread_join(native, ptr::null_mut()), 0);
+LL | |         }
+LL | |     });
+   | |______^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_mutex_deadlock.stderr

@@ -22,7 +22,14 @@ error: the evaluated program deadlocked
 LL |             assert_eq!(libc::pthread_mutex_lock(lock_copy.0.get() as *mut _), 0);
    |                                                                            ^ thread got stuck here
    |
-   = note: this is on thread `unnamed-ID`
+   = note: this is on thread `unnamed-ID`, inside closure
+note: which got called indirectly due to this code
+  --> tests/fail-dep/concurrency/libc_pthread_mutex_deadlock.rs:LL:CC
+   |
+LL | /         thread::spawn(move || {
+LL | |             assert_eq!(libc::pthread_mutex_lock(lock_copy.0.get() as *mut _), 0);
+LL | |         })
+   | |__________^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_mutex_free_while_queued.stderr

@@ -14,6 +14,15 @@ note: which got called inside closure
    |
 LL |             drop(unsafe { Box::from_raw(m.get().cast::<Mutex>()) });
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: which got called indirectly due to this code
+  --> tests/fail-dep/concurrency/libc_pthread_mutex_free_while_queued.rs:LL:CC
+   |
+LL | /         s.spawn(|| {
+LL | |             // Ensure we happen-after the initialization write.
+LL | |             assert!(initialized.load(Ordering::Acquire));
+...  |
+LL | |         });
+   | |__________^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_mutex_read_while_queued.stderr

@@ -6,7 +6,15 @@ LL | ...   let _val = atomic_ref.load(Ordering::Relaxed);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-   = note: this is on thread `unnamed-ID`
+   = note: this is on thread `unnamed-ID`, inside closure
+note: which got called indirectly due to this code
+  --> tests/fail-dep/concurrency/libc_pthread_mutex_read_while_queued.rs:LL:CC
+   |
+LL | / ...   s.spawn(|| {
+LL | | ...       let atomic_ref = unsafe { &*m.get().byte_add(OFFSET).cast::<AtomicU32>() };
+LL | | ...       let _val = atomic_ref.load(Ordering::Relaxed);
+LL | | ...   });
+   | |________^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_mutex_write_while_queued.stderr

@@ -6,7 +6,15 @@ LL |             atomic_ref.store(0, Ordering::Relaxed);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-   = note: this is on thread `unnamed-ID`
+   = note: this is on thread `unnamed-ID`, inside closure
+note: which got called indirectly due to this code
+  --> tests/fail-dep/concurrency/libc_pthread_mutex_write_while_queued.rs:LL:CC
+   |
+LL | /         s.spawn(|| {
+LL | |             let atomic_ref = unsafe { &*m.get().byte_add(OFFSET).cast::<AtomicU32>() };
+LL | |             atomic_ref.store(0, Ordering::Relaxed);
+LL | |         });
+   | |__________^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_mutex_wrong_owner.stderr

@@ -6,7 +6,14 @@ LL | ...   assert_eq!(libc::pthread_mutex_unlock(lock_copy.0.get() as *mut _), 0
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-   = note: this is on thread `unnamed-ID`
+   = note: this is on thread `unnamed-ID`, inside closure
+note: which got called indirectly due to this code
+  --> tests/fail-dep/concurrency/libc_pthread_mutex_wrong_owner.rs:LL:CC
+   |
+LL | / ...   thread::spawn(move || {
+LL | | ...       assert_eq!(libc::pthread_mutex_unlock(lock_copy.0.get() as *mut _), 0);
+LL | | ...   })
+   | |________^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace