init previous work on passing pointers through miri FFI (causes ice)

Author: Strophox

src/tools/miri/src/alloc_addresses/mod.rs

@@ -166,7 +166,28 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 assert!(!matches!(kind, AllocKind::Dead));
 
                 // This allocation does not have a base address yet, pick or reuse one.
-                let base_addr = if let Some((reuse_addr, clock)) = global_state.reuse.take_addr(
+                let base_addr = if ecx.machine.native_lib.is_some() { // V1: memory.rs:212  InterpError(UseAfterFree...
+                // let base_addr = if ecx.machine.native_lib.is_some() && kind != AllocKind::Function { // V2: /home/lwerner/.rustup/toolchains/miri/lib/rustlib/src/rust/library/std/src/rt.rs:159:9  UB???...
+                // let base_addr = if ecx.machine.native_lib.is_some() && kind == AllocKind::LiveData { // V3: alloc_addresses/mod.rs:151  BorrowMutError...
+                    // Work with the real underlying machine address directly TODO https://doc.rust-lang.org/std/primitive.pointer.html
+                    match kind {
+                        AllocKind::LiveData => {
+                            let the = ecx.get_alloc_bytes_unchecked_raw(alloc_id);
+                            dbg!((1, &alloc_id, &kind, &the)); // TODO
+                            let the2 = the?.addr().try_into().unwrap();
+                            dbg!((2, &the2)); // TODO
+                            the2
+                        }
+                        AllocKind::Function | AllocKind::VTable => {
+                            let alloc_bytes = MiriAllocBytes::from_bytes(&[0u8; 1], Align::from_bytes(1).unwrap());
+                            let addr = alloc_bytes.as_ptr().addr().try_into().unwrap();
+                            // Leak this.
+                            std::mem::forget(alloc_bytes);
+                            addr
+                        }
+                        AllocKind::Dead => unreachable!()
+                    }
+                } else if let Some((reuse_addr, clock)) = global_state.reuse.take_addr(                    
                     &mut *rng,
                     size,
                     align,

src/tools/miri/src/lib.rs

@@ -12,6 +12,7 @@
 #![feature(let_chains)]
 #![feature(trait_upcasting)]
 #![feature(strict_overflow_ops)]
+#![feature(strict_provenance)]
 // Configure clippy and other lints
 #![allow(
     clippy::collapsible_else_if,

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

@@ -194,6 +194,8 @@ enum CArg {
     UInt64(u64),
     /// usize.
     USize(usize),
+    /// Raw pointer, stored as C's `void*`.
+    RawPtr(*mut std::ffi::c_void),
 }
 
 impl<'a> CArg {
@@ -210,6 +212,7 @@ impl<'a> CArg {
             CArg::UInt32(i) => ffi::arg(i),
             CArg::UInt64(i) => ffi::arg(i),
             CArg::USize(i) => ffi::arg(i),
+            CArg::RawPtr(i) => ffi::arg(i),
         }
     }
 }
@@ -234,6 +237,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(..) => {
+            let s = v.to_scalar().to_pointer(cx)?.addr();
+            CArg::RawPtr(s.bytes() as *mut std::ffi::c_void) // TODO
+        },
         _ => throw_unsup_format!("unsupported argument type for native call: {}", v.layout.ty),
     })
 }

src/tools/miri/tests/native-lib/libtest.map

@@ -3,6 +3,7 @@ CODEABI_1.0 {
     global:
         add_one_int;
         printer;
+        ptr_printer;
         test_stack_spill;
         get_unsigned_int;
         add_int16;

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

@@ -21,6 +21,7 @@ extern "C" {
     fn add_short_to_long(x: i16, y: i64) -> i64;
     fn get_unsigned_int() -> u32;
     fn printer();
+    fn ptr_printer(ptr: *mut i32);
 }
 
 fn main() {
@@ -42,5 +43,13 @@ fn main() {
 
         // test void function that prints from C
         printer();
+
+        // test void function that dereferences a pointer and prints from C
+        let mut x = 42i32;
+        let ptr = &mut x as *mut i32;
+        //println!("pointer address from Rust: {:?}", ptr);
+        //println!("printing dereference from Rust: {}", *ptr);
+        ptr_printer(ptr);
+
     }
 }

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

@@ -8,6 +8,12 @@ void printer() {
   printf("printing from C\n");
 }
 
+void ptr_printer(int *ptr) {
+  printf("printing address from C: %p\n", ptr);
+  // TODO: Get *this* to work.
+  //printf("printing dereference from C: %d\n", *ptr);
+}
+
 // function with many arguments, to test functionality when some args are stored
 // on the stack
 int test_stack_spill(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j, int k, int l) {