learning llvm...

Author: pskrgag

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

@@ -1324,26 +1324,23 @@ Instruction *InstCombinerImpl::foldICmpWithZero(ICmpInst &Cmp) {
 //      to
 //      icmp eq 0, (and num, val - 1)
 // For value being power of two
-Instruction *InstCombinerImpl::foldNextMultiply(ICmpInst &Cmp) {
-  Value *Op0 = Cmp.getOperand(0);
-  Value *Neg, *Add, *Num, *Mask, *Value;
+Instruction *InstCombinerImpl::foldIsMultipleOfAPowerOfTwo(ICmpInst &Cmp) {
+  Value *Op0 = Cmp.getOperand(0), *Op1 = Cmp.getOperand(1);
+  Value *Neg, *Num, *Mask, *Value;
   CmpPredicate Pred;
   const APInt *NegConst, *MaskConst;
 
-  // Match num + neg
-  if (!match(Op0, m_OneUse(m_c_And(m_Value(Add), m_Value(Neg)))))
+  if (!match(&Cmp, m_c_ICmp(Pred, m_Value(Num),
+                            m_OneUse(m_c_And(
+                                m_OneUse(m_c_Add(m_Value(Num), m_Value(Mask))),
+                                m_Value(Neg))))))
     return nullptr;
 
-  // Match num & mask and handle commutative care
-  if (!match(Op0, m_c_And(m_c_Add(m_Value(Num), m_Value(Mask)), m_Value(Neg))))
+  if (!ICmpInst::isEquality(Pred))
     return nullptr;
 
   // Check the constant case
-  if (match(Neg, m_APInt(NegConst)) && match(Mask, m_APInt(MaskConst))) {
-    // Mask + 1 should be a power-of-two
-    if (!(*MaskConst + 1).isPowerOf2())
-      return nullptr;
-
+  if (match(Neg, m_APInt(NegConst)) && match(Mask, m_LowBitMask(MaskConst))) {
     // Neg = -(Mask + 1)
     if (*NegConst != -(*MaskConst + 1))
       return nullptr;
@@ -1367,11 +1364,7 @@ Instruction *InstCombinerImpl::foldNextMultiply(ICmpInst &Cmp) {
       return nullptr;
   }
 
-  // Verify that Add and Num are connected by ICmp.
-  if (!match(&Cmp, m_c_ICmp(Pred, m_Value(Add), m_Specific(Num))))
-    return nullptr;
-
-  if (!ICmpInst::isEquality(Pred))
+  if (!match(Op0, m_Specific(Num)) && !match(Op1, m_Specific(Num)))
     return nullptr;
 
   // Create new icmp eq (num & (val - 1)), 0
@@ -7705,7 +7698,7 @@ Instruction *InstCombinerImpl::visitICmpInst(ICmpInst &I) {
   if (Instruction *Res = foldICmpUsingKnownBits(I))
     return Res;
 
-  if (Instruction *Res = foldNextMultiply(I))
+  if (Instruction *Res = foldIsMultipleOfAPowerOfTwo(I))
     return Res;
 
   // Test if the ICmpInst instruction is used exclusively by a select as

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

@@ -721,7 +721,7 @@ class LLVM_LIBRARY_VISIBILITY InstCombinerImpl final
   Instruction *foldICmpUsingKnownBits(ICmpInst &Cmp);
   Instruction *foldICmpWithDominatingICmp(ICmpInst &Cmp);
   Instruction *foldICmpWithConstant(ICmpInst &Cmp);
-  Instruction *foldNextMultiply(ICmpInst &Cmp);
+  Instruction *foldIsMultipleOfAPowerOfTwo(ICmpInst &Cmp);
   Instruction *foldICmpUsingBoolRange(ICmpInst &I);
   Instruction *foldICmpInstWithConstant(ICmpInst &Cmp);
   Instruction *foldICmpInstWithConstantNotInt(ICmpInst &Cmp);

llvm/test/Transforms/InstCombine/icmp-add.ll

@@ -3454,12 +3454,13 @@ define i1 @val_is_aligend_const_pow2_multiuse(i32 %num) {
   ret i1 %_0
 }
 
+; Applies since number of instructions do not change
 define i1 @val_is_aligend_const_pow2_multiuse1(i32 %num) {
 ; CHECK-LABEL: @val_is_aligend_const_pow2_multiuse1(
 ; CHECK-NEXT:    [[NUM_BIASED:%.*]] = add i32 [[NUM:%.*]], 4095
 ; CHECK-NEXT:    call void @use(i32 [[NUM_BIASED]])
-; CHECK-NEXT:    [[TMP1:%.*]] = and i32 [[NUM]], 4095
-; CHECK-NEXT:    [[_0:%.*]] = icmp eq i32 [[TMP1]], 0
+; CHECK-NEXT:    [[_2_SROA_0_0:%.*]] = and i32 [[NUM_BIASED]], -4096
+; CHECK-NEXT:    [[_0:%.*]] = icmp eq i32 [[_2_SROA_0_0]], [[NUM]]
 ; CHECK-NEXT:    ret i1 [[_0]]
 ;
   %num.biased = add i32 %num, 4095