[InstCombine] OptimizePointerDifference when a gep has phi ptr

[bipmis]

Summary

For scenarios like
phi(sub(prttoint(A), ptrint(B)), ...)
where A -> GEP(PHI(gep A, B)) and B is a ptr/GEP
if the use of this sub results in a cmp with 0, or(cmp with 0) and
the difference of Indexes b/w 2 GEP's is a positive index
the sub can essentially be folded.

[bipmis]

Gentle Ping.

[goldstein.w.n]

Can you add alive2 links?

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

96

nit: Can you put this decl a bit later in the file? (After the block of visit*)

llvm/test/Transforms/InstCombine/sub-gep.ll

472

Can you precommit tests?

[bipmis]

Rebase patch after pre-committing tests. Address review comments.
Alive 2 links
https://alive2.llvm.org/ce/z/wZJfzE
https://alive2.llvm.org/ce/z/izA8ij

[bipmis]

Ping.

[goldstein.w.n]

In D157977#4636857, @bipmis wrote:

Rebase patch after pre-committing tests. Address review comments.
Alive 2 links
https://alive2.llvm.org/ce/z/wZJfzE
https://alive2.llvm.org/ce/z/izA8ij

These can/should be simplified a great deal.
For example if I understand correctly youre trying to transform the following pattern:

define i1 @src(ptr %p, i64 %A, i64 %B, i64 %C, i1 %c) {
entry:
  br i1 %c, label %true, label %false

true:
  %p_gepA = getelementptr i8, ptr %p, i64 %A
  br label %false
false:
  %p_phi = phi ptr [ %p_gepA, %true ], [ %p, %entry ]
  %phi_gepC = getelementptr i8, ptr %p_phi, i64 %C

  %gepC_int = ptrtoint ptr %phi_gepC to i64
  %p_gepB = getelementptr i8, ptr %p, i64 %B
  %gepB_int = ptrtoint ptr %p_gepB to i64
  %sub = sub i64 %gepC_int, %gepB_int
  %r = icmp eq i64 %sub, 0
  ret i1 %r
}

Also in general this patch appears to be doing a lot more than the summary indicates.
Please update to summary to be more precise.

AFAICT Its really:

(phi, (sub (phi (phi GEPA), GEPB), GEPB), ...)
or
(phi, (ashr/lshr (sub (phi (phi GEPA), GEPB), GEPB), ...), ...)

Is that correct?

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

1994

just cast.

1997

These need to be part of proof + tested.

Should probably also use match here but thats not particularly important.

2002

Should be split to a seperate function, otherwise early returns may interfere with other folds.

2012

What is this Or doing here?

[bipmis]

Updated the patch with review comments.

[bipmis]

In D157977#4641397, @goldstein.w.n wrote:

In D157977#4636857, @bipmis wrote:

Rebase patch after pre-committing tests. Address review comments.
Alive 2 links
https://alive2.llvm.org/ce/z/wZJfzE
https://alive2.llvm.org/ce/z/izA8ij

These can/should be simplified a great deal.
For example if I understand correctly youre trying to transform the following pattern:

define i1 @src(ptr %p, i64 %A, i64 %B, i64 %C, i1 %c) {
entry:
  br i1 %c, label %true, label %false

true:
  %p_gepA = getelementptr i8, ptr %p, i64 %A
  br label %false
false:
  %p_phi = phi ptr [ %p_gepA, %true ], [ %p, %entry ]
  %phi_gepC = getelementptr i8, ptr %p_phi, i64 %C

  %gepC_int = ptrtoint ptr %phi_gepC to i64
  %p_gepB = getelementptr i8, ptr %p, i64 %B
  %gepB_int = ptrtoint ptr %p_gepB to i64
  %sub = sub i64 %gepC_int, %gepB_int
  %r = icmp eq i64 %sub, 0
  ret i1 %r
}

Also in general this patch appears to be doing a lot more than the summary indicates.
Please update to summary to be more precise.

AFAICT Its really:

(phi, (sub (phi (phi GEPA), GEPB), GEPB), ...)
or
(phi, (ashr/lshr (sub (phi (phi GEPA), GEPB), GEPB), ...), ...)

Is that correct?

