[InstCombine] Add folds for `(icmp spred (ssub.sat X, Y), 0)` -> `X spred Y`

[goldstein.w.n]

Summary

Alive2 links:

eq: https://alive2.llvm.org/ce/z/Fv3mvc
ne: https://alive2.llvm.org/ce/z/AEuEXU
sle: https://alive2.llvm.org/ce/z/mfKGUS
sge: https://alive2.llvm.org/ce/z/tX3_M4
sgt: https://alive2.llvm.org/ce/z/x7VgnZ
slt: https://alive2.llvm.org/ce/z/rQN4TM

[nikic]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

3608

Shouldn't this be sle?

[goldstein.w.n]

sle -> slt

[nikic]

LGTM

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

case Intrinsic::uadd_sat: {
     // umax(a, b) == 0  ->  (a | b) == 0
     if (C.isZero() && II->hasOneUse()) {
       Value *Or = Builder.CreateOr(II->getArgOperand(0), II->getArgOperand(1));
       return new ICmpInst(Pred, Or, Constant::getNullValue(Ty));
     }
     break;
   }
 
+  case Intrinsic::ssub_sat:
+    // ssub.sat(a, b) == 0 -> a == b
+    if (C.isZero())
+      return new ICmpInst(Pred, II->getArgOperand(0), II->getArgOperand(1));
+    break;
   case Intrinsic::usub_sat: {
     // usub.sat(a, b) == 0  ->  a <= b
     if (C.isZero()) {
       ICmpInst::Predicate NewPred =
           Pred == ICmpInst::ICMP_EQ ? ICmpInst::ICMP_ULE : ICmpInst::ICMP_UGT;
       return new ICmpInst(NewPred, II->getArgOperand(0), II->getArgOperand(1));
     }
     break;
case Intrinsic::cttz: {
     if (Pred == ICmpInst::ICMP_ULT && C.uge(1) && C.ule(BitWidth)) {
       APInt Mask = APInt::getLowBitsSet(BitWidth, C.getLimitedValue());
       return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_NE,
                              Builder.CreateAnd(II->getArgOperand(0), Mask),
                              ConstantInt::getNullValue(Ty));
     }
     break;
   }
+  case Intrinsic::ssub_sat:
+    // ssub.sat(a, b) spred 0 -> a spred b
+    if (ICmpInst::isSigned(Pred)) {
+      if (C.isZero())
+        return new ICmpInst(Pred, II->getArgOperand(0), II->getArgOperand(1));
+      // X s<= 0 is cannonicalized to X s< 1
+      if (Pred == ICmpInst::ICMP_SLT && C.isOne())
+        return new ICmpInst(ICmpInst::ICMP_SLE, II->getArgOperand(0),
+                            II->getArgOperand(1));
+      // X s>= 0 is cannonicalized to X s> -1
+      if (Pred == ICmpInst::ICMP_SGT && C.isAllOnes())
+        return new ICmpInst(ICmpInst::ICMP_SGE, II->getArgOperand(0),
+                            II->getArgOperand(1));
+    }
+    break;
   default:
     break;
   }
 
   return nullptr;
 }
 
 /// Handle icmp with constant (but not simple integer constant) RHS.

llvm/test/Transforms/InstCombine/cmp-intrinsic.ll

;
   call void @use8(i8 %m)
   %r = icmp ne i8 %m, 0
   ret i1 %r
 }
 
 
 define i1 @ssub_sat_ne_zero(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_sat_ne_zero(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp ne i8 [[M]], 0
+; CHECK-NEXT:    [[R:%.*]] = icmp ne i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
   %r = icmp ne i8 %m, 0
   ret i1 %r
 }
 
 define i1 @ssub_sat_ne_fail_nonzero(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_sat_ne_fail_nonzero(
 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    [[R:%.*]] = icmp ne i8 [[M]], 4
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
   %r = icmp ne i8 %m, 4
   ret i1 %r
 }
 
 define i1 @ssub_sat_eq_zero(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_sat_eq_zero(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[M]], 0
+; CHECK-NEXT:    [[R:%.*]] = icmp eq i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
   %r = icmp eq i8 %m, 0
   ret i1 %r
 }
 
 define i1 @ssub_sat_sle_zero(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_sat_sle_zero(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[M]], 1
+; CHECK-NEXT:    [[R:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
   %r = icmp sle i8 %m, 0
   ret i1 %r
 }
 
 define i1 @ssub_sat_sge_zero(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_sat_sge_zero(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp sgt i8 [[M]], -1
+; CHECK-NEXT:    [[R:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
   %r = icmp sge i8 %m, 0
   ret i1 %r
 }
 
 define i1 @ssub_sat_slt_zero(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_sat_slt_zero(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[M]], 0
+; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
   %r = icmp slt i8 %m, 0
   ret i1 %r
 }
 
 define i1 @ssub_sat_slt_neg1_fail(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_sat_slt_neg1_fail(
 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
 ; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[M]], -1
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
   %r = icmp slt i8 %m, -1
   ret i1 %r
 }
 
 define i1 @ssub_sat_sgt_zero(i8 %x, i8 %y) {
 ; CHECK-LABEL: @ssub_sat_sgt_zero(
-; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[X:%.*]], i8 [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = icmp sgt i8 [[M]], 0
+; CHECK-NEXT:    [[R:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
   %r = icmp sgt i8 %m, 0
   ret i1 %r
 }
 
 define i1 @ssub_sat_sgt_one_fail(i8 %x, i8 %y) {