Dynamically generate new blocks with Builder.invoke.

 * Updates Drop, Assert, and Call TerminatorKinds to do this.
 * Changes various code in these terminators to have more uniform
   completions and replaced non-end-of-block llblock and funclet_br
   with the code that they'd execute.

Author: Mark-Simulacrum

src/librustc_trans/mir/block.rs

@@ -231,20 +231,23 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                             lvalue.project_index(&bcx, C_uint(bcx.ccx, 0u64)),
                             ety,
                             lvalue.len(bcx.ccx),
-                            |bcx, llval, loop_bb| {
+                            |mut bcx, llval, loop_bb| {
                                 self.set_debug_loc(&bcx, terminator.source_info);
                                 if let Some(unwind) = unwind {
-                                    bcx.invoke(
+                                    let old_bcx = bcx;
+                                    bcx = old_bcx.build_sibling_block("drop-next");
+                                    old_bcx.invoke(
                                         drop_fn,
                                         &[llval],
-                                        loop_bb,
-                                        llblock(self, unwind),
+                                        bcx.llbb(),
+                                        self.landing_pad_to(unwind),
                                         cleanup_bundle
                                     );
                                 } else {
                                     bcx.call(drop_fn, &[llval], cleanup_bundle);
-                                    bcx.br(loop_bb);
                                 }
+                                bcx.br(loop_bb);
+                                bcx
                             });
                         funclet_br(self, bcx, target);
                         return
@@ -253,17 +256,19 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                 };
                 let args = &[lvalue.llval, lvalue.llextra][..1 + need_extra as usize];
                 if let Some(unwind) = unwind {
-                    bcx.invoke(
+                    let old_bcx = bcx;
+                    bcx = old_bcx.build_sibling_block("drop-next");
+                    old_bcx.invoke(
                         drop_fn,
                         args,
-                        self.blocks[target],
-                        llblock(self, unwind),
+                        bcx.llbb(),
+                        self.landing_pad_to(unwind),
                         cleanup_bundle
                     );
                 } else {
                     bcx.call(drop_fn, args, cleanup_bundle);
-                    funclet_br(self, bcx, target);
                 }
+                funclet_br(self, bcx, target);
             }
 
             mir::TerminatorKind::Assert { ref cond, expected, ref msg, target, cleanup } => {
@@ -297,12 +302,12 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                 let cond = bcx.call(expect, &[cond, C_bool(bcx.ccx, expected)], None);
 
                 // Create the failure block and the conditional branch to it.
-                let lltarget = llblock(self, target);
+                let success_block = self.new_block("success");
                 let panic_block = self.new_block("panic");
                 if expected {
-                    bcx.cond_br(cond, lltarget, panic_block.llbb());
+                    bcx.cond_br(cond, success_block.llbb(), panic_block.llbb());
                 } else {
-                    bcx.cond_br(cond, panic_block.llbb(), lltarget);
+                    bcx.cond_br(cond, panic_block.llbb(), success_block.llbb());
                 }
 
                 // After this point, bcx is the block for the call to panic.
@@ -377,12 +382,14 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                     bcx.invoke(llfn,
                                &args,
                                self.unreachable_block(),
-                               llblock(self, unwind),
+                               self.landing_pad_to(unwind),
                                cleanup_bundle);
                 } else {
                     bcx.call(llfn, &args, cleanup_bundle);
                     bcx.unreachable();
                 }
+
+                success_block.br(self.blocks[target]);
             }
 
             mir::TerminatorKind::DropAndReplace { .. } => {
@@ -552,42 +559,33 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                     _ => span_bug!(span, "no llfn for call"),
                 };
 
