intermediate commit (no compile)

Strophox · Strophox · commit bf5d369ba548 · 2024-11-19T06:54:56.000+01:00
diff --git a/compiler/rustc_const_eval/src/const_eval/dummy_machine.rs b/compiler/rustc_const_eval/src/const_eval/dummy_machine.rs
@@ -168,9 +168,9 @@ impl<'tcx> interpret::Machine<'tcx> for DummyMachine {
         })
     }
 
-    fn expose_ptr(
+    fn expose_provenance(
         _ecx: &mut InterpCx<'tcx, Self>,
-        _ptr: interpret::Pointer<Self::Provenance>,
+        _provenance: Self::Provenance,
     ) -> interpret::InterpResult<'tcx> {
         unimplemented!()
     }
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -586,7 +586,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
     }
 
     #[inline(always)]
-    fn expose_ptr(_ecx: &mut InterpCx<'tcx, Self>, _ptr: Pointer) -> 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")
     }
diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs
@@ -238,7 +238,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         let scalar = src.to_scalar();
         let ptr = scalar.to_pointer(self)?;
         match ptr.into_pointer_or_addr() {
-            Ok(ptr) => M::expose_ptr(self, ptr)?,
+            Ok(ptr) => M::expose_provenance(self, ptr.provenance)?,
             Err(_) => {} // Do nothing, exposing an invalid pointer (`None` provenance) is a NOP.
         };
         interp_ok(ImmTy::from_scalar(
diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs
@@ -329,9 +329,9 @@ pub trait Machine<'tcx>: Sized {
 
     /// Marks a pointer as exposed, allowing it's provenance
     /// to be recovered. "Pointer-to-int cast"
-    fn expose_ptr(
+    fn expose_provenance(
         ecx: &mut InterpCx<'tcx, Self>,
-        ptr: Pointer<Self::Provenance>,
+        provenance: Self::Provenance,
     ) -> InterpResult<'tcx>;
 
     /// Convert a pointer with provenance into an allocation-offset pair and extra provenance info.
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -943,25 +943,37 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         self.get_alloc_raw_mut(id)?.0.mutability = Mutability::Not;
         interp_ok(())
     }
-
-    pub fn alloc_mark_init_rec(&mut self, id: AllocId) -> InterpResult<'tcx> {
-        let mut reachable = rustc_data_structures::fx::FxHashSet::default();
+    
+    pub fn prepare_for_native_call(&mut self, id: AllocId, initial_prov: M) -> InterpResult<'tcx> {
+        let mut done = rustc_data_structures::fx::FxHashSet::default();
         let mut todo = vec![id];
         while let Some(id) = todo.pop() {
-            if reachable.insert(id) {
+            if done.insert(id) {
                 // This is a new allocation, add the allocation it points to `todo`.
-                if let Ok((alloc, _)) = self.get_alloc_raw_mut(id) {
-                    let range = AllocRange { start: Size::ZERO, size: Size::from_bytes(alloc.len()) };
-                    alloc
-                        .write_zero_if_uninit(range)
+                let (_size, _align, kind, mutability) = self.get_alloc_info(id); // TODO: Rebasing will give me the mutaility.
+
+                // If there is no data behind this pointer, skip this.
+                if !matches!(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?
+                    if let Some(id) = prov.get_alloc_id() {
+                        todo.push(id);
+                    }
+                }
+
+                // Prepare for possible write from native code if mutable.
+                if mutability.is_mut() {
+                    self.get_alloc_raw_mut(id)?
+                        .prepare_for_native_call()
                         .map_err(|e| e.to_interp_error(id))?;
-                    todo.extend(
-                        alloc.provenance().provenances().filter_map(|prov| prov.get_alloc_id()),
-                    );
                 }
             }
         }
-        Ok(())
+        interp_ok(())
     }
 
     /// Create a lazy debug printer that prints the given allocation and all allocations it points
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation.rs b/compiler/rustc_middle/src/mir/interpret/allocation.rs
@@ -643,9 +643,23 @@ impl<Prov: Provenance, Extra, Bytes: AllocBytes> Allocation<Prov, Extra, Bytes>
         Ok(())
     }
 
-    /// Write zeroes to the unitialized memory within the given memory range.
-    pub fn write_zero_if_uninit(&mut self, range: AllocRange) -> AllocResult {
-        self.mark_init(range, true); // TODO: Write zeroes?
+    /// 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 {
+        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()];
+                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());
+        
         Ok(())
     }
 
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
@@ -195,6 +195,15 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
 
         Ok(())
     }
