removed redundant functions in the codegen

Author: x17jiri

compiler/rustc_codegen_llvm/src/builder.rs

@@ -191,17 +191,6 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         cond: &'ll Value,
         then_llbb: &'ll BasicBlock,
         else_llbb: &'ll BasicBlock,
-    ) {
-        unsafe {
-            llvm::LLVMBuildCondBr(self.llbuilder, cond, then_llbb, else_llbb);
-        }
-    }
-
-    fn cond_br_with_cold_br(
-        &mut self,
-        cond: &'ll Value,
-        then_llbb: Self::BasicBlock,
-        else_llbb: Self::BasicBlock,
         cold_br: Option<bool>,
     ) {
         // emit the branch instruction
@@ -637,7 +626,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         let i = header_bx.phi(self.val_ty(zero), &[zero], &[self.llbb()]);
 
         let keep_going = header_bx.icmp(IntPredicate::IntULT, i, count);
-        header_bx.cond_br(keep_going, body_bb, next_bb);
+        header_bx.cond_br(keep_going, body_bb, next_bb, None);
 
         let mut body_bx = Self::build(self.cx, body_bb);
         let dest_elem = dest.project_index(&mut body_bx, i);
@@ -1588,7 +1577,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
             let cond = self.type_test(llfn, typeid_metadata);
             let bb_pass = self.append_sibling_block("type_test.pass");
             let bb_fail = self.append_sibling_block("type_test.fail");
-            self.cond_br(cond, bb_pass, bb_fail);
+            self.cond_br(cond, bb_pass, bb_fail, None);
 
             self.switch_to_block(bb_fail);
             self.abort();

compiler/rustc_codegen_llvm/src/va_arg.rs

@@ -119,7 +119,7 @@ fn emit_aapcs_va_arg<'ll, 'tcx>(
     // if the offset >= 0 then the value will be on the stack
     let mut reg_off_v = bx.load(bx.type_i32(), reg_off, offset_align);
     let use_stack = bx.icmp(IntPredicate::IntSGE, reg_off_v, zero);
-    bx.cond_br(use_stack, on_stack, maybe_reg);
+    bx.cond_br(use_stack, on_stack, maybe_reg, None);
 
     // The value at this point might be in a register, but there is a chance that
     // it could be on the stack so we have to update the offset and then check
@@ -137,7 +137,7 @@ fn emit_aapcs_va_arg<'ll, 'tcx>(
     // Check to see if we have overflowed the registers as a result of this.
     // If we have then we need to use the stack for this value
     let use_stack = bx.icmp(IntPredicate::IntSGT, new_reg_off_v, zero);
-    bx.cond_br(use_stack, on_stack, in_reg);
+    bx.cond_br(use_stack, on_stack, in_reg, None);
 
     bx.switch_to_block(in_reg);
     let top_type = bx.type_ptr();
@@ -203,7 +203,7 @@ fn emit_s390x_va_arg<'ll, 'tcx>(
     );
     let reg_count_v = bx.load(bx.type_i64(), reg_count, Align::from_bytes(8).unwrap());
     let use_regs = bx.icmp(IntPredicate::IntULT, reg_count_v, bx.const_u64(max_regs));
-    bx.cond_br(use_regs, in_reg, in_mem);
+    bx.cond_br(use_regs, in_reg, in_mem, None);
 
     // Emit code to load the value if it was passed in a register.
     bx.switch_to_block(in_reg);

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -335,16 +335,16 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 match test_value {
                     0 => {
                         let cold_br = cold_br.and_then(|t| Some(!t));
-                        bx.cond_br_with_cold_br(discr.immediate(), llfalse, lltrue, cold_br);
+                        bx.cond_br(discr.immediate(), llfalse, lltrue, cold_br);
                     }
-                    1 => bx.cond_br_with_cold_br(discr.immediate(), lltrue, llfalse, cold_br),
+                    1 => bx.cond_br(discr.immediate(), lltrue, llfalse, cold_br),
                     _ => bug!(),
                 }
             } else {
                 let switch_llty = bx.immediate_backend_type(bx.layout_of(switch_ty));
                 let llval = bx.const_uint_big(switch_llty, test_value);
                 let cmp = bx.icmp(IntPredicate::IntEQ, discr.immediate(), llval);
-                bx.cond_br_with_cold_br(cmp, lltrue, llfalse, cold_br);
+                bx.cond_br(cmp, lltrue, llfalse, cold_br);
             }
         } else if self.cx.sess().opts.optimize == OptLevel::No
             && target_iter.len() == 2
@@ -369,7 +369,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             let switch_llty = bx.immediate_backend_type(bx.layout_of(switch_ty));
             let llval = bx.const_uint_big(switch_llty, test_value1);
             let cmp = bx.icmp(IntPredicate::IntEQ, discr.immediate(), llval);
-            bx.cond_br(cmp, ll1, ll2);
+            bx.cond_br(cmp, ll1, ll2, None);
         } else {
             bx.switch(
                 discr.immediate(),
@@ -601,9 +601,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         let lltarget = helper.llbb_with_cleanup(self, target);
         let panic_block = bx.append_sibling_block("panic");
         if expected {
-            bx.cond_br(cond, lltarget, panic_block);
+            bx.cond_br(cond, lltarget, panic_block, None);
         } else {
-            bx.cond_br(cond, panic_block, lltarget);
+            bx.cond_br(cond, panic_block, lltarget, None);
         }
 
         // After this point, bx is the block for the call to panic.

compiler/rustc_codegen_ssa/src/traits/builder.rs

@@ -63,12 +63,6 @@ pub trait BuilderMethods<'a, 'tcx>:
         cond: Self::Value,
         then_llbb: Self::BasicBlock,
         else_llbb: Self::BasicBlock,
-    );
-    fn cond_br_with_cold_br(
-        &mut self,
-        cond: Self::Value,
-        then_llbb: Self::BasicBlock,
-        else_llbb: Self::BasicBlock,
         cold_br: Option<bool>,
     );
     fn switch(

compiler/rustc_middle/src/mir/terminator.rs

@@ -20,20 +20,10 @@ impl SwitchTargets {
         Self { values, targets, cold_targets: ThinVec::new() }
     }
 
-    /// Builds a switch targets definition that jumps to `then` if the tested value equals `value`,
-    /// and to `else_` if not.
-    pub fn static_if(value: u128, then: BasicBlock, else_: BasicBlock) -> Self {
-        Self {
-            values: smallvec![value],
-            targets: smallvec![then, else_],
-            cold_targets: ThinVec::new(),
-        }
-    }
-
     /// Builds a switch targets definition that jumps to `then` if the tested value equals `value`,
     /// and to `else_` if not.
     /// If cold_br is some bool value, the given outcome is considered cold (i.e., unlikely).
-    pub fn static_if_with_cold_br(
+    pub fn static_if(
         value: u128,
         then: BasicBlock,
         else_: BasicBlock,
@@ -61,7 +51,7 @@ impl SwitchTargets {
         }
     }
 
-    // If this switch has exactly one target, returns it.
+    // If this switch has exactly one cold target, returns it.
     pub fn cold_target(&self) -> Option<usize> {
         if self.cold_targets.len() == 1 { Some(self.cold_targets[0]) } else { None }
     }
@@ -390,19 +380,15 @@ impl<'tcx> Terminator<'tcx> {
 
 impl<'tcx> TerminatorKind<'tcx> {
     #[inline]
-    pub fn if_(cond: Operand<'tcx>, t: BasicBlock, f: BasicBlock) -> TerminatorKind<'tcx> {
-        TerminatorKind::SwitchInt { discr: cond, targets: SwitchTargets::static_if(0, f, t) }
-    }
-
-    pub fn if_with_cold_br(
+    pub fn if_(
         cond: Operand<'tcx>,
         t: BasicBlock,
         f: BasicBlock,
         cold_branch: Option<bool>,
     ) -> TerminatorKind<'tcx> {
         TerminatorKind::SwitchInt {
             discr: cond,
-            targets: SwitchTargets::static_if_with_cold_br(
+            targets: SwitchTargets::static_if(
                 0,
                 f,
                 t,

compiler/rustc_mir_build/src/build/matches/mod.rs

@@ -174,7 +174,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let then_block = this.cfg.start_new_block();
                 let else_block = this.cfg.start_new_block();
                 let term =
-                    TerminatorKind::if_with_cold_br(operand, then_block, else_block, cold_branch);
+                    TerminatorKind::if_(operand, then_block, else_block, cold_branch);
 
                 let source_info = this.source_info(expr_span);
                 this.cfg.terminate(block, source_info, term);

compiler/rustc_mir_build/src/build/matches/test.rs

@@ -233,12 +233,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         0 => (second_bb, first_bb, cold_br.and_then(|x| Some(!x))),
                         v => span_bug!(test.span, "expected boolean value but got {:?}", v),
                     };
-                    TerminatorKind::if_with_cold_br(
-                        Operand::Copy(place),
-                        true_bb,
-                        false_bb,
-                        cold_br,
-                    )
+                    TerminatorKind::if_(Operand::Copy(place), true_bb, false_bb, cold_br)
                 } else {
                     // The switch may be inexhaustive so we have a catch all block
                     debug_assert_eq!(options.len() + 1, target_blocks.len());
@@ -419,7 +414,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         self.cfg.terminate(
             block,
             source_info,
-            TerminatorKind::if_(Operand::Move(result), success_block, fail_block),
+            TerminatorKind::if_(Operand::Move(result), success_block, fail_block, None),
         );
     }
 
@@ -562,7 +557,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         self.cfg.terminate(
             eq_block,
             source_info,
-            TerminatorKind::if_(Operand::Move(eq_result), success_block, fail_block),
+            TerminatorKind::if_(Operand::Move(eq_result), success_block, fail_block, None),
         );
     }
 

compiler/rustc_mir_dataflow/src/elaborate_drops.rs

@@ -733,7 +733,7 @@ where
             is_cleanup: unwind.is_cleanup(),
             terminator: Some(Terminator {
                 source_info: self.source_info,
-                kind: TerminatorKind::if_(move_(can_go), succ, drop_block),
+                kind: TerminatorKind::if_(move_(can_go), succ, drop_block, None),
             }),
         };
         let loop_block = self.elaborator.patch().new_block(loop_block);
@@ -954,7 +954,7 @@ where
             DropStyle::Static => on_set,
             DropStyle::Conditional | DropStyle::Open => {
                 let flag = self.elaborator.get_drop_flag(self.path).unwrap();
-                let term = TerminatorKind::if_(flag, on_set, on_unset);
+                let term = TerminatorKind::if_(flag, on_set, on_unset, None);
                 self.new_block(unwind, term)
             }
         }

compiler/rustc_mir_transform/src/coverage/tests.rs

@@ -153,7 +153,7 @@ impl<'tcx> MockBlocks<'tcx> {
     fn switchint(&mut self, some_from_block: Option<BasicBlock>) -> BasicBlock {
         let switchint_kind = TerminatorKind::SwitchInt {
             discr: Operand::Move(Place::from(self.new_temp())),
-            targets: SwitchTargets::static_if(0, TEMP_BLOCK, TEMP_BLOCK),
+            targets: SwitchTargets::static_if(0, TEMP_BLOCK, TEMP_BLOCK, None),
         };
         self.add_block_from(some_from_block, switchint_kind)
     }

compiler/rustc_mir_transform/src/early_otherwise_branch.rs

@@ -191,7 +191,7 @@ impl<'tcx> MirPass<'tcx> for EarlyOtherwiseBranch {
             let false_case = eq_bb;
             patch.patch_terminator(
                 parent,
-                TerminatorKind::if_(Operand::Move(Place::from(comp_temp)), true_case, false_case),
+                TerminatorKind::if_(Operand::Move(Place::from(comp_temp)), true_case, false_case, None),
             );
 
             // generate StorageDead for the second_discriminant_temp not in use anymore