-                // Many different ways to call a function handled here
-                if let &Some(cleanup) = cleanup {
-                    let ret_bcx = if let Some((_, target)) = *destination {
-                        self.blocks[target]
-                    } else {
-                        self.unreachable_block()
-                    };
-                    let invokeret = bcx.invoke(fn_ptr,
-                                               &llargs,
-                                               ret_bcx,
-                                               llblock(self, cleanup),
-                                               cleanup_bundle);
-                    fn_ty.apply_attrs_callsite(invokeret);
+                let llret = if let &Some(cleanup) = cleanup {
+                    let old_bcx = bcx;
+                    bcx = old_bcx.build_sibling_block("call-next");
+                    self.set_debug_loc(&bcx, terminator.source_info);
+                    old_bcx.invoke(
+                        fn_ptr,
+                        &llargs,
+                        bcx.llbb(),
+                        self.landing_pad_to(cleanup),
+                        cleanup_bundle,
+                    )
+                } else {
+                    bcx.call(fn_ptr, &llargs, cleanup_bundle)
+                };
 
-                    if let Some((_, target)) = *destination {
-                        let ret_bcx = self.get_builder(target);
-                        self.set_debug_loc(&ret_bcx, terminator.source_info);
-                        let op = OperandRef {
-                            val: Immediate(invokeret),
-                            ty: sig.output(),
-                        };
-                        self.store_return(&ret_bcx, ret_dest, fn_ty.ret, op);
-                    }
+                fn_ty.apply_attrs_callsite(llret);
+
+                let op = OperandRef {
+                    val: Immediate(llret),
+                    ty: sig.output(),
+                };
+                self.store_return(&bcx, ret_dest, fn_ty.ret, op);
+
+                if let Some((_, target)) = *destination {
+                    funclet_br(self, bcx, target);
                 } else {
-                    let llret = bcx.call(fn_ptr, &llargs, cleanup_bundle);
-                    fn_ty.apply_attrs_callsite(llret);
-                    if let Some((_, target)) = *destination {
-                        let op = OperandRef {
-                            val: Immediate(llret),
-                            ty: sig.output(),
-                        };
-                        self.store_return(&bcx, ret_dest, fn_ty.ret, op);
-                        funclet_br(self, bcx, target);
-                    } else {
-                        bcx.unreachable();
-                    }
+                    bcx.unreachable();
                 }
             }
         }

src/librustc_trans/mir/rvalue.rs

@@ -99,8 +99,9 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                 let size = C_uint(bcx.ccx, size);
                 let base = base::get_dataptr(&bcx, dest.llval);
                 tvec::slice_for_each(&bcx, base, tr_elem.ty, size, |bcx, llslot, loop_bb| {
-                    self.store_operand(bcx, llslot, dest.alignment.to_align(), tr_elem);
+                    self.store_operand(&bcx, llslot, dest.alignment.to_align(), tr_elem);
                     bcx.br(loop_bb);
+                    bcx
                 })
             }
 

src/librustc_trans/tvec.rs

@@ -20,7 +20,9 @@ pub fn slice_for_each<'a, 'tcx, F>(
     unit_ty: Ty<'tcx>,
     len: ValueRef,
     f: F
-) -> Builder<'a, 'tcx> where F: FnOnce(&Builder<'a, 'tcx>, ValueRef, BasicBlockRef) {
+) -> Builder<'a, 'tcx>
+    where F: FnOnce(Builder<'a, 'tcx>, ValueRef, BasicBlockRef) -> Builder<'a, 'tcx>
+{
     // Special-case vectors with elements of size 0  so they don't go out of bounds (#9890)
     let zst = type_is_zero_size(bcx.ccx, unit_ty);
     let add = |bcx: &Builder, a, b| if zst {
@@ -47,7 +49,7 @@ pub fn slice_for_each<'a, 'tcx, F>(
     header_bcx.cond_br(keep_going, body_bcx.llbb(), next_bcx.llbb());
 
     let next = add(&body_bcx, current, C_uint(bcx.ccx, 1usize));
-    f(&body_bcx, if zst { data_ptr } else { current }, header_bcx.llbb());
+    let body_bcx = f(body_bcx, if zst { data_ptr } else { current }, header_bcx.llbb());
     header_bcx.add_incoming_to_phi(current, next, body_bcx.llbb());
     next_bcx
 }