InterpCx::size_and_align_of to InterpCx::mem_pos_of

Author: Dante-Broggi

src/librustc_mir/interpret/eval_context.rs

@@ -7,7 +7,7 @@ use rustc::hir::def_id::DefId;
 use rustc::hir::def::DefKind;
 use rustc::mir;
 use rustc::ty::layout::{
-    self, Size, Align, HasDataLayout, LayoutOf, TyLayout
+    self, Size, MemoryPosition, HasDataLayout, LayoutOf, TyLayout
 };
 use rustc::ty::subst::SubstsRef;
 use rustc::ty::{self, Ty, TyCtxt, TypeFoldable};
@@ -369,13 +369,13 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     /// Returns the actual dynamic size and alignment of the place at the given type.
     /// Only the "meta" (metadata) part of the place matters.
     /// This can fail to provide an answer for extern types.
-    pub(super) fn size_and_align_of(
+    pub(super) fn mem_pos_of(
         &self,
         metadata: Option<Scalar<M::PointerTag>>,
         layout: TyLayout<'tcx>,
-    ) -> InterpResult<'tcx, Option<(Size, Align)>> {
+    ) -> InterpResult<'tcx, Option<MemoryPosition>> {
         if !layout.is_unsized() {
-            return Ok(Some((layout.pref_pos.size, layout.pref_pos.align.abi)));
+            return Ok(Some(layout.pref_pos.mem_pos()));
         }
         match layout.ty.kind {
             ty::Adt(..) | ty::Tuple(..) => {
@@ -399,7 +399,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 // the last field).  Can't have foreign types here, how would we
                 // adjust alignment and size for them?
                 let field = layout.field(self, layout.fields.count() - 1)?;
-                let (unsized_size, unsized_align) = match self.size_and_align_of(metadata, field)? {
+                let unsized_mem_pos = match self.mem_pos_of(metadata, field)? {
                     Some(size_and_align) => size_and_align,
                     None => {
                         // A field with extern type.  If this field is at offset 0, we behave
@@ -415,6 +415,9 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                     }
                 };
 
+                let unsized_size = unsized_mem_pos.size;
+                let unsized_align = unsized_mem_pos.align;
+
                 // FIXME (#26403, #27023): We should be adding padding
                 // to `sized_size` (to accommodate the `unsized_align`
                 // required of the unsized field that follows) before
@@ -438,12 +441,16 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                     throw_ub_format!("wide pointer metadata contains invalid information: \
                         total size is bigger than largest supported object");
                 }
-                Ok(Some((size, align)))
-            }
+                let mem_pos = MemoryPosition::new(size, align).strided();
+
+                Ok(Some(mem_pos))
+            },
             ty::Dynamic(..) => {
                 let vtable = metadata.expect("dyn trait fat ptr must have vtable");
                 // Read size and align from vtable (already checks size).
-                Ok(Some(self.read_size_and_align_from_vtable(vtable)?))
+                let (size, align) = self.read_size_and_align_from_vtable(vtable)?;
+                let mem_pos = MemoryPosition::new(size, align);
+                Ok(Some(mem_pos))
             }
 
             ty::Slice(_) | ty::Str => {
@@ -454,22 +461,22 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 let pref_pos = elem.pref_pos.checked_mul(len, &*self.tcx)
                     .ok_or_else(|| err_ub_format!("invalid slice: \
                         total size is bigger than largest supported object"))?;
-                Ok(Some((pref_pos.size, pref_pos.align.abi)))
+                Ok(Some(pref_pos.mem_pos()))
             }
 
             ty::Foreign(_) => {
                 Ok(None)
             }
 
-            _ => bug!("size_and_align_of::<{:?}> not supported", layout.ty),
+            _ => bug!("mem_pos_of::<{:?}> not supported", layout.ty),
         }
     }
     #[inline]
