[ValueTracking] Improve non-zero tracking of `X` by also searching through `Use(X)` that imply non-zero

[goldstein.w.n]

Summary

We currently are able to prove X is non-zero if there are dominating
compares or assumes directly on X, but we can do a bit better and
also check uses of X s.t Use(X) != 0 implies X != 0.

For example if we have assume(X & Y != 0), we know X != 0.
Likewise if we have a dominating condition:

if(X & Y != 0)
  {
    // X is known zero here
  }

Currently implemented to track through:

• X&Y -- https://alive2.llvm.org/ce/z/zdkf-x
• 0-X -- https://alive2.llvm.org/ce/z/yvEAZx
• bitreverse(X) -- https://alive2.llvm.org/ce/z/zEPy9z
• bswap(X) -- https://alive2.llvm.org/ce/z/i_li18
• ctpop(X) -- https://alive2.llvm.org/ce/z/fXMDTs
• abs(X) -- https://alive2.llvm.org/ce/z/EbP82g https://alive2.llvm.org/ce/z/hfzZuX

[StephenFan]

llvm/lib/Analysis/ValueTracking.cpp

2380–2385

This is a repeat of the above.

2409–2410

Blank line.

2419

IIUC, Intrinsic::umin may also imply non-zero.

[nikic]

We should be testing canonical IR here (use -passes=instcombine), at which point many of these should already be handled. E.g. if you have a condition abs(X) != 0, that should get canonicalized to X != 0 first, and then handled by existing code.

[goldstein.w.n]

In D142830#4088647, @nikic wrote:

We should be testing canonical IR here (use -passes=instcombine), at which point many of these should already be handled. E.g. if you have a condition abs(X) != 0, that should get canonicalized to X != 0 first, and then handled by existing code.

Done, my goal was to try and isolate the tests to test the added logic.

Updated to use instcombine and changed many of the compares so they don't hit the canonicalization cases.

llvm/lib/Analysis/ValueTracking.cpp

2419

IIUC, Intrinsic::umin may also imply non-zero.

Would rather make this another patch if thats okay with you.
this one is mostly to setup the infrastructure.

[goldstein.w.n]

Updated tests, fixed some nits, rebase

[goldstein.w.n]

ping @nikic

[goldstein.w.n]

Rebase

[goldstein.w.n]

ping2.

[goldstein.w.n]

ping3.

[goldstein.w.n]

Rebase

[goldstein.w.n]

ping 4 @nikic

[goldstein.w.n]

ping5 @nikic

[xbolva00]

llvm/lib/Analysis/ValueTracking.cpp

2368–2369

'Null' -> 'Zero' ?

[goldstein.w.n]

llvm/lib/Analysis/ValueTracking.cpp

2368–2369

'Null' -> 'Zero' ?

I think its best to keep the original function name the same.

[goldstein.w.n]

ping6

@nikic if you think that change should be abandoned, can you at least make that clear?

[goldstein.w.n]

ping7.

llvm/lib/Analysis/ValueTracking.cpp

for (gep_type_iterator GTI = gep_type_begin(GEP), GTE = gep_type_end(GEP);
 
     if (isKnownNonZero(GTI.getOperand(), Depth, Q))
       return true;
   }
 
   return false;
 }
 
