fix sus provenance in tests/smoke.rs for miri

Author: workingjubilee

tests/smoke.rs

@@ -1,8 +1,9 @@
 use backtrace::Frame;
+use core::ffi::c_void;
 use std::ptr;
 use std::thread;
 
-fn get_actual_fn_pointer(fp: usize) -> usize {
+fn get_actual_fn_pointer(fp: *mut c_void) -> *mut c_void {
     // On AIX, the function name references a function descriptor.
     // A function descriptor consists of (See https://reviews.llvm.org/D62532)
     // * The address of the entry point of the function.
@@ -15,17 +16,18 @@ fn get_actual_fn_pointer(fp: usize) -> usize {
     // https://www.ibm.com/docs/en/aix/7.2?topic=program-understanding-programming-toc
     if cfg!(target_os = "aix") {
         unsafe {
-            let actual_fn_entry = *(fp as *const usize);
+            let actual_fn_entry = *(fp as *const *mut c_void);
             actual_fn_entry
         }
     } else {
-        fp
+        fp as *mut c_void
     }
 }
 
 #[test]
 // FIXME: shouldn't ignore this test on i686-msvc, unsure why it's failing
 #[cfg_attr(all(target_arch = "x86", target_env = "msvc"), ignore)]
+#[inline(never)]
 #[rustfmt::skip] // we care about line numbers here
 fn smoke_test_frames() {
     frame_1(line!());
@@ -42,10 +44,10 @@ fn smoke_test_frames() {
         // Various platforms have various bits of weirdness about their
         // backtraces. To find a good starting spot let's search through the
         // frames
-        let target = get_actual_fn_pointer(frame_4 as usize);
+        let target = get_actual_fn_pointer(frame_4 as *mut c_void);
         let offset = v
             .iter()
-            .map(|frame| frame.symbol_address() as usize)
+            .map(|frame| frame.symbol_address())
             .enumerate()
             .filter_map(|(i, sym)| {
                 if sym >= target {
@@ -61,39 +63,39 @@ fn smoke_test_frames() {
 
         assert_frame(
             frames.next().unwrap(),
-            get_actual_fn_pointer(frame_4 as usize),
+            get_actual_fn_pointer(frame_4 as *mut c_void) as usize,
             "frame_4",
             "tests/smoke.rs",
             start_line + 6,
             9,
         );
         assert_frame(
             frames.next().unwrap(),
-            get_actual_fn_pointer(frame_3 as usize),
+            get_actual_fn_pointer(frame_3 as *mut c_void) as usize,
             "frame_3",
             "tests/smoke.rs",
             start_line + 3,
             52,
         );
         assert_frame(
             frames.next().unwrap(),
-            get_actual_fn_pointer(frame_2 as usize),
+            get_actual_fn_pointer(frame_2 as *mut c_void) as usize,
             "frame_2",
             "tests/smoke.rs",
             start_line + 2,
             52,
         );
         assert_frame(
             frames.next().unwrap(),
-            get_actual_fn_pointer(frame_1 as usize),
+            get_actual_fn_pointer(frame_1 as *mut c_void) as usize,
             "frame_1",
             "tests/smoke.rs",
             start_line + 1,
             52,
         );
         assert_frame(
             frames.next().unwrap(),
-            get_actual_fn_pointer(smoke_test_frames as usize),
+            get_actual_fn_pointer(smoke_test_frames as *mut c_void) as usize,
             "smoke_test_frames",
             "",
             0,
@@ -249,11 +251,11 @@ fn sp_smoke_test() {
     return;
 
     #[inline(never)]
-    fn recursive_stack_references(refs: &mut Vec<usize>) {
+    fn recursive_stack_references(refs: &mut Vec<*mut c_void>) {
         assert!(refs.len() < 5);
 
-        let x = refs.len();
-        refs.push(ptr::addr_of!(x) as usize);
+        let mut x = refs.len();
+        refs.push(ptr::addr_of_mut!(x).cast());
 
         if refs.len() < 5 {
             recursive_stack_references(refs);
@@ -271,7 +273,7 @@ fn sp_smoke_test() {
     // mangled names.
 
     fn make_trace_closure<'a>(
-        refs: &'a mut Vec<usize>,
+        refs: &'a mut Vec<*mut c_void>,
     ) -> impl FnMut(&backtrace::Frame) -> bool + 'a {
         let mut child_sp = None;
         let mut child_ref = None;
@@ -289,9 +291,9 @@ fn sp_smoke_test() {
                         })
             });
 
-            let sp = frame.sp() as usize;
-            eprintln!("sp  = {:p}", sp as *const u8);
-            if sp == 0 {
+            let sp = frame.sp();
+            eprintln!("sp  = {sp:p}");
+            if sp as usize == 0 {
                 // If the SP is null, then we don't have an implementation for
                 // getting the SP on this target. Just keep walking the stack,
                 // but don't make our assertions about the on-stack pointers and
@@ -306,8 +308,8 @@ fn sp_smoke_test() {
 
             if is_recursive_stack_references {
                 let r = refs.pop().unwrap();
-                eprintln!("ref = {:p}", r as *const u8);
-                if sp != 0 {
+                eprintln!("ref = {:p}", r);
+                if sp as usize != 0 {
                     assert!(r > sp);
                     if let Some(child_ref) = child_ref {
                         assert!(sp >= child_ref);