Not exactly. This transform will benefit but what I am trying to address is the test case which has a loop in the given pattern. If the sub which is the result of the loop results in an icmp, or(icmp) and based on the pattern it can be deduced that we can are better off with just the difference of index of the 2 pointers. In our example it then
converts the sub to a sub(gep_index1, gep_index2).
It is also noted that other transforms in presence of TBAA can further reduce this reduction by eliminating the entire loop.

As per my understanding it is a
phi(sub(prttoint(A), ptrint(B)), ...)
where A -> GEP(PHI(gep A, B)) and B is a ptr/GEP

[goldstein.w.n]

In D157977#4643062, @bipmis wrote:

In D157977#4641397, @goldstein.w.n wrote:

In D157977#4636857, @bipmis wrote:

Rebase patch after pre-committing tests. Address review comments.
Alive 2 links
https://alive2.llvm.org/ce/z/wZJfzE
https://alive2.llvm.org/ce/z/izA8ij

These can/should be simplified a great deal.
For example if I understand correctly youre trying to transform the following pattern:

define i1 @src(ptr %p, i64 %A, i64 %B, i64 %C, i1 %c) {
entry:
  br i1 %c, label %true, label %false

true:
  %p_gepA = getelementptr i8, ptr %p, i64 %A
  br label %false
false:
  %p_phi = phi ptr [ %p_gepA, %true ], [ %p, %entry ]
  %phi_gepC = getelementptr i8, ptr %p_phi, i64 %C

  %gepC_int = ptrtoint ptr %phi_gepC to i64
  %p_gepB = getelementptr i8, ptr %p, i64 %B
  %gepB_int = ptrtoint ptr %p_gepB to i64
  %sub = sub i64 %gepC_int, %gepB_int
  %r = icmp eq i64 %sub, 0
  ret i1 %r
}

Also in general this patch appears to be doing a lot more than the summary indicates.
Please update to summary to be more precise.

AFAICT Its really:

(phi, (sub (phi (phi GEPA), GEPB), GEPB), ...)
or
(phi, (ashr/lshr (sub (phi (phi GEPA), GEPB), GEPB), ...), ...)

Is that correct?

Not exactly. This transform will benefit but what I am trying to address is the test case which has a loop in the given pattern. If the sub which is the result of the loop results in an icmp, or(icmp) and based on the pattern it can be deduced that we can are better off with just the difference of index of the 2 pointers. In our example it then
converts the sub to a sub(gep_index1, gep_index2).
It is also noted that other transforms in presence of TBAA can further reduce this reduction by eliminating the entire loop.

As per my understanding it is a
phi(sub(prttoint(A), ptrint(B)), ...)
where A -> GEP(PHI(gep A, B)) and B is a ptr/GEP

So:

