Consider all zero-sized data structures to be voidish, bypassing some "quirky" parts of LLVM (see e.g. LLVM bug 9900) but also generating better code

Author: nikomatsakis

src/librustc/middle/trans/base.rs

@@ -1320,7 +1320,7 @@ pub fn init_function<'a>(
         }
     };
 
-    if !ty::type_is_voidish(fcx.ccx.tcx, substd_output_type) {
+    if !type_is_voidish(fcx.ccx, substd_output_type) {
         // If the function returns nil/bot, there is no real return
         // value, so do not set `llretptr`.
         if !skip_retptr || fcx.caller_expects_out_pointer {
@@ -1539,7 +1539,7 @@ pub fn trans_closure(ccx: @CrateContext,
     // translation calls that don't have a return value (trans_crate,
     // trans_mod, trans_item, et cetera) and those that do
     // (trans_block, trans_expr, et cetera).
-    if body.expr.is_none() || ty::type_is_voidish(bcx.tcx(), block_ty) {
+    if body.expr.is_none() || type_is_voidish(bcx.ccx(), block_ty) {
         bcx = controlflow::trans_block(bcx, body, expr::Ignore);
     } else {
         let dest = expr::SaveIn(fcx.llretptr.get().unwrap());
@@ -1679,15 +1679,17 @@ fn trans_enum_variant_or_tuple_like_struct(ccx: @CrateContext,
 
     let bcx = fcx.entry_bcx.get().unwrap();
 
-    let repr = adt::represent_type(ccx, result_ty);
-    adt::trans_start_init(bcx, repr, fcx.llretptr.get().unwrap(), disr);
-    for (i, arg_datum) in arg_datums.move_iter().enumerate() {
-        let lldestptr = adt::trans_field_ptr(bcx,
-                                             repr,
-                                             fcx.llretptr.get().unwrap(),
-                                             disr,
-                                             i);
-        arg_datum.store_to(bcx, lldestptr);
+    if !type_is_voidish(fcx.ccx, result_ty) {
+        let repr = adt::represent_type(ccx, result_ty);
+        adt::trans_start_init(bcx, repr, fcx.llretptr.get().unwrap(), disr);
+        for (i, arg_datum) in arg_datums.move_iter().enumerate() {
+            let lldestptr = adt::trans_field_ptr(bcx,
+                                                 repr,
+                                                 fcx.llretptr.get().unwrap(),
+                                                 disr,
+                                                 i);
+            arg_datum.store_to(bcx, lldestptr);
+        }
     }
 
     finish_fn(&fcx, bcx);

src/librustc/middle/trans/callee.rs

@@ -623,7 +623,6 @@ pub fn trans_call_inner<'a>(
     // scope will ever execute.
     let fcx = bcx.fcx;
     let ccx = fcx.ccx;
-    let tcx = ccx.tcx;
     let arg_cleanup_scope = fcx.push_custom_cleanup_scope();
 
     let callee = get_callee(bcx, cleanup::CustomScope(arg_cleanup_scope));
@@ -668,12 +667,11 @@ pub fn trans_call_inner<'a>(
         }
         Some(expr::SaveIn(dst)) => Some(dst),
         Some(expr::Ignore) => {
-            if !ty::type_is_voidish(tcx, ret_ty) {
+            if !type_is_voidish(ccx, ret_ty) {
                 Some(alloc_ty(bcx, ret_ty, "__llret"))
             } else {
-                unsafe {
-                    Some(llvm::LLVMGetUndef(Type::nil().ptr_to().to_ref()))
-                }
+                let llty = type_of::type_of(ccx, ret_ty);
+                Some(C_undef(llty.ptr_to()))
             }
         }
     };
@@ -738,7 +736,7 @@ pub fn trans_call_inner<'a>(
         match opt_llretslot {
             Some(llretslot) => {
                 if !type_of::return_uses_outptr(bcx.ccx(), ret_ty) &&
-                    !ty::type_is_voidish(bcx.tcx(), ret_ty)
+                    !type_is_voidish(bcx.ccx(), ret_ty)
                 {
                     Store(bcx, llret, llretslot);
                 }

src/librustc/middle/trans/common.rs

@@ -79,6 +79,15 @@ pub fn type_is_immediate(ccx: &CrateContext, ty: ty::t) -> bool {
     }
 }
 
+pub fn type_is_voidish(ccx: &CrateContext, ty: ty::t) -> bool {
+    //! Identify types like `()`, bottom, or empty structs, which
+    //! contain no information at all.
+    use middle::trans::machine::llsize_of_alloc;
+    use middle::trans::type_of::sizing_type_of;
+    let llty = sizing_type_of(ccx, ty);
+    llsize_of_alloc(ccx, llty) == 0
+}
+
 pub fn gensym_name(name: &str) -> (Ident, PathElem) {
     let name = token::gensym(name);
     let ident = Ident::new(name);

src/librustc/middle/trans/datum.rs

@@ -171,7 +171,7 @@ pub fn appropriate_rvalue_mode(ccx: &CrateContext, ty: ty::t) -> RvalueMode {
      * on whether type is immediate or not.
      */
 
-    if ty::type_is_voidish(ccx.tcx, ty) {
+    if type_is_voidish(ccx, ty) {
         ByValue
     } else if type_is_immediate(ccx, ty) {
         ByValue
@@ -583,8 +583,8 @@ fn load<'a>(bcx: &'a Block<'a>, llptr: ValueRef, ty: ty::t) -> ValueRef {
      * what we are loading.
      */
 
-    if ty::type_is_voidish(bcx.tcx(), ty) {
-        C_nil()
+    if type_is_voidish(bcx.ccx(), ty) {
+        C_undef(type_of::type_of(bcx.ccx(), ty))
     } else if ty::type_is_bool(ty) {
         LoadRangeAssert(bcx, llptr, 0, 2, lib::llvm::True)
     } else {
@@ -638,7 +638,7 @@ impl<K:KindOps> Datum<K> {
 
         let _icx = push_ctxt("copy_to_no_check");
 
-        if ty::type_is_voidish(bcx.tcx(), self.ty) {
+        if type_is_voidish(bcx.ccx(), self.ty) {
             return bcx;
         }
 

src/librustc/middle/trans/expr.rs

@@ -474,7 +474,7 @@ fn trans_unadjusted<'a>(bcx: &'a Block<'a>,
 
         ty::RvalueDpsExpr => {
             let ty = expr_ty(bcx, expr);
-            if ty::type_is_voidish(bcx.tcx(), ty) {
+            if type_is_voidish(bcx.ccx(), ty) {
                 bcx = trans_rvalue_dps_unadjusted(bcx, expr, Ignore);
                 nil(bcx, ty)
             } else {
@@ -500,7 +500,8 @@ fn trans_unadjusted<'a>(bcx: &'a Block<'a>,
     };
 
     fn nil<'a>(bcx: &'a Block<'a>, ty: ty::t) -> DatumBlock<'a, Expr> {
-        let datum = immediate_rvalue(C_nil(), ty);
+        let llval = C_undef(type_of::type_of(bcx.ccx(), ty));
+        let datum = immediate_rvalue(llval, ty);
         DatumBlock(bcx, datum.to_expr_datum())
     }
 }

src/librustc/middle/trans/foreign.rs

@@ -198,7 +198,7 @@ pub fn trans_native_call<'a>(
         _ => ccx.sess.bug("trans_native_call called on non-function type")
     };
     let llsig = foreign_signature(ccx, &fn_sig, passed_arg_tys);
-    let ret_def = !ty::type_is_voidish(bcx.tcx(), fn_sig.output);
+    let ret_def = !type_is_voidish(bcx.ccx(), fn_sig.output);
     let fn_type = cabi::compute_abi_info(ccx,
                                          llsig.llarg_tys,
                                          llsig.llret_ty,
@@ -778,7 +778,7 @@ fn foreign_types_for_fn_ty(ccx: &CrateContext,
         _ => ccx.sess.bug("foreign_types_for_fn_ty called on non-function type")
     };
     let llsig = foreign_signature(ccx, &fn_sig, fn_sig.inputs);
-    let ret_def = !ty::type_is_voidish(ccx.tcx, fn_sig.output);
+    let ret_def = !type_is_voidish(ccx, fn_sig.output);
     let fn_ty = cabi::compute_abi_info(ccx,
                                        llsig.llarg_tys,
                                        llsig.llret_ty,

src/librustc/middle/trans/intrinsic.rs

@@ -356,7 +356,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                                          pluralize(out_type_size)));
             }
 
-            if !ty::type_is_voidish(ccx.tcx, out_type) {
+            if !type_is_voidish(ccx, out_type) {
                 let llsrcval = get_param(decl, first_real_arg);
                 if type_is_immediate(ccx, in_type) {
                     match fcx.llretptr.get() {

src/librustc/middle/trans/type_of.rs

@@ -68,7 +68,7 @@ pub fn type_of_rust_fn(cx: &CrateContext,
     atys.push_all(type_of_explicit_args(cx, inputs));
 
     // Use the output as the actual return value if it's immediate.
-    if !use_out_pointer && !ty::type_is_voidish(cx.tcx, output) {
+    if !use_out_pointer && !type_is_voidish(cx, output) {
         Type::func(atys, &lloutputtype)
     } else {
         Type::func(atys, &Type::void())

src/librustc/middle/ty.rs

@@ -1455,11 +1455,6 @@ pub fn subst(cx: ctxt,
 
 // Type utilities
 
-pub fn type_is_voidish(tcx: ctxt, ty: t) -> bool {
-    //! "nil" and "bot" are void types in that they represent 0 bits of information
-    type_is_nil(ty) || type_is_bot(ty) || type_is_empty(tcx, ty)
-}
-
 pub fn type_is_nil(ty: t) -> bool { get(ty).sty == ty_nil }
 
 pub fn type_is_bot(ty: t) -> bool {