changes

Author: nia-e

src/shims/native_lib/mod.rs

@@ -20,8 +20,7 @@ mod ffi;
 )]
 pub mod trace;
 
-use self::ffi::CArg;
-use crate::shims::native_lib::ffi::CPrimitive;
+use self::ffi::{CArg, CPrimitive, FfiArg};
 use crate::*;
 
 /// The final results of an FFI trace, containing every relevant event detected
@@ -83,7 +82,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         link_name: Symbol,
         dest: &MPlaceTy<'tcx>,
         ptr: CodePtr,
-        libffi_args: Vec<ffi::FfiArg<'a>>,
+        libffi_args: Vec<FfiArg<'a>>,
     ) -> InterpResult<'tcx, (crate::ImmTy<'tcx>, Option<MemEvents>)> {
         let this = self.eval_context_mut();
         #[cfg(target_os = "linux")]
@@ -280,7 +279,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         interp_ok(())
     }
 
-    /// Extract the value from the result of reading a scalar or mplace from the machine,
+    /// Extract the value from the result of reading an operand from the machine
     /// and convert it to a `CArg`.
     fn op_to_carg(&self, v: &OpTy<'tcx>, tracing: bool) -> InterpResult<'tcx, CArg> {
         let this = self.eval_context_ref();
@@ -316,7 +315,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 };
 
                 // This relies on the `expose_provenance` in the `visit_reachable_allocs` callback
-                // below.
+                // below to expose the actual interpreter-level allocation.
                 CPrimitive::RawPtr(std::ptr::with_exposed_provenance_mut(ptr.addr().bytes_usize()))
                     .into()
             }
@@ -332,21 +331,21 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                         // exposed recursively.
                         let ptr = mplace.ptr();
                         // Make sure the provenance of this allocation is exposed;
-                        // there must be one for this arg to be valid at all.
+                        // there must be one for this mplace to be valid at all.
+                        // The interpreter-level allocation itself is exposed in
+                        // visit_reachable_allocs.
                         this.expose_provenance(ptr.provenance.unwrap())?;
                         // Then get the actual bytes.
                         let id = this
                             .alloc_id_from_addr(
                                 ptr.addr().bytes(),
                                 mplace.layout.size.bytes_usize().try_into().unwrap(),
-                                /* only_exposed_allocations */ false,
+                                /* only_exposed_allocations */ true,
                             )
                             .unwrap();
                         let ptr_raw = this.get_alloc_bytes_unchecked_raw(id)?;
-                        // Expose the allocation here so that the FFI code can access it.
-                        std::hint::black_box(ptr_raw.expose_provenance());
-                        // SAFETY: We know for sure that at ptr_raw there are initialised
-                        // bytes as indicated by the layout size.
+                        // SAFETY: We know for sure that at ptr_raw the next layout.size bytes
+                        // are part of this allocation and initialised.
                         unsafe {
                             std::slice::from_raw_parts(ptr_raw, mplace.layout.size.bytes_usize())
                                 .to_vec()