[InstCombine] fold unsigned predicates to signed on srem result

This allows optimization of more signed floor implementations when the
divisor is a known power of two to an arithmetic shift.

Proof for the implemented optimizations:
https://alive2.llvm.org/ce/z/2msAMA

Proof for the test cases:
https://alive2.llvm.org/ce/z/M_PBjw

Author: jacobly0

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

@@ -2674,10 +2674,41 @@ Instruction *InstCombinerImpl::foldICmpShrConstant(ICmpInst &Cmp,
 Instruction *InstCombinerImpl::foldICmpSRemConstant(ICmpInst &Cmp,
                                                     BinaryOperator *SRem,
                                                     const APInt &C) {
+  const ICmpInst::Predicate Pred = Cmp.getPredicate();
+  if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_ULT) {
+    // Canonicalize unsigned predicates to signed:
+    // (X % DivisorC) ugt C -> (X % DivisorC) slt 0
+    //   iff abs(DivisorC) ule (C slt 0 ? ~C : C)+1
+    // (X % DivisorC) ult C+1 -> (X % DivisorC) sgt -1
+    //   iff abs(DivisorC) ule (C+1 slt 0 ? ~C : C)+1
+
+    const APInt *DivisorC;
+    if (!match(SRem->getOperand(1), m_APInt(DivisorC)))
+      return nullptr;
+
+    APInt NormalizedC = C;
+    assert(!NormalizedC.isZero() &&
+           "srem X, 0 should have been simplified already.");
+    if (Pred == ICmpInst::ICMP_ULT)
+      --NormalizedC;
+    if (C.isNegative())
+      NormalizedC.flipAllBits();
+    assert(!NormalizedC.isMaxValue() &&
+           "srem i1 X, -1 should have been simplified already.");
+    ++NormalizedC;
+    if (!DivisorC->abs().ule(NormalizedC))
+      return nullptr;
+
+    Type *Ty = SRem->getType();
+    if (Pred == ICmpInst::ICMP_UGT)
+      return new ICmpInst(ICmpInst::ICMP_SLT, SRem,
+                          ConstantInt::getNullValue(Ty));
+    return new ICmpInst(ICmpInst::ICMP_SGT, SRem,
+                        ConstantInt::getAllOnesValue(Ty));
+  }
   // Match an 'is positive' or 'is negative' comparison of remainder by a
   // constant power-of-2 value:
   // (X % pow2C) sgt/slt 0
-  const ICmpInst::Predicate Pred = Cmp.getPredicate();
   if (Pred != ICmpInst::ICMP_SGT && Pred != ICmpInst::ICMP_SLT &&
       Pred != ICmpInst::ICMP_EQ && Pred != ICmpInst::ICMP_NE)
     return nullptr;

llvm/test/Transforms/InstCombine/add.ll

@@ -3020,11 +3020,7 @@ define i32 @floor_sdiv_wrong_op(i32 %x, i32 %y) {
 
 define i32 @floor_sdiv_using_srem_by_8(i32 %x) {
 ; CHECK-LABEL: @floor_sdiv_using_srem_by_8(
-; CHECK-NEXT:    [[D:%.*]] = sdiv i32 [[X:%.*]], 8
-; CHECK-NEXT:    [[R:%.*]] = srem i32 [[X]], 8
-; CHECK-NEXT:    [[I:%.*]] = icmp ugt i32 [[R]], -2147483648
-; CHECK-NEXT:    [[S:%.*]] = sext i1 [[I]] to i32
-; CHECK-NEXT:    [[F:%.*]] = add nsw i32 [[D]], [[S]]
+; CHECK-NEXT:    [[F:%.*]] = ashr i32 [[X:%.*]], 3
 ; CHECK-NEXT:    ret i32 [[F]]
 ;
   %d = sdiv i32 %x, 8
@@ -3037,11 +3033,7 @@ define i32 @floor_sdiv_using_srem_by_8(i32 %x) {
 
 define i32 @floor_sdiv_using_srem_by_2(i32 %x) {
 ; CHECK-LABEL: @floor_sdiv_using_srem_by_2(
-; CHECK-NEXT:    [[D:%.*]] = sdiv i32 [[X:%.*]], 2
-; CHECK-NEXT:    [[R:%.*]] = srem i32 [[X]], 2
-; CHECK-NEXT:    [[I:%.*]] = icmp ugt i32 [[R]], -2147483648
-; CHECK-NEXT:    [[S:%.*]] = sext i1 [[I]] to i32
-; CHECK-NEXT:    [[F:%.*]] = add nsw i32 [[D]], [[S]]
+; CHECK-NEXT:    [[F:%.*]] = ashr i32 [[X:%.*]], 1
 ; CHECK-NEXT:    ret i32 [[F]]
 ;
   %d = sdiv i32 %x, 2