adjust for rustc changes; normalize mplace before doing freeze-sensitive visit

Author: RalfJung

src/eval.rs

@@ -136,7 +136,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
         let place = ecx.mplace_field(argvs_place, idx as u64)?;
         ecx.write_scalar(Scalar::Ptr(arg), place.into())?;
     }
-    ecx.memory_mut().mark_immutable(argvs_place.to_ptr()?.alloc_id)?;
+    ecx.memory_mut().mark_immutable(argvs_place.ptr.assert_ptr().alloc_id)?;
     // Write a pointer to that place as the argument.
     let argv = argvs_place.ptr;
     ecx.write_scalar(argv, dest)?;

src/helpers.rs

@@ -116,36 +116,33 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             .map(|(size, _)| size)
             .unwrap_or_else(|| place.layout.size)
         );
-        assert!(size.bytes() > 0);
+        let place = this.normalize_mplace_ptr(place)?;
         // Store how far we proceeded into the place so far. Everything to the left of
         // this offset has already been handled, in the sense that the frozen parts
         // have had `action` called on them.
-        let mut end_ptr = place.ptr;
+        let mut end_ptr = place.ptr.assert_ptr();
         // Called when we detected an `UnsafeCell` at the given offset and size.
         // Calls `action` and advances `end_ptr`.
         let mut unsafe_cell_action = |unsafe_cell_ptr: Scalar<Tag>, unsafe_cell_size: Size| {
-            if unsafe_cell_size != Size::ZERO {
-                debug_assert_eq!(unsafe_cell_ptr.to_ptr().unwrap().alloc_id,
-                    end_ptr.to_ptr().unwrap().alloc_id);
-                debug_assert_eq!(unsafe_cell_ptr.to_ptr().unwrap().tag,
-                    end_ptr.to_ptr().unwrap().tag);
-            }
+            let unsafe_cell_ptr = unsafe_cell_ptr.assert_ptr();
+            debug_assert_eq!(unsafe_cell_ptr.alloc_id, end_ptr.alloc_id);
+            debug_assert_eq!(unsafe_cell_ptr.tag, end_ptr.tag);
             // We assume that we are given the fields in increasing offset order,
             // and nothing else changes.
-            let unsafe_cell_offset = unsafe_cell_ptr.get_ptr_offset(this);
-            let end_offset = end_ptr.get_ptr_offset(this);
+            let unsafe_cell_offset = unsafe_cell_ptr.offset;
+            let end_offset = end_ptr.offset;
             assert!(unsafe_cell_offset >= end_offset);
             let frozen_size = unsafe_cell_offset - end_offset;
             // Everything between the end_ptr and this `UnsafeCell` is frozen.
             if frozen_size != Size::ZERO {
-                action(end_ptr.to_ptr()?, frozen_size, /*frozen*/true)?;
+                action(end_ptr, frozen_size, /*frozen*/true)?;
             }
             // This `UnsafeCell` is NOT frozen.
             if unsafe_cell_size != Size::ZERO {
-                action(unsafe_cell_ptr.to_ptr()?, unsafe_cell_size, /*frozen*/false)?;
+                action(unsafe_cell_ptr, unsafe_cell_size, /*frozen*/false)?;
             }
             // Update end end_ptr.
-            end_ptr = unsafe_cell_ptr.ptr_wrapping_offset(unsafe_cell_size, this);
+            end_ptr = unsafe_cell_ptr.wrapping_offset(unsafe_cell_size, this);
             // Done
             Ok(())
         };
@@ -234,7 +231,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                     layout::FieldPlacement::Arbitrary { .. } => {
                         // Gather the subplaces and sort them before visiting.
                         let mut places = fields.collect::<InterpResult<'tcx, Vec<MPlaceTy<'tcx, Tag>>>>()?;
-                        places.sort_by_key(|place| place.ptr.get_ptr_offset(self.ecx()));
+                        places.sort_by_key(|place| place.ptr.assert_ptr().offset);
                         self.walk_aggregate(place, places.into_iter().map(Ok))
                     }
                     layout::FieldPlacement::Union { .. } => {

src/shims/foreign_items.rs

@@ -842,13 +842,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             },
             "GetSystemInfo" => {
                 let system_info = this.deref_operand(args[0])?;
-                let (system_info_ptr, align) = system_info.to_scalar_ptr_align();
-                let system_info_ptr = this.memory()
-                    .check_ptr_access(
-                        system_info_ptr,
-                        system_info.layout.size,
-                        align,
-                    )?
+                let system_info_ptr = this.check_mplace_access(system_info, None)?
                     .expect("cannot be a ZST");
                 // Initialize with `0`.
                 this.memory_mut().get_mut(system_info_ptr.alloc_id)?

src/shims/intrinsics.rs

@@ -166,17 +166,21 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 let elem_size = elem_layout.size.bytes();
                 let count = this.read_scalar(args[2])?.to_usize(this)?;
                 let elem_align = elem_layout.align.abi;
-                // erase tags: this is a raw ptr operation
+
+                let size = Size::from_bytes(count * elem_size);
                 let src = this.read_scalar(args[0])?.not_undef()?;
+                let src = this.memory().check_ptr_access(src, size, elem_align)?;
                 let dest = this.read_scalar(args[1])?.not_undef()?;
-                this.memory_mut().copy(
-                    src,
-                    elem_align,
-                    dest,
-                    elem_align,
-                    Size::from_bytes(count * elem_size),
-                    intrinsic_name.ends_with("_nonoverlapping"),
-                )?;
+                let dest = this.memory().check_ptr_access(dest, size, elem_align)?;
+
+                if let (Some(src), Some(dest)) = (src, dest) {
+                    this.memory_mut().copy(
+                        src,
+                        dest,
+                        size,
+                        intrinsic_name.ends_with("_nonoverlapping"),
+                    )?;
+                }
             }
 
             "discriminant_value" => {