manual fmt adjustments, fmt, adjust and bless miri native test

Author: Strophox

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

@@ -362,7 +362,7 @@ impl Allocation {
         mut adjust_ptr: impl FnMut(Pointer<CtfeProvenance>) -> Result<Pointer<Prov>, Err>,
     ) -> Result<Allocation<Prov, (), Bytes>, Err> {
         // Copy the data.
-        let mut bytes = alloc_bytes(&*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,7 +42,10 @@ 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.
+    /// 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,
@@ -348,13 +351,18 @@ 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.
+    // This returns some prepared `MiriAllocBytes`, either because `addr_from_alloc_id` reserved
+    // memory space in the past, 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");
+        let mut global_state = ecx.machine.alloc_addresses.borrow_mut();
+        let prepared_alloc_bytes = global_state
+            .prepared_alloc_bytes
+            .remove(&id)
+            .expect("alloc bytes for alloc_id could not prepared");
         Ok(prepared_alloc_bytes)
     }
 

src/tools/miri/src/machine.rs

@@ -1244,11 +1244,13 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
         // 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.
+        // 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);
+                let kind = MemoryKind::Machine(kind);
                 // TODO: is this unwrap warranted?
-                let mut alloc_bytes = ecx.take_prepared_alloc_bytes(id, MemoryKind::Machine(kind)).unwrap();
+                let mut alloc_bytes = ecx.take_prepared_alloc_bytes(id, 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()) };

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

@@ -44,12 +44,9 @@ fn main() {
         // test void function that prints from C
         printer();
 
-        // test void function that dereferences a pointer and prints from C
+        // test void function that dereferences a pointer and prints its contents 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/pass/call_extern_c_fn.stdout

@@ -1 +1,2 @@
 printing from C
+printing pointer dereference from C: 42

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

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