+
+    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();
+        
+        // TODO: This.
+
+    }
 }
 
 /// A partial, owned list of provenance to transfer into another allocation.
diff --git a/compiler/rustc_middle/src/mir/interpret/pointer.rs b/compiler/rustc_middle/src/mir/interpret/pointer.rs
@@ -66,6 +66,9 @@ pub trait Provenance: Copy + fmt::Debug + 'static {
     ///   pointer, and implement ptr-to-int transmutation by stripping provenance.
     const OFFSET_IS_ADDR: bool;
 
+    /// If wildcard provenance is implemented, contains the unique, general wildcard provenance variant.
+    const WILDCARD: Option<Self>;
+
     /// Determines how a pointer should be printed.
     fn fmt(ptr: &Pointer<Self>, f: &mut fmt::Formatter<'_>) -> fmt::Result;
 
@@ -168,6 +171,9 @@ impl Provenance for CtfeProvenance {
     // so ptr-to-int casts are not possible (since we do not know the global physical offset).
     const OFFSET_IS_ADDR: bool = false;
 
+    // `CtfeProvenance` does not implement wildcard provenance.
+    const WILDCARD: Option<Self> = None;
+
     fn fmt(ptr: &Pointer<Self>, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Print AllocId.
         fmt::Debug::fmt(&ptr.provenance.alloc_id(), f)?; // propagates `alternate` flag
@@ -197,6 +203,9 @@ impl Provenance for AllocId {
     // so ptr-to-int casts are not possible (since we do not know the global physical offset).
     const OFFSET_IS_ADDR: bool = false;
 
+    // `AllocId` does not implement wildcard provenance.
+    const WILDCARD: Option<Self> = None;
+
     fn fmt(ptr: &Pointer<Self>, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Forward `alternate` flag to `alloc_id` printing.
         if f.alternate() {
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
@@ -268,6 +268,9 @@ impl interpret::Provenance for Provenance {
     /// We use absolute addresses in the `offset` of a `StrictPointer`.
     const OFFSET_IS_ADDR: bool = true;
 
+    /// Miri implements wildcard provenance.
+    const WILDCARD: Option<Self> = Some(Provenance::Wildcard);
+
     fn get_alloc_id(self) -> Option<AllocId> {
         match self {
             Provenance::Concrete { alloc_id, .. } => Some(alloc_id),
@@ -1241,8 +1244,8 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
     /// Called on `ptr as usize` casts.
     /// (Actually computing the resulting `usize` doesn't need machine help,
     /// that's just `Scalar::try_to_int`.)
-    fn expose_ptr(ecx: &mut InterpCx<'tcx, Self>, ptr: StrictPointer) -> InterpResult<'tcx> {
-        match ptr.provenance {
+    fn expose_provenance(ecx: &mut InterpCx<'tcx, Self>, provenance: Self::Provenance) -> InterpResult<'tcx> {
+        match provenance {
             Provenance::Concrete { alloc_id, tag } => ecx.expose_ptr(alloc_id, tag),
             Provenance::Wildcard => {
                 // No need to do anything for wildcard pointers as
diff --git a/src/tools/miri/src/shims/native_lib.rs b/src/tools/miri/src/shims/native_lib.rs
@@ -153,17 +153,19 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 throw_unsup_format!("only scalar argument types are support for native calls")
             }
             let imm = this.read_immediate(arg)?;
-            if matches!(arg.layout.ty.kind(), ty::RawPtr(_, rustc_ast::Mutability::Mut)) {
-                let ptr = this.read_pointer(&imm)?;
-                let Ok((alloc_id, _size, _prov_extra)) = this.ptr_try_get_alloc_id(ptr, 0) else {
-                    todo!(); // TODO: Handle absolute-address-returned case.
+            libffi_args.push(imm_to_carg(&imm, this)?);
+            if matches!(arg.layout.ty.kind(), ty::RawPtr(..)) {
+                let ptr = imm.to_scalar().to_pointer(self)?;
+                // 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 {
+                    // Pointer without provenance may access any memory.
+                    continue;
                 };
-                this.alloc_mark_init_rec(alloc_id)?;
+                this.prepare_for_native_call(alloc_id, ptr.provenance)?; 
+                // TODO: Write tests for (forgetting to) expose: -initial allocation -recursively all allocations -unexposed pointers.
             }
-            libffi_args.push(imm_to_carg(imm, this)?);
         }
 
-        // TODO: Directly collect into correct Vec? -- lifetime issues.
         // Convert them to `libffi::high::Arg` type.
         let libffi_args = libffi_args
             .iter()
@@ -229,7 +231,7 @@ impl<'a> CArg {
 
 /// Extract the scalar value from the result of reading a scalar from the machine,
 /// and convert it to a `CArg`.
-fn imm_to_carg<'tcx>(v: ImmTy<'tcx>, cx: &impl HasDataLayout) -> InterpResult<'tcx, CArg> {
+fn imm_to_carg<'tcx>(v: &ImmTy<'tcx>, cx: &impl HasDataLayout) -> InterpResult<'tcx, CArg> {
     interp_ok(match v.layout.ty.kind() {
         // If the primitive provided can be converted to a type matching the type pattern
         // then create a `CArg` of this primitive value with the corresponding `CArg` constructor.
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_write_access.rs b/src/tools/miri/tests/native-lib/pass/ptr_write_access.rs
@@ -12,17 +12,19 @@ fn main() {
     test_init_array();
 
     test_swap_ptr();
+
+    test_dangling();
 }
 
 fn test_modify_int() {
     extern "C" {
         fn modify_int(ptr: *mut i32);
     }
 
-    let mut x = 1;
+    let mut x = 11;
     unsafe { modify_int(&mut x) };
 
-    assert_eq!(x, 3);
+    assert_eq!(x, 12);
 }
 
 fn test_init_int() {
@@ -36,7 +38,7 @@ fn test_init_int() {
         x.assume_init()
     };
 
-    assert_eq!(x, 29);
+    assert_eq!(x, 21);
 }
 
 fn test_init_array() {
@@ -45,11 +47,11 @@ fn test_init_array() {
     }
 
     const LEN: usize = 4;
-    let init_value = 5;
+    let init_value = 41;
 
     let mut array = MaybeUninit::<[i32; LEN]>::uninit();
     let array = unsafe {
-        init_array((*array.as_mut_ptr()).as_mut_ptr(), LEN, init_value);
+        init_array(array.as_mut_ptr().cast::<i32>(), LEN, init_value);
         array.assume_init()
     };
 
@@ -58,12 +60,37 @@ fn test_init_array() {
 
 fn test_swap_ptr() {
     extern "C" {
-        fn swap_ptr(x: *mut *const i32, y: *mut *const i32);
+        fn swap_ptr(pptr0: *mut *const i32, pptr1: *mut *const i32);
     }
 
-    let x = 6;
-    let [mut ptr0, mut ptr1] = [&x, std::ptr::null()];
-    unsafe { swap_ptr(&mut ptr0, &mut ptr1); };
+    let x = 51;
+    let mut ptr0 = &x;
+    let mut ptr1 = std::ptr::null();
+    unsafe { swap_ptr(&mut ptr0, &mut ptr1) };
 
     assert_eq!(unsafe { *ptr1 }, x);
+}
+
+fn test_init_static_inner() {
+    extern "C" {
+        fn init_static_inner(pptr: *const *mut MaybeUninit<i32>);
+    }
+
+    static mut INNER: MaybeUninit<i32> = MaybeUninit::uninit();
+    static STATIC: *mut MaybeUninit<i32> = &raw mut INNER;
+    unsafe { init_static_inner(&STATIC) }
+
+    assert_eq!(unsafe { INNER.assume_init() }, 61);
+}
+
+fn test_dangling() {
+    extern "C" {
+        fn write_nullptr(pptr: *mut *const i32);
+    }
+
+    let x = 71;
+    let mut ptr = &raw const x;
+    drop(x);
+    unsafe { write_nullptr(&mut ptr) };
+    assert_eq!(ptr)
 }
diff --git a/src/tools/miri/tests/native-lib/ptr_write_access.c b/src/tools/miri/tests/native-lib/ptr_write_access.c
@@ -6,13 +6,13 @@
 /* Test: test_modify_int */
 
 EXPORT void modify_int(int *ptr) {
-  *ptr += 2;
+  *ptr += 1;
 }
 
 /* Test: test_init_int */
 
 EXPORT void init_int(int *ptr) {
-  *ptr = 29;
+  *ptr = 12;
 }
 
 /* Test: test_init_array */
@@ -25,8 +25,20 @@ EXPORT void init_array(int *array, size_t len, int value) {
 
 /* Test: test_swap_ptr */
 
-EXPORT void swap_ptr(const int **x, const int **y) {
-  const int *tmp = *x;
-  *x = *y;
-  *y = tmp;
+EXPORT void swap_ptr(const int **pptr0, const int **pptr1) {
+  const int *tmp = *pptr0;
+  *pptr0 = *pptr1;
+  *pptr1 = tmp;
+}
+
+/* Test: test_init_static_inner */
+
+EXPORT void init_static_inner(int **const pptr) {
+  **pptr = 1234;
+}
+
+/* Test: test_dangling */
+
+EXPORT void write_nullptr(const int **pptr) {
+  *pptr = NULL;
 }

Original file line number	Diff line number	Diff line change
`@@ -168,9 +168,9 @@ impl<'tcx> interpret::Machine<'tcx> for DummyMachine {`
`168`	`168`	`})`
`169`	`169`	`}`
`170`	`170`
`171`		`- fn expose_ptr(`
	`171`	`+ fn expose_provenance(`
`172`	`172`	`_ecx: &mut InterpCx<'tcx, Self>,`
`173`		`- _ptr: interpret::Pointer<Self::Provenance>,`
	`173`	`+ _provenance: Self::Provenance,`
`174`	`174`	`) -> interpret::InterpResult<'tcx> {`
`175`	`175`	`unimplemented!()`
`176`	`176`	`}`
Original file line number	Diff line number	Diff line change
`@@ -586,7 +586,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {`
`586`	`586`	`}`
`587`	`587`
`588`	`588`	`#[inline(always)]`
`589`		`- fn expose_ptr(_ecx: &mut InterpCx<'tcx, Self>, _ptr: Pointer) -> InterpResult<'tcx> {`
	`589`	`+ fn expose_provenance(_ecx: &mut InterpCx<'tcx, Self>, _provenance: Self::Provenance) -> InterpResult<'tcx> {`
`590`	`590`	`// This is only reachable with -Zunleash-the-miri-inside-of-you.`
`591`	`591`	`throw_unsup_format!("exposing pointers is not possible at compile-time")`
`592`	`592`	`}`
Original file line number	Diff line number	Diff line change
`@@ -195,6 +195,15 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {`
`195`	`195`
`196`	`196`	`Ok(())`
`197`	`197`	`}`
	`198`	`+`
	`199`	`+ pub fn write_wildcards(&mut self, _alloc_size: usize) {`
	`200`	`+ // We can only write wildcards in Miri.`
	`201`	+ assert!(Prov::OFFSET_IS_ADDR, "writing wildcard provenance is not supported when `OFFSET_IS_ADDR` is false");
	`202`	`+ let _wildcard = Prov::WILDCARD.unwrap();`
	`203`	`+`
	`204`	`+ // TODO: This.`
	`205`	`+`
	`206`	`+ }`
`198`	`207`	`}`
`199`	`208`
`200`	`209`	`/// A partial, owned list of provenance to transfer into another allocation.`