[InstCombine] remove one-use restriction for not (cmp P, A, B) --> cmp P', A, B

[spatel]

Summary

We can always move the 'not' op of a compare into the predicate of the compare itself to eliminate the not (xor).

The test case (poo) that looks worse was discussed in D33172 / PR32791 ( https://bugs.llvm.org/show_bug.cgi?id=32791 ). The common value is easy for CSE to detect, so there should be no actual regressions in that case.

D35044 reminded me that I had a draft patch for this ready to go once PR32791 was resolved. That change will make this cleaner, but it doesn't affect the functionality.

This patch will help clear the way for the remaining fixes needed to resolve:
https://bugs.llvm.org/show_bug.cgi?id=32706 (making 'not' ops rather than random 'xor' canonical in IR).

[craig.topper]

Are any of the improved tests, cases that wouldn't be improved by my earlier proposal to demorgan logical ops on compare when one side is free to invert and the other side isn't. Which I think avoids the CSE issues.

test/Transforms/SimplifyCFG/merge-cond-stores.ll

45

This test also got worse, but I guess it will CSE too?

[spatel]

In D35182#803754, @craig.topper wrote:

Are any of the improved tests, cases that wouldn't be improved by my earlier proposal to demorgan logical ops on compare when one side is free to invert and the other side isn't. Which I think avoids the CSE issues.

I was wondering about that too. You're referring to D32725? We're getting the same outcome on the SimplifyCFG tests - 'test_simple' and 'test_recursive', but yes, we have the CSE-related diff on 'test_simple_commuted'.

test/Transforms/SimplifyCFG/merge-cond-stores.ll

45

Right - we'd expect X3 to be matched with X2 and deleted by -early-cse.

[spatel]

Ping.

For reference, I mentioned this patch in a related discussion about instcombine and folding of cmps:
http://lists.llvm.org/pipermail/llvm-dev/2017-July/115452.html

Based on that thread, I think we do want to proceed with this canonicalization, rather than the inverse transform suggested in:
https://bugs.llvm.org/show_bug.cgi?id=27431
...but let me know if there's a better way.

[craig.topper]

We definitely should do something to fix an invert of a compare feeding an 'and' or 'or' op. I've seen it prevent folding 'and of icmps' or 'or of icmps' because we won't look through the not in those folds. The ones I've seen would have been handled by something like D32725.

This doesn't do anything to fix PR27431 right?

Do we have any real motivating examples that don't involve the compares being used by bitwise operations that D32725 would take care of?

[spatel]

In D35182#828175, @craig.topper wrote:

We definitely should do something to fix an invert of a compare feeding an 'and' or 'or' op. I've seen it prevent folding 'and of icmps' or 'or of icmps' because we won't look through the not in those folds. The ones I've seen would have been handled by something like D32725.

This doesn't do anything to fix PR27431 right?

int a;
char b;
int fn1() { return a && b || a && b; }

This eliminates a 'not' op, but doesn't actually solve that example. Currently, we have this at -O2:

define i32 @fn1(i32 %a, i8 signext %b) {
entry:
  %tobool = icmp ne i32 %a, 0
  %tobool.not = xor i1 %tobool, true
  %tobool1 = icmp eq i8 %b, 0
  %or.cond = or i1 %tobool1, %tobool.not
  br i1 %or.cond, label %lor.rhs, label %lor.end

lor.rhs:                                          ; preds = %entry
  %tobool4 = icmp ne i8 %b, 0
  %0 = and i1 %tobool, %tobool4
  %phitmp = zext i1 %0 to i32
  br label %lor.end

lor.end:                                          ; preds = %entry, %lor.rhs
  %1 = phi i32 [ %phitmp, %lor.rhs ], [ 1, %entry ]
  ret i32 %1
}

With this patch applied, we get:

define i32 @fn1(i32 %a, i8 signext %b)  {
entry:
  %tobool.not = icmp eq i32 %a, 0
  %tobool1 = icmp eq i8 %b, 0
  %or.cond = or i1 %tobool.not, %tobool1
  br i1 %or.cond, label %lor.rhs, label %lor.end

lor.rhs:                                          ; preds = %entry
  %tobool = icmp ne i32 %a, 0
  %tobool4 = icmp ne i8 %b, 0
  %0 = and i1 %tobool, %tobool4
  %phitmp = zext i1 %0 to i32
  br label %lor.end

lor.end:                                          ; preds = %entry, %lor.rhs
  %1 = phi i32 [ %phitmp, %lor.rhs ], [ 1, %entry ]
  ret i32 %1
}

This form (more clearly DeMorganized ops) seems easier to have GVN match?

Do we have any real motivating examples that don't involve the compares being used by bitwise operations that D32725 would take care of?

My motivation is actually PR32706...although I've lost track of how these things actually interact to conflict with each other and infinite loop.

[craig.topper]

That's not really the IR for that C code is it. The C code has two global variables and the IR has two arguments.

[spatel]

In D35182#828364, @craig.topper wrote:

That's not really the IR for that C code is it. The C code has two global variables and the IR has two arguments.

Oops - that's correct. I simplified the example from PR27431 to:

int fn1(int a, char b) { return (a && b) || (a && b); }

It shows the same problem though AFAICT.

[davide]

In D35182#828371, @spatel wrote:

In D35182#828364, @craig.topper wrote:

That's not really the IR for that C code is it. The C code has two global variables and the IR has two arguments.

Oops - that's correct. I simplified the example from PR27431 to:

int fn1(int a, char b) { return (a && b) || (a && b); }

It shows the same problem though AFAICT.

Unless I'm reading this example incorrectly, which may be possible, this is clearly an example of redundant expression.
FWIW, you should be able to prove that:
a' OR a can be simplified to a
if a is structurally equivalent to a'

In this case the two things are trivially structurally equivalent.
Same opcode, same operands.

This, FWIW, it's the whole point of doing value numbering.

[craig.topper]

The C code with the global variables never creates a 'not' operation and never combines the 4 compares with 0. For your modified version, it looks like something combined the two compares with A into a single compare and the xor and with this patch instcombine undoes that. Isn't that moving in the opposite direction of PR27431?

[spatel]

In D35182#828396, @craig.topper wrote:

The C code with the global variables never creates a 'not' operation and never combines the 4 compares with 0. For your modified version, it looks like something combined the two compares with A into a single compare and the xor and with this patch instcombine undoes that. Isn't that moving in the opposite direction of PR27431?

Yes, you're correct - the 'not' isn't in the version with the globals for some reason. But the end result is similar - we fail to recognize the DeMorgan equivalents.

And yes, this is going in the other direction from the suggestion in PR27431. There are 3 options as I see it:

1. We standardize instcombine to always transform not(cmp) to the inverted predicate (this patch); we enhance GVN or other passes to recognize DeMorgan patterns (which we may want to do first and anyway).
2. We standardize instcombine to not transform not(cmp) and enhance its pattern matching to account for the extra 'not' ops.
3. We live with the current instcombine behavior (not(cmp) is transformed with only 1-use), and add folds like D32725. That patch alone isn't enough to catch the PR27431 example with globals, is it?

[craig.topper]

I don't believe D32725 won't do anything to the patch with globals in it. I don't believe an xor ever exists there.

I think the globals test is somehow different do to the presence of the loads of the globals that don't exist in the argument test.

I've been wondering if there's some way to canonicalize (br (and cmp ne, cmp ne) and (br (or cmp eq, cmp eq)) to the same thing by inverting the branch targets in one which would allow CSE to catch it. But I think it gets difficult when there are more than 2 compares involved that need to be canonicalized since you need to walk a tree to make sure you can flip all the compares.

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

if (match(NotVal, m_LShr(m_APInt(C), m_Value(Y))) && C->isNonNegative()) {
       // ~(C >>u Y) --> ~C >>s Y (when inverting the replicated sign bits)
       Constant *NotC = ConstantInt::get(I.getType(), ~(*C));
       return BinaryOperator::CreateAShr(NotC, Y);
     }
   }
 
   // not (cmp A, B) = !cmp A, B
   CmpInst::Predicate Pred;
-  if (match(&I, m_Not(m_OneUse(m_Cmp(Pred, m_Value(), m_Value()))))) {
-    cast<CmpInst>(Op0)->setPredicate(CmpInst::getInversePredicate(Pred));
-    return replaceInstUsesWith(I, Op0);
+  Value *CmpL, *CmpR;
+  if (match(&I, m_Not(m_Cmp(Pred, m_Value(CmpL), m_Value(CmpR))))) {
+    CmpInst::Predicate InvPred = CmpInst::getInversePredicate(Pred);
+    return CmpInst::Create(cast<CmpInst>(I.getOperand(0))->getOpcode(), InvPred,
+                           CmpL, CmpR);
   }
 
   if (ConstantInt *RHSC = dyn_cast<ConstantInt>(Op1)) {
     // fold (xor(zext(cmp)), 1) and (xor(sext(cmp)), -1) to ext(!cmp).
     if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) {
       if (CmpInst *CI = dyn_cast<CmpInst>(Op0C->getOperand(0))) {
         if (CI->hasOneUse() && Op0C->hasOneUse()) {
           Instruction::CastOps Opcode = Op0C->getOpcode();

test/Transforms/InstCombine/logical-select.ll

;
   %iftmp.0.0 = select i1 %t0, i32 -1, i32 0
   %t1 = and i32 %iftmp.0.0, %c
   %not = xor i32 %iftmp.0.0, -1
   %t2 = and i32 %not, %d
   %t3 = or i32 %t1, %t2
   ret i32 %t3
 }
 
+; This is a variation of the next test; see the bug report for more info.
+
 define i32 @poo(i32 %a, i32 %b, i32 %c, i32 %d) {
 ; CHECK-LABEL: @poo(
 ; CHECK-NEXT:    [[T0:%.*]] = icmp slt i32 %a, %b
-; CHECK-NEXT:    [[T3:%.*]] = select i1 [[T0]], i32 %c, i32 %d
+; CHECK-NEXT:    [[T1:%.*]] = select i1 [[T0]], i32 %c, i32 0
+; CHECK-NEXT:    [[NOT_T0:%.*]] = icmp slt i32 %a, %b
+; CHECK-NEXT:    [[T2:%.*]] = select i1 [[NOT_T0]], i32 0, i32 %d
+; CHECK-NEXT:    [[T3:%.*]] = or i32 [[T1]], [[T2]]
 ; CHECK-NEXT:    ret i32 [[T3]]
 ;
   %t0 = icmp slt i32 %a, %b
   %iftmp.0.0 = select i1 %t0, i32 -1, i32 0
   %t1 = and i32 %iftmp.0.0, %c
   %iftmp = select i1 %t0, i32 0, i32 -1
   %t2 = and i32 %iftmp, %d
   %t3 = or i32 %t1, %t2

test/Transforms/InstCombine/select-cmp-br.ll

 
 define void @test1(%C* %arg) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP:%.*]] = getelementptr inbounds [[C:%.*]], %C* [[ARG:%.*]], i64 0, i32 0, i32 0
 ; CHECK-NEXT:    [[M:%.*]] = load i64*, i64** [[TMP]], align 8
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[C]], %C* [[ARG]], i64 1, i32 0, i32 0
 ; CHECK-NEXT:    [[N:%.*]] = load i64*, i64** [[TMP1]], align 8
-; CHECK-NEXT:    [[NOT_TMP5:%.*]] = icmp ne i64* [[M]], [[N]]
 ; CHECK-NEXT:    [[TMP71:%.*]] = icmp eq %C* [[ARG]], null
+; CHECK-NEXT:    [[NOT_TMP5:%.*]] = icmp ne i64* [[M]], [[N]]
 ; CHECK-NEXT:    [[TMP7:%.*]] = or i1 [[TMP71]], [[NOT_TMP5]]
 ; CHECK-NEXT:    br i1 [[TMP7]], label [[BB10:%.*]], label [[BB8:%.*]]
 ; CHECK:       bb:
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb8:
 ; CHECK-NEXT:    [[TMP9:%.*]] = getelementptr inbounds [[C]], %C* [[ARG]], i64 0, i32 0
 ; CHECK-NEXT:    tail call void @bar(%struct.S* [[TMP9]])
 ; CHECK-NEXT:    br label [[BB:%.*]]

 
 define void @test3(%C* %arg) {
 ; CHECK-LABEL: @test3(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP:%.*]] = getelementptr inbounds [[C:%.*]], %C* [[ARG:%.*]], i64 0, i32 0, i32 0
 ; CHECK-NEXT:    [[M:%.*]] = load i64*, i64** [[TMP]], align 8
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[C]], %C* [[ARG]], i64 1, i32 0, i32 0
 ; CHECK-NEXT:    [[N:%.*]] = load i64*, i64** [[TMP1]], align 8
-; CHECK-NEXT:    [[NOT_TMP5:%.*]] = icmp ne i64* [[M]], [[N]]
 ; CHECK-NEXT:    [[TMP71:%.*]] = icmp eq %C* [[ARG]], null
+; CHECK-NEXT:    [[NOT_TMP5:%.*]] = icmp ne i64* [[M]], [[N]]
 ; CHECK-NEXT:    [[TMP7:%.*]] = or i1 [[TMP71]], [[NOT_TMP5]]
 ; CHECK-NEXT:    br i1 [[TMP7]], label [[BB10:%.*]], label [[BB8:%.*]]
 ; CHECK:       bb:
 ; CHECK-NEXT:    ret void
 ; CHECK:       bb8:
 ; CHECK-NEXT:    [[TMP9:%.*]] = getelementptr inbounds [[C]], %C* [[ARG]], i64 0, i32 0
 ; CHECK-NEXT:    tail call void @bar(%struct.S* [[TMP9]])
 ; CHECK-NEXT:    br label [[BB:%.*]]

test/Transforms/LoopVectorize/if-conversion-nest.ll

 ; CHECK-NEXT:    [[TMP10:%.*]] = bitcast i32* [[TMP9]] to <4 x i32>*
 ; CHECK-NEXT:    [[WIDE_LOAD6:%.*]] = load <4 x i32>, <4 x i32>* [[TMP10]], align 4, !alias.scope !3
 ; CHECK-NEXT:    [[TMP11:%.*]] = icmp sgt <4 x i32> [[WIDE_LOAD]], [[WIDE_LOAD6]]
 ; CHECK-NEXT:    [[TMP12:%.*]] = icmp sgt <4 x i32> [[WIDE_LOAD]], <i32 19, i32 19, i32 19, i32 19>
 ; CHECK-NEXT:    [[TMP13:%.*]] = icmp slt <4 x i32> [[WIDE_LOAD6]], <i32 4, i32 4, i32 4, i32 4>
 ; CHECK-NEXT:    [[TMP14:%.*]] = select <4 x i1> [[TMP13]], <4 x i32> <i32 4, i32 4, i32 4, i32 4>, <4 x i32> <i32 5, i32 5, i32 5, i32 5>
 ; CHECK-NEXT:    [[TMP15:%.*]] = and <4 x i1> [[TMP12]], [[TMP11]]
 ; CHECK-NEXT:    [[PREDPHI:%.*]] = select <4 x i1> [[TMP15]], <4 x i32> <i32 3, i32 3, i32 3, i32 3>, <4 x i32> <i32 9, i32 9, i32 9, i32 9>
-; CHECK-NEXT:    [[TMP16:%.*]] = xor <4 x i1> [[TMP12]], <i1 true, i1 true, i1 true, i1 true>
-; CHECK-NEXT:    [[TMP17:%.*]] = and <4 x i1> [[TMP11]], [[TMP16]]
+; CHECK-NEXT:    [[TMP16:%.*]] = icmp slt <4 x i32> [[WIDE_LOAD]], <i32 20, i32 20, i32 20, i32 20>
+; CHECK-NEXT:    [[TMP17:%.*]] = and <4 x i1> [[TMP16]], [[TMP11]]
 ; CHECK-NEXT:    [[PREDPHI7:%.*]] = select <4 x i1> [[TMP17]], <4 x i32> [[TMP14]], <4 x i32> [[PREDPHI]]
 ; CHECK-NEXT:    [[TMP18:%.*]] = bitcast i32* [[TMP7]] to <4 x i32>*
 ; CHECK-NEXT:    store <4 x i32> [[PREDPHI7]], <4 x i32>* [[TMP18]], align 4, !alias.scope !0, !noalias !3
 ; CHECK-NEXT:    [[INDEX_NEXT]] = add i64 [[INDEX]], 4
 ; CHECK-NEXT:    [[TMP19:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]]
 ; CHECK-NEXT:    br i1 [[TMP19]], label [[MIDDLE_BLOCK:%.*]], label [[VECTOR_BODY]], !llvm.loop !5
 ; CHECK:       middle.block:
 ; CHECK-NEXT:    [[CMP_N:%.*]] = icmp eq i32 [[TMP3]], 0

test/Transforms/LoopVectorize/if-conversion.ll

 ;      k = k * 5 + 3;
 ;
 ;    a[i] = k;  <---- K is a phi node that becomes vector-select.
 ;  }
 ;}
 
 ;CHECK-LABEL: @function0(
 ;CHECK: load <4 x i32>
-;CHECK: icmp sgt <4 x i32>
 ;CHECK: mul <4 x i32>
 ;CHECK: add <4 x i32>
+;CHECK: icmp sgt <4 x i32>
 ;CHECK: select <4 x i1>
 ;CHECK: ret i32
 define i32 @function0(i32* nocapture %a, i32* nocapture %b, i32 %start, i32 %end) nounwind uwtable ssp {
 entry:
   %cmp16 = icmp slt i32 %start, %end
   br i1 %cmp16, label %for.body.lr.ph, label %for.end
 
 for.body.lr.ph:

 ;     if (A[i] > 30)
 ;       sum += A[i] + 2;
 ;
 ;   return sum;
 ; }
 
 ;CHECK-LABEL: @reduction_func(
 ;CHECK: load <4 x i32>
-;CHECK: icmp slt <4 x i32>
 ;CHECK: add <4 x i32>
+;CHECK: icmp slt <4 x i32>
 ;CHECK: select <4 x i1>
 ;CHECK: ret i32
 define i32 @reduction_func(i32* nocapture %A, i32 %n) nounwind uwtable readonly ssp {
 entry:
   %cmp10 = icmp sgt i32 %n, 0
   br i1 %cmp10, label %for.body, label %for.end
 
 for.body:                                         ; preds = %entry, %for.inc

test/Transforms/SimplifyCFG/merge-cond-stores.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -simplifycfg -instcombine < %s -simplifycfg-merge-cond-stores=true -simplifycfg-merge-cond-stores-aggressively=false -phi-node-folding-threshold=2 -S | FileCheck %s
 
 ; This test should succeed and end up if-converted.
 define void @test_simple(i32* %p, i32 %a, i32 %b) {
 ; CHECK-LABEL: @test_simple(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = icmp ne i32 [[A:%.*]], 0
-; CHECK-NEXT:    [[X2:%.*]] = icmp eq i32 [[B:%.*]], 0
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[X2]], true
-; CHECK-NEXT:    [[TMP2:%.*]] = or i1 [[TMP0]], [[TMP1]]
-; CHECK-NEXT:    br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP4:%.*]]
-; CHECK:         [[NOT_X2:%.*]] = xor i1 [[X2]], true
+; CHECK-NEXT:    [[TMP0:%.*]] = or i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[TMP0]], 0
+; CHECK-NEXT:    br i1 [[TMP1]], label [[TMP3:%.*]], label [[TMP2:%.*]]
+; CHECK:         [[NOT_X2:%.*]] = icmp ne i32 [[B]], 0
 ; CHECK-NEXT:    [[DOT:%.*]] = zext i1 [[NOT_X2]] to i32
 ; CHECK-NEXT:    store i32 [[DOT]], i32* [[P:%.*]], align 4
-; CHECK-NEXT:    br label [[TMP4]]
+; CHECK-NEXT:    br label [[TMP3]]
 ; CHECK:         ret void
 ;
 entry:
   %x1 = icmp eq i32 %a, 0
   br i1 %x1, label %fallthrough, label %yes1
 
 yes1:
   store i32 0, i32* %p

 ; This is the same as test_simple, but the branch target order has been swapped
 define void @test_simple_commuted(i32* %p, i32 %a, i32 %b) {
 ; CHECK-LABEL: @test_simple_commuted(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[X1:%.*]] = icmp eq i32 [[A:%.*]], 0
 ; CHECK-NEXT:    [[X2:%.*]] = icmp eq i32 [[B:%.*]], 0
 ; CHECK-NEXT:    [[TMP0:%.*]] = or i1 [[X1]], [[X2]]
 ; CHECK-NEXT:    br i1 [[TMP0]], label [[TMP1:%.*]], label [[TMP2:%.*]]
-; CHECK:         [[DOT:%.*]] = zext i1 [[X2]] to i32
+; CHECK:         [[X3:%.*]] = icmp eq i32 [[B:%.*]], 0
+; CHECK-NEXT:    [[DOT:%.*]] = zext i1 [[X3]] to i32
 ; CHECK-NEXT:    store i32 [[DOT]], i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    br label [[TMP2]]
 ; CHECK:         ret void
 ;
 entry:
   %x1 = icmp eq i32 %a, 0
   br i1 %x1, label %yes1, label %fallthrough
 

 end:
   ret void
 }
 
 ; This test should entirely fold away, leaving one large basic block.
 define void @test_recursive(i32* %p, i32 %a, i32 %b, i32 %c, i32 %d) {
 ; CHECK-LABEL: @test_recursive(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = or i32 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[X4:%.*]] = icmp eq i32 [[D:%.*]], 0
+; CHECK-NEXT:    [[TMP0:%.*]] = or i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = or i32 [[TMP0]], [[C:%.*]]
-; CHECK-NEXT:    [[TMP3:%.*]] = icmp ne i32 [[TMP1]], 0
-; CHECK-NEXT:    [[TMP2:%.*]] = xor i1 [[X4]], true
-; CHECK-NEXT:    [[TMP4:%.*]] = or i1 [[TMP3]], [[TMP2]]
-; CHECK-NEXT:    br i1 [[TMP4]], label [[TMP5:%.*]], label [[TMP6:%.*]]
-; CHECK:         [[X3:%.*]] = icmp eq i32 [[C]], 0
+; CHECK-NEXT:    [[TMP2:%.*]] = or i32 [[TMP1]], [[D:%.*]]
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i32 [[TMP2]], 0
+; CHECK-NEXT:    br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
+; CHECK:         [[X4:%.*]] = icmp eq i32 [[D]], 0
+; CHECK-NEXT:    [[X3:%.*]] = icmp eq i32 [[C]], 0
 ; CHECK-NEXT:    [[NOT_X2:%.*]] = icmp ne i32 [[B]], 0
 ; CHECK-NEXT:    [[DOT:%.*]] = zext i1 [[NOT_X2]] to i32
 ; CHECK-NEXT:    [[DOT_:%.*]] = select i1 [[X3]], i32 [[DOT]], i32 2
 ; CHECK-NEXT:    [[DOT__:%.*]] = select i1 [[X4]], i32 [[DOT_]], i32 3
 ; CHECK-NEXT:    store i32 [[DOT__]], i32* [[P:%.*]], align 4
-; CHECK-NEXT:    br label [[TMP6]]
+; CHECK-NEXT:    br label [[TMP5]]
 ; CHECK:         ret void
 ;
 entry:
   %x1 = icmp eq i32 %a, 0
   br i1 %x1, label %fallthrough, label %yes1
 
 yes1:
   store i32 0, i32* %p