(phi (sub (ptrtoint (gep (phi (gep A, (ptrtoint B)), ...)), (ptrtoint B), ...)

?

If so can you make the proofs / tests explicitly test that construct. As well if you are going to keep
the ashr/or stuff in also include that in the proofs/tests.

Even if the motivation is loops, the tests for the InstCombine codes shouldn't have to rely on that.
Its fine to keep some loop tests, but robust tests of all the cases in there simplest form (esp for the
proofs) makes it easier to review.

Also, can you split the tests to a seperate patch so we can see the diff generated by this patch?

[bipmis]

Thanks for the review.
On further observation I see a lot of the optimization of similar kind happening in InstructionCombineCompares.
So a fold should allow for these optimzations to happen. I have made these in the patch https://reviews.llvm.org/D159499
Maybe it would be good to review this first. Thanks

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

Instruction *InstCombinerImpl::visitFAdd(BinaryOperator &I) {
 
   return nullptr;
 }
 
 /// Optimize pointer differences into the same array into a size.  Consider:
 ///  &A[10] - &A[0]: we should compile this to "10".  LHS/RHS are the pointer
 /// operands to the ptrtoint instructions for the LHS/RHS of the subtract.
 Value *InstCombinerImpl::OptimizePointerDifference(Value *LHS, Value *RHS,
-                                                   Type *Ty, bool IsNUW) {
+                                                   Type *Ty, BinaryOperator &I,
+                                                   bool IsNUW) {
   // If LHS is a gep based on RHS or RHS is a gep based on LHS, we can optimize
   // this.
   bool Swapped = false;
   GEPOperator *GEP1 = nullptr, *GEP2 = nullptr;
   if (!isa<GEPOperator>(LHS) && isa<GEPOperator>(RHS)) {
     std::swap(LHS, RHS);
     Swapped = true;
   }
 
   // Require at least one GEP with a common base pointer on both sides.
   if (auto *LHSGEP = dyn_cast<GEPOperator>(LHS)) {
     // (gep X, ...) - X
     if (LHSGEP->getOperand(0)->stripPointerCasts() ==
         RHS->stripPointerCasts()) {
       GEP1 = LHSGEP;
     } else if (auto *RHSGEP = dyn_cast<GEPOperator>(RHS)) {
       // (gep X, ...) - (gep X, ...)
       if (LHSGEP->getOperand(0)->stripPointerCasts() ==
           RHSGEP->getOperand(0)->stripPointerCasts()) {
         GEP1 = LHSGEP;
         GEP2 = RHSGEP;
       }
+    } else if (isa<PHINode>(LHSGEP->getPointerOperand())) {
+      // ( gep (PHI(X+A, X)), ...) - ( gep X, ...)
+      auto *PHI = dyn_cast<PHINode>(LHSGEP->getPointerOperand());
+      if (PHI->getNumIncomingValues() == 2) {
+        auto *FirstInst = cast<Value>(PHI->getIncomingValue(0));
+        auto *SecondInst = cast<Value>(PHI->getIncomingValue(1));
+
+        // Check if one of the PHI Node is same as the RHS and other is same as
+        // LHS.
+        if (FirstInst == LHS && SecondInst == RHS) {
+          // Verify if the GEP is indexed at incrementing addresses and the only
+          // use of SUB is to check if one pointer is higher than the other.
+          APInt Offset1(DL.getIndexTypeSizeInBits(FirstInst->getType()), 0);
+          FirstInst = FirstInst->stripAndAccumulateConstantOffsets(
+              DL, Offset1, /* AllowNonInbounds */ true);
+          APInt Offset2(DL.getIndexTypeSizeInBits(SecondInst->getType()), 0);
+          SecondInst = SecondInst->stripAndAccumulateConstantOffsets(
+              DL, Offset2, /* AllowNonInbounds */ true);
+          if (Offset1.slt(Offset2))
+            return nullptr;
+
+          // Check there is only one use of Substract. Handle scenarios where
+          // only use is a PHI or ashr/lshr(PHI)
+          if (I.hasOneUse()) {
+            PHINode *PHI2 = dyn_cast<PHINode>(I.user_back());
+            if (!PHI2) {
+              // Not a 8-bit Pointer. Need to check shift amt as power of 2?
+              Instruction *PHIUser = cast<Instruction>(I.user_back());
+              PHI2 = dyn_cast<PHINode>(PHIUser->user_back());
+              if ((PHIUser->getOpcode() != Instruction::AShr &&
+                   PHIUser->getOpcode() != Instruction::LShr) ||
+                  !PHIUser->hasOneUse() || !PHI2)
+                return nullptr;
+            }
+
+            // PHI now is an early value or difference of 2 pointers. Can verify
+            // if other Incoming Values are 0. Only use of this PHI is a cmp or
+            // a cmp(or), means it reduces to a type bool.
+            for (const auto *U : PHI2->users()) {
+              ICmpInst::Predicate EqPred;
+              // Match to specific. Handling specific predicates. Can relax to
+              // any predicate when compared with Zero.
+              if (!(U->hasOneUse() &&
+                    ((match(U, m_Or(m_Specific(PHI2), m_Value())) &&
+                      match(U->user_back(),
+                            m_ICmp(EqPred, m_Specific(U), m_Zero())) &&
+                      EqPred == ICmpInst::ICMP_EQ) ||
+                     (match(U, m_ICmp(EqPred, m_Specific(PHI2), m_Zero())) &&
+                      EqPred == ICmpInst::ICMP_NE))))
+                return nullptr;
+            }
+            // If we have reached here the sub of 2 ptr2int's can be folded as
+            // X+A > X
+            GEP1 = LHSGEP;
+          }
+        }
+      }
     }
   }
 
   if (!GEP1)
     return nullptr;
 
   if (GEP2) {
     // (gep X, ...) - (gep X, ...)
if (match(Op1, m_Not(m_Value(X))) &&
     return BinaryOperator::CreateSub(X, Not);
   }
 
   // Optimize pointer differences into the same array into a size.  Consider:
   //  &A[10] - &A[0]: we should compile this to "10".
   Value *LHSOp, *RHSOp;
   if (match(Op0, m_PtrToInt(m_Value(LHSOp))) &&
       match(Op1, m_PtrToInt(m_Value(RHSOp))))
-    if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType(),
+    if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType(), I,
                                                I.hasNoUnsignedWrap()))
       return replaceInstUsesWith(I, Res);
 
   // trunc(p)-trunc(q) -> trunc(p-q)
   if (match(Op0, m_Trunc(m_PtrToInt(m_Value(LHSOp)))) &&
       match(Op1, m_Trunc(m_PtrToInt(m_Value(RHSOp)))))
-    if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType(),
+    if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType(), I,
                                                /* IsNUW */ false))
       return replaceInstUsesWith(I, Res);
 
   // Canonicalize a shifty way to code absolute value to the common pattern.
   // There are 2 potential commuted variants.
   // We're relying on the fact that we only do this transform when the shift has
   // exactly 2 uses and the xor has exactly 1 use (otherwise, we might increase
   // instructions).

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

