add prepared_alloc_bytes to GlobalStateInner, fn take_prepared_alloc_bytes, adapt Allocation::adjust_from_tcx

Author: Strophox

compiler/rustc_const_eval/src/interpret/machine.rs

@@ -357,17 +357,7 @@ pub trait Machine<'tcx>: Sized {
         ecx: &InterpCx<'tcx, Self>,
         id: AllocId,
         alloc: &'b Allocation,
-    ) -> InterpResult<'tcx, Cow<'b, Allocation<Self::Provenance, Self::AllocExtra, Self::Bytes>>>
-    {
-        // The default implementation does a copy; CTFE machines have a more efficient implementation
-        // based on their particular choice for `Provenance`, `AllocExtra`, and `Bytes`.
-        let kind = Self::GLOBAL_KIND
-            .expect("if GLOBAL_KIND is None, adjust_global_allocation must be overwritten");
-        let alloc = alloc.adjust_from_tcx(&ecx.tcx, |ptr| ecx.global_root_pointer(ptr))?;
-        let extra =
-            Self::init_alloc_extra(ecx, id, MemoryKind::Machine(kind), alloc.size(), alloc.align)?;
-        Ok(Cow::Owned(alloc.with_extra(extra)))
-    }
+    ) -> InterpResult<'tcx, Cow<'b, Allocation<Self::Provenance, Self::AllocExtra, Self::Bytes>>>;
 
     /// Initialize the extra state of an allocation.
     ///

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

