[NFC][JumpThreading] Remove InsertFreezeWhenUnfoldingSelect pass parameter

[aeubanks]

Summary

All callers pass true.

select-unfold-freeze.ll is now a subset of select.ll so delete it.

[nikic]

Dropping the freeze option is fine, but I'm not sure about the threshold. It looks like it was added for out-of-tree users? https://github.com/llvm/llvm-project/commit/d120916ca732ca0d7639a0e60ce5f246b77e711d Don't know if still relevant.

llvm/test/Transforms/JumpThreading/select-unfold-freeze.ll

0

Can you check whether this test is the same as select-unfold.ll now and delete if so?

[aeubanks]

drop test, keep threshold parameter

[nikic]

LGTM

llvm/include/llvm/Transforms/Scalar.h

 //
 // For example:  4 + (x + 5)  ->  x + (4 + 5)
 //
 FunctionPass *createReassociatePass();
 
 //===----------------------------------------------------------------------===//
 //
 // JumpThreading - Thread control through mult-pred/multi-succ blocks where some
-// preds always go to some succ. If FreezeSelectCond is true, unfold the
-// condition of a select that unfolds to branch. Thresholds other than minus one
+// preds always go to some succ. Thresholds other than minus one
 // override the internal BB duplication default threshold.
 //
-FunctionPass *createJumpThreadingPass(bool FreezeSelectCond = false,
-                                      int Threshold = -1);
+FunctionPass *createJumpThreadingPass(int Threshold = -1);
 
 //===----------------------------------------------------------------------===//
 //
 // DFAJumpThreading - When a switch statement inside a loop is used to
 // implement a deterministic finite automata we can jump thread the switch
 // statement reducing number of conditional jumps.
 //
 FunctionPass *createDFAJumpThreadingPass();

llvm/include/llvm/Transforms/Scalar/JumpThreading.h

 #ifndef LLVM_ENABLE_ABI_BREAKING_CHECKS
   SmallPtrSet<const BasicBlock *, 16> LoopHeaders;
 #else
   SmallSet<AssertingVH<const BasicBlock>, 16> LoopHeaders;
 #endif
 
   unsigned BBDupThreshold;
   unsigned DefaultBBDupThreshold;
-  bool InsertFreezeWhenUnfoldingSelect;
 
 public:
-  JumpThreadingPass(bool InsertFreezeWhenUnfoldingSelect = true, int T = -1);
+  JumpThreadingPass(int T = -1);
 
   // Glue for old PM.
   bool runImpl(Function &F, TargetLibraryInfo *TLI, TargetTransformInfo *TTI,
                LazyValueInfo *LVI, AAResults *AA, DomTreeUpdater *DTU,
                bool HasProfileData, std::unique_ptr<BlockFrequencyInfo> BFI,
                std::unique_ptr<BranchProbabilityInfo> BPI);
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);

llvm/lib/Passes/PassBuilderPipelines.cpp

PassBuilder::buildLTODefaultPipeline(OptimizationLevel Level,
   // transform it to pass arguments by value instead of by reference.
   MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(ArgumentPromotionPass()));
 
   FunctionPassManager FPM;
   // The IPO Passes may leave cruft around. Clean up after them.
   FPM.addPass(InstCombinePass());
   invokePeepholeEPCallbacks(FPM, Level);
 
-  FPM.addPass(JumpThreadingPass(/*InsertFreezeWhenUnfoldingSelect*/ true));
+  FPM.addPass(JumpThreadingPass());
 
   // Do a post inline PGO instrumentation and use pass. This is a context
   // sensitive PGO pass.
   if (PGOOpt) {
     if (PGOOpt->CSAction == PGOOptions::CSIRInstr)
       addPGOInstrPasses(MPM, Level, /* RunProfileGen */ true,
                         /* IsCS */ true, PGOOpt->CSProfileGenFile,
                         PGOOpt->ProfileRemappingFile);
PassBuilder::buildLTODefaultPipeline(OptimizationLevel Level,
 
   addVectorPasses(Level, MainFPM, /* IsFullLTO */ true);
 
   // Run the OpenMPOpt CGSCC pass again late.
   MPM.addPass(
       createModuleToPostOrderCGSCCPassAdaptor(OpenMPOptCGSCCPass()));
 
   invokePeepholeEPCallbacks(MainFPM, Level);
-  MainFPM.addPass(JumpThreadingPass(/*InsertFreezeWhenUnfoldingSelect*/ true));
+  MainFPM.addPass(JumpThreadingPass());
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(MainFPM),
                                                 PTO.EagerlyInvalidateAnalyses));
 
   // Lower type metadata and the type.test intrinsic. This pass supports
   // clang's control flow integrity mechanisms (-fsanitize=cfi*) and needs
   // to be run at link time if CFI is enabled. This pass does nothing if
   // CFI is disabled.
   MPM.addPass(LowerTypeTestsPass(ExportSummary, nullptr));

llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) {
 
   // If we didn't decide to inline a function, check to see if we can
   // transform it to pass arguments by value instead of by reference.
   PM.add(createArgumentPromotionPass());
 
   // The IPO passes may leave cruft around.  Clean up after them.
   PM.add(createInstructionCombiningPass());
   addExtensionsToPM(EP_Peephole, PM);
-  PM.add(createJumpThreadingPass(/*FreezeSelectCond*/ true));
+  PM.add(createJumpThreadingPass());
 
   // Break up allocas
   PM.add(createSROAPass());
 
   // LTO provides additional opportunities for tailcall elimination due to
   // link-time inlining, and visibility of nocapture attribute.
   if (OptLevel > 1)
     PM.add(createTailCallEliminationPass());
void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) {
   PM.add(createSimpleLoopUnrollPass(OptLevel, DisableUnrollLoops,
                                     ForgetAllSCEVInLoopUnroll));
   PM.add(createLoopDistributePass());
 
   addVectorPasses(PM, /* IsFullLTO */ true);
 
   addExtensionsToPM(EP_Peephole, PM);
 
-  PM.add(createJumpThreadingPass(/*FreezeSelectCond*/ true));
+  PM.add(createJumpThreadingPass());
 }
 
 void PassManagerBuilder::addLateLTOOptimizationPasses(
     legacy::PassManagerBase &PM) {
   // See comment in the new PM for justification of scheduling splitting at
   // this stage (\ref buildLTODefaultPipeline).
   if (EnableHotColdSplit)
     PM.add(createHotColdSplittingPass());

llvm/lib/Transforms/Scalar/JumpThreading.cpp

cl::desc("The number of predecessors to search for a stronger "
            "condition to use to thread over a weaker condition"),
   cl::init(3), cl::Hidden);
 
 static cl::opt<bool> PrintLVIAfterJumpThreading(
     "print-lvi-after-jump-threading",
     cl::desc("Print the LazyValueInfo cache after JumpThreading"), cl::init(false),
     cl::Hidden);
 
