fix current compile errors, fmt

Author: Strophox

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -21,9 +21,8 @@ use crate::errors::{LongRunning, LongRunningWarn};
 use crate::fluent_generated as fluent;
 use crate::interpret::{
     self, AllocId, AllocRange, ConstAllocation, CtfeProvenance, FnArg, Frame, GlobalAlloc, ImmTy,
-    InterpCx, InterpResult, MPlaceTy, OpTy, Pointer, RangeSet, Scalar, compile_time_machine,
-    interp_ok, throw_exhaust, throw_inval, throw_ub, throw_ub_custom, throw_unsup,
-    throw_unsup_format,
+    InterpCx, InterpResult, MPlaceTy, OpTy, RangeSet, Scalar, compile_time_machine, interp_ok,
+    throw_exhaust, throw_inval, throw_ub, throw_ub_custom, throw_unsup, throw_unsup_format,
 };
 
 /// When hitting this many interpreted terminators we emit a deny by default lint
@@ -586,7 +585,10 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
     }
 
     #[inline(always)]
-    fn expose_provenance(_ecx: &mut InterpCx<'tcx, Self>, _provenance: Self::Provenance) -> InterpResult<'tcx> {
+    fn expose_provenance(
+        _ecx: &mut InterpCx<'tcx, Self>,
+        _provenance: Self::Provenance,
+    ) -> InterpResult<'tcx> {
         // This is only reachable with -Zunleash-the-miri-inside-of-you.
         throw_unsup_format!("exposing pointers is not possible at compile-time")
     }

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -943,32 +943,41 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         self.get_alloc_raw_mut(id)?.0.mutability = Mutability::Not;
         interp_ok(())
     }
-    
-    pub fn prepare_for_native_call(&mut self, id: AllocId, initial_prov: M) -> InterpResult<'tcx> {
+
+    pub fn prepare_for_native_call(
+        &mut self,
+        id: AllocId,
+        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?
+
         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 (_size, _align, kind, mutability) = self.get_alloc_info(id); // TODO: Rebasing will give me the mutaility.
+                let info = self.get_alloc_info(id);
 
                 // If there is no data behind this pointer, skip this.
-                if !matches!(kind, AllocKind::LiveData) {
+                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 right?
+                    //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);
                     }
                 }
 
                 // Prepare for possible write from native code if mutable.
-                if mutability.is_mut() {
+                if info.mutbl.is_mut() {
+                    let tcx = self.tcx;
                     self.get_alloc_raw_mut(id)?
-                        .prepare_for_native_call()
+                        .0
+                        .prepare_for_native_call(&tcx)
                         .map_err(|e| e.to_interp_error(id))?;
                 }
             }

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

@@ -645,21 +645,22 @@ 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`
-    pub fn prepare_for_native_call(&mut self) -> AllocResult {
+    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.
         for chunk in self.init_mask.range_as_init_chunks(full_range) {
             if !chunk.is_init() {
-                let uninit_bytes = &mut self.bytes[chunk.range().start.bytes_usize()..chunk.range().end.bytes_usize()];
+                let uninit_bytes = &mut self.bytes
+                    [chunk.range().start.bytes_usize()..chunk.range().end.bytes_usize()];
                 uninit_bytes.fill(0);
             }
         }
         // Mark everything as initialized now.
         self.mark_init(full_range, true);
 
         // Set provenance of all bytes to wildcard.
-        self.provenance.write_wildcards(self.len());
-        
+        self.provenance.write_wildcards(self.len(), cx);
+
         Ok(())
     }
 

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

@@ -196,13 +196,15 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
         Ok(())
     }
 
-    pub fn write_wildcards(&mut self, _alloc_size: usize) {
+    pub fn write_wildcards(&mut self, _alloc_size: usize, _cx: &impl HasDataLayout) {
         // We can only write wildcards in Miri.
-        assert!(Prov::OFFSET_IS_ADDR, "writing wildcard provenance is not supported when `OFFSET_IS_ADDR` is false");
+        assert!(
+            Prov::OFFSET_IS_ADDR,
+            "writing wildcard provenance is not supported when `OFFSET_IS_ADDR` is false"
+        );
         let _wildcard = Prov::WILDCARD.unwrap();
-        
-        // TODO: This.
 
+        // TODO: Write wildcards into `self` in intervals of `cx.data_layout().pointer_size` + remaining bytes?
     }
 }
 

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

@@ -155,14 +155,17 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             let imm = this.read_immediate(arg)?;
             libffi_args.push(imm_to_carg(&imm, this)?);
             if matches!(arg.layout.ty.kind(), ty::RawPtr(..)) {
-                let ptr = imm.to_scalar().to_pointer(self)?;
+                let ptr = imm.to_scalar().to_pointer(this)?;
+                let Some(prov) = ptr.provenance else {
+                    // Pointer without provenance may access any memory.
+                    continue;
+                };
                 // We use `get_alloc_id` for its best-effort behaviour with Wildcard provenance.
-                let Ok(alloc_id) = ptr.provenance.and_then(|prov| prov.get_alloc_id()) else {
+                let Some(alloc_id) = prov.get_alloc_id() else {
                     // Pointer without provenance may access any memory.
                     continue;
                 };
-                this.prepare_for_native_call(alloc_id, ptr.provenance)?; 
-                // TODO: Write tests for (forgetting to) expose: -initial allocation -recursively all allocations -unexposed pointers.
+                this.prepare_for_native_call(alloc_id, prov)?;
             }
         }
 

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

@@ -92,5 +92,7 @@ fn test_dangling() {
     let mut ptr = &raw const x;
     drop(x);
     unsafe { write_nullptr(&mut ptr) };
-    assert_eq!(ptr)
-}
+    assert_eq!(ptr, std::ptr::null());
+}
+
+// TODO: Write tests for (forgetting to) expose: -initial allocation -recursively all allocations -unexposed pointers.