public:
   // Return Value:
   //    null        - No change was made
   //     I          - Change was made, I is still valid, I may be dead though
   //   otherwise    - Change was made, replace I with returned instruction
   //
   Instruction *visitFNeg(UnaryOperator &I);
   Instruction *visitAdd(BinaryOperator &I);
   Instruction *visitFAdd(BinaryOperator &I);
-  Value *OptimizePointerDifference(
-      Value *LHS, Value *RHS, Type *Ty, bool isNUW);
   Instruction *visitSub(BinaryOperator &I);
   Instruction *visitFSub(BinaryOperator &I);
   Instruction *visitMul(BinaryOperator &I);
   Instruction *visitFMul(BinaryOperator &I);
   Instruction *visitURem(BinaryOperator &I);
   Instruction *visitSRem(BinaryOperator &I);
   Instruction *visitFRem(BinaryOperator &I);
+  Value *OptimizePointerDifference(Value *LHS, Value *RHS, Type *Ty,
+                                   BinaryOperator &I, bool isNUW);
   bool simplifyDivRemOfSelectWithZeroOp(BinaryOperator &I);
   Instruction *commonIRemTransforms(BinaryOperator &I);
   Instruction *commonIDivTransforms(BinaryOperator &I);
   Instruction *visitUDiv(BinaryOperator &I);
   Instruction *visitSDiv(BinaryOperator &I);
   Instruction *visitFDiv(BinaryOperator &I);
   Value *simplifyRangeCheck(ICmpInst *Cmp0, ICmpInst *Cmp1, bool Inverted);
   Instruction *visitAnd(BinaryOperator &I);

llvm/test/Transforms/InstCombine/sub-gep.ll

 ; CHECK-NEXT:    br i1 [[CMP1_I]], label [[_Z3FOOPKC_EXIT]], label [[WHILE_COND_I:%.*]]
 ; CHECK:       while.cond.i:
 ; CHECK-NEXT:    [[A_PN_I:%.*]] = phi ptr [ [[TEST_0_I:%.*]], [[WHILE_COND_I]] ], [ [[STR1]], [[LOR_LHS_FALSE_I]] ]
 ; CHECK-NEXT:    [[TEST_0_I]] = getelementptr inbounds i8, ptr [[A_PN_I]], i64 1
 ; CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[TEST_0_I]], align 1
 ; CHECK-NEXT:    [[CMP3_NOT_I:%.*]] = icmp eq i8 [[TMP1]], 0
 ; CHECK-NEXT:    br i1 [[CMP3_NOT_I]], label [[WHILE_END_I:%.*]], label [[WHILE_COND_I]]
 ; CHECK:       while.end.i:
-; CHECK-NEXT:    [[TMP2:%.*]] = icmp ne ptr [[TEST_0_I]], [[STR1]]
 ; CHECK-NEXT:    br label [[_Z3FOOPKC_EXIT]]
 ; CHECK:       _Z3fooPKc.exit:
