start implementing alloc_mark_init_rec, write_zero_if_uninit, write ptr_write_access.rs tests (modifying, initializing memory, provenance)

Author: Strophox

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -944,6 +944,26 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         interp_ok(())
     }
 
+    pub fn alloc_mark_init_rec(&mut self, id: AllocId) -> InterpResult<'tcx> {
+        let mut reachable = rustc_data_structures::fx::FxHashSet::default();
+        let mut todo = vec![id];
+        while let Some(id) = todo.pop() {
+            if reachable.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)
+                        .map_err(|e| e.to_interp_error(id))?;
+                    todo.extend(
+                        alloc.provenance().provenances().filter_map(|prov| prov.get_alloc_id()),
+                    );
+                }
+            }
+        }
+        Ok(())
+    }
+
     /// Create a lazy debug printer that prints the given allocation and all allocations it points
     /// to, recursively.
     #[must_use]

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

@@ -643,6 +643,12 @@ 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?
+        Ok(())
+    }
+
     /// Remove all provenance in the given memory range.
     pub fn clear_provenance(&mut self, cx: &impl HasDataLayout, range: AllocRange) -> AllocResult {
         self.provenance.clear(range, cx)?;

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

@@ -152,9 +152,18 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             if !matches!(arg.layout.backend_repr, BackendRepr::Scalar(_)) {
                 throw_unsup_format!("only scalar argument types are support for native calls")
             }
-            libffi_args.push(imm_to_carg(this.read_immediate(arg)?, this)?);
+            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.
+                };
+                this.alloc_mark_init_rec(alloc_id)?;
+            }
+            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()
@@ -238,18 +247,10 @@ fn imm_to_carg<'tcx>(v: ImmTy<'tcx>, cx: &impl HasDataLayout) -> InterpResult<'t
         ty::Uint(UintTy::U64) => CArg::UInt64(v.to_scalar().to_u64()?),
         ty::Uint(UintTy::Usize) =>
             CArg::USize(v.to_scalar().to_target_usize(cx)?.try_into().unwrap()),
-        ty::RawPtr(_, mutability) => {
-            // Arbitrary mutable pointer accesses are not currently supported in Miri.
-            if mutability.is_mut() {
-                throw_unsup_format!(
-                    "unsupported mutable pointer type for native call: {}",
-                    v.layout.ty
-                );
-            } else {
-                let s = v.to_scalar().to_pointer(cx)?.addr();
-                // This relies on the `expose_provenance` in `addr_from_alloc_id`.
-                CArg::RawPtr(std::ptr::with_exposed_provenance_mut(s.bytes_usize()))
-            }
+        ty::RawPtr(..) => {
+            let s = v.to_scalar().to_pointer(cx)?.addr();
+            // This relies on the `expose_provenance` in `addr_from_alloc_id`.
+            CArg::RawPtr(std::ptr::with_exposed_provenance_mut(s.bytes_usize()))
         }
         _ => throw_unsup_format!("unsupported argument type for native call: {}", v.layout.ty),
     })

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

@@ -0,0 +1,69 @@
+// Only works on Unix targets
+//@ignore-target: windows wasm
+//@only-on-host
+
+use std::mem::MaybeUninit;
+
+fn main() {
+    test_modify_int();
+
+    test_init_int();
+
+    test_init_array();
+
+    test_swap_ptr();
+}
+
+fn test_modify_int() {
+    extern "C" {
+        fn modify_int(ptr: *mut i32);
+    }
+
+    let mut x = 1;
+    unsafe { modify_int(&mut x) };
+
+    assert_eq!(x, 3);
+}
+
+fn test_init_int() {
+    extern "C" {
+        fn init_int(ptr: *mut i32);
+    }
+
+    let mut x = MaybeUninit::<i32>::uninit();
+    let x = unsafe {
+        init_int(x.as_mut_ptr());
+        x.assume_init()
+    };
+
+    assert_eq!(x, 29);
+}
+
+fn test_init_array() {
+    extern "C" {
+        fn init_array(ptr: *mut i32, len: usize, value: i32);
+    }
+
+    const LEN: usize = 4;
+    let init_value = 5;
+
+    let mut array = MaybeUninit::<[i32; LEN]>::uninit();
+    let array = unsafe {
+        init_array((*array.as_mut_ptr()).as_mut_ptr(), LEN, init_value);
+        array.assume_init()
+    };
+
+    assert_eq!(array, [init_value; LEN]);
+}
+
+fn test_swap_ptr() {
+    extern "C" {
+        fn swap_ptr(x: *mut *const i32, y: *mut *const i32);
+    }
+
+    let x = 6;
+    let [mut ptr0, mut ptr1] = [&x, std::ptr::null()];
+    unsafe { swap_ptr(&mut ptr0, &mut ptr1); };
+
+    assert_eq!(unsafe { *ptr1 }, x);
+}

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

@@ -0,0 +1,32 @@
+#include <stddef.h>
+
+// See comments in build_native_lib()
+#define EXPORT __attribute__((visibility("default")))
+
+/* Test: test_modify_int */
+
+EXPORT void modify_int(int *ptr) {
+  *ptr += 2;
+}
+
+/* Test: test_init_int */
+
+EXPORT void init_int(int *ptr) {
+  *ptr = 29;
+}
+
+/* Test: test_init_array */
+
+EXPORT void init_array(int *array, size_t len, int value) {
+  for (size_t i = 0; i < len; i++) {
+    array[i] = value;
+  }
+}
+
+/* Test: test_swap_ptr */
+
+EXPORT void swap_ptr(const int **x, const int **y) {
+  const int *tmp = *x;
+  *x = *y;
+  *y = tmp;
+}

src/tools/miri/tests/ui.rs

@@ -64,6 +64,7 @@ fn build_native_lib() -> PathBuf {
             // FIXME: Automate gathering of all relevant C source files in the directory.
             "tests/native-lib/scalar_arguments.c",
             "tests/native-lib/ptr_read_access.c",
+            "tests/native-lib/ptr_write_access.c",
             // Ensure we notice serious problems in the C code.
             "-Wall",
             "-Wextra",