rustc_trans: query LLVM types from a layout instead of a Ty.

Author: eddyb

src/librustc_trans/abi.rs

@@ -32,6 +32,7 @@ use cabi_nvptx64;
 use cabi_hexagon;
 use mir::lvalue::LvalueRef;
 use type_::Type;
+use type_of::LayoutLlvmExt;
 
 use rustc::hir;
 use rustc::ty::{self, Ty};
@@ -506,7 +507,7 @@ impl<'a, 'tcx> ArgType<'tcx> {
     /// Get the LLVM type for an lvalue of the original Rust type of
     /// this argument/return, i.e. the result of `type_of::type_of`.
     pub fn memory_ty(&self, ccx: &CrateContext<'a, 'tcx>) -> Type {
-        ccx.llvm_type_of(self.layout.ty)
+        self.layout.llvm_type(ccx)
     }
 
     /// Store a direct/indirect value described by this ArgType into a
@@ -934,7 +935,7 @@ impl<'a, 'tcx> FnType<'tcx> {
         } else if let Some(cast) = self.ret.cast {
             cast.llvm_type(ccx)
         } else {
-            ccx.immediate_llvm_type_of(self.ret.layout.ty)
+            self.ret.layout.immediate_llvm_type(ccx)
         };
 
         {
@@ -952,7 +953,7 @@ impl<'a, 'tcx> FnType<'tcx> {
                 } else if let Some(cast) = arg.cast {
                     cast.llvm_type(ccx)
                 } else {
-                    ccx.immediate_llvm_type_of(arg.layout.ty)
+                    arg.layout.immediate_llvm_type(ccx)
                 };
 
                 llargument_tys.push(llarg_ty);

src/librustc_trans/asm.rs

@@ -13,6 +13,7 @@
 use llvm::{self, ValueRef};
 use common::*;
 use type_::Type;
+use type_of::LayoutLlvmExt;
 use builder::Builder;
 
 use rustc::hir;
@@ -44,7 +45,7 @@ pub fn trans_inline_asm<'a, 'tcx>(
         if out.is_indirect {
             indirect_outputs.push(lvalue.load(bcx).immediate());
         } else {
-            output_types.push(bcx.ccx.llvm_type_of(lvalue.layout.ty));
+            output_types.push(lvalue.layout.llvm_type(bcx.ccx));
         }
     }
     if !indirect_outputs.is_empty() {

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, FullLayout};
+use rustc::ty::layout::{self, Align, FullLayout, LayoutOf};
 use rustc::ty::maps::Providers;
 use rustc::dep_graph::{DepNode, DepKind, DepConstructor};
 use rustc::middle::cstore::{self, LinkMeta, LinkagePreference};
@@ -68,7 +68,7 @@ use symbol_names_test;
 use time_graph;
 use trans_item::{TransItem, BaseTransItemExt, TransItemExt, DefPathBasedNames};
 use type_::Type;
-use type_of;
+use type_of::{self, LayoutLlvmExt};
 use rustc::util::nodemap::{NodeSet, FxHashMap, FxHashSet, DefIdSet};
 use CrateInfo;
 
@@ -228,13 +228,13 @@ pub fn unsize_thin_ptr<'a, 'tcx>(
         (&ty::TyRawPtr(ty::TypeAndMut { ty: a, .. }),
          &ty::TyRawPtr(ty::TypeAndMut { ty: b, .. })) => {
             assert!(bcx.ccx.shared().type_is_sized(a));
-            let ptr_ty = bcx.ccx.llvm_type_of(b).ptr_to();
+            let ptr_ty = bcx.ccx.layout_of(b).llvm_type(bcx.ccx).ptr_to();
             (bcx.pointercast(src, ptr_ty), unsized_info(bcx.ccx, a, b, None))
         }
         (&ty::TyAdt(def_a, _), &ty::TyAdt(def_b, _)) if def_a.is_box() && def_b.is_box() => {
             let (a, b) = (src_ty.boxed_ty(), dst_ty.boxed_ty());
             assert!(bcx.ccx.shared().type_is_sized(a));
-            let ptr_ty = bcx.ccx.llvm_type_of(b).ptr_to();
+            let ptr_ty = bcx.ccx.layout_of(b).llvm_type(bcx.ccx).ptr_to();
             (bcx.pointercast(src, ptr_ty), unsized_info(bcx.ccx, a, b, None))
         }
         _ => bug!("unsize_thin_ptr: called on bad types"),
@@ -371,8 +371,8 @@ pub fn from_immediate(bcx: &Builder, val: ValueRef) -> ValueRef {
     }
 }
 
