rustc_trans: don't special-case Box<T> to have T* LLVM types.

Author: eddyb

src/librustc_trans/intrinsic.rs

@@ -248,7 +248,7 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
         },
         "volatile_store" => {
             let tp_ty = substs.type_at(0);
-            let dst = args[0].deref(bcx.ccx);
+            let dst = args[0].deref(bcx);
             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);
@@ -394,7 +394,7 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
         },
 
         "discriminant_value" => {
-            args[0].deref(bcx.ccx).trans_get_discr(bcx, ret_ty)
+            args[0].deref(bcx).trans_get_discr(bcx, ret_ty)
         }
 
         "align_offset" => {
@@ -542,7 +542,7 @@ pub fn trans_intrinsic_call<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
 
         "nontemporal_store" => {
             let tp_ty = substs.type_at(0);
-            let dst = args[0].deref(bcx.ccx);
+            let dst = args[0].deref(bcx);
             let val = if let OperandValue::Ref(ptr, align) = args[1].val {
                 bcx.load(ptr, align)
             } else {

src/librustc_trans/mir/block.rs

@@ -592,9 +592,12 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
 
                     self.trans_argument(&bcx, op, &mut llargs, &fn_ty.args[i]);
                 }
-                if let Some(tup) = untuple {
-                    self.trans_arguments_untupled(&bcx, tup, &mut llargs,
-                        &fn_ty.args[first_args.len()..])
+                if let Some(tuple) = untuple {
+                    let tuple = self.trans_operand(&bcx, tuple);
+                    for (i, arg) in fn_ty.args[first_args.len()..].iter().enumerate() {
+                        let op = tuple.extract_field(&bcx, i);
+                        self.trans_argument(&bcx, op, &mut llargs, arg);
+                    }
                 }
 
                 let fn_ptr = match (llfn, instance) {
@@ -692,29 +695,6 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
         llargs.push(llval);
     }
 
-    fn trans_arguments_untupled(&mut self,
-                                bcx: &Builder<'a, 'tcx>,
-                                operand: &mir::Operand<'tcx>,
-                                llargs: &mut Vec<ValueRef>,
-                                args: &[ArgType<'tcx>]) {
-        let tuple = self.trans_operand(bcx, operand);
-
-        // Handle both by-ref and immediate tuples.
-        if let Ref(llval, align) = tuple.val {
-            let tuple_ptr = PlaceRef::new_sized(llval, tuple.layout, align);
-            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]);
-            }
-        } else {
-            // If the tuple is immediate, the elements are as well.
-            for i in 0..tuple.layout.fields.count() {
-                let op = tuple.extract_field(bcx, i);
-                self.trans_argument(bcx, op, llargs, &args[i]);
-            }
-        }
-    }
-
     fn get_personality_slot(&mut self, bcx: &Builder<'a, 'tcx>) -> PlaceRef<'tcx> {
         let ccx = bcx.ccx;
         if let Some(slot) = self.personality_slot {

src/librustc_trans/mir/operand.rs

@@ -99,15 +99,24 @@ impl<'a, 'tcx> OperandRef<'tcx> {
         }
     }
 
-    pub fn deref(self, ccx: &CrateContext<'a, 'tcx>) -> PlaceRef<'tcx> {
+    pub fn deref(mut self, bcx: &Builder<'a, 'tcx>) -> PlaceRef<'tcx> {
+        if let ty::TyAdt(def, _) = self.layout.ty.sty {
+            if def.is_box() {
+                // HACK(eddyb) Get the raw pointer, assuming it's always
+                // the first field of the first field of ... of `struct Box`.
+                while !self.layout.ty.is_unsafe_ptr() {
+                    self = self.extract_field(bcx, 0);
+                }
+            }
+        }
         let projected_ty = self.layout.ty.builtin_deref(true, ty::NoPreference)
             .unwrap_or_else(|| bug!("deref of non-pointer {:?}", self)).ty;
         let (llptr, llextra) = match self.val {
             OperandValue::Immediate(llptr) => (llptr, ptr::null_mut()),
             OperandValue::Pair(llptr, llextra) => (llptr, llextra),
             OperandValue::Ref(..) => bug!("Deref of by-Ref operand {:?}", self)
         };
-        let layout = ccx.layout_of(projected_ty);
+        let layout = bcx.ccx.layout_of(projected_ty);
         PlaceRef {
             llval: llptr,
             llextra,
@@ -152,6 +161,12 @@ impl<'a, 'tcx> OperandRef<'tcx> {
     }
 
     pub fn extract_field(&self, bcx: &Builder<'a, 'tcx>, i: usize) -> OperandRef<'tcx> {
+        // For indirect values, we can just go through `PlaceRef::project_field`.
+        if let OperandValue::Ref(ptr, align) = self.val {
+            let place = PlaceRef::new_sized(ptr, self.layout, align);
+            return place.project_field(bcx, i).load(bcx);
+        }
+
         let field = self.layout.field(bcx.ccx, i);
         let offset = self.layout.fields.offset(i);
 

src/librustc_trans/mir/place.rs

@@ -431,7 +431,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                 elem: mir::ProjectionElem::Deref
             }) => {
                 // Load the pointer from its location.
-                self.trans_consume(bcx, base).deref(bcx.ccx)
+                self.trans_consume(bcx, base).deref(bcx)
             }
             mir::Place::Projection(ref projection) => {
                 let tr_base = self.trans_place(bcx, &projection.base);

src/librustc_trans/type_of.rs

@@ -252,9 +252,6 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyLayout<'tcx> {
                 ty::TyRawPtr(ty::TypeAndMut { ty, .. }) => {
                     ccx.layout_of(ty).llvm_type(ccx).ptr_to()
                 }
-                ty::TyAdt(def, _) if def.is_box() => {
-                    ccx.layout_of(self.ty.boxed_ty()).llvm_type(ccx).ptr_to()
-                }
                 ty::TyFnPtr(sig) => {
                     let sig = ccx.tcx().erase_late_bound_regions_and_normalize(&sig);
                     FnType::new(ccx, sig, &[]).llvm_type(ccx).ptr_to()
@@ -341,10 +338,6 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyLayout<'tcx> {
             ty::TyRawPtr(_) => {
                 return self.field(ccx, index).llvm_type(ccx);
             }
-            ty::TyAdt(def, _) if def.is_box() => {
-                let ptr_ty = ccx.tcx().mk_mut_ptr(self.ty.boxed_ty());
-                return ccx.layout_of(ptr_ty).scalar_pair_element_llvm_type(ccx, index);
-            }
             _ => {}
         }
 

src/test/codegen/function-arguments.rs

@@ -128,7 +128,7 @@ pub fn str(_: &[u8]) {
 pub fn trait_borrow(_: &Drop) {
 }
 
-// CHECK: @trait_box(%"core::ops::drop::Drop"* noalias nonnull, {}* noalias nonnull readonly)
+// CHECK: @trait_box(i8* noalias nonnull, i8* noalias nonnull readonly)
 #[no_mangle]
 pub fn trait_box(_: Box<Drop>) {
 }