try document prepare_for_native_call, fix BorrowMutError in expose_ptr, overhaul ptr_write_access tests, refactor ptr_read_access, fix typo

Author: Strophox

compiler/rustc_const_eval/src/interpret/machine.rs

@@ -327,7 +327,7 @@ pub trait Machine<'tcx>: Sized {
         addr: u64,
     ) -> InterpResult<'tcx, Pointer<Option<Self::Provenance>>>;
 
-    /// Marks a pointer as exposed, allowing it's provenance
+    /// Marks a pointer as exposed, allowing its provenance
     /// to be recovered. "Pointer-to-int cast"
     fn expose_provenance(
         ecx: &InterpCx<'tcx, Self>,

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -944,6 +944,10 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         interp_ok(())
     }
 
+    /// Handle the effect an FFI call might have on the state of allocations.
+    /// This overapproximates the modifications which external code might make to memory:
+    /// We set all reachable allocations as initialized, mark all provenances as exposed
+    /// and overwrite them with `Provenance::WILDCARD`.
     pub fn prepare_for_native_call(
         &mut self,
         id: AllocId,

src/tools/miri/src/alloc_addresses/mod.rs

@@ -300,6 +300,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
         trace!("Exposing allocation id {alloc_id:?}");
         global_state.exposed.insert(alloc_id);
+        drop(global_state);
         if this.machine.borrow_tracker.is_some() {
             this.expose_tag(alloc_id, tag)?;
         }

src/tools/miri/tests/native-lib/pass/ptr_read_access.rs

@@ -3,17 +3,17 @@
 //@only-on-host
 
 fn main() {
-    test_pointer();
+    test_access_pointer();
 
-    test_simple();
+    test_access_simple();
 
-    test_nested();
+    test_access_nested();
 
-    test_static();
+    test_access_static();
 }
 
-// Test void function that dereferences a pointer and prints its contents from C.
-fn test_pointer() {
+// Test function that dereferences an int pointer and prints its contents from C.
+fn test_access_pointer() {
     extern "C" {
         fn print_pointer(ptr: *const i32);
     }
@@ -24,7 +24,7 @@ fn test_pointer() {
 }
 
 // Test function that dereferences a simple struct pointer and accesses a field.
-fn test_simple() {
+fn test_access_simple() {
     #[repr(C)]
     struct Simple {
         field: i32,
@@ -40,7 +40,7 @@ fn test_simple() {
 }
 
 // Test function that dereferences nested struct pointers and accesses fields.
-fn test_nested() {
+fn test_access_nested() {
     use std::ptr::NonNull;
 
     #[derive(Debug, PartialEq, Eq)]
@@ -61,8 +61,8 @@ fn test_nested() {
     assert_eq!(unsafe { access_nested(&nested_2) }, 97);
 }
 
-// Test function that dereferences static struct pointers and accesses fields.
-fn test_static() {
+// Test function that dereferences a static struct pointer and accesses fields.
+fn test_access_static() {
     #[repr(C)]
     struct Static {
         value: i32,

src/tools/miri/tests/native-lib/pass/ptr_write_access.rs

@@ -5,118 +5,192 @@
 #![feature(box_as_ptr)]
 
 use std::mem::MaybeUninit;
+use std::ptr::null;
 
 fn main() {
-    test_modify_int();
+    test_increment_int();
 
     test_init_int();
 
     test_init_array();
 
-    test_init_interior_mutable();
+    test_init_static_inner();
+
+    test_expose_int();
 
     test_swap_ptr();
 
-    test_interact_dangling();
+    test_swap_nested_ptr();
+
+    test_swap_tuple();
+
+    test_overwrite_dangling();
 
-    test_inner_alloc_exposed();
+    test_expose_triple();
 }
 
-fn test_modify_int() {
+// Test function that modifies an int.
+fn test_increment_int() {
     extern "C" {
-        fn modify_int(ptr: *mut i32);
+        fn increment_int(ptr: *mut i32);
     }
 
     let mut x = 11;
-    unsafe { modify_int(&mut x) };
 
+    unsafe { increment_int(&mut x) };
     assert_eq!(x, 12);
 }
 
+// Test function that initializes an int.
 fn test_init_int() {
     extern "C" {
-        fn init_int(ptr: *mut i32);
+        fn init_int(ptr: *mut i32, val: i32);
     }
 
     let mut x = MaybeUninit::<i32>::uninit();
+    let val = 21;
+
     let x = unsafe {
-        init_int(x.as_mut_ptr());
+        init_int(x.as_mut_ptr(), val);
         x.assume_init()
     };
-
-    assert_eq!(x, 21);
+    assert_eq!(x, val);
 }
 
+// Test function that initializes an array.
 fn test_init_array() {
     extern "C" {
-        fn init_array(ptr: *mut i32, len: usize);
+        fn init_array(ptr: *mut i32, len: usize, val: i32);
     }
 
     const LEN: usize = 3;
-
     let mut array = MaybeUninit::<[i32; LEN]>::uninit();
+    let val = 31;
+    
     let array = unsafe {
-        init_array(array.as_mut_ptr().cast::<i32>(), LEN);
+        init_array(array.as_mut_ptr().cast::<i32>(), LEN, val);
         array.assume_init()
     };
-
-    assert_eq!(array, [31; LEN]);
+    assert_eq!(array, [val; LEN]);
 }
 
-fn test_init_interior_mutable() {
+// Test function that initializes an int pointed to by an immutable static.
+fn test_init_static_inner() {
+    #[repr(C)]
+    struct SyncPtr {
+        ptr: *mut i32
+    }
+    unsafe impl Sync for SyncPtr {}
+
     extern "C" {
-        fn init_interior_mutable(pptr: *const UnsafeInterior);
+        fn init_static_inner(s_ptr: *const SyncPtr, val: i32);
     }
 
-    #[repr(C)]
-    struct UnsafeInterior {
-        mut_ptr: *mut i32
+    static mut INNER: MaybeUninit<i32> = MaybeUninit::uninit();
+    #[allow(static_mut_refs)]
+    static STATIC: SyncPtr = SyncPtr { ptr: unsafe { INNER.as_mut_ptr() } };
+    let val = 41;
+
+    let inner = unsafe {
+        init_static_inner(&STATIC, val);
+        INNER.assume_init()
+    };
+    assert_eq!(inner, val);
+}
+
+// Test function that writes a pointer and exposes the alloc of its int argument.
+fn test_expose_int() {
+    extern "C" {
+        fn expose_int(int_ptr: *const i32, pptr: *mut *const i32);
     }
-    unsafe impl Sync for UnsafeInterior {}
-    
-    let mut x = MaybeUninit::<i32>::uninit();
-    let unsafe_interior = UnsafeInterior { mut_ptr: x.as_mut_ptr() };
-    unsafe { init_interior_mutable(&unsafe_interior) };
 
-    assert_eq!(unsafe { x.assume_init() }, 51);
+    let x = 51;
+    let mut ptr = std::ptr::null();
+
+    unsafe { expose_int(&x, &mut ptr) };
+    assert_eq!(unsafe { *ptr }, x);
 }
 
+// Test function that swaps two pointers and exposes the alloc of an int.
 fn test_swap_ptr() {
     extern "C" {
         fn swap_ptr(pptr0: *mut *const i32, pptr1: *mut *const i32);
     }
 
-    let x = 41;
-    let mut ptr0 = &raw const x;
-    let mut ptr1 = std::ptr::null();
+    let x = 61;
+    let (mut ptr0, mut ptr1) = (&raw const x, null());
+
     unsafe { swap_ptr(&mut ptr0, &mut ptr1) };
+    assert_eq!(unsafe { *ptr1 }, x);
+}
+
+// Test function that swaps two nested pointers and exposes the alloc of an int.
+fn test_swap_nested_ptr() {
+    extern "C" {
+        fn swap_nested_ptr(ppptr0: *mut *mut *const i32, ppptr1: *mut *mut *const i32);
+    }
+
+    let x = 71;
+    let (mut ptr0, mut ptr1) = (&raw const x, null());
+    let (mut pptr0, mut pptr1) = (&raw mut ptr0, &raw mut ptr1);
 
+    unsafe { swap_nested_ptr(&mut pptr0, &mut pptr1) }
     assert_eq!(unsafe { *ptr1 }, x);
 }
 
-fn test_interact_dangling() {
+// Test function that swaps two pointers in a struct and exposes the alloc of an int.
+fn test_swap_tuple() {
+    #[repr(C)]
+    struct Tuple {
+        ptr0: *const i32,
+        ptr1: *const i32,
+    }
+
+    extern "C" {
+        fn swap_tuple(t_ptr: *mut Tuple);
+    }
+
+    let x = 81;
+    let mut tuple = Tuple { ptr0: &raw const x, ptr1: null() };
+
+    unsafe { swap_tuple(&mut tuple) }
+    assert_eq!(unsafe { *tuple.ptr1 }, x);
+}
+
+// Test function that interacts with a dangling pointer.
+fn test_overwrite_dangling() {
     extern "C" {
         fn overwrite_ptr(pptr: *mut *const i32);
     }
 
-    let x = Box::new(61);
-    let mut ptr = Box::as_ptr(&x);
-    drop(x);
+    let b = Box::new(91);
+    let mut ptr = Box::as_ptr(&b);
+    drop(b);
     unsafe { overwrite_ptr(&mut ptr) };
 
-    assert_eq!(ptr, std::ptr::null());
+    assert_eq!(ptr, null());
 }
 
-// TODO: Write tests for correctly exposing: [initial allocation; recursively all allocations; previously unexposed pointers].
-fn test_inner_alloc_exposed() {
+// Test function that interacts with a struct storing a dangling pointer.
+fn test_expose_triple() {
+    #[repr(C)]
+    struct Triple {
+        ptr0: *const i32,
+        ptr1: *const i32,
+        ptr2: *const i32,
+    }
+
     extern "C" {
-        fn blackbox(ptr: *mut *mut *const i32);
+        fn expose_triple(t_ptr: *const Triple);
     }
 
-    let x = 71i32;
-    let mut ptr = &raw const x;
-    let mut pptr = &raw mut ptr;
-    unsafe { blackbox(&mut pptr) }
+    let x = 101;
+    let y = 111;
+    let b = Box::new(121);
+    let ptr = Box::as_ptr(&b);
+    drop(b);
+    let triple = Triple { ptr0: &raw const x, ptr1: ptr, ptr2: &raw const y };
 
-    assert_eq!(unsafe { *ptr }, x);
+    unsafe { expose_triple(&triple) }
+    assert_eq!(unsafe { *triple.ptr2 }, y);
 }

src/tools/miri/tests/native-lib/ptr_read_access.c

@@ -3,13 +3,13 @@
 // See comments in build_native_lib()
 #define EXPORT __attribute__((visibility("default")))
 
-/* Test: test_pointer */
+/* Test: test_access_pointer */
 
 EXPORT void print_pointer(const int *ptr) {
   printf("printing pointer dereference from C: %d\n", *ptr);
 }
 
-/* Test: test_simple */
+/* Test: test_access_simple */
 
 typedef struct Simple {
   int field;
@@ -19,7 +19,7 @@ EXPORT int access_simple(const Simple *s_ptr) {
   return s_ptr->field;
 }
 
-/* Test: test_nested */
+/* Test: test_access_nested */
 
 typedef struct Nested {
   int value;
@@ -38,7 +38,7 @@ EXPORT int access_nested(const Nested *n_ptr) {
   return n_ptr->value;
 }
 
-/* Test: test_static */
+/* Test: test_access_static */
 
 typedef struct Static {
     int value;