-; CHECK-NEXT:    [[RETVAL_0_I:%.*]] = phi i1 [ [[TMP2]], [[WHILE_END_I]] ], [ false, [[LOR_LHS_FALSE_I]] ], [ false, [[ENTRY:%.*]] ]
-; CHECK-NEXT:    ret i1 [[RETVAL_0_I]]
+; CHECK-NEXT:    [[TOBOOL:%.*]] = phi i1 [ true, [[WHILE_END_I]] ], [ false, [[LOR_LHS_FALSE_I]] ], [ false, [[ENTRY:%.*]] ]
+; CHECK-NEXT:    ret i1 [[TOBOOL]]
 ;
 entry:
   %cmp.i = icmp eq ptr %str1, null
   br i1 %cmp.i, label %_Z3fooPKc.exit, label %lor.lhs.false.i
 
 lor.lhs.false.i:
   %0 = load i8, ptr %str1, align 1
   %cmp1.i = icmp eq i8 %0, 0

 ; CHECK-NEXT:    br i1 [[CMP1_I]], label [[_Z3FOOPKC_EXIT]], label [[WHILE_COND_I:%.*]]
 ; CHECK:       while.cond.i:
 ; CHECK-NEXT:    [[A_PN_I:%.*]] = phi ptr [ [[TEST_0_I:%.*]], [[WHILE_COND_I]] ], [ [[STR1]], [[LOR_LHS_FALSE_I]] ]
 ; CHECK-NEXT:    [[TEST_0_I]] = getelementptr inbounds i8, ptr [[A_PN_I]], i64 1
 ; CHECK-NEXT:    [[TMP1:%.*]] = load i8, ptr [[TEST_0_I]], align 1
 ; CHECK-NEXT:    [[CMP3_NOT_I:%.*]] = icmp eq i8 [[TMP1]], 0
 ; CHECK-NEXT:    br i1 [[CMP3_NOT_I]], label [[WHILE_END_I:%.*]], label [[WHILE_COND_I]]
 ; CHECK:       while.end.i:
-; CHECK-NEXT:    [[SUB_PTR_LHS_CAST_I:%.*]] = ptrtoint ptr [[TEST_0_I]] to i64
-; CHECK-NEXT:    [[SUB_PTR_RHS_CAST_I:%.*]] = ptrtoint ptr [[STR1]] to i64
-; CHECK-NEXT:    [[SUB_PTR_SUB_I:%.*]] = sub i64 [[SUB_PTR_LHS_CAST_I]], [[SUB_PTR_RHS_CAST_I]]
 ; CHECK-NEXT:    br label [[_Z3FOOPKC_EXIT]]
 ; CHECK:       _Z3fooPKc.exit:
-; CHECK-NEXT:    [[RETVAL_0_I:%.*]] = phi i64 [ [[SUB_PTR_SUB_I]], [[WHILE_END_I]] ], [ 0, [[LOR_LHS_FALSE_I]] ], [ 0, [[ENTRY:%.*]] ]
+; CHECK-NEXT:    [[RETVAL_0_I:%.*]] = phi i64 [ 1, [[WHILE_END_I]] ], [ 0, [[LOR_LHS_FALSE_I]] ], [ 0, [[ENTRY:%.*]] ]
 ; CHECK-NEXT:    [[TMP2:%.*]] = or i64 [[RETVAL_0_I]], [[VAL2:%.*]]
 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i64 [[TMP2]], 0
 ; CHECK-NEXT:    ret i1 [[TOBOOL]]
 ;
 entry:
   %cmp.i = icmp eq ptr %str1, null
   br i1 %cmp.i, label %_Z3fooPKc.exit, label %lor.lhs.false.i
 
while.end.i:
   %sub.ptr.sub.i = sub i64 %sub.ptr.lhs.cast.i, %sub.ptr.rhs.cast.i
   br label %_Z3fooPKc.exit
 
 _Z3fooPKc.exit:
   %retval.0.i = phi i64 [ %sub.ptr.sub.i, %while.end.i ], [ 0, %lor.lhs.false.i ], [ 0, %entry ]
   %2 = or i64 %retval.0.i, %val2
   %tobool = icmp eq i64 %2, 0
   ret i1 %tobool
 }
