Improve translation of functions with simple return types

Previously, all function calls would store the result to a temporary
stack slot. While this would often be optimized out, it prevents the
branch hinting from taking effect.

Now function calls that return a scalar have their return values, well,
returned directly, avoiding the redundant store/load pair that was there
before. The return types it does this for are fairly limited due to
issues when doing it for other types.

Author: Aatch

src/librustc_trans/trans/callee.rs

@@ -87,8 +87,8 @@ pub struct Callee<'blk, 'tcx: 'blk> {
     pub data: CalleeData<'tcx>,
 }
 
-fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr)
-                     -> Callee<'blk, 'tcx> {
+pub fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr)
+                         -> Callee<'blk, 'tcx> {
     let _icx = push_ctxt("trans_callee");
     debug!("callee::trans(expr={})", expr.repr(bcx.tcx()));
 

src/librustc_trans/trans/expr.rs

@@ -82,6 +82,7 @@ use util::ppaux::Repr;
 use trans::machine::{llsize_of, llsize_of_alloc};
 use trans::type_::Type;
 
+use syntax::abi as synabi;
 use syntax::{ast, ast_util, codemap};
 use syntax::parse::token::InternedString;
 use syntax::ptr::P;
@@ -571,15 +572,51 @@ pub fn trans_to_lvalue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 /// A version of `trans` that ignores adjustments. You almost certainly do not want to call this
 /// directly.
 fn trans_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
-                                expr: &ast::Expr)
-                                -> DatumBlock<'blk, 'tcx, Expr> {
+                                expr: &ast::Expr) -> DatumBlock<'blk, 'tcx, Expr> {
     let mut bcx = bcx;
 
     debug!("trans_unadjusted(expr={})", bcx.expr_to_string(expr));
     let _indenter = indenter();
 
     debuginfo::set_source_location(bcx.fcx, expr.id, expr.span);
 
+    match expr.node {
+        ast::ExprCall(ref f, ref args) if !bcx.tcx().is_method_call(expr.id) => {
+            if let ast::ExprPath(..) = f.node {
+                let fn_ty = expr_ty_adjusted(bcx, f);
+                let (fty, ret_ty) = match fn_ty.sty {
+                    ty::ty_bare_fn(_, ref fty) => {
+                        (fty, ty::erase_late_bound_regions(bcx.tcx(), &fty.sig.output()))
+                    }
+                    _ => panic!("Not calling a function?!")
+                };
+
+                if let ty::FnConverging(ret_ty) = ret_ty {
+                    let is_rust_fn = fty.abi == synabi::Rust ||
+                        fty.abi == synabi::RustIntrinsic;
+
+                    let valid_type =
+                        ty::type_is_scalar(ret_ty) ||
+                        ty::type_is_simd(bcx.tcx(), ret_ty);
+
+                    if is_rust_fn && type_is_immediate(bcx.ccx(), ret_ty) && valid_type {
+
+                        let args = callee::ArgExprs(&args[..]);
+                        let result = callee::trans_call_inner(bcx,
+                                                              expr.debug_loc(),
+                                                              fn_ty,
+                                                              |cx, _| callee::trans(cx, f),
+                                                              args, Some(Ignore));
+
+                        return immediate_rvalue_bcx(result.bcx, result.val, ret_ty)
+                            .to_expr_datumblock();
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+
     return match ty::expr_kind(bcx.tcx(), expr) {
         ty::LvalueExpr | ty::RvalueDatumExpr => {
             let datum = unpack_datum!(bcx, {

src/librustc_trans/trans/intrinsic.rs

@@ -208,7 +208,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                         in_kind == TypeKind::Pointer && ret_kind == TypeKind::Pointer
                     };
 
-                let dest = if bitcast_compatible {
+                let val = if bitcast_compatible {
                     // if we're here, the type is scalar-like (a primitive, a
                     // SIMD type or a pointer), and so can be handled as a
                     // by-value ValueRef and can also be directly bitcast to the
@@ -233,10 +233,10 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                             // this often occurs in a sequence like `Store(val,
                             // d); val2 = Load(d)`, so disappears easily.
                             Store(bcx, cast_val, d);
+                            d
                         }
-                        expr::Ignore => {}
+                        expr::Ignore => { cast_val }
                     }
-                    dest
                 } else {
                     // The types are too complicated to do with a by-value
                     // bitcast, so pointer cast instead. We need to cast the
@@ -246,16 +246,17 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                         expr::Ignore => expr::Ignore
                     };
                     bcx = expr::trans_into(bcx, &*arg_exprs[0], dest);
-                    dest
+                    match dest {
+                        expr::SaveIn(d) => d,
+                        expr::Ignore => C_undef(llret_ty)
+                    }
                 };
 
                 fcx.scopes.borrow_mut().last_mut().unwrap().drop_non_lifetime_clean();
                 fcx.pop_and_trans_custom_cleanup_scope(bcx, cleanup_scope);
 
-                return match dest {
-                    expr::SaveIn(d) => Result::new(bcx, d),
-                    expr::Ignore => Result::new(bcx, C_undef(llret_ty.ptr_to()))
-                };
+                return Result::new(bcx, val);
+
 
             }
 
@@ -888,7 +889,14 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
 
     fcx.pop_and_trans_custom_cleanup_scope(bcx, cleanup_scope);
 
-    Result::new(bcx, llresult)
+    match dest {
+        expr::Ignore => {
+            Result::new(bcx, llval)
+        }
+        expr::SaveIn(_) => {
+            Result::new(bcx, llresult)
+        }
+    }
 }
 
 fn copy_intrinsic<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,