[CGP] Sink compare through freeze

[dmgreen]

Summary

CodeGenPrepare will sink most compares to the block that uses then, as an optimization to keep the compare and the branch/select/etc next to on another. This can be blocked by the presence of freeze, however. Usually freeze(icmp(x, C)) is converted to icmp(freeze(x), C)), allowing the cmp to be sunk. If there are multiple uses of the cmp though, this currently doesn't happen.

This patch relaxes that, as the cmp will already be duplicated to be sunk into a different block, we can more aggressively convert the icmp-freeze to freeze-icmp.

[aqjune]

llvm/lib/CodeGen/CodeGenPrepare.cpp

7904

Should we factor out this and multiple condition registers check as a separate function so that the check can be shared with sinkCmpExpression?

7905

typo?

7911

Could you elaborate why this condition is necessary please?

llvm/test/Transforms/CodeGenPrepare/X86/freeze-brcond.ll

55

This extra freeze here should be removed - would a simple constant-ness check using Const0 and Const1 be enough?
A slightly more expensive check would be isGuaranteedNotToBeUndefOrPoison, not sure it is fine for CodeGenPrepare to call it.

[aqjune]

Also, could you leave a link to Alive2 in the patch description showing that pushing freeze into icmp ops is safe when there are multiple users?

[dmgreen]

Thanks for taking a look. I decided this might be better to sink the freeze more directly in sinkCmpExpression. According to alive that is still valid, even if it duplicates the freeze. I'll update when I have more details.

llvm/lib/CodeGen/CodeGenPrepare.cpp