-static bool isKnownNonNullFromDominatingCondition(const Value *V,
-                                                  const Instruction *CtxI,
-                                                  const DominatorTree *DT) {
-  if (isa<Constant>(V))
-    return false;
-
-  if (!CtxI || !DT)
-    return false;
-
-  unsigned NumUsesExplored = 0;
-  for (const auto *U : V->users()) {
-    // Avoid massive lists
-    if (NumUsesExplored >= DomConditionsMaxUses)
-      break;
-    NumUsesExplored++;
-
-    // If the value is used as an argument to a call or invoke, then argument
-    // attributes may provide an answer about null-ness.
-    if (const auto *CB = dyn_cast<CallBase>(U))
-      if (auto *CalledFunc = CB->getCalledFunction())
-        for (const Argument &Arg : CalledFunc->args())
-          if (CB->getArgOperand(Arg.getArgNo()) == V &&
-              Arg.hasNonNullAttr(/* AllowUndefOrPoison */ false) &&
-              DT->dominates(CB, CtxI))
-            return true;
-
-    // If the value is used as a load/store, then the pointer must be non null.
-    if (V == getLoadStorePointerOperand(U)) {
-      const Instruction *I = cast<Instruction>(U);
-      if (!NullPointerIsDefined(I->getFunction(),
-                                V->getType()->getPointerAddressSpace()) &&
-          DT->dominates(I, CtxI))
-        return true;
-    }
+// Helper for `isKnownNonNullFromDominatingCondition` to actually check the
+// dominating condition.
+static bool checkDominatingConditionForNonNull(const Value *V, const User *U,
+                                               const Query &Q) {
+  const Instruction *CtxI = Q.CxtI;
+  const DominatorTree *DT = Q.DT;
 
-    // Consider only compare instructions uniquely controlling a branch
-    Value *RHS;
-    CmpInst::Predicate Pred;
-    if (!match(U, m_c_ICmp(Pred, m_Specific(V), m_Value(RHS))))
-      continue;
-
-    bool NonNullIfTrue;
+  const User *CmpUse = nullptr;
+  if (match(U, m_c_ICmp(Pred, m_Specific(V), m_Value(RHS)))) {
+    CmpUse = U;
     if (cmpExcludesZero(Pred, RHS))
       NonNullIfTrue = true;
     else if (cmpExcludesZero(CmpInst::getInversePredicate(Pred), RHS))
       NonNullIfTrue = false;
     else
-      continue;
+      return false;
+  } else
+    return false;
 
-    SmallVector<const User *, 4> WorkList;
-    SmallPtrSet<const User *, 4> Visited;
-    for (const auto *CmpU : U->users()) {
-      assert(WorkList.empty() && "Should be!");
-      if (Visited.insert(CmpU).second)
-        WorkList.push_back(CmpU);
+  for (const auto *CmpU : CmpUse->users()) {
+
 
-      while (!WorkList.empty()) {
-        auto *Curr = WorkList.pop_back_val();
 
-        // If a user is an AND, add all its users to the work list. We only
-        // propagate "pred != null" condition through AND because it is only
-        // correct to assume that all conditions of AND are met in true branch.
-        // TODO: Support similar logic of OR and EQ predicate?
-        if (NonNullIfTrue)
-          if (match(Curr, m_LogicalAnd(m_Value(), m_Value()))) {
-            for (const auto *CurrU : Curr->users())
-              if (Visited.insert(CurrU).second)
-                WorkList.push_back(CurrU);
-            continue;
-          }
+      // correct to assume that all conditions of AND are met in true
+      // branch.
 
-        if (const BranchInst *BI = dyn_cast<BranchInst>(Curr)) {
-          assert(BI->isConditional() && "uses a comparison!");
 
-          BasicBlock *NonNullSuccessor =
-              BI->getSuccessor(NonNullIfTrue ? 0 : 1);
-          BasicBlockEdge Edge(BI->getParent(), NonNullSuccessor);
-          if (Edge.isSingleEdge() && DT->dominates(Edge, CtxI->getParent()))
-            return true;
-        } else if (NonNullIfTrue && isGuard(Curr) &&
-                   DT->dominates(cast<Instruction>(Curr), CtxI)) {
-          return true;
-        }
-      }
-    }
+        BasicBlock *NonNullSuccessor = BI->getSuccessor(NonNullIfTrue ? 0 : 1);
+
+  return false;
+}
+
+static bool isKnownNonNullFromDominatingCondition(const Value *V,
+                                                  unsigned DomDepth,
+                                                  const Query &Q) {
+  const Instruction *CtxI = Q.CxtI;
+  const DominatorTree *DT = Q.DT;
+
+  if (isa<Constant>(V))
+    return false;
+
+  if (!CtxI || !DT)
+    return false;
+
+  if (DomDepth++ >= MaxAnalysisRecursionDepth)
+    return false;
+
+  // Scale down number of uses explored with depth to avoid otherwise
+  // potentially very large exponential explosition.
+  unsigned NumUsesRemaining = (DomConditionsMaxUses / DomDepth) + 1;
+  for (const auto *U : V->users()) {
+    // Avoid massive lists
+    if (NumUsesRemaining-- == 0)
+      break;
+
+    // If the value is used as an argument to a call or invoke, then argument
+    // attributes may provide an answer about null-ness.
+    if (const auto *CB = dyn_cast<CallBase>(U))
+      if (auto *CalledFunc = CB->getCalledFunction())
+        for (const Argument &Arg : CalledFunc->args())
+          if (CB->getArgOperand(Arg.getArgNo()) == V &&
+              Arg.hasNonNullAttr(/* AllowUndefOrPoison */ false) &&
+              DT->dominates(CB, CtxI))
+            return true;
+
+    // If the value is used as a load/store, then the pointer must be non null.
+    if (V == getLoadStorePointerOperand(U)) {
+      const Instruction *I = cast<Instruction>(U);
+      if (!NullPointerIsDefined(I->getFunction(),
+                                V->getType()->getPointerAddressSpace()) &&
+          DT->dominates(I, CtxI))
+        return true;
+    }
+
+    bool ImpliesNonZero = false;
+    if (auto *OpU = dyn_cast<Operator>(U)) {
+      switch (OpU->getOpcode()) {
+      case Instruction::ICmp:
+        if (checkDominatingConditionForNonNull(V, U, Q))
+          return true;
+        break;
+      case Instruction::And:
+        ImpliesNonZero = true;
+        break;
+      case Instruction::Sub:
+        if (auto *C = dyn_cast<Constant>(OpU->getOperand(0)))
+          ImpliesNonZero = C->isNullValue();
+        break;
+      case Instruction::Call:
+        if (auto *II = dyn_cast<IntrinsicInst>(OpU)) {
+          switch (II->getIntrinsicID()) {
+          case Intrinsic::abs:
+          case Intrinsic::bitreverse:
+          case Intrinsic::bswap:
+          case Intrinsic::ctpop:
+            ImpliesNonZero = true;
+            break;
+          default:
+            break;
+          }
+        }
+        break;
+      default:
+        break;
+      }
+    }
+    if (ImpliesNonZero &&
+        (isKnownNonZeroFromAssume(U, Q) ||
+         isKnownNonNullFromDominatingCondition(U, DomDepth, Q)))
+      return true;
   }
 
   return false;
 }
 
 /// Does the 'Range' metadata (which must be a valid MD_range operand list)
 /// ensure that the value it's attached to is never Value?  'RangeType' is
 /// is the type of the value described by the range.
if (const auto *Call = dyn_cast<CallBase>(V)) {
       if (Call->isReturnNonNull())
         return true;
       if (const auto *RP = getArgumentAliasingToReturnedPointer(Call, true))
         return isKnownNonZero(RP, Depth, Q);
     }
   }
 
   if (!isa<Constant>(V) &&
-      isKnownNonNullFromDominatingCondition(V, Q.CxtI, Q.DT))
+      isKnownNonNullFromDominatingCondition(V, /*DomDepth*/ 0, Q))
     return true;
 
   const Operator *I = dyn_cast<Operator>(V);
   if (!I)
     return false;
 
   unsigned BitWidth = getBitWidth(V->getType()->getScalarType(), Q.DL);
   switch (I->getOpcode()) {

llvm/test/Analysis/ValueTracking/known-non-zero-through-dom-use.ll

 
 define i1 @check_abs(i8 %x, i8 %y) {
 ; CHECK-LABEL: @check_abs(
 ; CHECK-NEXT:    [[Z:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 true)
 ; CHECK-NEXT:    [[NE:%.*]] = icmp ugt i8 [[Z]], 3
 ; CHECK-NEXT:    br i1 [[NE]], label [[TRUE:%.*]], label [[FALSE:%.*]]
 ; CHECK:       true:
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[X]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ; CHECK:       false:
 ; CHECK-NEXT:    call void @use1(i1 [[NE]])
 ; CHECK-NEXT:    ret i1 [[NE]]
 ;
   %z = call i8 @llvm.abs.i8(i8 %x, i1 true)
   %ne = icmp ugt i8 %z, 3
   br i1 %ne, label %true, label %false
 true:
   %cmp0 = icmp ugt i8 %x, %y
   %cmp1 = icmp eq i8 %y, 0
   %r = or i1 %cmp0, %cmp1
   ret i1 %r
 false:
   ;; So that branch doesn't fold to select.
   call void @use1(i1 %ne)
   ret i1 %ne
 }
 
 define i1 @check_bswap(i16 %x, i16 %y) {
 ; CHECK-LABEL: @check_bswap(
 ; CHECK-NEXT:    [[Z:%.*]] = call i16 @llvm.bswap.i16(i16 [[X:%.*]])
 ; CHECK-NEXT:    [[NE:%.*]] = icmp sgt i16 [[Z]], 3
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NE]])
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i16 [[X]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i16 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ;
   %z = call i16 @llvm.bswap.i16(i16 %x)
   %ne = icmp sgt i16 %z, 3
   call void @llvm.assume(i1 %ne)
   %cmp0 = icmp ugt i16 %x, %y
   %cmp1 = icmp eq i16 %y, 0
   %r = or i1 %cmp0, %cmp1
   ret i1 %r
 }
 
 define i1 @check_bitreverse(i8 %x, i8 %y) {
 ; CHECK-LABEL: @check_bitreverse(
 ; CHECK-NEXT:    [[Z:%.*]] = call i8 @llvm.bitreverse.i8(i8 [[X:%.*]])
 ; CHECK-NEXT:    [[NE:%.*]] = icmp slt i8 [[Z]], -4
 ; CHECK-NEXT:    br i1 [[NE]], label [[TRUE:%.*]], label [[FALSE:%.*]]
 ; CHECK:       false:
 ; CHECK-NEXT:    [[RT:%.*]] = icmp eq i8 [[X]], 0
 ; CHECK-NEXT:    call void @use1(i1 [[RT]])
 ; CHECK-NEXT:    ret i1 [[RT]]
 ; CHECK:       true:
-; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[X]], -1
-; CHECK-NEXT:    [[TMP2:%.*]] = icmp uge i8 [[TMP1]], [[Y:%.*]]
-; CHECK-NEXT:    ret i1 [[TMP2]]
+; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[X]], [[Y:%.*]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ;
   %z = call i8 @llvm.bitreverse.i8(i8 %x)
   %ne = icmp slt i8 %z, -4
   br i1 %ne, label %true, label %false
 false:
   ;; This is mostly to test that we don't constant fold this the
   ;; wrong-way (false), but should in fact be foldable to true. Maybe
   ;; an `isKnownZero` that goes through the same level of analysis as

 
 define i1 @check_ctpop(i8 %x, i8 %y) {
 ; CHECK-LABEL: @check_ctpop(
 ; CHECK-NEXT:    [[Z:%.*]] = call i8 @llvm.ctpop.i8(i8 [[X:%.*]]), !range [[RNG0:![0-9]+]]
 ; CHECK-NEXT:    [[NE:%.*]] = icmp ugt i8 [[Z]], 2
 ; CHECK-NEXT:    br i1 [[NE]], label [[TRUE:%.*]], label [[FALSE:%.*]]
 ; CHECK:       true:
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[X]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ; CHECK:       false:
 ; CHECK-NEXT:    call void @use1(i1 [[NE]])
 ; CHECK-NEXT:    ret i1 [[NE]]
 ;
   %z = call i8 @llvm.ctpop.i8(i8 %x)
   %ne = icmp sgt i8 %z, 2
   br i1 %ne, label %true, label %false
 true:

 
 define i1 @check_and(i8 %x, i8 %y) {
 ; CHECK-LABEL: @check_and(
 ; CHECK-NEXT:    [[Z:%.*]] = and i8 [[X:%.*]], 123
 ; CHECK-NEXT:    [[NE_NOT:%.*]] = icmp eq i8 [[Z]], 0
 ; CHECK-NEXT:    br i1 [[NE_NOT]], label [[FALSE:%.*]], label [[TRUE:%.*]]
 ; CHECK:       true:
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[X]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ; CHECK:       false:
 ; CHECK-NEXT:    [[RT:%.*]] = icmp eq i8 [[X]], 0
 ; CHECK-NEXT:    call void @use1(i1 [[RT]])
 ; CHECK-NEXT:    ret i1 [[RT]]
 ;
   %z = and i8 %x, 123
   %ne = icmp ne i8 %z, 0
   br i1 %ne, label %true, label %false

 ; CHECK-NEXT:    [[NE:%.*]] = icmp ult i8 [[Z]], 5
 ; CHECK-NEXT:    br i1 [[NE]], label [[TRUE:%.*]], label [[FALSE:%.*]]
 ; CHECK:       true:
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[X]], [[Y:%.*]]
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[Y]], 0
 ; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ; CHECK:       false:
-; CHECK-NEXT:    [[RT:%.*]] = icmp eq i8 [[X]], 0
-; CHECK-NEXT:    call void @use1(i1 [[RT]])
-; CHECK-NEXT:    ret i1 [[RT]]
+; CHECK-NEXT:    call void @use1(i1 false)
+; CHECK-NEXT:    ret i1 false
 ;
   %z = and i8 %x, 123
   %ne = icmp slt i8 %z, 5
   br i1 %ne, label %true, label %false
 true:
   %cmp0 = icmp ugt i8 %x, %y
   %cmp1 = icmp eq i8 %y, 0
   %r = or i1 %cmp0, %cmp1

 ; CHECK-NEXT:    [[NE:%.*]] = icmp eq i8 [[Z]], 0
 ; CHECK-NEXT:    br i1 [[NE]], label [[TRUE:%.*]], label [[FALSE:%.*]]
 ; CHECK:       true:
 ; CHECK-NEXT:    [[RT:%.*]] = icmp eq i8 [[X]], 0
 ; CHECK-NEXT:    call void @use1(i1 [[RT]])
 ; CHECK-NEXT:    ret i1 [[RT]]
 ; CHECK:       false:
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[X]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ;
   %z = and i8 %x, 123
   %z2 = sub i8 0, %z
   %ne = icmp eq i8 %z2, 0
   br i1 %ne, label %true, label %false
 true:
   ;; This is mostly to test that we don't constant fold this the
   ;; wrong-way (false), but should in fact be foldable to true. Maybe

 ; CHECK-NEXT:    [[NE:%.*]] = icmp ult i8 [[Z3]], 5
 ; CHECK-NEXT:    br i1 [[NE]], label [[TRUE:%.*]], label [[FALSE:%.*]]
 ; CHECK:       true:
 ; CHECK-NEXT:    [[RT:%.*]] = icmp eq i8 [[X]], 0
 ; CHECK-NEXT:    call void @use1(i1 [[RT]])
 ; CHECK-NEXT:    ret i1 [[RT]]
 ; CHECK:       false:
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[X]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ;
   %z = and i8 %x, 123
   %z2 = sub i8 0, %z
   %z3 = call i8 @llvm.ctpop.i8(i8 %z2)
   %ne = icmp ule i8 %z3, 4
   br i1 %ne, label %true, label %false
 true:
   ;; This is mostly to test that we don't constant fold this the

 ; CHECK-NEXT:    [[NE:%.*]] = icmp ult i8 [[Z3]], 4
 ; CHECK-NEXT:    br i1 [[NE]], label [[TRUE:%.*]], label [[FALSE:%.*]]
 ; CHECK:       true:
 ; CHECK-NEXT:    [[RT:%.*]] = icmp eq i8 [[X]], 0
 ; CHECK-NEXT:    call void @use1(i1 [[RT]])
 ; CHECK-NEXT:    ret i1 [[RT]]
 ; CHECK:       false:
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[X]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ;
   %z = and i8 %x, 123
   %z2 = sub i8 0, %z
   %z3 = call i8 @llvm.ctpop.i8(i8 %z2)
   %ne = icmp sle i8 %z3, 3
   br i1 %ne, label %true, label %false
 true:
   ;; This is mostly to test that we don't constant fold this the

 ; CHECK-LABEL: @check_and_ctpop_neg_bitreverse(
 ; CHECK-NEXT:    [[Z:%.*]] = and i8 [[X:%.*]], 123
 ; CHECK-NEXT:    [[Z2:%.*]] = sub nsw i8 0, [[Z]]
 ; CHECK-NEXT:    [[Z3:%.*]] = call i8 @llvm.ctpop.i8(i8 [[Z2]]), !range [[RNG0]]
 ; CHECK-NEXT:    [[Z4:%.*]] = call i8 @llvm.bitreverse.i8(i8 [[Z3]])
 ; CHECK-NEXT:    [[NE:%.*]] = icmp ne i8 [[Z4]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NE]])
 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp ugt i8 [[X]], [[Y:%.*]]
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i8 [[Y]], 0
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP0]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP0]]
 ;
   %z = and i8 %x, 123
   %z2 = sub i8 0, %z
   %z3 = call i8 @llvm.ctpop.i8(i8 %z2)
   %z4 = call i8 @llvm.bitreverse.i8(i8 %z3)
   %ne = icmp ne i8 %z4, 0
   call void @llvm.assume(i1 %ne)
   %cmp0 = icmp ugt i8 %x, %y
   %cmp1 = icmp eq i8 %y, 0
   %r = or i1 %cmp0, %cmp1
   ret i1 %r
 }