rustc_trans: always keep track of the Align in LvalueRef.

Author: eddyb

src/librustc_trans/abi.rs

@@ -30,7 +30,7 @@ use cabi_sparc64;
 use cabi_nvptx;
 use cabi_nvptx64;
 use cabi_hexagon;
-use mir::place::{Alignment, PlaceRef};
+use mir::place::PlaceRef;
 use mir::operand::OperandValue;
 use type_::Type;
 use type_of::{LayoutLlvmExt, PointerKind};
@@ -561,7 +561,7 @@ impl<'a, 'tcx> ArgType<'tcx> {
         }
         let ccx = bcx.ccx;
         if self.is_indirect() {
-            OperandValue::Ref(val, Alignment::AbiAligned).store(bcx, dst)
+            OperandValue::Ref(val, self.layout.align).store(bcx, dst)
         } else if let PassMode::Cast(cast) = self.mode {
             // FIXME(eddyb): Figure out when the simpler Store is safe, clang
             // uses it for i16 -> {i8, i8}, but not for i24 -> {i8, i8, i8}.

src/librustc_trans/base.rs

@@ -316,7 +316,7 @@ pub fn coerce_unsized_into<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
 
                 if src_f.layout.ty == dst_f.layout.ty {
                     memcpy_ty(bcx, dst_f.llval, src_f.llval, src_f.layout,
-                        (src_f.alignment | dst_f.alignment).non_abi());
+                        Some(src_f.align.min(dst_f.align)));
                 } else {
                     coerce_unsized_into(bcx, src_f, dst_f);
                 }

src/librustc_trans/intrinsic.rs

@@ -14,7 +14,7 @@ use intrinsics::{self, Intrinsic};
 use llvm;
 use llvm::{ValueRef};
 use abi::{Abi, FnType, PassMode};
-use mir::place::{PlaceRef, Alignment};
+use mir::place::PlaceRef;
 use mir::operand::{OperandRef, OperandValue};
 use base::*;
 use common::*;
@@ -106,7 +106,7 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
     let name = &*tcx.item_name(def_id);
 
     let llret_ty = ccx.layout_of(ret_ty).llvm_type(ccx);
