Mem.check_ptr_access

Author: Dante-Broggi

src/librustc_mir/interpret/memory.rs

@@ -309,11 +309,10 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
     pub fn check_ptr_access(
         &self,
         sptr: Scalar<M::PointerTag>,
-        size: Size,
-        align: Align,
+        mem_pos: MemoryPosition,
     ) -> InterpResult<'tcx, Option<Pointer<M::PointerTag>>> {
-        let align = if M::CHECK_ALIGN { Some(align) } else { None };
-        self.check_ptr_access_align(sptr, size, align, CheckInAllocMsg::MemoryAccessTest)
+        let align = if M::CHECK_ALIGN { Some(mem_pos.align) } else { None };
+        self.check_ptr_access_align(sptr, mem_pos.size, align, CheckInAllocMsg::MemoryAccessTest)
     }
 
     /// Like `check_ptr_access`, but *definitely* checks alignment when `align`
@@ -776,7 +775,8 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         ptr: Scalar<M::PointerTag>,
         size: Size,
     ) -> InterpResult<'tcx, &[u8]> {
-        let ptr = match self.check_ptr_access(ptr, size, Align::from_bytes(1).unwrap())? {
+        let mem_pos = MemoryPosition::new(size, Align::from_bytes(1).unwrap());
+        let ptr = match self.check_ptr_access(ptr, mem_pos)? {
             Some(ptr) => ptr,
             None => return Ok(&[]), // zero-sized access
         };
@@ -803,7 +803,8 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         let src = src.into_iter();
         let size = Size::from_bytes(src.size_hint().0 as u64);
         // `write_bytes` checks that this lower bound matches the upper bound matches reality.
-        let ptr = match self.check_ptr_access(ptr, size, Align::from_bytes(1).unwrap())? {
+        let mem_pos = MemoryPosition::new(size, Align::from_bytes(1).unwrap());
+        let ptr = match self.check_ptr_access(ptr, mem_pos)? {
             Some(ptr) => ptr,
             None => return Ok(()), // zero-sized access
         };

src/librustc_mir/interpret/place.rs

@@ -9,7 +9,7 @@ use rustc::mir;
 use rustc::mir::interpret::truncate;
 use rustc::ty::{self, Ty};
 use rustc::ty::layout::{
-    self, Size, Align, LayoutOf, TyLayout, HasDataLayout, VariantIdx, PrimitiveExt
+    self, Size, Align, MemoryPosition, LayoutOf, TyLayout, HasDataLayout, VariantIdx, PrimitiveExt
 };
 use rustc::ty::TypeFoldable;
 
@@ -332,12 +332,14 @@ where
         place: MPlaceTy<'tcx, M::PointerTag>,
         size: Option<Size>,
     ) -> InterpResult<'tcx, Option<Pointer<M::PointerTag>>> {
-        let size = size.unwrap_or_else(|| {
+        let mem_pos = if let Some(size) = size {
+            MemoryPosition::new(size, place.align)
+        } else {
             assert!(!place.layout.is_unsized());
             assert!(place.meta.is_none());
-            place.layout.pref_pos.size
-        });
-        self.memory.check_ptr_access(place.ptr, size, place.align)
+            place.layout.pref_pos.mem_pos()
+        };
+        self.memory.check_ptr_access(place.ptr, mem_pos)
     }
 
     /// Return the "access-checked" version of this `MPlace`, where for non-ZST

src/librustc_mir/interpret/terminator.rs

@@ -422,7 +422,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             // cannot use the shim here, because that will only result in infinite recursion
             ty::InstanceDef::Virtual(_, idx) => {
                 let mut args = args.to_vec();
-                let ptr_pos = self.pointer_pos();
+                let ptr_pos = self.pointer_pos().mem_pos();
                 // We have to implement all "object safe receivers".  Currently we
                 // support built-in pointers (&, &mut, Box) as well as unsized-self.  We do
                 // not yet support custom self types.
@@ -442,8 +442,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 let vtable_slot = vtable.ptr_offset((ptr_pos * (idx as u64 + 3)).size, self)?;
                 let vtable_slot = self.memory.check_ptr_access(
                     vtable_slot,
-                    ptr_pos.size,
-                    ptr_pos.align.abi,
+                    ptr_pos,
                 )?.expect("cannot be a ZST");
                 let fn_ptr = self.memory.get_raw(vtable_slot.alloc_id)?
                     .read_ptr_sized(self, vtable_slot)?.not_undef()?;

src/librustc_mir/interpret/traits.rs

@@ -106,8 +106,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         // we don't care about the pointee type, we just want a pointer
         let vtable = self.memory.check_ptr_access(
             vtable,
-            self.tcx.data_layout.pointer_pos.size,
-            self.tcx.data_layout.pointer_pos.align.abi,
+            self.tcx.data_layout.pointer_pos.mem_pos(),
         )?.expect("cannot be a ZST");
         let drop_fn = self.memory
             .get_raw(vtable.alloc_id)?
@@ -128,13 +127,12 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         &self,
         vtable: Scalar<M::PointerTag>,
     ) -> InterpResult<'tcx, (Size, Align)> {
-        let ptr_pos = self.pointer_pos();
+        let ptr_pos = self.pointer_pos().mem_pos();
         // We check for size = 3*ptr_size, that covers the drop fn (unused here),
         // the size, and the align (which we read below).
         let vtable = self.memory.check_ptr_access(
             vtable,
-            (3 * ptr_pos).size,
-            self.tcx.data_layout.pointer_pos.align.abi,
+            3 * ptr_pos,
         )?.expect("cannot be a ZST");
         let alloc = self.memory.get_raw(vtable.alloc_id)?;
         let size = alloc.read_ptr_sized(

src/librustc_mir/interpret/validity.rs

@@ -269,8 +269,7 @@ impl<'rt, 'mir, 'tcx, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, 'tcx, M
                 try_validation!(
                     self.ecx.memory.check_ptr_access(
                         vtable,
-                        3*self.ecx.tcx.data_layout.pointer_pos.size, // drop, size, align
-                        self.ecx.tcx.data_layout.pointer_pos.align.abi,
+                        3 * self.ecx.tcx.data_layout.pointer_pos.mem_pos(), // drop, size, align
                     ),
                     "dangling or unaligned vtable pointer in wide pointer or too small vtable",
                     self.path