dl.pointer_pos && d.vector_align

Author: Dante-Broggi

src/librustc/mir/interpret/allocation.rs

@@ -398,7 +398,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {
         // Now we do the actual reading.
         let bits = read_target_uint(cx.data_layout().endian, bytes).unwrap();
         // See if we got a pointer.
-        if size != cx.data_layout().pointer_size {
+        if size != cx.data_layout().pointer_pos.size {
             // *Now*, we better make sure that the inside is free of relocations too.
             self.check_relocations(cx, ptr, size)?;
         } else {
@@ -424,7 +424,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {
         ptr: Pointer<Tag>,
     ) -> InterpResult<'tcx, ScalarMaybeUndef<Tag>>
     {
-        self.read_scalar(cx, ptr, cx.data_layout().pointer_size)
+        self.read_scalar(cx, ptr, cx.data_layout().pointer_pos.size)
     }
 
     /// Writes a *non-ZST* scalar.
@@ -486,7 +486,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {
         val: ScalarMaybeUndef<Tag>
     ) -> InterpResult<'tcx>
     {
-        let ptr_size = cx.data_layout().pointer_size;
+        let ptr_size = cx.data_layout().pointer_pos.size;
         self.write_scalar(cx, ptr.into(), val, ptr_size)
     }
 }
@@ -500,9 +500,10 @@ impl<'tcx, Tag: Copy, Extra> Allocation<Tag, Extra> {
         ptr: Pointer<Tag>,
         size: Size,
     ) -> &[(Size, (Tag, AllocId))] {
+        let ptr_pos = cx.data_layout().pointer_pos;
         // We have to go back `pointer_size - 1` bytes, as that one would still overlap with
         // the beginning of this range.
-        let start = ptr.offset.bytes().saturating_sub(cx.data_layout().pointer_size.bytes() - 1);
+        let start = ptr.offset.bytes().saturating_sub(ptr_pos.size.bytes() - 1);
         let end = ptr.offset + size; // This does overflow checking.
         self.relocations.range(Size::from_bytes(start)..end)
     }
@@ -543,7 +544,7 @@ impl<'tcx, Tag: Copy, Extra> Allocation<Tag, Extra> {
             }
 
             (relocations.first().unwrap().0,
-             relocations.last().unwrap().0 + cx.data_layout().pointer_size)
+             relocations.last().unwrap().0 + cx.data_layout().pointer_pos.size)
         };
         let start = ptr.offset;
         let end = start + size;

src/librustc/mir/interpret/pointer.rs