+
+define i1 @_gep_phi3(ptr noundef %str1, i64 %val2) {
+; CHECK-LABEL: @_gep_phi3(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP_I:%.*]] = icmp eq ptr [[STR1:%.*]], null
+; CHECK-NEXT:    br i1 [[CMP_I]], label [[_Z3FOOPKC_EXIT:%.*]], label [[LOR_LHS_FALSE_I:%.*]]
+; CHECK:       lor.lhs.false.i:
+; CHECK-NEXT:    [[TMP0:%.*]] = load i16, ptr [[STR1]], align 2
+; CHECK-NEXT:    [[CMP1_I:%.*]] = icmp eq i16 [[TMP0]], 0
+; CHECK-NEXT:    br i1 [[CMP1_I]], label [[_Z3FOOPKC_EXIT]], label [[WHILE_COND_I:%.*]]
+; CHECK:       while.cond.i:
+; CHECK-NEXT:    [[A_PN_I:%.*]] = phi ptr [ [[TEST_0_I:%.*]], [[WHILE_COND_I]] ], [ [[STR1]], [[LOR_LHS_FALSE_I]] ]
+; CHECK-NEXT:    [[TEST_0_I]] = getelementptr inbounds i16, ptr [[A_PN_I]], i64 1
+; CHECK-NEXT:    [[TMP1:%.*]] = load i16, ptr [[TEST_0_I]], align 2
+; CHECK-NEXT:    [[CMP3_NOT_I:%.*]] = icmp eq i16 [[TMP1]], 0
+; CHECK-NEXT:    br i1 [[CMP3_NOT_I]], label [[WHILE_END_I:%.*]], label [[WHILE_COND_I]]
+; CHECK:       while.end.i:
+; CHECK-NEXT:    br label [[_Z3FOOPKC_EXIT]]
+; CHECK:       _Z3fooPKc.exit:
+; CHECK-NEXT:    [[RETVAL_0_I:%.*]] = phi i64 [ 1, [[WHILE_END_I]] ], [ 0, [[LOR_LHS_FALSE_I]] ], [ 0, [[ENTRY:%.*]] ]
+; CHECK-NEXT:    [[TMP2:%.*]] = or i64 [[RETVAL_0_I]], [[VAL2:%.*]]
+; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i64 [[TMP2]], 0
+; CHECK-NEXT:    ret i1 [[TOBOOL]]
+;
+entry:
+  %cmp.i = icmp eq ptr %str1, null
+  br i1 %cmp.i, label %_Z3fooPKc.exit, label %lor.lhs.false.i
+
+lor.lhs.false.i:
+  %0 = load i16, ptr %str1, align 2
+  %cmp1.i = icmp eq i16 %0, 0
+  br i1 %cmp1.i, label %_Z3fooPKc.exit, label %while.cond.i
+
+while.cond.i:
+  %a.pn.i = phi ptr [ %test.0.i, %while.cond.i ], [ %str1, %lor.lhs.false.i ]
+  %test.0.i = getelementptr inbounds i16, ptr %a.pn.i, i64 1
+  %1 = load i16, ptr %test.0.i, align 2
+  %cmp3.not.i = icmp eq i16 %1, 0
+  br i1 %cmp3.not.i, label %while.end.i, label %while.cond.i
+
+while.end.i:
+  %sub.ptr.lhs.cast.i = ptrtoint ptr %test.0.i to i64
+  %sub.ptr.rhs.cast.i = ptrtoint ptr %str1 to i64
+  %sub.ptr.sub.i = sub i64 %sub.ptr.lhs.cast.i, %sub.ptr.rhs.cast.i
+  %sub.ptr.div = ashr exact i64 %sub.ptr.sub.i, 1
+  br label %_Z3fooPKc.exit
+
+_Z3fooPKc.exit:
+  %retval.0.i = phi i64 [ %sub.ptr.div, %while.end.i ], [ 0, %lor.lhs.false.i ], [ 0, %entry ]
+  %2 = or i64 %retval.0.i, %val2
+  %tobool = icmp eq i64 %2, 0
+  ret i1 %tobool
+}