-static cl::opt<bool> JumpThreadingFreezeSelectCond(
-    "jump-threading-freeze-select-cond",
-    cl::desc("Freeze the condition when unfolding select"), cl::init(true),
-    cl::Hidden);
-
 static cl::opt<bool> ThreadAcrossLoopHeaders(
     "jump-threading-across-loop-headers",
     cl::desc("Allow JumpThreading to thread across loop headers, for testing"),
     cl::init(false), cl::Hidden);
 
 
 namespace {
 
namespace {
   /// In this case, the unconditional branch at the end of the first if can be
   /// revectored to the false side of the second if.
   class JumpThreading : public FunctionPass {
     JumpThreadingPass Impl;
 
   public:
     static char ID; // Pass identification
 
-    JumpThreading(bool InsertFreezeWhenUnfoldingSelect = true, int T = -1)
-        : FunctionPass(ID), Impl(InsertFreezeWhenUnfoldingSelect, T) {
+    JumpThreading(int T = -1) : FunctionPass(ID), Impl(T) {
       initializeJumpThreadingPass(*PassRegistry::getPassRegistry());
     }
 
     bool runOnFunction(Function &F) override;
 
     void getAnalysisUsage(AnalysisUsage &AU) const override {
       AU.addRequired<DominatorTreeWrapperPass>();
       AU.addPreserved<DominatorTreeWrapperPass>();

 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(LazyValueInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
 INITIALIZE_PASS_END(JumpThreading, "jump-threading",
                 "Jump Threading", false, false)
 
 // Public interface to the Jump Threading pass
-FunctionPass *llvm::createJumpThreadingPass(bool InsertFr, int Threshold) {
-  return new JumpThreading(InsertFr, Threshold);
+FunctionPass *llvm::createJumpThreadingPass(int Threshold) {
+  return new JumpThreading(Threshold);
 }
 
-JumpThreadingPass::JumpThreadingPass(bool InsertFr, int T) {
-  InsertFreezeWhenUnfoldingSelect = JumpThreadingFreezeSelectCond | InsertFr;
+JumpThreadingPass::JumpThreadingPass(int T) {
   DefaultBBDupThreshold = (T == -1) ? BBDuplicateThreshold : unsigned(T);
 }
 
 // Update branch probability information according to conditional
 // branch probability. This is usually made possible for cloned branches
 // in inline instances by the context specific profile in the caller.
 // For instance,
 //
for (Use &U : PN->uses()) {
         }
       }
     }
 
     if (!SI)
       continue;
     // Expand the select.
     Value *Cond = SI->getCondition();
-    if (InsertFreezeWhenUnfoldingSelect &&
-        !isGuaranteedNotToBeUndefOrPoison(Cond, nullptr, SI))
+    if (!isGuaranteedNotToBeUndefOrPoison(Cond, nullptr, SI))
       Cond = new FreezeInst(Cond, "cond.fr", SI);
     Instruction *Term = SplitBlockAndInsertIfThen(Cond, SI, false);
     BasicBlock *SplitBB = SI->getParent();
     BasicBlock *NewBB = Term->getParent();
     PHINode *NewPN = PHINode::Create(SI->getType(), 2, "", SI);
     NewPN->addIncoming(SI->getTrueValue(), Term->getParent());
     NewPN->addIncoming(SI->getFalseValue(), BB);
     SI->replaceAllUsesWith(NewPN);

llvm/test/Transforms/JumpThreading/select-unfold-freeze.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -jump-threading-freeze-select-cond -jump-threading < %s | FileCheck %s
-
-declare void @foo()
-declare void @bar()
-declare void @baz()
-declare void @quux()
-
-
-define void @test_switch_cmp(i1 %cond, i32 %val, i8 %value) nounwind {
-; CHECK-LABEL: @test_switch_cmp(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br i1 [[COND:%.*]], label [[L0:%.*]], label [[L0_THREAD:%.*]]
-; CHECK:       L0:
-; CHECK-NEXT:    [[VAL_PHI:%.*]] = phi i32 [ [[VAL:%.*]], [[ENTRY:%.*]] ]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[VAL_PHI]], 0
-; CHECK-NEXT:    [[COND_FR:%.*]] = freeze i1 [[CMP]]
-; CHECK-NEXT:    br i1 [[COND_FR]], label [[L1:%.*]], label [[TMP0:%.*]]
-; CHECK:       0:
-; CHECK-NEXT:    [[TMP1:%.*]] = phi i8 [ [[VALUE:%.*]], [[L0]] ]
-; CHECK-NEXT:    switch i8 [[TMP1]], label [[L3:%.*]] [
-; CHECK-NEXT:    i8 1, label [[L1]]
-; CHECK-NEXT:    i8 2, label [[L2:%.*]]
-; CHECK-NEXT:    ]
-; CHECK:       L1:
-; CHECK-NEXT:    call void @foo()
-; CHECK-NEXT:    ret void
-; CHECK:       L2:
-; CHECK-NEXT:    call void @bar()
-; CHECK-NEXT:    ret void
-; CHECK:       L3:
-; CHECK-NEXT:    call void @baz()
-; CHECK-NEXT:    ret void
-; CHECK:       L0.thread:
-; CHECK-NEXT:    call void @quux()
-; CHECK-NEXT:    br label [[L1]]
-;
-entry:
-  br i1 %cond, label %L0, label %L4
-L0:
-  %val.phi = phi i32 [%val, %entry], [-1, %L4]
-  %cmp = icmp slt i32 %val.phi, 0
-  %expr = select i1 %cmp, i8 1, i8 %value
-  switch i8 %expr, label %L3 [i8 1, label %L1 i8 2, label %L2]
-
-L1:
-  call void @foo()
-  ret void
-L2:
-  call void @bar()
-  ret void
-L3:
-  call void @baz()
-  ret void
-L4:
-  call void @quux()
-  br label %L0
-}
-
-define i32 @unfold3(i32 %u, i32 %v, i32 %w, i32 %x, i32 %y, i32 %z, i32 %j) nounwind {
-; CHECK-LABEL: @unfold3(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[ADD3:%.*]] = add nsw i32 [[J:%.*]], 2
-; CHECK-NEXT:    [[CMP_I:%.*]] = icmp slt i32 [[U:%.*]], [[V:%.*]]
-; CHECK-NEXT:    br i1 [[CMP_I]], label [[DOTEXIT_THREAD4:%.*]], label [[COND_FALSE_I:%.*]]
-; CHECK:       cond.false.i:
-; CHECK-NEXT:    [[CMP4_I:%.*]] = icmp sgt i32 [[U]], [[V]]
-; CHECK-NEXT:    br i1 [[CMP4_I]], label [[DOTEXIT_THREAD:%.*]], label [[COND_FALSE_6_I:%.*]]
-; CHECK:       cond.false.6.i:
-; CHECK-NEXT:    [[CMP8_I:%.*]] = icmp slt i32 [[W:%.*]], [[X:%.*]]
-; CHECK-NEXT:    br i1 [[CMP8_I]], label [[DOTEXIT_THREAD4]], label [[COND_FALSE_10_I:%.*]]
-; CHECK:       cond.false.10.i:
-; CHECK-NEXT:    [[CMP13_I:%.*]] = icmp sgt i32 [[W]], [[X]]
-; CHECK-NEXT:    br i1 [[CMP13_I]], label [[DOTEXIT_THREAD]], label [[DOTEXIT:%.*]]
-; CHECK:       .exit:
-; CHECK-NEXT:    [[PHITMP:%.*]] = icmp sge i32 [[Y:%.*]], [[Z:%.*]]
-; CHECK-NEXT:    [[COND_FR:%.*]] = freeze i1 [[PHITMP]]
-; CHECK-NEXT:    br i1 [[COND_FR]], label [[DOTEXIT_THREAD]], label [[DOTEXIT_THREAD4]]
-; CHECK:       .exit.thread:
-; CHECK-NEXT:    br label [[DOTEXIT_THREAD4]]
-; CHECK:       .exit.thread4:
-; CHECK-NEXT:    [[TMP0:%.*]] = phi i32 [ [[J]], [[DOTEXIT_THREAD]] ], [ [[ADD3]], [[DOTEXIT]] ], [ [[ADD3]], [[ENTRY:%.*]] ], [ [[ADD3]], [[COND_FALSE_6_I]] ]
-; CHECK-NEXT:    ret i32 [[TMP0]]
-;
-entry:
-  %add3 = add nsw i32 %j, 2
-  %cmp.i = icmp slt i32 %u, %v
-  br i1 %cmp.i, label %.exit, label %cond.false.i
-
-cond.false.i:                                     ; preds = %entry
-  %cmp4.i = icmp sgt i32 %u, %v
-  br i1 %cmp4.i, label %.exit, label %cond.false.6.i
-
-cond.false.6.i:                                   ; preds = %cond.false.i
-  %cmp8.i = icmp slt i32 %w, %x
-  br i1 %cmp8.i, label %.exit, label %cond.false.10.i
-
-cond.false.10.i:                                  ; preds = %cond.false.6.i
-  %cmp13.i = icmp sgt i32 %w, %x
-  br i1 %cmp13.i, label %.exit, label %cond.false.15.i
-
-cond.false.15.i:                                  ; preds = %cond.false.10.i
-  %phitmp = icmp sge i32 %y, %z
-  br label %.exit
-
-.exit:                                  ; preds = %entry, %cond.false.i, %cond.false.6.i, %cond.false.10.i, %cond.false.15.i
-  %cond23.i = phi i1 [ false, %entry ], [ true, %cond.false.i ], [ false, %cond.false.6.i ], [ %phitmp, %cond.false.15.i ], [ true, %cond.false.10.i ]
-  %j.add3 = select i1 %cond23.i, i32 %j, i32 %add3
-  ret i32 %j.add3
-}
-
-define i32 @unfold4(i32 %u, i32 %v, i32 %w, i32 %x, i32 %y, i32 %z, i32 %j) nounwind {
-; CHECK-LABEL: @unfold4(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[ADD3:%.*]] = add nsw i32 [[J:%.*]], 2
-; CHECK-NEXT:    [[CMP_I:%.*]] = icmp slt i32 [[U:%.*]], [[V:%.*]]
-; CHECK-NEXT:    br i1 [[CMP_I]], label [[DOTEXIT_THREAD:%.*]], label [[COND_FALSE_I:%.*]]
-; CHECK:       cond.false.i:
-; CHECK-NEXT:    [[CMP4_I:%.*]] = icmp sgt i32 [[U]], [[V]]
-; CHECK-NEXT:    br i1 [[CMP4_I]], label [[DOTEXIT_THREAD5:%.*]], label [[COND_FALSE_6_I:%.*]]
-; CHECK:       cond.false.6.i:
-; CHECK-NEXT:    [[CMP8_I:%.*]] = icmp slt i32 [[W:%.*]], [[X:%.*]]
-; CHECK-NEXT:    br i1 [[CMP8_I]], label [[DOTEXIT_THREAD]], label [[COND_FALSE_10_I:%.*]]
-; CHECK:       cond.false.10.i:
-; CHECK-NEXT:    [[CMP13_I:%.*]] = icmp sgt i32 [[W]], [[X]]
-; CHECK-NEXT:    br i1 [[CMP13_I]], label [[DOTEXIT_THREAD5]], label [[DOTEXIT:%.*]]
-; CHECK:       .exit:
-; CHECK-NEXT:    [[CMP19_I:%.*]] = icmp sge i32 [[Y:%.*]], [[Z:%.*]]
-; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP19_I]] to i32
-; CHECK-NEXT:    [[LNOT_I18:%.*]] = icmp eq i32 [[CONV]], 1
-; CHECK-NEXT:    [[COND_FR:%.*]] = freeze i1 [[LNOT_I18]]
-; CHECK-NEXT:    br i1 [[COND_FR]], label [[DOTEXIT_THREAD]], label [[DOTEXIT_THREAD5]]
-; CHECK:       .exit.thread:
-; CHECK-NEXT:    br label [[DOTEXIT_THREAD5]]
-; CHECK:       .exit.thread5:
-; CHECK-NEXT:    [[TMP0:%.*]] = phi i32 [ [[J]], [[DOTEXIT_THREAD]] ], [ [[ADD3]], [[DOTEXIT]] ], [ [[ADD3]], [[COND_FALSE_I]] ], [ [[ADD3]], [[COND_FALSE_10_I]] ]
-; CHECK-NEXT:    ret i32 [[TMP0]]
-;
-entry:
-  %add3 = add nsw i32 %j, 2
-  %cmp.i = icmp slt i32 %u, %v
-  br i1 %cmp.i, label %.exit, label %cond.false.i
-
-cond.false.i:                                     ; preds = %entry
-  %cmp4.i = icmp sgt i32 %u, %v
-  br i1 %cmp4.i, label %.exit, label %cond.false.6.i
-
-cond.false.6.i:                                   ; preds = %cond.false.i
-  %cmp8.i = icmp slt i32 %w, %x
-  br i1 %cmp8.i, label %.exit, label %cond.false.10.i
-
-cond.false.10.i:                                  ; preds = %cond.false.6.i
-  %cmp13.i = icmp sgt i32 %w, %x
-  br i1 %cmp13.i, label %.exit, label %cond.false.15.i
-
-cond.false.15.i:                                  ; preds = %cond.false.10.i
-  %cmp19.i = icmp sge i32 %y, %z
-  %conv = zext i1 %cmp19.i to i32
-  br label %.exit
-
-.exit:                                  ; preds = %entry, %cond.false.i, %cond.false.6.i, %cond.false.10.i, %cond.false.15.i
-  %cond23.i = phi i32 [ 1, %entry ], [ 0, %cond.false.i ], [ 1, %cond.false.6.i ], [ %conv, %cond.false.15.i ], [ 0, %cond.false.10.i ]
-  %lnot.i18 = icmp eq i32 %cond23.i, 1
-  %j.add3 = select i1 %lnot.i18, i32 %j, i32 %add3
-  ret i32 %j.add3
-}
-
-; TODO: cond23_i should be constant-folded.
-define i32 @unfold5(i32 %u, i32 %v, i32 %w, i32 %x, i32 %y, i32 %z, i32 %j) nounwind {
-; CHECK-LABEL: @unfold5(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[ADD3:%.*]] = add nsw i32 [[J:%.*]], 2
-; CHECK-NEXT:    [[CMP_I:%.*]] = icmp slt i32 [[U:%.*]], [[V:%.*]]
-; CHECK-NEXT:    br i1 [[CMP_I]], label [[DOTEXIT:%.*]], label [[COND_FALSE_I:%.*]]
-; CHECK:       cond.false.i:
-; CHECK-NEXT:    [[CMP4_I:%.*]] = icmp sgt i32 [[U]], [[V]]
-; CHECK-NEXT:    br i1 [[CMP4_I]], label [[DOTEXIT]], label [[COND_FALSE_6_I:%.*]]
-; CHECK:       cond.false.6.i:
-; CHECK-NEXT:    [[CMP8_I:%.*]] = icmp slt i32 [[W:%.*]], [[X:%.*]]
-; CHECK-NEXT:    br i1 [[CMP8_I]], label [[DOTEXIT]], label [[COND_FALSE_10_I:%.*]]
-; CHECK:       cond.false.10.i:
-; CHECK-NEXT:    [[CMP13_I:%.*]] = icmp sgt i32 [[W]], [[X]]
-; CHECK-NEXT:    br i1 [[CMP13_I]], label [[DOTEXIT]], label [[COND_FALSE_15_I:%.*]]
-; CHECK:       cond.false.15.i:
-; CHECK-NEXT:    [[CMP19_I:%.*]] = icmp sge i32 [[Y:%.*]], [[Z:%.*]]
-; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP19_I]] to i32
-; CHECK-NEXT:    br label [[DOTEXIT]]
-; CHECK:       .exit:
-; CHECK-NEXT:    [[TMP0:%.*]] = phi i32 [ [[J]], [[COND_FALSE_10_I]] ], [ [[CONV]], [[COND_FALSE_15_I]] ], [ 1, [[COND_FALSE_6_I]] ], [ 3, [[COND_FALSE_I]] ], [ 2, [[ENTRY:%.*]] ]
-; CHECK-NEXT:    ret i32 [[TMP0]]
-;
-entry:
-  %add3 = add nsw i32 %j, 2
-  %cmp.i = icmp slt i32 %u, %v
-  br i1 %cmp.i, label %.exit, label %cond.false.i
-
-cond.false.i:                                     ; preds = %entry
-  %cmp4.i = icmp sgt i32 %u, %v
-  br i1 %cmp4.i, label %.exit, label %cond.false.6.i
-
-cond.false.6.i:                                   ; preds = %cond.false.i
-  %cmp8.i = icmp slt i32 %w, %x
-  br i1 %cmp8.i, label %.exit, label %cond.false.10.i
-
-cond.false.10.i:                                  ; preds = %cond.false.6.i
-  %cmp13.i = icmp sgt i32 %w, %x
-  br i1 %cmp13.i, label %.exit, label %cond.false.15.i
-
-cond.false.15.i:                                  ; preds = %cond.false.10.i
-  %cmp19.i = icmp sge i32 %y, %z
-  %conv = zext i1 %cmp19.i to i32
-  br label %.exit
-
-.exit:                                  ; preds = %entry, %cond.false.i, %cond.false.6.i, %cond.false.10.i, %cond.false.15.i
-  %cond23.i = phi i32 [ 2, %entry ], [ 3, %cond.false.i ], [ 1, %cond.false.6.i ], [ %conv, %cond.false.15.i ], [ 7, %cond.false.10.i ]
-  %lnot.i18 = icmp sgt i32 %cond23.i, 5
-  %j.add3 = select i1 %lnot.i18, i32 %j, i32 %cond23.i
-  ret i32 %j.add3
-}
-
-define i32 @TryToUnfoldSelectInCurrBB(i1 %b, i1 %ui, i32 %s, i1 %x) {
-; CHECK-LABEL: @TryToUnfoldSelectInCurrBB(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    br i1 [[B:%.*]], label [[IF_END_THREAD:%.*]], label [[IF_END:%.*]]
-; CHECK:       if.end:
-; CHECK-NEXT:    [[COND_FR:%.*]] = freeze i1 [[X:%.*]]
-; CHECK-NEXT:    br i1 [[COND_FR]], label [[TMP0:%.*]], label [[IF_END_THREAD]]
-; CHECK:       0:
-; CHECK-NEXT:    br label [[IF_END_THREAD]]
-; CHECK:       if.end.thread:
-; CHECK-NEXT:    [[TMP1:%.*]] = phi i32 [ [[S:%.*]], [[TMP0]] ], [ 42, [[IF_END]] ], [ 42, [[ENTRY:%.*]] ]
-; CHECK-NEXT:    ret i32 [[TMP1]]
-;
-entry:
-  br i1 %b, label %if.end, label %if.else
-
-if.else:
-  br label %if.end
-
-if.end:
-  %v = phi i1 [ %x, %if.else ], [ false, %entry ]
-  %v1 = select i1 %v, i32 %s, i32 42
-  ret i32 %v1
-}