@@ -37,7 +37,7 @@ pub trait PointerArithmetic: layout::HasDataLayout {
 
     #[inline(always)]
     fn pointer_size(&self) -> Size {
-        self.data_layout().pointer_size
+        self.data_layout().pointer_pos.size
     }
 
     /// Helper function: truncate given value-"overflowed flag" pair to pointer size and

src/librustc/mir/interpret/value.rs

@@ -191,7 +191,7 @@ impl<'tcx, Tag> Scalar<Tag> {
     pub fn ptr_null(cx: &impl HasDataLayout) -> Self {
         Scalar::Raw {
             data: 0,
-            size: cx.data_layout().pointer_size.bytes() as u8,
+            size: cx.data_layout().pointer_pos.size.bytes() as u8,
         }
     }
 
@@ -205,7 +205,7 @@ impl<'tcx, Tag> Scalar<Tag> {
         let dl = cx.data_layout();
         match self {
             Scalar::Raw { data, size } => {
-                assert_eq!(size as u64, dl.pointer_size.bytes());
+                assert_eq!(size as u64, dl.pointer_pos.size.bytes());
                 Ok(Scalar::Raw {
                     data: dl.offset(data as u64, i.bytes())? as u128,
                     size,
@@ -220,7 +220,7 @@ impl<'tcx, Tag> Scalar<Tag> {
         let dl = cx.data_layout();
         match self {
             Scalar::Raw { data, size } => {
-                assert_eq!(size as u64, dl.pointer_size.bytes());
+                assert_eq!(size as u64, dl.pointer_pos.size.bytes());
                 Scalar::Raw {
                     data: dl.overflowing_offset(data as u64, i.bytes()).0 as u128,
                     size,
@@ -250,7 +250,7 @@ impl<'tcx, Tag> Scalar<Tag> {
         let dl = cx.data_layout();
         match self {
             Scalar::Raw { data, size } => {
-                assert_eq!(size as u64, dl.pointer_size.bytes());
+                assert_eq!(size as u64, dl.pointer_pos.size.bytes());
                 Scalar::Raw {
                     data: dl.overflowing_signed_offset(data as u64, i128::from(i)).0 as u128,
                     size,
@@ -342,7 +342,7 @@ impl<'tcx, Tag> Scalar<Tag> {
                 Ok(data)
             }
             Scalar::Ptr(ptr) => {
-                assert_eq!(target_size, cx.data_layout().pointer_size);
+                assert_eq!(target_size, cx.data_layout().pointer_pos.size);
                 Err(ptr)
             }
         }
@@ -440,7 +440,7 @@ impl<'tcx, Tag> Scalar<Tag> {
     }
 
     pub fn to_machine_usize(self, cx: &impl HasDataLayout) -> InterpResult<'static, u64> {
-        let b = self.to_bits(cx.data_layout().pointer_size)?;
+        let b = self.to_bits(cx.data_layout().pointer_pos.size)?;
         Ok(b as u64)
     }
 
@@ -466,7 +466,7 @@ impl<'tcx, Tag> Scalar<Tag> {
     }
 
     pub fn to_machine_isize(self, cx: &impl HasDataLayout) -> InterpResult<'static, i64> {
-        let sz = cx.data_layout().pointer_size;
+        let sz = cx.data_layout().pointer_pos.size;
         let b = self.to_bits(sz)?;
         let b = sign_extend(b, sz) as i128;
         Ok(b as i64)

src/librustc_codegen_llvm/common.rs

@@ -202,7 +202,7 @@ impl ConstMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     }
 
     fn const_usize(&self, i: u64) -> &'ll Value {
-        let bit_size = self.data_layout().pointer_size.bits();
+        let bit_size = self.data_layout().pointer_pos.size.bits();
         if bit_size < 64 {
             // make sure it doesn't overflow
             assert!(i < (1<<bit_size));

src/librustc_codegen_llvm/consts.rs

@@ -26,7 +26,7 @@ use std::ffi::{CStr, CString};
 pub fn const_alloc_to_llvm(cx: &CodegenCx<'ll, '_>, alloc: &Allocation) -> &'ll Value {
     let mut llvals = Vec::with_capacity(alloc.relocations().len() + 1);
     let dl = cx.data_layout();
-    let pointer_size = dl.pointer_size.bytes() as usize;
+    let pointer_size = dl.pointer_pos.size.bytes() as usize;
 
     let mut next_offset = 0;
     for &(offset, ((), alloc_id)) in alloc.relocations().iter() {

src/librustc_codegen_llvm/context.rs

@@ -288,7 +288,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
             None
         };
 
-        let isize_ty = Type::ix_llcx(llcx, tcx.data_layout.pointer_size.bits());
+        let isize_ty = Type::ix_llcx(llcx, tcx.data_layout.pointer_pos.size.bits());
 
         CodegenCx {
             tcx,

src/librustc_codegen_llvm/debuginfo/metadata.rs

@@ -2304,7 +2304,7 @@ pub fn create_vtable_metadata(cx: &CodegenCx<'ll, 'tcx>, ty: Ty<'tcx>, vtable: &
             unknown_file_metadata(cx),
             UNKNOWN_LINE_NUMBER,
             Size::ZERO.bits(),
-            cx.tcx.data_layout.pointer_align.abi.bits() as u32,
+            cx.tcx.data_layout.pointer_pos.align.abi.bits() as u32,
             DIFlags::FlagArtificial,
             None,
             empty_array,

src/librustc_codegen_llvm/intrinsic.rs

@@ -810,7 +810,7 @@ fn try_intrinsic(
 ) {
     if bx.sess().no_landing_pads() {
         bx.call(func, &[data], None);
-        let ptr_align = bx.tcx().data_layout.pointer_align.abi;
+        let ptr_align = bx.tcx().data_layout.pointer_pos.align.abi;
         bx.store(bx.const_null(bx.type_i8p()), dest, ptr_align);
     } else if wants_msvc_seh(bx.sess()) {
         codegen_msvc_try(bx, func, data, local_ptr, dest);
@@ -984,7 +984,7 @@ fn codegen_gnu_try(
         };
         catch.add_clause(vals, tydesc);
         let ptr = catch.extract_value(vals, 0);
-        let ptr_align = bx.tcx().data_layout.pointer_align.abi;
+        let ptr_align = bx.tcx().data_layout.pointer_pos.align.abi;
         let bitcast = catch.bitcast(local_ptr, bx.type_ptr_to(bx.type_i8p()));
         catch.store(ptr, bitcast, ptr_align);
         catch.ret(bx.const_i32(1));
@@ -1262,11 +1262,11 @@ fn generic_simd_intrinsic(
         let (i_xn, in_elem_bitwidth) = match in_elem.kind {
             ty::Int(i) => (
                 args[0].immediate(),
-                i.bit_width().unwrap_or(bx.data_layout().pointer_size.bits() as _)
+                i.bit_width().unwrap_or(bx.data_layout().pointer_pos.size.bits() as _)
             ),
             ty::Uint(i) => (
                 args[0].immediate(),
-                i.bit_width().unwrap_or(bx.data_layout().pointer_size.bits() as _)
+                i.bit_width().unwrap_or(bx.data_layout().pointer_pos.size.bits() as _)
             ),
             _ => return_error!(
                 "vector argument `{}`'s element type `{}`, expected integer element type",
@@ -1876,7 +1876,7 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,
         let lhs = args[0].immediate();
         let rhs = args[1].immediate();
         let is_add = name == "simd_saturating_add";
-        let ptr_bits = bx.tcx().data_layout.pointer_size.bits() as _;
+        let ptr_bits = bx.tcx().data_layout.pointer_pos.size.bits() as _;
         let (signed, elem_width, elem_ty) = match in_elem.kind {
             ty::Int(i) =>
                 (

src/librustc_codegen_llvm/va_arg.rs

@@ -36,7 +36,7 @@ fn emit_direct_ptr_va_arg(
         list.immediate()
     };
 
-    let ptr = bx.load(va_list_addr, bx.tcx().data_layout.pointer_align.abi);
+    let ptr = bx.load(va_list_addr, bx.tcx().data_layout.pointer_pos.align.abi);
 
     let (addr, addr_align) = if allow_higher_align && align > slot_size {
         (round_pointer_up_to_alignment(bx, ptr, align, bx.cx().type_i8p()), align)
@@ -48,7 +48,7 @@ fn emit_direct_ptr_va_arg(
     let aligned_size = size.align_to(slot_size).bytes() as i32;
     let full_direct_size = bx.cx().const_i32(aligned_size);
     let next = bx.inbounds_gep(addr, &[full_direct_size]);
-    bx.store(next, va_list_addr, bx.tcx().data_layout.pointer_align.abi);
+    bx.store(next, va_list_addr, bx.tcx().data_layout.pointer_pos.align.abi);
 
     if size.bytes() < slot_size.bytes() &&
             &*bx.tcx().sess.target.target.target_endian == "big" {
@@ -71,8 +71,8 @@ fn emit_ptr_va_arg(
     let layout = bx.cx.layout_of(target_ty);
     let (llty, size, align) = if indirect {
         (bx.cx.layout_of(bx.cx.tcx.mk_imm_ptr(target_ty)).llvm_type(bx.cx),
-         bx.cx.data_layout().pointer_size,
-         bx.cx.data_layout().pointer_align)
+         bx.cx.data_layout().pointer_pos.size,
+         bx.cx.data_layout().pointer_pos.align)
     } else {
         (layout.llvm_type(bx.cx),
          layout.size,

src/librustc_codegen_ssa/meth.rs

@@ -29,7 +29,7 @@ impl<'a, 'tcx> VirtualIndex {
             llvtable,
             bx.type_ptr_to(bx.fn_ptr_backend_type(fn_abi))
         );
-        let ptr_align = bx.tcx().data_layout.pointer_align.abi;
+        let ptr_align = bx.tcx().data_layout.pointer_pos.align.abi;
         let gep = bx.inbounds_gep(llvtable, &[bx.const_usize(self.0)]);
         let ptr = bx.load(gep, ptr_align);
         bx.nonnull_metadata(ptr);
@@ -47,7 +47,7 @@ impl<'a, 'tcx> VirtualIndex {
         debug!("get_int({:?}, {:?})", llvtable, self);
 
         let llvtable = bx.pointercast(llvtable, bx.type_ptr_to(bx.type_isize()));
-        let usize_align = bx.tcx().data_layout.pointer_align.abi;
+        let usize_align = bx.tcx().data_layout.pointer_pos.align.abi;
         let gep = bx.inbounds_gep(llvtable, &[bx.const_usize(self.0)]);
         let ptr = bx.load(gep, usize_align);
         // Vtable loads are invariant
@@ -114,7 +114,7 @@ pub fn get_vtable<'tcx, Cx: CodegenMethods<'tcx>>(
     ].iter().cloned().chain(methods).collect();
 
     let vtable_const = cx.const_struct(&components, false);
-    let align = cx.data_layout().pointer_align.abi;
+    let align = cx.data_layout().pointer_pos.align.abi;
     let vtable = cx.static_addr_of(vtable_const, align, Some("vtable"));
 
     cx.create_vtable_metadata(ty, vtable);