diff --git a/src/librustc_trans/mir/block.rs b/src/librustc_trans/mir/block.rs index 7f720f723b8d92196cd9782ab54dbca4cb6bdcef..db54bd717afcb7b2766d2e3e89c1fda561cde1f2 100644 --- a/src/librustc_trans/mir/block.rs +++ b/src/librustc_trans/mir/block.rs @@ -44,7 +44,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> { pub fn trans_block(&mut self, bb: mir::BasicBlock, funclets: &IndexVec>) { - let mut bcx = self.build_block(bb); + let mut bcx = self.get_builder(bb); let data = &self.mir[bb]; debug!("trans_block({:?}={:?})", bb, data); @@ -75,7 +75,7 @@ pub fn trans_block(&mut self, bb: mir::BasicBlock, } }; - let llblock = |this: &mut Self, bcx: &Builder, target: mir::BasicBlock| { + let llblock = |this: &mut Self, target: mir::BasicBlock| { let lltarget = this.blocks[target]; if let Some(cp) = cleanup_pad { @@ -85,7 +85,7 @@ pub fn trans_block(&mut self, bb: mir::BasicBlock, debug!("llblock: creating cleanup trampoline for {:?}", target); let name = &format!("{:?}_cleanup_trampoline_{:?}", bb, target); - let trampoline = bcx.build_new_block(name); + let trampoline = this.new_block(name); trampoline.cleanup_ret(cp, Some(lltarget)); trampoline.llbb() } @@ -139,8 +139,8 @@ pub fn trans_block(&mut self, bb: mir::BasicBlock, mir::TerminatorKind::If { ref cond, targets: (true_bb, false_bb) } => { let cond = self.trans_operand(&bcx, cond); - let lltrue = llblock(self, &bcx, true_bb); - let llfalse = llblock(self, &bcx, false_bb); + let lltrue = llblock(self, true_bb); + let llfalse = llblock(self, false_bb); bcx.cond_br(cond.immediate(), lltrue, llfalse); } @@ -159,7 +159,7 @@ pub fn trans_block(&mut self, bb: mir::BasicBlock, // code. This is especially helpful in cases like an if-let on a huge enum. // Note: This optimization is only valid for exhaustive matches. Some((&&bb, &c)) if c > targets.len() / 2 => { - (Some(bb), llblock(self, &bcx, bb)) + (Some(bb), llblock(self, bb)) } // We're generating an exhaustive switch, so the else branch // can't be hit. Branching to an unreachable instruction @@ -170,7 +170,7 @@ pub fn trans_block(&mut self, bb: mir::BasicBlock, assert_eq!(adt_def.variants.len(), targets.len()); for (adt_variant, &target) in adt_def.variants.iter().zip(targets) { if default_bb != Some(target) { - let llbb = llblock(self, &bcx, target); + let llbb = llblock(self, target); let llval = adt::trans_case(&bcx, ty, Disr::from(adt_variant.disr_val)); bcx.add_case(switch, llval, llbb) } @@ -181,10 +181,10 @@ pub fn trans_block(&mut self, bb: mir::BasicBlock, let (otherwise, targets) = targets.split_last().unwrap(); let discr = bcx.load(self.trans_lvalue(&bcx, discr).llval); let discr = base::to_immediate(&bcx, discr, switch_ty); - let switch = bcx.switch(discr, llblock(self, &bcx, *otherwise), values.len()); + let switch = bcx.switch(discr, llblock(self, *otherwise), values.len()); for (value, target) in values.iter().zip(targets) { let val = Const::from_constval(bcx.ccx, value.clone(), switch_ty); - let llbb = llblock(self, &bcx, *target); + let llbb = llblock(self, *target); bcx.add_case(switch, val.llval, llbb) } } @@ -261,7 +261,7 @@ pub fn trans_block(&mut self, bb: mir::BasicBlock, drop_fn, args, self.blocks[target], - llblock(self, &bcx, unwind), + llblock(self, unwind), cleanup_bundle ); } else { @@ -301,8 +301,8 @@ pub fn trans_block(&mut self, bb: mir::BasicBlock, 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, &bcx, target); - let panic_block = bcx.build_new_block("panic"); + let lltarget = llblock(self, target); + let panic_block = self.new_block("panic"); if expected { bcx.cond_br(cond, lltarget, panic_block.llbb()); } else { @@ -382,7 +382,7 @@ pub fn trans_block(&mut self, bb: mir::BasicBlock, bcx.invoke(llfn, &args, self.unreachable_block(), - llblock(self, &bcx, unwind), + llblock(self, unwind), cleanup_bundle); } else { bcx.call(llfn, &args, cleanup_bundle); @@ -580,12 +580,12 @@ pub fn trans_block(&mut self, bb: mir::BasicBlock, let invokeret = bcx.invoke(fn_ptr, &llargs, ret_bcx, - llblock(self, &bcx, cleanup), + llblock(self, cleanup), cleanup_bundle); fn_ty.apply_attrs_callsite(invokeret); if let Some((_, target)) = *destination { - let ret_bcx = self.build_block(target); + let ret_bcx = self.get_builder(target); ret_bcx.position_at_start(ret_bcx.llbb()); self.set_debug_loc(&ret_bcx, terminator.source_info); let op = OperandRef { @@ -791,9 +791,9 @@ fn landing_pad_to(&mut self, target_bb: mir::BasicBlock) -> BasicBlockRef { return self.blocks[target_bb]; } - let target = self.build_block(target_bb); + let target = self.get_builder(target_bb); - let bcx = target.build_new_block("cleanup"); + let bcx = self.new_block("cleanup"); self.landing_pads[target_bb] = Some(bcx.llbb()); let ccx = bcx.ccx; @@ -809,14 +809,18 @@ fn landing_pad_to(&mut self, target_bb: mir::BasicBlock) -> BasicBlockRef { fn unreachable_block(&mut self) -> BasicBlockRef { self.unreachable_block.unwrap_or_else(|| { - let bl = self.build_block(mir::START_BLOCK).build_new_block("unreachable"); + let bl = self.new_block("unreachable"); bl.unreachable(); self.unreachable_block = Some(bl.llbb()); bl.llbb() }) } - pub fn build_block(&self, bb: mir::BasicBlock) -> Builder<'a, 'tcx> { + pub fn new_block(&self, name: &str) -> Builder<'a, 'tcx> { + Builder::new_block(self.ccx, self.llfn, name) + } + + pub fn get_builder(&self, bb: mir::BasicBlock) -> Builder<'a, 'tcx> { let builder = Builder::with_ccx(self.ccx); builder.position_at_end(self.blocks[bb]); builder diff --git a/src/librustc_trans/mir/mod.rs b/src/librustc_trans/mir/mod.rs index b7b3663b85a383c8cd087787383efda38f6c3496..2090c8eaab929bbf847b81718901e624e69d370b 100644 --- a/src/librustc_trans/mir/mod.rs +++ b/src/librustc_trans/mir/mod.rs @@ -326,7 +326,7 @@ pub fn trans_mir<'a, 'tcx: 'a>( let funclets: IndexVec> = mircx.cleanup_kinds.iter_enumerated().map(|(bb, cleanup_kind)| { if let CleanupKind::Funclet = *cleanup_kind { - let bcx = mircx.build_block(bb); + let bcx = mircx.get_builder(bb); bcx.set_personality_fn(mircx.ccx.eh_personality()); if base::wants_msvc_seh(ccx.sess()) { return Some(Funclet::new(bcx.cleanup_pad(None, &[])));