-pub fn to_immediate(bcx: &Builder, val: ValueRef, ty: Ty) -> ValueRef {
-    if ty.is_bool() {
+pub fn to_immediate(bcx: &Builder, val: ValueRef, layout: layout::FullLayout) -> ValueRef {
+    if let layout::Abi::Scalar(layout::Int(layout::I1, _)) = layout.abi {
         bcx.trunc(val, Type::i1(bcx.ccx))
     } else {
         val

src/librustc_trans/callee.rs

@@ -20,8 +20,11 @@ use consts;
 use declare;
 use llvm::{self, ValueRef};
 use monomorphize::Instance;
+use type_of::LayoutLlvmExt;
+
 use rustc::hir::def_id::DefId;
 use rustc::ty::{self, TypeFoldable};
+use rustc::ty::layout::LayoutOf;
 use rustc::traits;
 use rustc::ty::subst::Substs;
 use rustc_back::PanicStrategy;
@@ -55,7 +58,7 @@ pub fn get_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 
     // Create a fn pointer with the substituted signature.
     let fn_ptr_ty = tcx.mk_fn_ptr(common::ty_fn_sig(ccx, fn_ty));
-    let llptrty = ccx.llvm_type_of(fn_ptr_ty);
+    let llptrty = ccx.layout_of(fn_ptr_ty).llvm_type(ccx);
 
     let llfn = if let Some(llfn) = declare::get_declared_value(ccx, &sym) {
         // This is subtle and surprising, but sometimes we have to bitcast

src/librustc_trans/common.rs

@@ -24,6 +24,7 @@ use builder::Builder;
 use consts;
 use declare;
 use type_::Type;
+use type_of::LayoutLlvmExt;
 use value::Value;
 use rustc::traits;
 use rustc::ty::{self, Ty, TyCtxt};
@@ -254,7 +255,7 @@ pub fn C_cstr(cx: &CrateContext, s: InternedString, null_terminated: bool) -> Va
 pub fn C_str_slice(cx: &CrateContext, s: InternedString) -> ValueRef {
     let len = s.len();
     let cs = consts::ptrcast(C_cstr(cx, s, false),
-        cx.llvm_type_of(cx.tcx().mk_str()).ptr_to());
+        cx.layout_of(cx.tcx().mk_str()).llvm_type(cx).ptr_to());
     let empty = C_array(Type::i8(cx), &[]);
     assert_eq!(abi::FAT_PTR_ADDR, 0);
     assert_eq!(abi::FAT_PTR_EXTRA, 1);

src/librustc_trans/consts.rs

@@ -21,8 +21,9 @@ use common::{self, CrateContext, val_ty};
 use declare;
 use monomorphize::Instance;
 use type_::Type;
+use type_of::LayoutLlvmExt;
 use rustc::ty;
-use rustc::ty::layout::Align;
+use rustc::ty::layout::{Align, LayoutOf};
 
 use rustc::hir;
 
@@ -112,7 +113,7 @@ pub fn get_static(ccx: &CrateContext, def_id: DefId) -> ValueRef {
     let ty = common::instance_ty(ccx.tcx(), &instance);
     let g = if let Some(id) = ccx.tcx().hir.as_local_node_id(def_id) {
 
-        let llty = ccx.llvm_type_of(ty);
+        let llty = ccx.layout_of(ty).llvm_type(ccx);
         let (g, attrs) = match ccx.tcx().hir.get(id) {
             hir_map::NodeItem(&hir::Item {
                 ref attrs, span, node: hir::ItemStatic(..), ..
@@ -157,7 +158,7 @@ pub fn get_static(ccx: &CrateContext, def_id: DefId) -> ValueRef {
                         }
                     };
                     let llty2 = match ty.sty {
-                        ty::TyRawPtr(ref mt) => ccx.llvm_type_of(mt.ty),
+                        ty::TyRawPtr(ref mt) => ccx.layout_of(mt.ty).llvm_type(ccx),
                         _ => {
                             ccx.sess().span_fatal(span, "must have type `*const T` or `*mut T`");
                         }
@@ -206,7 +207,7 @@ pub fn get_static(ccx: &CrateContext, def_id: DefId) -> ValueRef {
 
         // FIXME(nagisa): perhaps the map of externs could be offloaded to llvm somehow?
         // FIXME(nagisa): investigate whether it can be changed into define_global
-        let g = declare::declare_global(ccx, &sym, ccx.llvm_type_of(ty));
+        let g = declare::declare_global(ccx, &sym, ccx.layout_of(ty).llvm_type(ccx));
         // Thread-local statics in some other crate need to *always* be linked
         // against in a thread-local fashion, so we need to be sure to apply the
         // thread-local attribute locally if it was present remotely. If we
@@ -266,7 +267,7 @@ pub fn trans_static<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 
         let instance = Instance::mono(ccx.tcx(), def_id);
         let ty = common::instance_ty(ccx.tcx(), &instance);
-        let llty = ccx.llvm_type_of(ty);
+        let llty = ccx.layout_of(ty).llvm_type(ccx);
         let g = if val_llty == llty {
             g
         } else {

src/librustc_trans/context.rs

@@ -24,6 +24,8 @@ use monomorphize::Instance;
 
 use partitioning::CodegenUnit;
 use type_::Type;
+use type_of::LayoutLlvmExt;
+
 use rustc_data_structures::base_n;
 use rustc::middle::trans::Stats;
 use rustc_data_structures::stable_hasher::StableHashingContextProvider;
@@ -397,7 +399,7 @@ impl<'a, 'tcx> LocalCrateContext<'a, 'tcx> {
                     let mut str_slice_ty = Type::named_struct(&dummy_ccx, "str_slice");
                     str_slice_ty.set_struct_body(&[
                         Type::array(&Type::i8(&dummy_ccx), 0),
-                        dummy_ccx.llvm_type_of(shared.tcx.mk_str()).ptr_to(),
+                        dummy_ccx.layout_of(shared.tcx.mk_str()).llvm_type(&dummy_ccx).ptr_to(),
                         Type::array(&Type::i8(&dummy_ccx), 0),
                         Type::isize(&dummy_ccx),
                         Type::array(&Type::i8(&dummy_ccx), 0)

src/librustc_trans/intrinsic.rs

@@ -21,6 +21,7 @@ use common::*;
 use declare;
 use glue;
 use type_::Type;
+use type_of::LayoutLlvmExt;
 use rustc::ty::{self, Ty};
 use rustc::ty::layout::{HasDataLayout, LayoutOf};
 use rustc::hir;
@@ -104,7 +105,7 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
     let ret_ty = sig.output();
     let name = &*tcx.item_name(def_id);
 
-    let llret_ty = ccx.llvm_type_of(ret_ty);
+    let llret_ty = ccx.layout_of(ret_ty).llvm_type(ccx);
     let result = LvalueRef::new_sized(llresult, fn_ty.ret.layout, Alignment::AbiAligned);
 
     let simple = get_simple_intrinsic(ccx, name);
@@ -243,7 +244,7 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
             unsafe {
                 llvm::LLVMSetAlignment(load, ccx.align_of(tp_ty).abi() as u32);
             }
-            to_immediate(bcx, load, tp_ty)
+            to_immediate(bcx, load, ccx.layout_of(tp_ty))
         },
         "volatile_store" => {
             let tp_ty = substs.type_at(0);

src/librustc_trans/mir/block.rs

@@ -662,7 +662,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
             if arg.layout.ty == bcx.tcx().types.bool {
                 llval = bcx.load_range_assert(llval, 0, 2, llvm::False, None);
                 // We store bools as i8 so we need to truncate to i1.
-                llval = base::to_immediate(bcx, llval, arg.layout.ty);
+                llval = base::to_immediate(bcx, llval, arg.layout);
             } else if let Some(ty) = arg.cast {
                 llval = bcx.load(bcx.pointercast(llval, ty.llvm_type(bcx.ccx).ptr_to()),
                                  (align | Alignment::Packed(arg.layout.align(bcx.ccx)))
@@ -682,45 +682,37 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                                 args: &[ArgType<'tcx>]) {
         let tuple = self.trans_operand(bcx, operand);
 
-        let arg_types = match tuple.layout.ty.sty {
-            ty::TyTuple(ref tys, _) => tys,
-            _ => span_bug!(self.mir.span,
-                           "bad final argument to \"rust-call\" fn {:?}", tuple.layout.ty)
-        };
-
         // Handle both by-ref and immediate tuples.
         match tuple.val {
             Ref(llval, align) => {
                 let tuple_ptr = LvalueRef::new_sized(llval, tuple.layout, align);
-                for n in 0..arg_types.len() {
-                    let field_ptr = tuple_ptr.project_field(bcx, n);
-                    self.trans_argument(bcx, field_ptr.load(bcx), llargs, &args[n]);
+                for i in 0..tuple.layout.fields.count() {
+                    let field_ptr = tuple_ptr.project_field(bcx, i);
+                    self.trans_argument(bcx, field_ptr.load(bcx), llargs, &args[i]);
                 }
 
             }
             Immediate(llval) => {
-                for (n, &ty) in arg_types.iter().enumerate() {
-                    let mut elem = bcx.extract_value(llval, tuple.layout.llvm_field_index(n));
-                    // Truncate bools to i1, if needed
-                    elem = base::to_immediate(bcx, elem, ty);
+                for i in 0..tuple.layout.fields.count() {
+                    let field = tuple.layout.field(bcx.ccx, i);
+                    let elem = bcx.extract_value(llval, tuple.layout.llvm_field_index(i));
                     // If the tuple is immediate, the elements are as well
                     let op = OperandRef {
-                        val: Immediate(elem),
-                        layout: bcx.ccx.layout_of(ty),
+                        val: Immediate(base::to_immediate(bcx, elem, field)),
+                        layout: field,
                     };
-                    self.trans_argument(bcx, op, llargs, &args[n]);
+                    self.trans_argument(bcx, op, llargs, &args[i]);
                 }
             }
             Pair(a, b) => {
                 let elems = [a, b];
-                for (n, &ty) in arg_types.iter().enumerate() {
-                    let elem = base::to_immediate(bcx, elems[n], ty);
+                for i in 0..tuple.layout.fields.count() {
                     // Pair is always made up of immediates
                     let op = OperandRef {
-                        val: Immediate(elem),
-                        layout: bcx.ccx.layout_of(ty),
+                        val: Immediate(elems[i]),
+                        layout: tuple.layout.field(bcx.ccx, i),
                     };
-                    self.trans_argument(bcx, op, llargs, &args[n]);
+                    self.trans_argument(bcx, op, llargs, &args[i]);
                 }
             }
         }
@@ -891,7 +883,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                             src: &mir::Operand<'tcx>,
                             dst: LvalueRef<'tcx>) {
         let src = self.trans_operand(bcx, src);
-        let llty = bcx.ccx.llvm_type_of(src.layout.ty);
+        let llty = src.layout.llvm_type(bcx.ccx);
         let cast_ptr = bcx.pointercast(dst.llval, llty.ptr_to());
         let align = src.layout.align(bcx.ccx).min(dst.layout.align(bcx.ccx));
         src.val.store(bcx,

src/librustc_trans/mir/constant.rs

@@ -87,7 +87,7 @@ impl<'a, 'tcx> Const<'tcx> {
                          cv: &ConstVal,
                          ty: Ty<'tcx>)
                          -> Const<'tcx> {
-        let llty = ccx.llvm_type_of(ty);
+        let llty = ccx.layout_of(ty).llvm_type(ccx);
         let val = match *cv {
             ConstVal::Float(v) => {
                 let bits = match v.ty {
@@ -139,7 +139,7 @@ impl<'a, 'tcx> Const<'tcx> {
     }
 
     pub fn to_operand(&self, ccx: &CrateContext<'a, 'tcx>) -> OperandRef<'tcx> {
-        let llty = ccx.immediate_llvm_type_of(self.ty);
+        let llty = ccx.layout_of(self.ty).immediate_llvm_type(ccx);
         let llvalty = val_ty(self.llval);
 
         let val = if llty == llvalty && common::type_is_imm_pair(ccx, self.ty) {
@@ -489,7 +489,7 @@ impl<'a, 'tcx> MirConstContext<'a, 'tcx> {
                         let llelem = if iv < len as u128 {
                             const_get_elt(base.llval, iv as u64)
                         } else {
-                            C_undef(self.ccx.llvm_type_of(projected_ty))
+                            C_undef(self.ccx.layout_of(projected_ty).llvm_type(self.ccx))
                         };
 
                         (Base::Value(llelem), ptr::null_mut())
@@ -543,7 +543,7 @@ impl<'a, 'tcx> MirConstContext<'a, 'tcx> {
         let elem_ty = array_ty.builtin_index().unwrap_or_else(|| {
             bug!("bad array type {:?}", array_ty)
         });
-        let llunitty = self.ccx.llvm_type_of(elem_ty);
+        let llunitty = self.ccx.layout_of(elem_ty).llvm_type(self.ccx);
         // If the array contains enums, an LLVM array won't work.
         let val = if fields.iter().all(|&f| val_ty(f) == llunitty) {
             C_array(llunitty, fields)
@@ -665,7 +665,7 @@ impl<'a, 'tcx> MirConstContext<'a, 'tcx> {
 
                         let unsized_ty = cast_ty.builtin_deref(true, ty::NoPreference)
                             .expect("consts: unsizing got non-pointer target type").ty;
-                        let ptr_ty = self.ccx.llvm_type_of(unsized_ty).ptr_to();
+                        let ptr_ty = self.ccx.layout_of(unsized_ty).llvm_type(self.ccx).ptr_to();
                         let base = consts::ptrcast(base, ptr_ty);
                         let info = base::unsized_info(self.ccx, pointee_ty,
                                                       unsized_ty, old_info);
@@ -681,7 +681,7 @@ impl<'a, 'tcx> MirConstContext<'a, 'tcx> {
                         debug_assert!(common::type_is_immediate(self.ccx, cast_ty));
                         let r_t_in = CastTy::from_ty(operand.ty).expect("bad input type for cast");
                         let r_t_out = CastTy::from_ty(cast_ty).expect("bad output type for cast");
-                        let ll_t_out = self.ccx.immediate_llvm_type_of(cast_ty);
+                        let ll_t_out = self.ccx.layout_of(cast_ty).immediate_llvm_type(self.ccx);
                         let llval = operand.llval;
                         let signed = match self.ccx.layout_of(operand.ty).abi {
                             layout::Abi::Scalar(layout::Int(_, signed)) => signed,
@@ -734,7 +734,8 @@ impl<'a, 'tcx> MirConstContext<'a, 'tcx> {
                             } else { // cast to thin-ptr
                                 // Cast of fat-ptr to thin-ptr is an extraction of data-ptr and
                                 // pointer-cast of that pointer to desired pointer type.
-                                let llcast_ty = self.ccx.immediate_llvm_type_of(cast_ty);
+                                let llcast_ty = self.ccx.layout_of(cast_ty)
+                                    .immediate_llvm_type(self.ccx);
                                 consts::ptrcast(data_ptr, llcast_ty)
                             }
                         } else {
@@ -1041,7 +1042,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
 
         let result = result.unwrap_or_else(|_| {
             // We've errored, so we don't have to produce working code.
-            let llty = bcx.ccx.llvm_type_of(ty);
+            let llty = bcx.ccx.layout_of(ty).llvm_type(bcx.ccx);
             Const::new(C_undef(llty), ty)
         });
 
@@ -1100,7 +1101,7 @@ fn trans_const_adt<'a, 'tcx>(
                 _ => 0,
             };
             let discr_ty = l.field(ccx, 0).ty;
-            let discr = C_int(ccx.llvm_type_of(discr_ty), discr as i64);
+            let discr = C_int(ccx.layout_of(discr_ty).llvm_type(ccx), discr as i64);
             if let layout::Abi::Scalar(_) = l.abi {
                 Const::new(discr, t)
             } else {
@@ -1130,7 +1131,7 @@ fn trans_const_adt<'a, 'tcx>(
             } else {
                 // Always use null even if it's not the `discrfield`th
                 // field; see #8506.
-                Const::new(C_null(ccx.llvm_type_of(t)), t)
+                Const::new(C_null(ccx.layout_of(t).llvm_type(ccx)), t)
             }
         }
         _ => bug!("trans_const_adt: cannot handle type {} repreented as {:#?}", t, l)