if (tryUnmergingGEPsAcrossIndirectBr(GEPI, TTI)) {
       return true;
     }
     return false;
   }
 
   if (FreezeInst *FI = dyn_cast<FreezeInst>(I)) {
     // freeze(icmp a, const)) -> icmp (freeze a), const
     // This helps generate efficient conditional jumps.
-    Instruction *CmpI = nullptr;
+    CmpInst *CmpI = nullptr;
     if (ICmpInst *II = dyn_cast<ICmpInst>(FI->getOperand(0)))
       CmpI = II;
     else if (FCmpInst *F = dyn_cast<FCmpInst>(FI->getOperand(0)))
       CmpI = F->getFastMathFlags().none() ? F : nullptr;
 
-    if (CmpI && CmpI->hasOneUse()) {
+    // Check if the Cmp/Freeze can be altered without increasing instructions. A
+    // Cmp will be sank to the uses by sinkCmpExpression, in which case it is
+    // worth folding even if the cmp has extra uses.
+    auto WillBeSunkOrHasOneUse = [&](CmpInst *CmpI, FreezeInst *FI) {
+      if (CmpI->hasOneUse())
+        return true;
+      // Return false if the sinking of compares is disabled.
+      if (TLI->hasMultipleConditionRegisters())
+        return false;
+      if (TLI->useSoftFloat() && isa<FCmpInst>(CmpI))
+        return false;
+      // Check if the cmp node can be sunk, if so will will be duplicating the
+      // node anyway, fold it here to allow more transforms.
+      if (FI->getParent() != CmpI->getParent())
+        return true;
+      return any_of(FI->users(), [&](const User *U) {
+        return cast<Instruction>(U)->getParent() != CmpI->getParent();
+      });
+    };
+
+    if (CmpI && WillBeSunkOrHasOneUse(CmpI, FI)) {
       auto Op0 = CmpI->getOperand(0), Op1 = CmpI->getOperand(1);
       bool Const0 = isa<ConstantInt>(Op0) || isa<ConstantFP>(Op0) ||
                     isa<ConstantPointerNull>(Op0);
       bool Const1 = isa<ConstantInt>(Op1) || isa<ConstantFP>(Op1) ||
                     isa<ConstantPointerNull>(Op1);
-      if (Const0 || Const1) {
-        if (!Const0 || !Const1) {
-          auto *F = new FreezeInst(Const0 ? Op1 : Op0, "", CmpI);
-          F->takeName(FI);
-          CmpI->setOperand(Const0 ? 1 : 0, F);
-        }
-        FI->replaceAllUsesWith(CmpI);
+      if (Const0 != Const1) {
+        auto *NewCmpI =
+            CmpInst::Create(CmpI->getOpcode(), CmpI->getPredicate(),
+                            Const0 ? Op0 : F, Const0 ? F : Op1, "", CmpI);
+        NewCmpI->setDebugLoc(CmpI->getDebugLoc());
+
+        FI->replaceAllUsesWith(NewCmpI);
         FI->eraseFromParent();
+        if (CmpI->use_empty()) {
+          salvageDebugInfo(*CmpI);
+          CmpI->eraseFromParent();
+        }
         return true;
       }
     }
     return false;
   }
 
   if (tryToSinkFreeOperands(I))
     return true;

llvm/test/CodeGen/PowerPC/select-to-branch.mir

define i32 @weighted_select2(i32 %a, i32 %b) {
     %sel = select i1 %cmp, i32 %a, i32 %b, !prof !15
     ret i32 %sel
 
   ; If branch_weights > 99% or branch_weights < 1%, the select will be converted
   ; to branch, here !15 = 100/101, !15 > 99%, so it will convert select to
   ; branch.
   ; CHECK-LABEL: weighted_select2
   ; CHECK:         %sel.frozen = freeze i32 %a
-  ; CHECK:         %cmp = icmp ne i32 %sel.frozen, 0
-  ; CHECK-NEXT:    br i1 %cmp, label %select.end, label %select.false, !prof !15
+  ; CHECK:         %1 = icmp ne i32 %sel.frozen, 0
+  ; CHECK-NEXT:    br i1 %1, label %select.end, label %select.false, !prof !15
   ; CHECK:       select.false:
   ; CHECK-NEXT:    br label %select.end
   ; CHECK:       select.end:
   ; CHECK-NEXT:    %sel = phi i32 [ %a, %0 ], [ %b, %select.false ]
   ; CHECK-NEXT:    ret i32 %sel
   }
 
   define i32 @weighted_select3(i32 %a, i32 %b) {
     %cmp = icmp ne i32 %a, 0
     %sel = select i1 %cmp, i32 %a, i32 %b, !prof !16
     ret i32 %sel
 
   ; If branch_weights > 99% or branch_weights < 1%, the select will be converted
   ; to branch, here !16 = 1/101, !16 < 1%, so it will convert select to branch.
   ; CHECK-LABEL: weighted_select3
   ; CHECK:         %sel.frozen = freeze i32 %a
-  ; CHECK:         %cmp = icmp ne i32 %sel.frozen, 0
-  ; CHECK-NEXT:    br i1 %cmp, label %select.end, label %select.false, !prof !16
+  ; CHECK:         %1 = icmp ne i32 %sel.frozen, 0
+  ; CHECK-NEXT:    br i1 %1, label %select.end, label %select.false, !prof !16
   ; CHECK:       select.false:
   ; CHECK-NEXT:    br label %select.end
   ; CHECK:       select.end:
   ; CHECK-NEXT:    %sel = phi i32 [ %a, %0 ], [ %b, %select.false ]
   ; CHECK-NEXT:    ret i32 %sel
   }
 
   define i32 @unweighted_select(i32 %a, i32 %b) {

llvm/test/Transforms/CodeGenPrepare/AArch64/sink-compare-freeze.ll

 tail:
   %e = phi i32 [ 2, %labc ], [ 3, %labb ], [ %b, %body ]
   ret i32 %e
 }
 
 define i32 @withfreeze(i32 %a, i1 %d) {
 ; CHECK-LABEL: @withfreeze(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[A:%.*]], 0
-; CHECK-NEXT:    [[F:%.*]] = freeze i1 [[C]]
+; CHECK-NEXT:    [[F:%.*]] = freeze i32 [[A:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[A]], 0
 ; CHECK-NEXT:    call void @use(i1 [[C]])
 ; CHECK-NEXT:    br i1 [[D:%.*]], label [[LABA:%.*]], label [[LABB:%.*]]
 ; CHECK:       laba:
-; CHECK-NEXT:    br i1 [[F]], label [[BODY:%.*]], label [[LABC:%.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = icmp eq i32 [[F]], 0
+; CHECK-NEXT:    br i1 [[TMP0]], label [[BODY:%.*]], label [[LABC:%.*]]
 ; CHECK:       labb:
-; CHECK-NEXT:    br i1 [[F]], label [[BODY]], label [[TAIL:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[F]], 0
+; CHECK-NEXT:    br i1 [[TMP1]], label [[BODY]], label [[TAIL:%.*]]
 ; CHECK:       labc:
-; CHECK-NEXT:    [[TMP0:%.*]] = icmp eq i32 [[A]], 0
-; CHECK-NEXT:    br i1 [[TMP0]], label [[BODY]], label [[TAIL]]
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i32 [[A]], 0
+; CHECK-NEXT:    br i1 [[TMP2]], label [[BODY]], label [[TAIL]]
 ; CHECK:       body:
 ; CHECK-NEXT:    [[B:%.*]] = phi i32 [ 0, [[LABA]] ], [ 1, [[LABB]] ], [ 4, [[LABC]] ]
 ; CHECK-NEXT:    br label [[TAIL]]
 ; CHECK:       tail:
 ; CHECK-NEXT:    [[E:%.*]] = phi i32 [ 2, [[LABC]] ], [ 3, [[LABB]] ], [ [[B]], [[BODY]] ]
 ; CHECK-NEXT:    ret i32 [[E]]
 ;
 entry:

llvm/test/Transforms/CodeGenPrepare/X86/freeze-brcond.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -codegenprepare < %s | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @f1(i32 %a) {
 ; CHECK-LABEL: @f1(
 ; CHECK-NEXT:    [[FR:%.*]] = freeze i32 [[A:%.*]]
-; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[FR]], 0
-; CHECK-NEXT:    br i1 [[C]], label [[A:%.*]], label [[B:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[FR]], 0
+; CHECK-NEXT:    br i1 [[TMP1]], label [[A:%.*]], label [[B:%.*]]
 ; CHECK:       A:
 ; CHECK-NEXT:    call void @g1()
 ; CHECK-NEXT:    ret void
 ; CHECK:       B:
 ; CHECK-NEXT:    call void @g2()
 ; CHECK-NEXT:    ret void
 ;
   %c = icmp eq i32 %a, 0
   %fr = freeze i1 %c
   br i1 %fr, label %A, label %B
 A:
   call void @g1()
   ret void
 B:
   call void @g2()
   ret void
 }
 
 define void @f2(i32 %a) {
 ; CHECK-LABEL: @f2(
 ; CHECK-NEXT:    [[FR:%.*]] = freeze i32 [[A:%.*]]
-; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 0, [[FR]]
-; CHECK-NEXT:    br i1 [[C]], label [[A:%.*]], label [[B:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 0, [[FR]]
+; CHECK-NEXT:    br i1 [[TMP1]], label [[A:%.*]], label [[B:%.*]]
 ; CHECK:       A:
 ; CHECK-NEXT:    call void @g1()
 ; CHECK-NEXT:    ret void
 ; CHECK:       B:
 ; CHECK-NEXT:    call void @g2()
 ; CHECK-NEXT:    ret void
 ;
   %c = icmp eq i32 0, %a
   %fr = freeze i1 %c
   br i1 %fr, label %A, label %B
 A:
   call void @g1()
   ret void
 B:
   call void @g2()
   ret void
 }
 
 define void @f3(i32 %a) {
 ; CHECK-LABEL: @f3(
 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 0, 1
-; CHECK-NEXT:    br i1 [[C]], label [[A:%.*]], label [[B:%.*]]
+; CHECK-NEXT:    [[FR:%.*]] = freeze i1 [[C]]
+; CHECK-NEXT:    br i1 [[FR]], label [[A:%.*]], label [[B:%.*]]
 ; CHECK:       A:
 ; CHECK-NEXT:    call void @g1()
 ; CHECK-NEXT:    ret void
 ; CHECK:       B:
 ; CHECK-NEXT:    call void @g2()
 ; CHECK-NEXT:    ret void
 ;
   %c = icmp eq i32 0, 1
   %fr = freeze i1 %c
   br i1 %fr, label %A, label %B
 A:
   call void @g1()
   ret void
 B:
   call void @g2()
   ret void
 }
 
 define i1 @ptrcmp(i8* %p) {
 ; CHECK-LABEL: @ptrcmp(
 ; CHECK-NEXT:    [[FR:%.*]] = freeze i8* [[P:%.*]]
-; CHECK-NEXT:    [[C:%.*]] = icmp eq i8* [[FR]], null
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i8* [[FR]], null
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %c = icmp eq i8* %p, null
   %fr = freeze i1 %c
   ret i1 %fr
 }
 
 
 define i1 @fcmp(float %a) {
 ; CHECK-LABEL: @fcmp(
 ; CHECK-NEXT:    [[FR:%.*]] = freeze float [[A:%.*]]
-; CHECK-NEXT:    [[C:%.*]] = fcmp oeq float [[FR]], 0.000000e+00
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq float [[FR]], 0.000000e+00
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %c = fcmp oeq float %a, 0.0
   %fr = freeze i1 %c
   ret i1 %fr
 }
 
 define i1 @fcmp_nan(float %a) {
 ; CHECK-LABEL: @fcmp_nan(
 ; CHECK-NEXT:    [[C:%.*]] = fcmp nnan oeq float [[A:%.*]], 0.000000e+00
 ; CHECK-NEXT:    [[FR:%.*]] = freeze i1 [[C]]
 ; CHECK-NEXT:    ret i1 [[FR]]
 ;
   %c = fcmp nnan oeq float %a, 0.0
   %fr = freeze i1 %c
   ret i1 %fr
 }
 
 define void @and_bitmask(i32 %flag) {
 ; CHECK-LABEL: @and_bitmask(
 ; CHECK-NEXT:    [[V:%.*]] = and i32 [[FLAG:%.*]], 1
 ; CHECK-NEXT:    [[FR:%.*]] = freeze i32 [[V]]
-; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[FR]], 0
-; CHECK-NEXT:    br i1 [[C]], label [[A:%.*]], label [[B:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[FR]], 0
+; CHECK-NEXT:    br i1 [[TMP1]], label [[A:%.*]], label [[B:%.*]]
 ; CHECK:       A:
 ; CHECK-NEXT:    call void @g1()
 ; CHECK-NEXT:    ret void
 ; CHECK:       B:
 ; CHECK-NEXT:    call void @g2()
 ; CHECK-NEXT:    ret void
 ;
   %v = and i32 %flag, 1
   %c = icmp eq i32 %v, 0
   %fr = freeze i1 %c
   br i1 %fr, label %A, label %B
 A:
   call void @g1()
   ret void
 B:
   call void @g2()
   ret void
 }
 
 define void @and_bitmask_r(i32 %flag) {
 ; CHECK-LABEL: @and_bitmask_r(
 ; CHECK-NEXT:    [[V:%.*]] = and i32 1, [[FLAG:%.*]]
 ; CHECK-NEXT:    [[FR:%.*]] = freeze i32 [[V]]
-; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 0, [[FR]]
-; CHECK-NEXT:    br i1 [[C]], label [[A:%.*]], label [[B:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 0, [[FR]]
+; CHECK-NEXT:    br i1 [[TMP1]], label [[A:%.*]], label [[B:%.*]]
 ; CHECK:       A:
 ; CHECK-NEXT:    call void @g1()
 ; CHECK-NEXT:    ret void
 ; CHECK:       B:
 ; CHECK-NEXT:    call void @g2()
 ; CHECK-NEXT:    ret void
 ;
   %v = and i32 1, %flag

llvm/test/Transforms/CodeGenPrepare/X86/select.ll

 
 
 ; An 'fdiv' is expensive, so sink it rather than speculatively execute it.
 
 define float @fdiv_true_sink(float %a, float %b) {
 ; CHECK-LABEL: @fdiv_true_sink(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[SEL_FROZEN:%.*]] = freeze float [[A:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ogt float [[SEL_FROZEN]], 1.000000e+00
-; CHECK-NEXT:    br i1 [[CMP]], label [[SELECT_TRUE_SINK:%.*]], label [[SELECT_END:%.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = fcmp ogt float [[SEL_FROZEN]], 1.000000e+00
+; CHECK-NEXT:    br i1 [[TMP0]], label [[SELECT_TRUE_SINK:%.*]], label [[SELECT_END:%.*]]
 ; CHECK:       select.true.sink:
 ; CHECK-NEXT:    [[DIV:%.*]] = fdiv float [[A]], [[B:%.*]]
 ; CHECK-NEXT:    br label [[SELECT_END]]
 ; CHECK:       select.end:
 ; CHECK-NEXT:    [[SEL:%.*]] = phi float [ [[DIV]], [[SELECT_TRUE_SINK]] ], [ 2.000000e+00, [[ENTRY:%.*]] ]
 ; CHECK-NEXT:    ret float [[SEL]]
 ;
 ; DEBUG-LABEL: @fdiv_true_sink(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[SEL_FROZEN:%.*]] = freeze float [[A:%.*]]
-; DEBUG-NEXT:    [[CMP:%.*]] = fcmp ogt float [[SEL_FROZEN]], 1.000000e+00, !dbg [[DBG24:![0-9]+]]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP]], metadata [[META22:![0-9]+]], metadata !DIExpression()), !dbg [[DBG24]]
-; DEBUG-NEXT:    br i1 [[CMP]], label [[SELECT_TRUE_SINK:%.*]], label [[SELECT_END:%.*]], !dbg [[DBG25:![0-9]+]]
+; DEBUG-NEXT:    [[TMP0:%.*]] = fcmp ogt float [[SEL_FROZEN]], 1.000000e+00, !dbg [[DBG24:![0-9]+]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 undef, metadata [[META22:![0-9]+]], metadata !DIExpression()), !dbg [[DBG24]]
+; DEBUG-NEXT:    br i1 [[TMP0]], label [[SELECT_TRUE_SINK:%.*]], label [[SELECT_END:%.*]], !dbg [[DBG25:![0-9]+]]
 ; DEBUG:       select.true.sink:
 ; DEBUG-NEXT:    [[DIV:%.*]] = fdiv float [[A]], [[B:%.*]], !dbg [[DBG26:![0-9]+]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[DIV]], metadata [[META21:![0-9]+]], metadata !DIExpression()), !dbg [[DBG26]]
 ; DEBUG-NEXT:    br label [[SELECT_END]], !dbg [[DBG25]]
 ; DEBUG:       select.end:
 ; DEBUG-NEXT:    [[SEL:%.*]] = phi float [ [[DIV]], [[SELECT_TRUE_SINK]] ], [ 2.000000e+00, [[ENTRY:%.*]] ], !dbg [[DBG25]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[SEL]], metadata [[META23:![0-9]+]], metadata !DIExpression()), !dbg [[DBG25]]
 ; DEBUG-NEXT:    ret float [[SEL]], !dbg [[DBG27:![0-9]+]]
 ;
 entry:
   %div = fdiv float %a, %b
   %cmp = fcmp ogt float %a, 1.0
   %sel = select i1 %cmp, float %div, float 2.0
   ret float %sel
 }
 
 define float @fdiv_false_sink(float %a, float %b) {
 ; CHECK-LABEL: @fdiv_false_sink(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[SEL_FROZEN:%.*]] = freeze float [[A:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ogt float [[SEL_FROZEN]], 3.000000e+00
-; CHECK-NEXT:    br i1 [[CMP]], label [[SELECT_END:%.*]], label [[SELECT_FALSE_SINK:%.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = fcmp ogt float [[SEL_FROZEN]], 3.000000e+00
+; CHECK-NEXT:    br i1 [[TMP0]], label [[SELECT_END:%.*]], label [[SELECT_FALSE_SINK:%.*]]
 ; CHECK:       select.false.sink:
 ; CHECK-NEXT:    [[DIV:%.*]] = fdiv float [[A]], [[B:%.*]]
 ; CHECK-NEXT:    br label [[SELECT_END]]
 ; CHECK:       select.end:
 ; CHECK-NEXT:    [[SEL:%.*]] = phi float [ 4.000000e+00, [[ENTRY:%.*]] ], [ [[DIV]], [[SELECT_FALSE_SINK]] ]
 ; CHECK-NEXT:    ret float [[SEL]]
 ;
 ; DEBUG-LABEL: @fdiv_false_sink(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[SEL_FROZEN:%.*]] = freeze float [[A:%.*]]
-; DEBUG-NEXT:    [[CMP:%.*]] = fcmp ogt float [[SEL_FROZEN]], 3.000000e+00, !dbg [[DBG33:![0-9]+]]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP]], metadata [[META31:![0-9]+]], metadata !DIExpression()), !dbg [[DBG33]]
-; DEBUG-NEXT:    br i1 [[CMP]], label [[SELECT_END:%.*]], label [[SELECT_FALSE_SINK:%.*]], !dbg [[DBG34:![0-9]+]]
+; DEBUG-NEXT:    [[TMP0:%.*]] = fcmp ogt float [[SEL_FROZEN]], 3.000000e+00, !dbg [[DBG33:![0-9]+]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 undef, metadata [[META31:![0-9]+]], metadata !DIExpression()), !dbg [[DBG33]]
+; DEBUG-NEXT:    br i1 [[TMP0]], label [[SELECT_END:%.*]], label [[SELECT_FALSE_SINK:%.*]], !dbg [[DBG34:![0-9]+]]
 ; DEBUG:       select.false.sink:
 ; DEBUG-NEXT:    [[DIV:%.*]] = fdiv float [[A]], [[B:%.*]], !dbg [[DBG35:![0-9]+]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[DIV]], metadata [[META30:![0-9]+]], metadata !DIExpression()), !dbg [[DBG35]]
 ; DEBUG-NEXT:    br label [[SELECT_END]], !dbg [[DBG34]]
 ; DEBUG:       select.end:
 ; DEBUG-NEXT:    [[SEL:%.*]] = phi float [ 4.000000e+00, [[ENTRY:%.*]] ], [ [[DIV]], [[SELECT_FALSE_SINK]] ], !dbg [[DBG34]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[SEL]], metadata [[META32:![0-9]+]], metadata !DIExpression()), !dbg [[DBG34]]
 ; DEBUG-NEXT:    ret float [[SEL]], !dbg [[DBG36:![0-9]+]]
 ;
 entry:
   %div = fdiv float %a, %b
   %cmp = fcmp ogt float %a, 3.0
   %sel = select i1 %cmp, float 4.0, float %div
   ret float %sel
 }
 
 define float @fdiv_both_sink(float %a, float %b) {
 ; CHECK-LABEL: @fdiv_both_sink(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[SEL_FROZEN:%.*]] = freeze float [[A:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ogt float [[SEL_FROZEN]], 5.000000e+00
-; CHECK-NEXT:    br i1 [[CMP]], label [[SELECT_TRUE_SINK:%.*]], label [[SELECT_FALSE_SINK:%.*]]
+; CHECK-NEXT:    [[TMP0:%.*]] = fcmp ogt float [[SEL_FROZEN]], 5.000000e+00
+; CHECK-NEXT:    br i1 [[TMP0]], label [[SELECT_TRUE_SINK:%.*]], label [[SELECT_FALSE_SINK:%.*]]
 ; CHECK:       select.true.sink:
 ; CHECK-NEXT:    [[DIV1:%.*]] = fdiv float [[A]], [[B:%.*]]
 ; CHECK-NEXT:    br label [[SELECT_END:%.*]]
 ; CHECK:       select.false.sink:
 ; CHECK-NEXT:    [[DIV2:%.*]] = fdiv float [[B]], [[A]]
 ; CHECK-NEXT:    br label [[SELECT_END]]
 ; CHECK:       select.end:
 ; CHECK-NEXT:    [[SEL:%.*]] = phi float [ [[DIV1]], [[SELECT_TRUE_SINK]] ], [ [[DIV2]], [[SELECT_FALSE_SINK]] ]
 ; CHECK-NEXT:    ret float [[SEL]]
 ;
 ; DEBUG-LABEL: @fdiv_both_sink(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[SEL_FROZEN:%.*]] = freeze float [[A:%.*]]
-; DEBUG-NEXT:    [[CMP:%.*]] = fcmp ogt float [[SEL_FROZEN]], 5.000000e+00, !dbg [[DBG43:![0-9]+]]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP]], metadata [[META41:![0-9]+]], metadata !DIExpression()), !dbg [[DBG43]]
-; DEBUG-NEXT:    br i1 [[CMP]], label [[SELECT_TRUE_SINK:%.*]], label [[SELECT_FALSE_SINK:%.*]], !dbg [[DBG44:![0-9]+]]
+; DEBUG-NEXT:    [[TMP0:%.*]] = fcmp ogt float [[SEL_FROZEN]], 5.000000e+00, !dbg [[DBG43:![0-9]+]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 undef, metadata [[META41:![0-9]+]], metadata !DIExpression()), !dbg [[DBG43]]
+; DEBUG-NEXT:    br i1 [[TMP0]], label [[SELECT_TRUE_SINK:%.*]], label [[SELECT_FALSE_SINK:%.*]], !dbg [[DBG44:![0-9]+]]
 ; DEBUG:       select.true.sink:
 ; DEBUG-NEXT:    [[DIV1:%.*]] = fdiv float [[A]], [[B:%.*]], !dbg [[DBG45:![0-9]+]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[DIV1]], metadata [[META39:![0-9]+]], metadata !DIExpression()), !dbg [[DBG45]]
 ; DEBUG-NEXT:    br label [[SELECT_END:%.*]], !dbg [[DBG44]]
 ; DEBUG:       select.false.sink:
 ; DEBUG-NEXT:    [[DIV2:%.*]] = fdiv float [[B]], [[A]], !dbg [[DBG46:![0-9]+]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[DIV2]], metadata [[META40:![0-9]+]], metadata !DIExpression()), !dbg [[DBG46]]
 ; DEBUG-NEXT:    br label [[SELECT_END]], !dbg [[DBG44]]