-    pub fn size_and_align_of_mplace(
+    pub fn mem_pos_of_mplace(
         &self,
         mplace: MPlaceTy<'tcx, M::PointerTag>
-    ) -> InterpResult<'tcx, Option<(Size, Align)>> {
-        self.size_and_align_of(mplace.meta, mplace.layout)
+    ) -> InterpResult<'tcx, Option<MemoryPosition>> {
+        self.mem_pos_of(mplace.meta, mplace.layout)
     }
 
     pub fn push_stack_frame(

src/librustc_mir/interpret/place.rs

@@ -346,8 +346,9 @@ where
         &self,
         mut place: MPlaceTy<'tcx, M::PointerTag>,
     ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>> {
-        let (size, align) = self.size_and_align_of_mplace(place)?
-            .unwrap_or((place.layout.pref_pos.size, place.layout.pref_pos.align.abi));
+        let mem_pos = self.mem_pos_of_mplace(place)?
+            .unwrap_or(place.layout.pref_pos.mem_pos());
+        let (size, align) = (mem_pos.size, mem_pos.align);
         assert!(place.mplace.align <= align, "dynamic alignment less strict than static one?");
         place.mplace.align = align; // maximally strict checking
         // When dereferencing a pointer, it must be non-NULL, aligned, and live.
@@ -407,8 +408,8 @@ where
             // Re-use parent metadata to determine dynamic field layout.
             // With custom DSTS, this *will* execute user-defined code, but the same
             // happens at run-time so that's okay.
-            let align = match self.size_and_align_of(base.meta, field_layout)? {
-                Some((_, align)) => align,
+            let align = match self.mem_pos_of(base.meta, field_layout)? {
+                Some(mem_pos) => mem_pos.align,
                 None if offset == Size::ZERO =>
                     // An extern type at offset 0, we fall back to its static alignment.
                     // FIXME: Once we have made decisions for how to handle size and alignment
@@ -989,8 +990,9 @@ where
                         // that has different alignment than the outer field.
                         // We also need to support unsized types, and hence cannot use `allocate`.
                         let local_layout = self.layout_of_local(&self.stack[frame], local, None)?;
-                        let (size, align) = self.size_and_align_of(meta, local_layout)?
+                        let mem_pos = self.mem_pos_of(meta, local_layout)?
                             .expect("Cannot allocate for non-dyn-sized type");
+                        let (size, align) = (mem_pos.size, mem_pos.align);
                         let ptr = self.memory.allocate(size, align, MemoryKind::Stack);
                         let mplace = MemPlace { ptr: ptr.into(), align, meta };
                         if let Some(value) = old_val {

src/librustc_mir/interpret/validity.rs

@@ -405,25 +405,24 @@ impl<'rt, 'mir, 'tcx, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
                     self.check_wide_ptr_meta(place.meta, place.layout)?;
                 }
                 // Make sure this is dereferencable and all.
-                let (size, align) = self.ecx.size_and_align_of(place.meta, place.layout)?
+                let mem_pos = self.ecx.mem_pos_of(place.meta, place.layout)?
                     // for the purpose of validity, consider foreign types to have
                     // alignment and size determined by the layout (size will be 0,
                     // alignment should take attributes into account).
-                    .unwrap_or_else(|| (place.layout.pref_pos.size,
-                        place.layout.pref_pos.align.abi));
+                    .unwrap_or_else(|| place.layout.pref_pos.mem_pos());
                 let ptr: Option<_> = match
                     self.ecx.memory.check_ptr_access_align(
                         place.ptr,
-                        size,
-                        Some(align),
+                        mem_pos.size,
+                        Some(mem_pos.align),
                         CheckInAllocMsg::InboundsTest,
                     )
                 {
                     Ok(ptr) => ptr,
                     Err(err) => {
                         info!(
                             "{:?} did not pass access check for size {:?}, align {:?}",
-                            place.ptr, size, align
+                            place.ptr, mem_pos.size, mem_pos.align
                         );
                         match err.kind {
                             err_unsup!(InvalidNullPointerUsage) =>
@@ -464,7 +463,7 @@ impl<'rt, 'mir, 'tcx, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
                     // `!` is a ZST and we want to validate it.
                     // Normalize before handing `place` to tracking because that will
                     // check for duplicates.
-                    let place = if size.bytes() > 0 {
+                    let place = if mem_pos.size.bytes() > 0 {
                         self.ecx.force_mplace_ptr(place)
                             .expect("we already bounds-checked")
                     } else {