Avoid return blocks that have only a single predecessor

Currently, we always create a dedicated "return" basic block, but when
there's only a single predecessor for that block, it can be merged with
that predecessor. We can achieve that merge by only creating the return
block on demand, avoiding its creation when its not required.

Reduces the pre-optimization size of librustc.ll created with --passes ""
by about 90k lines which equals about 4%.

Author: dotdash

src/librustc/middle/trans/base.rs

@@ -1102,11 +1102,6 @@ pub fn trans_trace(bcx: block, sp_opt: Option<span>, trace_str: @str) {
     Call(bcx, ccx.upcalls.trace, args);
 }
 
-pub fn build_return(bcx: block) {
-    let _icx = push_ctxt("build_return");
-    Br(bcx, bcx.fcx.llreturn);
-}
-
 pub fn ignore_lhs(_bcx: block, local: &ast::local) -> bool {
     match local.node.pat.node {
         ast::pat_wild => true, _ => false
@@ -1364,6 +1359,42 @@ pub fn cleanup_and_leave(bcx: block,
     }
 }
 
+pub fn cleanup_block(bcx: block, upto: Option<BasicBlockRef>) -> block{
+    let _icx = push_ctxt("cleanup_block");
+    let mut cur = bcx;
+    let mut bcx = bcx;
+    loop {
+        debug!("cleanup_block: %s", cur.to_str());
+
+        if bcx.sess().trace() {
+            trans_trace(
+                bcx, None,
+                (fmt!("cleanup_block(%s)", cur.to_str())).to_managed());
+        }
+
+        let mut cur_scope = cur.scope;
+        loop {
+            cur_scope = match cur_scope {
+                Some (inf) => {
+                    bcx = trans_block_cleanups_(bcx, inf.cleanups.to_owned(), false);
+                    inf.parent
+                }
+                None => break
+            }
+        }
+
+        match upto {
+          Some(bb) => { if cur.llbb == bb { break; } }
+          _ => ()
+        }
+        cur = match cur.parent {
+          Some(next) => next,
+          None => { assert!(upto.is_none()); break; }
+        };
+    }
+    bcx
+}
+
 pub fn cleanup_and_Br(bcx: block, upto: block, target: BasicBlockRef) {
     let _icx = push_ctxt("cleanup_and_Br");
     cleanup_and_leave(bcx, Some(upto.llbb), Some(target));
@@ -1544,7 +1575,6 @@ pub fn arrayalloca(cx: block, ty: Type, v: ValueRef) -> ValueRef {
 
 pub struct BasicBlocks {
     sa: BasicBlockRef,
-    rt: BasicBlockRef
 }
 
 // Creates the standard set of basic blocks for a function
@@ -1554,12 +1584,18 @@ pub fn mk_standard_basic_blocks(llfn: ValueRef) -> BasicBlocks {
         BasicBlocks {
             sa: str::as_c_str("static_allocas",
                            |buf| llvm::LLVMAppendBasicBlockInContext(cx, llfn, buf)),
-            rt: str::as_c_str("return",
-                           |buf| llvm::LLVMAppendBasicBlockInContext(cx, llfn, buf))
         }
     }
 }
 
+pub fn mk_return_basic_block(llfn: ValueRef) -> BasicBlockRef {
+    unsafe {
+        let cx = task_llcx();
+        str::as_c_str("return",
+                      |buf| llvm::LLVMAppendBasicBlockInContext(cx, llfn, buf))
+    }
+}
+
 // Creates and returns space for, or returns the argument representing, the
 // slot where the return value of the function must go.
 pub fn make_return_pointer(fcx: fn_ctxt, output_type: ty::t) -> ValueRef {
@@ -1613,7 +1649,7 @@ pub fn new_fn_ctxt_w_id(ccx: @mut CrateContext,
           llretptr: None,
           llstaticallocas: llbbs.sa,
           llloadenv: None,
-          llreturn: llbbs.rt,
+          llreturn: None,
           llself: None,
           personality: None,
           loop_ret: None,
@@ -1757,16 +1793,24 @@ pub fn copy_args_to_allocas(fcx: fn_ctxt,
 
 // Ties up the llstaticallocas -> llloadenv -> lltop edges,
 // and builds the return block.
-pub fn finish_fn(fcx: fn_ctxt, lltop: BasicBlockRef) {
+pub fn finish_fn(fcx: fn_ctxt, lltop: BasicBlockRef, last_bcx: block) {
     let _icx = push_ctxt("finish_fn");
     tie_up_header_blocks(fcx, lltop);
-    build_return_block(fcx);
+
+    let ret_cx = match fcx.llreturn {
+        Some(llreturn) => {
+            if !last_bcx.terminated {
+                Br(last_bcx, llreturn);
+            }
+            raw_block(fcx, false, llreturn)
+        }
+        None => last_bcx
+    };
+    build_return_block(fcx, ret_cx);
 }
 
 // Builds the return block for a function.
-pub fn build_return_block(fcx: fn_ctxt) {
-    let ret_cx = raw_block(fcx, false, fcx.llreturn);
-
+pub fn build_return_block(fcx: fn_ctxt, ret_cx: block) {
     // Return the value if this function immediate; otherwise, return void.
     if fcx.llretptr.is_some() && fcx.has_immediate_return_value {
         Ret(ret_cx, Load(ret_cx, fcx.llretptr.get()))
@@ -1854,16 +1898,21 @@ pub fn trans_closure(ccx: @mut CrateContext,
     }
 
     finish(bcx);
-    cleanup_and_Br(bcx, bcx_top, fcx.llreturn);
+    match fcx.llreturn {
+        Some(llreturn) => cleanup_and_Br(bcx, bcx_top, llreturn),
+        None => bcx = cleanup_block(bcx, Some(bcx_top.llbb))
+    };
 
     // Put return block after all other blocks.
     // This somewhat improves single-stepping experience in debugger.
     unsafe {
-        llvm::LLVMMoveBasicBlockAfter(fcx.llreturn, bcx.llbb);
+        for fcx.llreturn.iter().advance |&llreturn| {
+            llvm::LLVMMoveBasicBlockAfter(llreturn, bcx.llbb);
+        }
     }
 
     // Insert the mandatory first few basic blocks before lltop.
-    finish_fn(fcx, lltop);
+    finish_fn(fcx, lltop, bcx);
 }
 
 // trans_fn: creates an LLVM function corresponding to a source language
@@ -2046,8 +2095,7 @@ pub fn trans_enum_variant_or_tuple_like_struct<A:IdAndTy>(
         let arg_ty = arg_tys[i];
         memcpy_ty(bcx, lldestptr, llarg, arg_ty);
     }
-    build_return(bcx);
-    finish_fn(fcx, lltop);
+    finish_fn(fcx, lltop, bcx);
 }
 
 pub fn trans_enum_def(ccx: @mut CrateContext, enum_definition: &ast::enum_def,
@@ -2288,8 +2336,7 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext,
         let args = ~[llenvarg];
         Call(bcx, main_llfn, args);
 
-        build_return(bcx);
-        finish_fn(fcx, lltop);
+        finish_fn(fcx, lltop, bcx);
         return llfdecl;
     }
 

src/librustc/middle/trans/callee.rs

@@ -704,7 +704,7 @@ pub fn trans_call_inner(in_cx: block,
                         Store(bcx, C_bool(false), bcx.fcx.llretptr.get());
                     }
                 }
-                base::cleanup_and_leave(bcx, None, Some(bcx.fcx.llreturn));
+                base::cleanup_and_leave(bcx, None, Some(bcx.fcx.get_llreturn()));
                 Unreachable(bcx);
                 bcx
             }

src/librustc/middle/trans/common.rs

@@ -184,7 +184,7 @@ pub struct fn_ctxt_ {
     // (LLVM requires that arguments be copied to local allocas before
     // allowing most any operation to be performed on them.)
     llloadenv: Option<BasicBlockRef>,
-    llreturn: BasicBlockRef,
+    llreturn: Option<BasicBlockRef>,
     // The 'self' value currently in use in this function, if there
     // is one.
     //
@@ -251,6 +251,13 @@ impl fn_ctxt_ {
         }
     }
 
+    pub fn get_llreturn(&mut self) -> BasicBlockRef {
+        if self.llreturn.is_none() {
+            self.llreturn = Some(base::mk_return_basic_block(self.llfn));
+        }
+
+        self.llreturn.get()
+    }
 }
 
 pub type fn_ctxt = @mut fn_ctxt_;

src/librustc/middle/trans/controlflow.rs

@@ -279,7 +279,7 @@ pub fn trans_break_cont(bcx: block,
                         // This is a return from a loop body block
                         None => {
                             Store(bcx, C_bool(!to_end), bcx.fcx.llretptr.get());
-                            cleanup_and_leave(bcx, None, Some(bcx.fcx.llreturn));
+                            cleanup_and_leave(bcx, None, Some(bcx.fcx.get_llreturn()));
                             Unreachable(bcx);
                             return bcx;
                         }
@@ -328,7 +328,7 @@ pub fn trans_ret(bcx: block, e: Option<@ast::expr>) -> block {
       }
       _ => ()
     }
-    cleanup_and_leave(bcx, None, Some(bcx.fcx.llreturn));
+    cleanup_and_leave(bcx, None, Some(bcx.fcx.get_llreturn()));
     Unreachable(bcx);
     return bcx;
 }

src/librustc/middle/trans/foreign.rs

@@ -164,7 +164,10 @@ fn build_shim_fn_(ccx: @mut CrateContext,
     // follow the normal Rust calling conventions.
     tie_up_header_blocks(fcx, lltop);
 
-    let ret_cx = raw_block(fcx, false, fcx.llreturn);
+    let ret_cx = match fcx.llreturn {
+        Some(llreturn) => raw_block(fcx, false, llreturn),
+        None => bcx
+    };
     RetVoid(ret_cx);
 
     return llshimfn;
@@ -217,7 +220,10 @@ fn build_wrap_fn_(ccx: @mut CrateContext,
     tie_up_header_blocks(fcx, lltop);
 
     // Then return according to the C ABI.
-    let return_context = raw_block(fcx, false, fcx.llreturn);
+    let return_context = match fcx.llreturn {
+        Some(llreturn) => raw_block(fcx, false, llreturn),
+        None => bcx
+    };
 
     let llfunctiontype = val_ty(llwrapfn);
     let llfunctiontype = llfunctiontype.element_type();
@@ -388,7 +394,6 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
                                      tys.ret_def,
                                      llargbundle,
                                      llretval);
-            build_return(bcx);
         }
 
         let lname = link_name(ccx, foreign_item);
@@ -438,8 +443,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
         if !ty::type_is_nil(ret_ty) && !ty::type_is_bot(ret_ty) {
             Store(bcx, retval, fcx.llretptr.get());
         }
-        build_return(bcx);
-        finish_fn(fcx, lltop);
+        finish_fn(fcx, lltop, bcx);
     }
 
     // FIXME (#2535): this is very shaky and probably gets ABIs wrong all
@@ -467,8 +471,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
         if !ty::type_is_nil(ret_ty) && !ty::type_is_bot(ret_ty) {
             Store(bcx, retval, fcx.llretptr.get());
         }
-        build_return(bcx);
-        finish_fn(fcx, lltop);
+        finish_fn(fcx, lltop, bcx);
     }
 
     fn build_wrap_fn(ccx: @mut CrateContext,
@@ -534,7 +537,6 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
                 let llretptr = load_inbounds(bcx, llargbundle, [0, arg_count]);
                 Store(bcx, Load(bcx, llretptr), retptr);
             }
-            build_return(bcx);
         }
     }
 }
@@ -629,8 +631,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
             }
         }
 
-        build_return(bcx);
-        finish_fn(fcx, lltop);
+        finish_fn(fcx, lltop, bcx);
 
         return;
     }
@@ -1124,8 +1125,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
             ccx.sess.span_bug(item.span, "unknown intrinsic");
         }
     }
-    build_return(bcx);
-    finish_fn(fcx, lltop);
+    finish_fn(fcx, lltop, bcx);
 }
 
 /**
@@ -1257,8 +1257,6 @@ pub fn trans_foreign_fn(ccx: @mut CrateContext,
                 // NB: The return pointer in the Rust ABI function is wired
                 // directly into the return slot in the shim struct.
             }
-
-            build_return(bcx);
         }
 
         let shim_name = link::mangle_internal_name_by_path(
@@ -1314,7 +1312,6 @@ pub fn trans_foreign_fn(ccx: @mut CrateContext,
         fn build_ret(bcx: block, tys: &ShimTypes, llargbundle: ValueRef) {
             let _icx = push_ctxt("foreign::foreign::wrap::build_ret");
             tys.fn_ty.build_wrap_ret(bcx, tys.llsig.llarg_tys, llargbundle);
-            build_return(bcx);
         }
     }