try to fix write_wildcards, use Box instead of Vec for test, try to write new expose nested pointer test

Author: Strophox

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -976,10 +976,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 
             // Prepare for possible write from native code if mutable.
             if info.mutbl.is_mut() {
-                let tcx = self.tcx;
                 self.get_alloc_raw_mut(id)?
                     .0
-                    .prepare_for_native_call(&tcx)
+                    .prepare_for_native_call()
                     .map_err(|e| e.to_interp_error(id))?;
             }
         }

compiler/rustc_middle/src/mir/interpret/allocation.rs

@@ -646,7 +646,7 @@ impl<Prov: Provenance, Extra, Bytes: AllocBytes> Allocation<Prov, Extra, Bytes>
     /// Initialize all previously uninitialized bytes in the entire allocation, and set
     /// provenance of everything to `Wildcard`. Before calling this, make sure all
     /// provenance in this allocation is exposed!
-    pub fn prepare_for_native_call(&mut self, cx: &impl HasDataLayout) -> AllocResult {
+    pub fn prepare_for_native_call(&mut self) -> AllocResult {
         let full_range = AllocRange { start: Size::ZERO, size: Size::from_bytes(self.len()) };
         // Overwrite uninitialized bytes.
         for chunk in self.init_mask.range_as_init_chunks(full_range) {
@@ -660,7 +660,7 @@ impl<Prov: Provenance, Extra, Bytes: AllocBytes> Allocation<Prov, Extra, Bytes>
         self.mark_init(full_range, true);
 
         // Set provenance of all bytes to wildcard.
-        self.provenance.write_wildcards(self.len(), cx);
+        self.provenance.write_wildcards(self.len());
 
         Ok(())
     }

compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs

@@ -195,27 +195,21 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
 
         Ok(())
     }
-
-    pub fn write_wildcards(&mut self, alloc_size: usize, cx: &impl HasDataLayout) {
+    pub fn write_wildcards(&mut self, alloc_size: usize) {
         // We can only write wildcards in Miri.
         assert!(
             Prov::OFFSET_IS_ADDR,
             "writing wildcard provenance is not supported when `OFFSET_IS_ADDR` is false"
         );
         let wildcard = Prov::WILDCARD.unwrap();
-        let ptr_size = cx.data_layout().pointer_size;
 
-        // Write wildcards in intervals of pointer size.
-        let end = Size::from_bytes(alloc_size / ptr_size.bytes_usize());
-        for offset in Size::ZERO..end {
-            self.ptrs.insert(offset, wildcard);
-        }
-        // Write wildcards into the remaining bytes.
+        // Remove all pointer provenances, then write wildcards into the whole byte range.
+        self.ptrs.clear();
         let last = Size::from_bytes(alloc_size);
         let bytes = self.bytes.get_or_insert_with(Box::default);
-        for offset in end..last {
+        for offset in Size::ZERO..last {
             bytes.insert(offset, wildcard);
-        } // TODO: Is the above even remotely correct?
+        }
     }
 }
 

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

@@ -2,6 +2,8 @@
 //@ignore-target: windows wasm
 //@only-on-host
 
+#![feature(box_as_ptr)]
+
 use std::mem::MaybeUninit;
 
 fn main() {
@@ -11,11 +13,13 @@ fn main() {
 
     test_init_array();
 
+    test_init_interior_mutable();
+
     test_swap_ptr();
 
-    test_init_interior_mutable();
+    test_interact_dangling();
 
-    test_dangling();
+    test_inner_alloc_exposed();
 }
 
 fn test_modify_int() {
@@ -59,19 +63,6 @@ fn test_init_array() {
     assert_eq!(array, [31; LEN]);
 }
 
-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();
-    unsafe { swap_ptr(&mut ptr0, &mut ptr1) };
-
-    assert_eq!(unsafe { *ptr1 }, x);
-}
-
 fn test_init_interior_mutable() {
     extern "C" {
         fn init_interior_mutable(pptr: *const UnsafeInterior);
@@ -90,16 +81,42 @@ fn test_init_interior_mutable() {
     assert_eq!(unsafe { x.assume_init() }, 51);
 }
 
-fn test_dangling() {
+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();
+    unsafe { swap_ptr(&mut ptr0, &mut ptr1) };
+
+    assert_eq!(unsafe { *ptr1 }, x);
+}
+
+fn test_interact_dangling() {
     extern "C" {
         fn overwrite_ptr(pptr: *mut *const i32);
     }
 
-    let x = vec![61];
-    let mut ptr = x.as_ptr();
+    let x = Box::new(61);
+    let mut ptr = Box::as_ptr(&x);
     drop(x);
     unsafe { overwrite_ptr(&mut ptr) };
+
     assert_eq!(ptr, std::ptr::null());
 }
 
-// TODO: Write tests for (forgetting to) expose: -initial allocation -recursively all allocations -unexposed pointers.
+// TODO: Write tests for correctly exposing: [initial allocation; recursively all allocations; previously unexposed pointers].
+fn test_inner_alloc_exposed() {
+    extern "C" {
+        fn blackbox(ptr: *mut *mut *const i32);
+    }
+
+    let x = 71i32;
+    let mut ptr = &raw const x;
+    let mut pptr = &raw mut ptr;
+    unsafe { blackbox(&mut pptr) }
+
+    assert_eq!(unsafe { *ptr }, x);
+}

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

@@ -41,8 +41,14 @@ EXPORT void init_interior_mutable(const UnsafeInterior *u_ptr) {
   *(u_ptr->mut_ptr) = 51;
 }
 
-/* Test: test_dangling */
+/* Test: test_interact_dangling */
 
 EXPORT void overwrite_ptr(const int **pptr) {
   *pptr = NULL;
 }
+
+/* Test: test_initial_alloc_exposed */
+
+EXPORT void blackbox(__attribute__((unused)) const int ***_ppptr) {
+  return;
+}