first code review fixes

Author: Strophox

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -950,36 +950,37 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         initial_prov: M::Provenance,
     ) -> InterpResult<'tcx> {
         // Expose provenance of the root allocation.
-        M::expose_provenance(self, initial_prov)?; // TODO: Is this the right way to expose provenance?
+        M::expose_provenance(self, initial_prov)?;
 
         let mut done = rustc_data_structures::fx::FxHashSet::default();
         let mut todo = vec![id];
         while let Some(id) = todo.pop() {
-            if done.insert(id) {
-                // This is a new allocation, add the allocation it points to `todo`.
-                let info = self.get_alloc_info(id);
+            if !done.insert(id) {
+                continue;
+            }
+            // This is a new allocation, add the allocations it points to to `todo`.
+            let info = self.get_alloc_info(id);
 
-                // If there is no data behind this pointer, skip this.
-                if !matches!(info.kind, AllocKind::LiveData) {
-                    continue;
-                }
+            // If there is no data behind this pointer, skip this.
+            if !matches!(info.kind, AllocKind::LiveData) {
+                continue;
+            }
 
-                let alloc = self.get_alloc_raw(id)?;
-                for prov in alloc.provenance().provenances() {
-                    //M::expose_provenance(self, prov)?; // TODO: Is this the right way to expose provenance? + mutable borrow here gives issues due to provenances iterator lifetime...
-                    if let Some(id) = prov.get_alloc_id() {
-                        todo.push(id);
-                    }
+            let alloc = self.get_alloc_raw(id)?;
+            for prov in alloc.provenance().provenances() {
+                //M::expose_provenance(self, prov)?; // TODO: mutable borrow here gives issues due to provenances iterator lifetime...
+                if let Some(id) = prov.get_alloc_id() {
+                    todo.push(id);
                 }
+            }
 
-                // 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)
-                        .map_err(|e| e.to_interp_error(id))?;
-                }
+            // 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)
+                    .map_err(|e| e.to_interp_error(id))?;
             }
         }
         interp_ok(())

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

@@ -644,7 +644,8 @@ 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`
+    /// 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 {
         let full_range = AllocRange { start: Size::ZERO, size: Size::from_bytes(self.len()) };
         // Overwrite uninitialized bytes.

src/tools/miri/src/shims/native_lib.rs

@@ -154,15 +154,16 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
             let imm = this.read_immediate(arg)?;
             libffi_args.push(imm_to_carg(&imm, this)?);
+            // If we are passing a pointer, prepare the memory it points to.
             if matches!(arg.layout.ty.kind(), ty::RawPtr(..)) {
                 let ptr = imm.to_scalar().to_pointer(this)?;
                 let Some(prov) = ptr.provenance else {
-                    // Pointer without provenance may access any memory.
+                    // Pointer without provenance may not access any memory.
                     continue;
                 };
                 // We use `get_alloc_id` for its best-effort behaviour with Wildcard provenance.
                 let Some(alloc_id) = prov.get_alloc_id() else {
-                    // Pointer without provenance may access any memory.
+                    // Wildcard pointer, whatever it points to must be already exposed.
                     continue;
                 };
                 this.prepare_for_native_call(alloc_id, prov)?;

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

@@ -88,8 +88,8 @@ fn test_dangling() {
         fn write_nullptr(pptr: *mut *const i32);
     }
 
-    let x = 71;
-    let mut ptr = &raw const x;
+    let x = Box::new(71);
+    let mut ptr = x.into_raw();
     drop(x);
     unsafe { write_nullptr(&mut ptr) };
     assert_eq!(ptr, std::ptr::null());