-    let result = PlaceRef::new_sized(llresult, fn_ty.ret.layout, Alignment::AbiAligned);
+    let result = PlaceRef::new_sized(llresult, fn_ty.ret.layout, fn_ty.ret.layout.align);
 
     let simple = get_simple_intrinsic(ccx, name);
     let llval = match name {
@@ -254,7 +254,7 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
                 bcx.volatile_store(b, dst.project_field(bcx, 1).llval);
             } else {
                 let val = if let OperandValue::Ref(ptr, align) = args[1].val {
-                    bcx.load(ptr, align.non_abi())
+                    bcx.load(ptr, Some(align))
                 } else {
                     if dst.layout.is_zst() {
                         return;
@@ -330,9 +330,9 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
                             let overflow = bcx.zext(bcx.extract_value(pair, 1), Type::bool(ccx));
 
                             let dest = result.project_field(bcx, 0);
-                            bcx.store(val, dest.llval, dest.alignment.non_abi());
+                            bcx.store(val, dest.llval, dest.non_abi_align());
                             let dest = result.project_field(bcx, 1);
-                            bcx.store(overflow, dest.llval, dest.alignment.non_abi());
+                            bcx.store(overflow, dest.llval, dest.non_abi_align());
 
                             return;
                         },
@@ -473,9 +473,9 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
                         let success = bcx.zext(bcx.extract_value(pair, 1), Type::bool(bcx.ccx));
 
                         let dest = result.project_field(bcx, 0);
-                        bcx.store(val, dest.llval, dest.alignment.non_abi());
+                        bcx.store(val, dest.llval, dest.non_abi_align());
                         let dest = result.project_field(bcx, 1);
-                        bcx.store(success, dest.llval, dest.alignment.non_abi());
+                        bcx.store(success, dest.llval, dest.non_abi_align());
                         return;
                     } else {
                         return invalid_monomorphization(ty);
@@ -544,7 +544,7 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
             let tp_ty = substs.type_at(0);
             let dst = args[0].deref(bcx.ccx);
             let val = if let OperandValue::Ref(ptr, align) = args[1].val {
-                bcx.load(ptr, align.non_abi())
+                bcx.load(ptr, Some(align))
             } else {
                 from_immediate(bcx, args[1].immediate())
             };
@@ -677,7 +677,7 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
                     for i in 0..elems.len() {
                         let dest = result.project_field(bcx, i);
                         let val = bcx.extract_value(val, i as u64);
-                        bcx.store(val, dest.llval, dest.alignment.non_abi());
+                        bcx.store(val, dest.llval, dest.non_abi_align());
                     }
                     return;
                 }

src/librustc_trans/mir/block.rs

@@ -31,7 +31,7 @@ use syntax_pos::Pos;
 
 use super::{MirContext, LocalRef};
 use super::constant::Const;
-use super::place::{Alignment, PlaceRef};
+use super::place::PlaceRef;
 use super::operand::OperandRef;
 use super::operand::OperandValue::{Pair, Ref, Immediate};
 
@@ -216,7 +216,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                     PassMode::Direct(_) | PassMode::Pair(..) => {
                         let op = self.trans_consume(&bcx, &mir::Place::Local(mir::RETURN_PLACE));
                         if let Ref(llval, align) = op.val {
-                            bcx.load(llval, align.non_abi())
+                            bcx.load(llval, Some(align))
                         } else {
                             op.immediate_or_packed_pair(&bcx)
                         }
@@ -228,7 +228,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                             LocalRef::Operand(None) => bug!("use of return before def"),
                             LocalRef::Place(tr_place) => {
                                 OperandRef {
-                                    val: Ref(tr_place.llval, tr_place.alignment),
+                                    val: Ref(tr_place.llval, tr_place.align),
                                     layout: tr_place.layout
                                 }
                             }
@@ -240,7 +240,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                                 scratch.llval
                             }
                             Ref(llval, align) => {
-                                assert_eq!(align, Alignment::AbiAligned,
+                                assert_eq!(align.abi(), op.layout.align.abi(),
                                            "return place is unaligned!");
                                 llval
                             }
@@ -579,7 +579,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                         (&mir::Operand::Constant(_), Ref(..)) => {
                             let tmp = PlaceRef::alloca(&bcx, op.layout, "const");
                             op.val.store(&bcx, tmp);
-                            op.val = Ref(tmp.llval, tmp.alignment);
+                            op.val = Ref(tmp.llval, tmp.align);
                         }
                         _ => {}
                     }
@@ -639,38 +639,40 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                     PassMode::Indirect(_) | PassMode::Cast(_) => {
                         let scratch = PlaceRef::alloca(bcx, arg.layout, "arg");
                         op.val.store(bcx, scratch);
-                        (scratch.llval, Alignment::AbiAligned, true)
+                        (scratch.llval, scratch.align, true)
                     }
                     _ => {
-                        (op.immediate_or_packed_pair(bcx), Alignment::AbiAligned, false)
+                        (op.immediate_or_packed_pair(bcx), arg.layout.align, false)
                     }
                 }
             }