@@ -358,10 +358,11 @@ impl Allocation {
     pub fn adjust_from_tcx<Prov: Provenance, Bytes: AllocBytes, Err>(
         &self,
         cx: &impl HasDataLayout,
+        mut alloc_bytes: impl FnMut(&[u8], Align) -> Bytes,
         mut adjust_ptr: impl FnMut(Pointer<CtfeProvenance>) -> Result<Pointer<Prov>, Err>,
     ) -> Result<Allocation<Prov, (), Bytes>, Err> {
         // Copy the data.
-        let mut bytes = Bytes::from_bytes(Cow::Borrowed(&*self.bytes), self.align);
+        let mut bytes = alloc_bytes(&*self.bytes, self.align); 
         // Adjust provenance of pointers stored in this allocation.
         let mut new_provenance = Vec::with_capacity(self.provenance.ptrs().len());
         let ptr_size = cx.data_layout().pointer_size.bytes_usize();

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

@@ -42,6 +42,8 @@ pub struct GlobalStateInner {
     /// they do not have an `AllocExtra`.
     /// This is the inverse of `int_to_ptr_map`.
     base_addr: FxHashMap<AllocId, u64>,
+    // Temporarily store prepared memory space for global allocations the first time their memory address is required. This is used to ensure that the memory is allocated before Miri assigns it an internal address, which is important for matching the internal address to the machine address so FFI can read from pointers.
+    prepared_alloc_bytes: FxHashMap<AllocId, MiriAllocBytes>,
     /// A pool of addresses we can reuse for future allocations.
     reuse: ReusePool,
     /// Whether an allocation has been exposed or not. This cannot be put
@@ -59,6 +61,7 @@ impl VisitProvenance for GlobalStateInner {
         let GlobalStateInner {
             int_to_ptr_map: _,
             base_addr: _,
+            prepared_alloc_bytes: _,
             reuse: _,
             exposed: _,
             next_base_addr: _,
@@ -78,6 +81,7 @@ impl GlobalStateInner {
         GlobalStateInner {
             int_to_ptr_map: Vec::default(),
             base_addr: FxHashMap::default(),
+            prepared_alloc_bytes: FxHashMap::default(),
             reuse: ReusePool::new(config),
             exposed: FxHashSet::default(),
             next_base_addr: stack_addr,
@@ -166,17 +170,22 @@ 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 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
+                let base_addr = if ecx.machine.native_lib.is_some() {
                     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
+                            if ecx.tcx.try_get_global_alloc(alloc_id).is_some() {
+                                // For new global allocations, we always pre-allocate the memory to be able use the machine address directly.
+                                let prepared_bytes = MiriAllocBytes::zeroed(size, align)
+                                    .unwrap_or_else(|| {
+                                        panic!("Miri ran out of memory: cannot create allocation of {size:?} bytes")
+                                    });
+                                let addr = prepared_bytes.as_ptr().addr().try_into().unwrap();
+                                // Store prepared allocation space to be picked up for use later.
+                                global_state.prepared_alloc_bytes.try_insert(alloc_id, prepared_bytes).unwrap();
+                                addr
+                            } else {
+                                ecx.get_alloc_bytes_unchecked_raw(alloc_id)?.addr().try_into().unwrap()
+                            }
                         }
                         AllocKind::Function | AllocKind::VTable => {
                             let alloc_bytes = MiriAllocBytes::from_bytes(&[0u8; 1], Align::from_bytes(1).unwrap());
@@ -339,6 +348,16 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         Ok(base_ptr.wrapping_offset(offset, ecx))
     }
 
+    // This returns some prepared `MiriAllocBytes`, either because `addr_from_alloc_id` was called in the past and reserved memory space, or by doing the pre-allocation right upon being called.
+    fn take_prepared_alloc_bytes(&self, id: AllocId, kind: MemoryKind) -> InterpResult<'tcx, MiriAllocBytes> {
+        let ecx = self.eval_context_ref();
+        // This additional call ensures that some `MiriAllocBytes` are prepared.
+        ecx.addr_from_alloc_id(id, kind)?;
+        // TODO: Better debug message?
+        let prepared_alloc_bytes = ecx.machine.alloc_addresses.borrow_mut().prepared_alloc_bytes.remove(&id).expect("alloc bytes for alloc_id could not prepared");
+        Ok(prepared_alloc_bytes)
+    }
+
     /// When a pointer is used for a memory access, this computes where in which allocation the
     /// access is going.
     fn ptr_get_alloc(

src/tools/miri/src/concurrency/thread.rs

@@ -887,7 +887,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             let alloc = this.ctfe_query(|tcx| tcx.eval_static_initializer(def_id))?;
             // We make a full copy of this allocation.
             let mut alloc =
-                alloc.inner().adjust_from_tcx(&this.tcx, |ptr| this.global_root_pointer(ptr))?;
+                alloc.inner().adjust_from_tcx(&this.tcx, |bytes, align| MiriAllocBytes::from_bytes(std::borrow::Cow::Borrowed(bytes), align), |ptr| this.global_root_pointer(ptr))?;
             // This allocation will be deallocated when the thread dies, so it is not in read-only memory.
             alloc.mutability = Mutability::Mut;
             // Create a fresh allocation with this content.

src/tools/miri/src/machine.rs

@@ -1,6 +1,7 @@
 //! Global machine state as well as implementation of the interpreter engine
 //! `Machine` trait.
 
+use std::borrow::Cow;
 use std::cell::RefCell;
 use std::collections::hash_map::Entry;
 use std::fmt;
@@ -1225,6 +1226,41 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
         })
     }
 
+    /// Called to adjust global allocations to the Provenance and AllocExtra of this machine.
+    ///
+    /// If `alloc` contains pointers, then they are all pointing to globals.
+    ///
+    /// This should avoid copying if no work has to be done! If this returns an owned
+    /// allocation (because a copy had to be done to adjust things), machine memory will
+    /// cache the result. (This relies on `AllocMap::get_or` being able to add the
+    /// owned allocation to the map even when the map is shared.)
+    fn adjust_global_allocation<'b>(
+        ecx: &InterpCx<'tcx, Self>,
+        id: AllocId,
+        alloc: &'b Allocation,
+    ) -> InterpResult<'tcx, Cow<'b, Allocation<Self::Provenance, Self::AllocExtra, Self::Bytes>>>
+    {
+        // The default implementation does a copy; CTFE machines have a more efficient implementation
+        // based on their particular choice for `Provenance`, `AllocExtra`, and `Bytes`.
+        let kind = Self::GLOBAL_KIND
+            .expect("if GLOBAL_KIND is None, adjust_global_allocation must be overwritten");
+        // This closure is special in that it always relies on `take_prepared_alloc_bytes` to give it some reserved memory space.
+        let alloc = alloc.adjust_from_tcx(&ecx.tcx, |bytes, align| {
+                assert_eq!(alloc.align, align);
+                // TODO: is this unwrap warranted?
+                let mut alloc_bytes = ecx.take_prepared_alloc_bytes(id, MemoryKind::Machine(kind)).unwrap();
+                assert_eq!(alloc_bytes.len(), bytes.len());
+                // SAFETY: `alloc_bytes` and `bytes` span the same number of bytes.
+                unsafe { alloc_bytes.as_mut_ptr().copy_from(bytes.as_ptr(), bytes.len()) };
+                alloc_bytes
+            }, 
+            |ptr| ecx.global_root_pointer(ptr),
+        )?;
+        let extra =
+            Self::init_alloc_extra(ecx, id, MemoryKind::Machine(kind), alloc.size(), alloc.align)?;
+        Ok(Cow::Owned(alloc.with_extra(extra)))
+    }
+
     #[inline(always)]
     fn before_memory_read(
         _tcx: TyCtxtAt<'tcx>,

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

@@ -47,8 +47,8 @@ fn main() {
         // 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);
+        println!("pointer address from Rust: {:?}", ptr);
+        println!("printing dereference from Rust: {}", *ptr);
         ptr_printer(ptr);
 
     }

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

@@ -11,7 +11,7 @@ void printer() {
 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);
+  printf("printing dereference from C: %d\n", *ptr);
 }
 
 // function with many arguments, to test functionality when some args are stored