add Allocation::mem_pos

Author: Dante-Broggi

src/librustc/mir/interpret/allocation.rs

@@ -39,10 +39,9 @@ pub struct Allocation<Tag = (),Extra = ()> {
     relocations: Relocations<Tag>,
     /// Denotes which part of this allocation is initialized.
     undef_mask: UndefMask,
-    /// The size of the allocation. Currently, must always equal `bytes.len()`.
-    pub size: Size,
-    /// The alignment of the allocation to detect unaligned reads.
-    pub align: Align,
+    /// The position of the allocation.
+    /// Currently, the size must always equal `bytes.len()`.
+    pub mem_pos: MemoryPosition,
     /// `true` if the allocation is mutable.
     /// Also used by codegen to determine if a static should be put into mutable memory,
     /// which happens for `static mut` and `static` with interior mutability.
@@ -101,12 +100,12 @@ impl<Tag> Allocation<Tag> {
     pub fn from_bytes<'a>(slice: impl Into<Cow<'a, [u8]>>, align: Align) -> Self {
         let bytes = slice.into().into_owned();
         let size = Size::from_bytes(bytes.len() as u64);
+        let mem_pos = MemoryPosition::new(size, align);
         Self {
             bytes,
             relocations: Relocations::new(),
             undef_mask: UndefMask::new(size, true),
-            size,
-            align,
+            mem_pos,
             mutability: Mutability::Immutable,
             extra: (),
         }
@@ -122,8 +121,7 @@ impl<Tag> Allocation<Tag> {
             bytes: vec![0; mem_pos.size.bytes() as usize],
             relocations: Relocations::new(),
             undef_mask: UndefMask::new(mem_pos.size, false),
-            size: mem_pos.size,
-            align: mem_pos.align,
+            mem_pos: mem_pos,
             mutability: Mutability::Mutable,
             extra: (),
         }
@@ -139,7 +137,6 @@ impl Allocation<(), ()> {
     ) -> Allocation<T, E> {
         Allocation {
             bytes: self.bytes,
-            size: self.size,
             relocations: Relocations::from_presorted(
                 self.relocations.iter()
                     // The allocations in the relocations (pointers stored *inside* this allocation)
@@ -151,7 +148,7 @@ impl Allocation<(), ()> {
                     .collect()
             ),
             undef_mask: self.undef_mask,
-            align: self.align,
+            mem_pos: self.mem_pos,
             mutability: self.mutability,
             extra,
         }
@@ -161,7 +158,7 @@ impl Allocation<(), ()> {
 /// Raw accessors. Provide access to otherwise private bytes.
 impl<Tag, Extra> Allocation<Tag, Extra> {
     pub fn len(&self) -> usize {
-        self.size.bytes() as usize
+        self.mem_pos.size.bytes() as usize
     }
 
     /// Looks at a slice which may describe undefined bytes or describe a relocation. This differs

src/librustc_codegen_llvm/common.rs

@@ -280,9 +280,9 @@ impl ConstMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                     Some(GlobalAlloc::Memory(alloc)) => {
                         let init = const_alloc_to_llvm(self, alloc);
                         if alloc.mutability == Mutability::Mutable {
-                            self.static_addr_of_mut(init, alloc.align, None)
+                            self.static_addr_of_mut(init, alloc.mem_pos.align, None)
                         } else {
-                            self.static_addr_of(init, alloc.align, None)
+                            self.static_addr_of(init, alloc.mem_pos.align, None)
                         }
                     }
                     Some(GlobalAlloc::Function(fn_instance)) => {
@@ -314,14 +314,14 @@ impl ConstMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         alloc: &Allocation,
         offset: Size,
     ) -> PlaceRef<'tcx, &'ll Value> {
-        assert_eq!(alloc.align, layout.pref_pos.align.abi);
+        assert_eq!(alloc.mem_pos.align, layout.pref_pos.align.abi);
         let llty = self.type_ptr_to(layout.llvm_type(self));
         let llval = if layout.pref_pos.size == Size::ZERO {
-            let llval = self.const_usize(alloc.align.bytes());
+            let llval = self.const_usize(alloc.mem_pos.align.bytes());
             unsafe { llvm::LLVMConstIntToPtr(llval, llty) }
         } else {
             let init = const_alloc_to_llvm(self, alloc);
-            let base_addr = self.static_addr_of(init, alloc.align, None);
+            let base_addr = self.static_addr_of(init, alloc.mem_pos.align, None);
 
             let llval = unsafe { llvm::LLVMConstInBoundsGEP(
                 self.const_bitcast(base_addr, self.type_i8p()),

src/librustc_mir/interpret/memory.rs

@@ -208,7 +208,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         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,
+            None => self.get_raw(ptr.alloc_id)?.mem_pos.size,
         };
         self.copy(
             ptr,
@@ -268,21 +268,23 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
                 format!("{:?}", kind),
             ))
         }
+
+        let bytes_mem_pos = alloc.mem_pos;
+
         if let Some(mem_pos) = old_mem_pos {
-            if mem_pos != MemoryPosition::new(alloc.size, alloc.align) {
-                let got_mem_pos = MemoryPosition::new(alloc.size, alloc.align);
-                throw_unsup!(IncorrectAllocationInformation(mem_pos, got_mem_pos))
+            if mem_pos != bytes_mem_pos {
+                throw_unsup!(IncorrectAllocationInformation(mem_pos, bytes_mem_pos))
             }
         }
 
         // Let the machine take some extra action
-        let size = alloc.size;
+        let size = alloc.mem_pos.size;
         AllocationExtra::memory_deallocated(&mut alloc, ptr, size)?;
 
         // Don't forget to remember size and align of this now-dead allocation
         let old = self.dead_alloc_map.insert(
             ptr.alloc_id,
-            (alloc.size, alloc.align)
+            (alloc.mem_pos.size, alloc.mem_pos.align)
         );
         if old.is_some() {
             bug!("Nothing can be deallocated twice");
@@ -561,7 +563,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         // a) cause cycles in case `id` refers to a static
         // b) duplicate a static's allocation in miri
         if let Some((_, alloc)) = self.alloc_map.get(id) {
-            return Ok((alloc.size, alloc.align));
+            return Ok((alloc.mem_pos.size, alloc.mem_pos.align));
         }
 
         // # Function pointers
@@ -589,7 +591,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
             Some(GlobalAlloc::Memory(alloc)) =>
                 // Need to duplicate the logic here, because the global allocations have
                 // different associated types than the interpreter-local ones.
-                Ok((alloc.size, alloc.align)),
+                Ok((alloc.mem_pos.size, alloc.mem_pos.align)),
             Some(GlobalAlloc::Function(_)) =>
                 bug!("We already checked function pointers above"),
             // The rest must be dead.
@@ -651,7 +653,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         let prefix_len = msg.len();
         let mut relocations = vec![];
 
-        for i in 0..alloc.size.bytes() {
+        for i in 0..alloc.mem_pos.size.bytes() {
             let i = Size::from_bytes(i);
             if let Some(&(_, target_id)) = alloc.relocations().get(&i) {
                 if allocs_seen.insert(target_id) {
@@ -675,8 +677,8 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         trace!(
             "{}({} bytes, alignment {}){}",
             msg,
-            alloc.size.bytes(),
-            alloc.align.bytes(),
+            alloc.mem_pos.size.bytes(),
+            alloc.mem_pos.align.bytes(),
             extra
         );
 

src/librustc_mir/interpret/snapshot.rs

@@ -15,7 +15,7 @@ use rustc::mir::interpret::{
 };
 
 use rustc::ty::{self, TyCtxt};
-use rustc::ty::layout::{Align, Size};
+use rustc::ty::layout::MemoryPosition;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_index::vec::IndexVec;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
@@ -275,8 +275,7 @@ struct AllocationSnapshot<'a> {
     bytes: &'a [u8],
     relocations: Relocations<(), AllocIdSnapshot<'a>>,
     undef_mask: &'a UndefMask,
-    align: &'a Align,
-    size: &'a Size,
+    mem_pos: &'a MemoryPosition,
     mutability: &'a Mutability,
 }
 
@@ -287,8 +286,7 @@ impl<'a, Ctx> Snapshot<'a, Ctx> for &'a Allocation
 
     fn snapshot(&self, ctx: &'a Ctx) -> Self::Item {
         let Allocation {
-            size,
-            align,
+            mem_pos,
             mutability,
             extra: (),
             ..
@@ -306,8 +304,7 @@ impl<'a, Ctx> Snapshot<'a, Ctx> for &'a Allocation
         AllocationSnapshot {
             bytes,
             undef_mask,
-            align,
-            size,
+            mem_pos,
             mutability,
             relocations: relocations.snapshot(ctx),
         }

src/librustc_target/abi/mod.rs

@@ -601,6 +601,8 @@ impl AddAssign for LayoutPositionPref {
 /// An aligned size.
 /// Better name appreciated.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)]
+// I am opposed to adding these, therefore they are in a separate section, and this note.
+#[derive(PartialOrd, Ord)]
 pub struct MemoryPosition {
     /// A size not rounded up to alignment
     pub size: Size,