-            Ref(llval, align @ Alignment::Packed(_)) if arg.is_indirect() => {
-                // `foo(packed.large_field)`. We can't pass the (unaligned) field directly. I
-                // think that ATM (Rust 1.16) we only pass temporaries, but we shouldn't
-                // have scary latent bugs around.
-
-                let scratch = PlaceRef::alloca(bcx, arg.layout, "arg");
-                base::memcpy_ty(bcx, scratch.llval, llval, op.layout, align.non_abi());
-                (scratch.llval, Alignment::AbiAligned, true)
+            Ref(llval, align) => {
+                if arg.is_indirect() && align.abi() < arg.layout.align.abi() {
+                    // `foo(packed.large_field)`. We can't pass the (unaligned) field directly. I
+                    // think that ATM (Rust 1.16) we only pass temporaries, but we shouldn't
+                    // have scary latent bugs around.
+
+                    let scratch = PlaceRef::alloca(bcx, arg.layout, "arg");
+                    base::memcpy_ty(bcx, scratch.llval, llval, op.layout, Some(align));
+                    (scratch.llval, scratch.align, true)
+                } else {
+                    (llval, align, true)
+                }
             }
-            Ref(llval, align) => (llval, align, true)
         };
 
         if by_ref && !arg.is_indirect() {
             // Have to load the argument, maybe while casting it.
             if let PassMode::Cast(ty) = arg.mode {
                 llval = bcx.load(bcx.pointercast(llval, ty.llvm_type(bcx.ccx).ptr_to()),
-                                 (align | Alignment::Packed(arg.layout.align))
-                                    .non_abi());
+                                 Some(align.min(arg.layout.align)));
             } else {
                 // We can't use `PlaceRef::load` here because the argument
                 // may have a type we don't treat as immediate, but the ABI
                 // used for this call is passing it by-value. In that case,
                 // the load would just produce `OperandValue::Ref` instead
                 // of the `OperandValue::Immediate` we need for the call.
-                llval = bcx.load(llval, align.non_abi());
+                llval = bcx.load(llval, Some(align));
                 if let layout::Abi::Scalar(ref scalar) = arg.layout.abi {
                     if scalar.is_bool() {
                         bcx.range_metadata(llval, 0..2);
@@ -820,21 +822,17 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
             self.trans_place(bcx, dest)
         };
         if fn_ret.is_indirect() {
-            match dest.alignment {
-                Alignment::AbiAligned => {
-                    llargs.push(dest.llval);
-                    ReturnDest::Nothing
-                },
-                Alignment::Packed(_) => {
-                    // Currently, MIR code generation does not create calls
-                    // that store directly to fields of packed structs (in
-                    // fact, the calls it creates write only to temps),
-                    //
-                    // If someone changes that, please update this code path
-                    // to create a temporary.
-                    span_bug!(self.mir.span, "can't directly store to unaligned value");
-                }
+            if dest.align.abi() < dest.layout.align.abi() {
+                // Currently, MIR code generation does not create calls
+                // that store directly to fields of packed structs (in
+                // fact, the calls it creates write only to temps),
+                //
+                // If someone changes that, please update this code path
+                // to create a temporary.
+                span_bug!(self.mir.span, "can't directly store to unaligned value");
             }
+            llargs.push(dest.llval);
+            ReturnDest::Nothing
         } else {
             ReturnDest::Store(dest)
         }
@@ -874,8 +872,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
         let llty = src.layout.llvm_type(bcx.ccx);
         let cast_ptr = bcx.pointercast(dst.llval, llty.ptr_to());
         let align = src.layout.align.min(dst.layout.align);
-        src.val.store(bcx,
-            PlaceRef::new_sized(cast_ptr, src.layout, Alignment::Packed(align)));
+        src.val.store(bcx, PlaceRef::new_sized(cast_ptr, src.layout, align));
     }
 
 

src/librustc_trans/mir/constant.rs

@@ -42,7 +42,6 @@ use syntax::ast;
 use std::fmt;
 use std::ptr;
 
-use super::place::Alignment;
 use super::operand::{OperandRef, OperandValue};
 use super::MirContext;
 
@@ -182,12 +181,12 @@ impl<'a, 'tcx> Const<'tcx> {
             let align = ccx.align_of(self.ty);
             let ptr = consts::addr_of(ccx, self.llval, align, "const");
             OperandValue::Ref(consts::ptrcast(ptr, layout.llvm_type(ccx).ptr_to()),
-                              Alignment::AbiAligned)
+                              layout.align)
         };
 
         OperandRef {
             val,
-            layout: ccx.layout_of(self.ty)
+            layout
         }
     }
 }

src/librustc_trans/mir/mod.rs

@@ -35,7 +35,7 @@ use rustc_data_structures::indexed_vec::{IndexVec, Idx};
 pub use self::constant::trans_static_initializer;
 
 use self::analyze::CleanupKind;
-use self::place::{Alignment, PlaceRef};
+use self::place::PlaceRef;
 use rustc::mir::traversal;
 
 use self::operand::{OperandRef, OperandValue};
