Mem.[re||de]allocate

Author: Dante-Broggi

src/librustc_mir/interpret/memory.rs

@@ -11,7 +11,7 @@ use std::ptr;
 use std::borrow::Cow;
 
 use rustc::ty::{self, Instance, ParamEnv, query::TyCtxtAt};
-use rustc::ty::layout::{Align, TargetDataLayout, Size, HasDataLayout};
+use rustc::ty::layout::{Align, MemoryPosition, TargetDataLayout, Size, HasDataLayout};
 use rustc_data_structures::fx::{FxHashSet, FxHashMap};
 
 use syntax::ast::Mutability;
@@ -165,11 +165,10 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
 
     pub fn allocate(
         &mut self,
-        size: Size,
-        align: Align,
+        mem_pos: MemoryPosition,
         kind: MemoryKind<M::MemoryKinds>,
     ) -> Pointer<M::PointerTag> {
-        let alloc = Allocation::undef(size, align);
+        let alloc = Allocation::undef(mem_pos.size, mem_pos.align);
         self.allocate_with(alloc, kind)
     }
 
@@ -196,9 +195,8 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
     pub fn reallocate(
         &mut self,
         ptr: Pointer<M::PointerTag>,
-        old_size_and_align: Option<(Size, Align)>,
-        new_size: Size,
-        new_align: Align,
+        old_mem_pos: Option<MemoryPosition>,
+        new_mem_pos: MemoryPosition,
         kind: MemoryKind<M::MemoryKinds>,
     ) -> InterpResult<'tcx, Pointer<M::PointerTag>> {
         if ptr.offset.bytes() != 0 {
@@ -207,18 +205,18 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
 
         // For simplicities' sake, we implement reallocate as "alloc, copy, dealloc".
         // This happens so rarely, the perf advantage is outweighed by the maintenance cost.
-        let new_ptr = self.allocate(new_size, new_align, kind);
-        let old_size = match old_size_and_align {
-            Some((size, _align)) => size,
+        let new_ptr = self.allocate(new_mem_pos, kind);
+        let old_size = match old_mem_pos {
+            Some(old_mem_pos) => old_mem_pos.size,
             None => self.get_raw(ptr.alloc_id)?.size,
         };
         self.copy(
             ptr,
             new_ptr,
-            old_size.min(new_size),
+            old_size.min(new_mem_pos.size),
             /*nonoverlapping*/ true,
         )?;
-        self.deallocate(ptr, old_size_and_align, kind)?;
+        self.deallocate(ptr, old_mem_pos, kind)?;
 
         Ok(new_ptr)
     }
@@ -237,7 +235,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
     pub fn deallocate(
         &mut self,
         ptr: Pointer<M::PointerTag>,
-        old_size_and_align: Option<(Size, Align)>,
+        old_mem_pos: Option<MemoryPosition>,
         kind: MemoryKind<M::MemoryKinds>,
     ) -> InterpResult<'tcx> {
         trace!("deallocating: {}", ptr.alloc_id);
@@ -270,7 +268,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
                 format!("{:?}", kind),
             ))
         }
-        if let Some((size, align)) = old_size_and_align {
+        if let Some(MemoryPosition {size, align}) = old_mem_pos {
             if size != alloc.size || align != alloc.align {
                 let bytes = alloc.size;
                 throw_unsup!(IncorrectAllocationInformation(size, bytes, align, alloc.align))

src/librustc_mir/interpret/place.rs

@@ -993,7 +993,7 @@ where
                         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 ptr = self.memory.allocate(mem_pos, MemoryKind::Stack);
                         let mplace = MemPlace { ptr: ptr.into(), align, meta };
                         if let Some(value) = old_val {
                             // Preserve old value.
@@ -1030,7 +1030,7 @@ where
         layout: TyLayout<'tcx>,
         kind: MemoryKind<M::MemoryKinds>,
     ) -> MPlaceTy<'tcx, M::PointerTag> {
-        let ptr = self.memory.allocate(layout.pref_pos.size, layout.pref_pos.align.abi, kind);
+        let ptr = self.memory.allocate(layout.pref_pos.mem_pos(), kind);
         MPlaceTy::from_aligned_ptr(ptr, layout)
     }
 

src/librustc_mir/interpret/traits.rs

@@ -47,15 +47,14 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         let size = layout.pref_pos.size.bytes();
         let align = layout.pref_pos.align.abi.bytes();
 
-        let ptr_pref_pos = self.pointer_pos();
+        let ptr_mem_pos = self.tcx.data_layout.pointer_pos.mem_pos();
 
         // /////////////////////////////////////////////////////////////////////////////////////////
         // If you touch this code, be sure to also make the corresponding changes to
         // `get_vtable` in rust_codegen_llvm/meth.rs
         // /////////////////////////////////////////////////////////////////////////////////////////
         let vtable = self.memory.allocate(
-            (ptr_pref_pos * (3 + methods.len() as u64)).size,
-            ptr_pref_pos.align.abi,
+            ptr_mem_pos * (3 + methods.len() as u64),
             MemoryKind::Vtable,
         );
         let tcx = &*self.tcx;
@@ -69,12 +68,12 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         let vtable_alloc = self.memory.get_raw_mut(vtable.alloc_id)?;
         vtable_alloc.write_ptr_sized(tcx, vtable, Scalar::Ptr(drop).into())?;
 
-        let size_ptr = vtable.offset(ptr_pref_pos.size, tcx)?;
+        let size_ptr = vtable.offset(ptr_mem_pos.size, tcx)?;
         vtable_alloc.write_ptr_sized(tcx, size_ptr,
-            Scalar::from_uint(size, ptr_pref_pos.size).into())?;
-        let align_ptr = vtable.offset((ptr_pref_pos * 2).size, tcx)?;
+            Scalar::from_uint(size, ptr_mem_pos.size).into())?;
+        let align_ptr = vtable.offset((ptr_mem_pos * 2).size, tcx)?;
         vtable_alloc.write_ptr_sized(tcx, align_ptr,
-            Scalar::from_uint(align, ptr_pref_pos.size).into())?;
+            Scalar::from_uint(align, ptr_mem_pos.size).into())?;
 
         for (i, method) in methods.iter().enumerate() {
             if let Some((def_id, substs)) = *method {
@@ -87,7 +86,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 ).ok_or_else(|| err_inval!(TooGeneric))?;
                 let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
                 // We cannot use `vtable_allic` as we are creating fn ptrs in this loop.
-                let method_ptr = vtable.offset((ptr_pref_pos * (3 + i as u64)).size, tcx)?;
+                let method_ptr = vtable.offset((ptr_mem_pos * (3 + i as u64)).size, tcx)?;
                 self.memory.get_raw_mut(vtable.alloc_id)?
                     .write_ptr_sized(tcx, method_ptr, Scalar::Ptr(fn_ptr).into())?;
             }