rustc_trans: keep a layout instead of a type in {Lvalue,Operand}Ref.

Author: eddyb

src/librustc/ty/layout.rs

@@ -771,6 +771,15 @@ impl Abi {
         }
     }
 
+    /// Returns true if the type is a ZST and not unsized.
+    pub fn is_zst(&self) -> bool {
+        match *self {
+            Abi::Scalar(_) => false,
+            Abi::Vector { count, .. } => count == 0,
+            Abi::Aggregate { sized, size, .. } => sized && size.bytes() == 0
+        }
+    }
+
     pub fn size<C: HasDataLayout>(&self, cx: C) -> Size {
         let dl = cx.data_layout();
 
@@ -1377,7 +1386,7 @@ impl<'a, 'tcx> Layout {
                    no_explicit_discriminants {
                     // Nullable pointer optimization
                     for i in 0..2 {
-                        if !variants[1 - i].iter().all(|f| f.size(dl).bytes() == 0) {
+                        if !variants[1 - i].iter().all(|f| f.is_zst()) {
                             continue;
                         }
 
@@ -1456,7 +1465,7 @@ impl<'a, 'tcx> Layout {
                     for i in st.fields.index_by_increasing_offset() {
                         let field = field_layouts[i];
                         let field_align = field.align(dl);
-                        if field.size(dl).bytes() != 0 || field_align.abi() != 1 {
+                        if !field.is_zst() || field_align.abi() != 1 {
                             start_align = start_align.min(field_align);
                             break;
                         }
@@ -2145,6 +2154,11 @@ impl<'a, 'tcx> FullLayout<'tcx> {
         self.abi.is_packed()
     }
 
+    /// Returns true if the type is a ZST and not unsized.
+    pub fn is_zst(&self) -> bool {
+        self.abi.is_zst()
+    }
+
     pub fn size<C: HasDataLayout>(&self, cx: C) -> Size {
         self.abi.size(cx)
     }

src/librustc_trans/abi.rs

@@ -697,7 +697,7 @@ impl<'a, 'tcx> FnType<'tcx> {
             if ty.is_bool() {
                 arg.attrs.set(ArgAttribute::ZExt);
             } else {
-                if arg.layout.size(ccx).bytes() == 0 {
+                if arg.layout.is_zst() {
                     // For some forsaken reason, x86_64-pc-windows-gnu
                     // doesn't ignore zero-sized struct arguments.
                     // The same is true for s390x-unknown-linux-gnu.

src/librustc_trans/asm.rs

@@ -16,10 +16,9 @@ use type_::Type;
 use builder::Builder;
 
 use rustc::hir;
-use rustc::ty::Ty;
-use rustc::ty::layout::Align;
 
-use mir::lvalue::{LvalueRef, Alignment};
+use mir::lvalue::LvalueRef;
+use mir::operand::OperandValue;
 
 use std::ffi::CString;
 use syntax::ast::AsmDialect;
@@ -29,29 +28,23 @@ use libc::{c_uint, c_char};
 pub fn trans_inline_asm<'a, 'tcx>(
     bcx: &Builder<'a, 'tcx>,
     ia: &hir::InlineAsm,
-    outputs: Vec<(ValueRef, Ty<'tcx>)>,
+    outputs: Vec<LvalueRef<'tcx>>,
     mut inputs: Vec<ValueRef>
 ) {
     let mut ext_constraints = vec![];
     let mut output_types = vec![];
 
     // Prepare the output operands
     let mut indirect_outputs = vec![];
-    for (i, (out, &(val, ty))) in ia.outputs.iter().zip(&outputs).enumerate() {
-        let val = if out.is_rw || out.is_indirect {
-            Some(LvalueRef::new_sized(val, ty,
-                Alignment::Packed(Align::from_bytes(1, 1).unwrap())).load(bcx))
-        } else {
-            None
-        };
+    for (i, (out, lvalue)) in ia.outputs.iter().zip(&outputs).enumerate() {
         if out.is_rw {
-            inputs.push(val.unwrap().immediate());
+            inputs.push(lvalue.load(bcx).immediate());
             ext_constraints.push(i.to_string());
         }
         if out.is_indirect {
-            indirect_outputs.push(val.unwrap().immediate());
+            indirect_outputs.push(lvalue.load(bcx).immediate());
         } else {
-            output_types.push(bcx.ccx.llvm_type_of(ty));
+            output_types.push(bcx.ccx.llvm_type_of(lvalue.layout.ty));
         }
     }
     if !indirect_outputs.is_empty() {
@@ -106,9 +99,9 @@ pub fn trans_inline_asm<'a, 'tcx>(
 
     // Again, based on how many outputs we have
     let outputs = ia.outputs.iter().zip(&outputs).filter(|&(ref o, _)| !o.is_indirect);
-    for (i, (_, &(val, _))) in outputs.enumerate() {
+    for (i, (_, &lvalue)) in outputs.enumerate() {
         let v = if num_outputs == 1 { r } else { bcx.extract_value(r, i as u64) };
-        bcx.store(v, val, None);
+        OperandValue::Immediate(v).store(bcx, lvalue);
     }
 
     // Store mark in a metadata node so we can map LLVM errors

src/librustc_trans/base.rs

@@ -40,7 +40,7 @@ use rustc::middle::lang_items::StartFnLangItem;
 use rustc::middle::trans::{Linkage, Visibility, Stats};
 use rustc::middle::cstore::{EncodedMetadata, EncodedMetadataHashes};
 use rustc::ty::{self, Ty, TyCtxt};
-use rustc::ty::layout::Align;
+use rustc::ty::layout::{Align, FullLayout};
 use rustc::ty::maps::Providers;
 use rustc::dep_graph::{DepNode, DepKind, DepConstructor};
 use rustc::middle::cstore::{self, LinkMeta, LinkagePreference};
@@ -55,10 +55,7 @@ use builder::Builder;
 use callee;
 use common::{C_bool, C_bytes_in_context, C_i32, C_usize};
 use collector::{self, TransItemCollectionMode};
-use common::{C_struct_in_context, C_array};
-use common::CrateContext;
-use common::{type_is_zero_size, val_ty};
-use common;
+use common::{self, C_struct_in_context, C_array, CrateContext, val_ty};
 use consts;
 use context::{self, LocalCrateContext, SharedCrateContext};
 use debuginfo;
@@ -88,7 +85,7 @@ use syntax::attr;
 use rustc::hir;
 use syntax::ast;
 
-use mir::operand::{OperandRef, OperandValue};
+use mir::operand::OperandValue;
 
 pub use rustc_trans_utils::{find_exported_symbols, check_for_rustc_errors_attr};
 pub use rustc_trans_utils::trans_item::linkage_by_name;
@@ -249,8 +246,8 @@ pub fn unsize_thin_ptr<'a, 'tcx>(
 pub fn coerce_unsized_into<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
                                      src: LvalueRef<'tcx>,
                                      dst: LvalueRef<'tcx>) {
-    let src_ty = src.ty.to_ty(bcx.tcx());
-    let dst_ty = dst.ty.to_ty(bcx.tcx());
+    let src_ty = src.layout.ty;
+    let dst_ty = dst.layout.ty;
     let coerce_ptr = || {
         let (base, info) = match src.load(bcx).val {
             OperandValue::Pair(base, info) => {
@@ -266,10 +263,7 @@ pub fn coerce_unsized_into<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
             }
             OperandValue::Ref(..) => bug!()
         };
-        OperandRef {
-            val: OperandValue::Pair(base, info),
-            ty: dst_ty
-        }.store(bcx, dst);
+        OperandValue::Pair(base, info).store(bcx, dst);
     };
     match (&src_ty.sty, &dst_ty.sty) {
         (&ty::TyRef(..), &ty::TyRef(..)) |
@@ -288,15 +282,12 @@ pub fn coerce_unsized_into<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
                 let src_f = src.project_field(bcx, i);
                 let dst_f = dst.project_field(bcx, i);
 
-                let src_f_ty = src_f.ty.to_ty(bcx.tcx());
-                let dst_f_ty = dst_f.ty.to_ty(bcx.tcx());
-
-                if type_is_zero_size(bcx.ccx, dst_f_ty) {
+                if dst_f.layout.is_zst() {
                     continue;
                 }
 
-                if src_f_ty == dst_f_ty {
-                    memcpy_ty(bcx, dst_f.llval, src_f.llval, src_f_ty,
+                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());
                 } else {
                     coerce_unsized_into(bcx, src_f, dst_f);
@@ -409,17 +400,17 @@ pub fn memcpy_ty<'a, 'tcx>(
     bcx: &Builder<'a, 'tcx>,
     dst: ValueRef,
     src: ValueRef,
-    t: Ty<'tcx>,
+    layout: FullLayout<'tcx>,
     align: Option<Align>,
 ) {
     let ccx = bcx.ccx;
 
-    let size = ccx.size_of(t).bytes();
+    let size = layout.size(ccx).bytes();
     if size == 0 {
         return;
     }
 
-    let align = align.unwrap_or_else(|| ccx.align_of(t));
+    let align = align.unwrap_or_else(|| layout.align(ccx));
     call_memcpy(bcx, dst, src, C_usize(ccx, size), align);
 }
 

src/librustc_trans/cabi_x86_64.rs

@@ -58,7 +58,7 @@ fn classify_arg<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, arg: &ArgType<'tcx>)
                           off: Size)
                           -> Result<(), Memory> {
         if !off.is_abi_aligned(layout.align(ccx)) {
-            if layout.size(ccx).bytes() > 0 {
+            if !layout.is_zst() {
                 return Err(Memory);
             }
             return Ok(());

src/librustc_trans/common.rs

@@ -58,9 +58,7 @@ pub fn type_is_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -
     match layout.abi {
         layout::Abi::Scalar(_) | layout::Abi::Vector { .. } => true,
 
-        layout::Abi::Aggregate { .. } => {
-            !layout.is_unsized() && layout.size(ccx).bytes() == 0
-        }
+        layout::Abi::Aggregate { .. } => layout.is_zst()
     }
 }
 
@@ -83,12 +81,6 @@ pub fn type_is_imm_pair<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>)
     }
 }
 
-/// Identify types which have size zero at runtime.
-pub fn type_is_zero_size<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
-    let layout = ccx.layout_of(ty);
-    !layout.is_unsized() && layout.size(ccx).bytes() == 0
-}
-
 pub fn type_needs_drop<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>) -> bool {
     ty.needs_drop(tcx, ty::ParamEnv::empty(traits::Reveal::All))
 }

src/librustc_trans/debuginfo/mod.rs

@@ -335,8 +335,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             signature.extend(inputs.iter().map(|&t| {
                 let t = match t.sty {
                     ty::TyArray(ct, _)
-                        if (ct == cx.tcx().types.u8) ||
-                           (cx.layout_of(ct).size(cx).bytes() == 0) => {
+                        if (ct == cx.tcx().types.u8) || cx.layout_of(ct).is_zst() => {
                         cx.tcx().mk_imm_ptr(ct)
                     }
                     _ => t

src/librustc_trans/intrinsic.rs

@@ -22,7 +22,7 @@ use declare;
 use glue;
 use type_::Type;
 use rustc::ty::{self, Ty};
-use rustc::ty::layout::HasDataLayout;
+use rustc::ty::layout::{HasDataLayout, LayoutOf};
 use rustc::hir;
 use syntax::ast;
 use syntax::symbol::Symbol;
@@ -86,7 +86,7 @@ fn get_simple_intrinsic(ccx: &CrateContext, name: &str) -> Option<ValueRef> {
 /// add them to librustc_trans/trans/context.rs
 pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
                                       callee_ty: Ty<'tcx>,
-                                      fn_ty: &FnType,
+                                      fn_ty: &FnType<'tcx>,
                                       args: &[OperandRef<'tcx>],
                                       llresult: ValueRef,
                                       span: Span) {
@@ -105,7 +105,7 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
     let name = &*tcx.item_name(def_id);
 
     let llret_ty = ccx.llvm_type_of(ret_ty);
-    let result = LvalueRef::new_sized(llresult, ret_ty, Alignment::AbiAligned);
+    let result = LvalueRef::new_sized(llresult, fn_ty.ret.layout, Alignment::AbiAligned);
 
     let simple = get_simple_intrinsic(ccx, name);
     let llval = match name {
@@ -179,7 +179,7 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
         }
         "init" => {
             let ty = substs.type_at(0);
-            if !type_is_zero_size(ccx, ty) {
+            if !ccx.layout_of(ty).is_zst() {
                 // Just zero out the stack slot.
                 // If we store a zero constant, LLVM will drown in vreg allocation for large data
                 // structures, and the generated code will be awful. (A telltale sign of this is
@@ -247,15 +247,15 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
         },
         "volatile_store" => {
             let tp_ty = substs.type_at(0);
-            let dst = LvalueRef::new_sized(args[0].immediate(), tp_ty, Alignment::AbiAligned);
+            let dst = args[0].deref(bcx.ccx);
             if let OperandValue::Pair(a, b) = args[1].val {
                 bcx.volatile_store(a, dst.project_field(bcx, 0).llval);
                 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())
                 } else {
-                    if type_is_zero_size(ccx, tp_ty) {
+                    if dst.layout.is_zst() {
                         return;
                     }
                     from_immediate(bcx, args[1].immediate())
@@ -393,13 +393,9 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
         },
 
         "discriminant_value" => {
-            let val_ty = substs.type_at(0);
-            let adt_val = LvalueRef::new_sized(args[0].immediate(),
-                                               val_ty,
-                                               Alignment::AbiAligned);
-            match val_ty.sty {
+            match substs.type_at(0).sty {
                 ty::TyAdt(adt, ..) if adt.is_enum() => {
-                    adt_val.trans_get_discr(bcx, ret_ty)
+                    args[0].deref(bcx.ccx).trans_get_discr(bcx, ret_ty)
                 }
                 _ => C_null(llret_ty)
             }
@@ -612,12 +608,12 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
                         // This assumes the type is "simple", i.e. no
                         // destructors, and the contents are SIMD
                         // etc.
-                        assert!(!bcx.ccx.shared().type_needs_drop(arg.ty));
+                        assert!(!bcx.ccx.shared().type_needs_drop(arg.layout.ty));
                         let (ptr, align) = match arg.val {
                             OperandValue::Ref(ptr, align) => (ptr, align),
                             _ => bug!()
                         };
-                        let arg = LvalueRef::new_sized(ptr, arg.ty, align);
+                        let arg = LvalueRef::new_sized(ptr, arg.layout, align);
                         (0..contents.len()).map(|i| {
                             arg.project_field(bcx, i).load(bcx).immediate()
                         }).collect()
@@ -685,8 +681,8 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
         } else {
             OperandRef {
                 val: OperandValue::Immediate(llval),
-                ty: ret_ty
-            }.unpack_if_pair(bcx).store(bcx, result);
+                layout: result.layout
+            }.unpack_if_pair(bcx).val.store(bcx, result);
         }
     }
 }

src/librustc_trans/mir/analyze.rs

@@ -18,6 +18,7 @@ use rustc::mir::{self, Location, TerminatorKind, Literal};
 use rustc::mir::visit::{Visitor, LvalueContext};
 use rustc::mir::traversal;
 use rustc::ty;
+use rustc::ty::layout::LayoutOf;
 use common;
 use super::MirContext;
 
@@ -34,7 +35,7 @@ pub fn lvalue_locals<'a, 'tcx>(mircx: &MirContext<'a, 'tcx>) -> BitVector {
             ty.is_box() ||
             ty.is_region_ptr() ||
             ty.is_simd() ||
-            common::type_is_zero_size(mircx.ccx, ty)
+            mircx.ccx.layout_of(ty).is_zst()
         {
             // These sorts of types are immediates that we can store
             // in an ValueRef without an alloca.