@@ -279,9 +279,7 @@ pub fn trans_mir<'a, 'tcx: 'a>(
                 if local == mir::RETURN_PLACE && mircx.fn_ty.ret.is_indirect() {
                     debug!("alloc: {:?} (return place) -> place", local);
                     let llretptr = llvm::get_param(llfn, 0);
-                    LocalRef::Place(PlaceRef::new_sized(llretptr,
-                                                          layout,
-                                                          Alignment::AbiAligned))
+                    LocalRef::Place(PlaceRef::new_sized(llretptr, layout, layout.align))
                 } else if memory_locals.contains(local.index()) {
                     debug!("alloc: {:?} -> place", local);
                     LocalRef::Place(PlaceRef::alloca(&bcx, layout, &format!("{:?}", local)))
@@ -474,7 +472,7 @@ fn arg_local_refs<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
             let llarg = llvm::get_param(bcx.llfn(), llarg_idx as c_uint);
             bcx.set_value_name(llarg, &name);
             llarg_idx += 1;
-            PlaceRef::new_sized(llarg, arg.layout, Alignment::AbiAligned)
+            PlaceRef::new_sized(llarg, arg.layout, arg.layout.align)
         } else {
             let tmp = PlaceRef::alloca(bcx, arg.layout, &name);
             arg.store_fn_arg(bcx, &mut llarg_idx, tmp);

src/librustc_trans/mir/operand.rs

@@ -10,7 +10,7 @@
 
 use llvm::ValueRef;
 use rustc::ty;
-use rustc::ty::layout::{self, LayoutOf, TyLayout};
+use rustc::ty::layout::{self, Align, LayoutOf, TyLayout};
 use rustc::mir;
 use rustc_data_structures::indexed_vec::Idx;
 
@@ -25,7 +25,7 @@ use std::fmt;
 use std::ptr;
 
 use super::{MirContext, LocalRef};
-use super::place::{Alignment, PlaceRef};
+use super::place::PlaceRef;
 
 /// The representation of a Rust value. The enum variant is in fact
 /// uniquely determined by the value's type, but is kept as a
@@ -34,7 +34,7 @@ use super::place::{Alignment, PlaceRef};
 pub enum OperandValue {
     /// A reference to the actual operand. The data is guaranteed
     /// to be valid for the operand's lifetime.
-    Ref(ValueRef, Alignment),
+    Ref(ValueRef, Align),
     /// A single LLVM value.
     Immediate(ValueRef),
     /// A pair of immediate LLVM values. Used by fat pointers too.
@@ -107,11 +107,12 @@ impl<'a, 'tcx> OperandRef<'tcx> {
             OperandValue::Pair(llptr, llextra) => (llptr, llextra),
             OperandValue::Ref(..) => bug!("Deref of by-Ref operand {:?}", self)
         };
+        let layout = ccx.layout_of(projected_ty);
         PlaceRef {
             llval: llptr,
             llextra,
-            layout: ccx.layout_of(projected_ty),
-            alignment: Alignment::AbiAligned,
+            layout,
+            align: layout.align,
         }
     }
 
@@ -222,9 +223,9 @@ impl<'a, 'tcx> OperandValue {
         match self {
             OperandValue::Ref(r, source_align) =>
                 base::memcpy_ty(bcx, dest.llval, r, dest.layout,
-                                (source_align | dest.alignment).non_abi()),
+                                Some(source_align.min(dest.align))),
             OperandValue::Immediate(s) => {
-                bcx.store(base::from_immediate(bcx, s), dest.llval, dest.alignment.non_abi());
+                bcx.store(base::from_immediate(bcx, s), dest.llval, dest.non_abi_align());
             }
             OperandValue::Pair(a, b) => {
                 for (i, &x) in [a, b].iter().enumerate() {
@@ -233,7 +234,7 @@ impl<'a, 'tcx> OperandValue {
                     if common::val_ty(x) == Type::i1(bcx.ccx) {
                         llptr = bcx.pointercast(llptr, Type::i8p(bcx.ccx));
                     }
-                    bcx.store(base::from_immediate(bcx, x), llptr, dest.alignment.non_abi());
+                    bcx.store(base::from_immediate(bcx, x), llptr, dest.non_abi_align());
                 }
             }
         }