[InstCombine] Fold uadd.sat(a, b) == 0 and usub.sat(a, b) == 0

[nikic]

Summary

This adds folds for comparing uadd.sat/usub.sat with zero:

• uadd.sat(a, b) == 0 => a == 0 && b == 0 => (a | b) == 0
• usub.sat(a, b) == 0 => a <= b

And inverted forms for !=.

[lebedev.ri]

----------------------------------------
Name: uadd.sat(a, b) == 0  ->  (a | b) == 0
  %o0 = uadd_sat i8 %x, %y
  %r = icmp eq i8 %o0, 0
  ret i1 %r
=>
  %n0 = or i8 %x, %y
  %r = icmp eq i8 %n0, 0
  ret i1 %r
  %o0 = uadd_sat i8 %x, %y

Done: 1
Optimization is correct!

----------------------------------------
Name: uadd.sat(a, b) != 0  ->  (a | b) != 0
  %o0 = uadd_sat i8 %x, %y
  %r = icmp ne i8 %o0, 0
  ret i1 %r
=>
  %n0 = or i8 %x, %y
  %r = icmp ne i8 %n0, 0
  ret i1 %r
  %o0 = uadd_sat i8 %x, %y

Done: 1
Optimization is correct!

----------------------------------------
Name: usub.sat(a, b) == 0  ->  a <= b
  %o0 = usub_sat i8 %x, %y
  %r = icmp eq i8 %o0, 0
  ret i1 %r
=>
  %r = icmp ule i8 %x, %y
  ret i1 %r
  %o0 = usub_sat i8 %x, %y

Done: 1
Optimization is correct!

----------------------------------------
Name: usub.sat(a, b) != 0  ->  a > b
  %o0 = usub_sat i8 %x, %y
  %r = icmp ne i8 %o0, 0
  ret i1 %r
=>
  %r = icmp ugt i8 %x, %y
  ret i1 %r
  %o0 = usub_sat i8 %x, %y

Done: 1
Optimization is correct!

LG

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

if (IsZero || C == BitWidth) {
       Cmp.setOperand(0, II->getArgOperand(0));
       auto *NewOp =
           IsZero ? Constant::getNullValue(Ty) : Constant::getAllOnesValue(Ty);
       Cmp.setOperand(1, NewOp);
       return &Cmp;
     }
     break;
   }
+
+  case Intrinsic::uadd_sat: {
+    // uadd.sat(a, b) == 0  ->  (a | b) == 0
+    if (C.isNullValue()) {
+      Value *Or = Builder.CreateOr(II->getArgOperand(0), II->getArgOperand(1));
+      return replaceInstUsesWith(Cmp, Builder.CreateICmp(
+          Cmp.getPredicate(), Or, Constant::getNullValue(Ty)));
+
+    }
+    break;
+  }
+
+  case Intrinsic::usub_sat: {
+    // usub.sat(a, b) == 0  ->  a <= b
+    if (C.isNullValue()) {
+      ICmpInst::Predicate NewPred = Cmp.getPredicate() == ICmpInst::ICMP_EQ
+          ? ICmpInst::ICMP_ULE : ICmpInst::ICMP_UGT;
+      return ICmpInst::Create(Instruction::ICmp, NewPred,
+                              II->getArgOperand(0), II->getArgOperand(1));
+    }
+    break;
+  }
   default:
     break;
   }
 
   return nullptr;
 }
 
 /// Fold an icmp with LLVM intrinsic and constant operand: icmp Pred II, C.

llvm/test/Transforms/InstCombine/saturating-add-sub.ll

 ;
   %sat = call i8 @llvm.uadd.sat.i8(i8 %a, i8 42)
   %res = sub i8 %sat, 42
   ret i8 %res
 }
 
 define i1 @scalar_uadd_eq_zero(i8 %a, i8 %b) {
 ; CHECK-LABEL: @scalar_uadd_eq_zero(
-; CHECK-NEXT:    [[SAT:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A:%.*]], i8 [[B:%.*]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[SAT]], 0
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = or i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i8 [[TMP1]], 0
+; CHECK-NEXT:    ret i1 [[TMP2]]
 ;
   %sat = call i8 @llvm.uadd.sat.i8(i8 %a, i8 %b)
   %cmp = icmp eq i8 %sat, 0
   ret i1 %cmp
 }
 
 define i1 @scalar_uadd_ne_zero(i8 %a, i8 %b) {
 ; CHECK-LABEL: @scalar_uadd_ne_zero(
-; CHECK-NEXT:    [[SAT:%.*]] = call i8 @llvm.uadd.sat.i8(i8 [[A:%.*]], i8 [[B:%.*]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i8 [[SAT]], 0
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = or i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp ne i8 [[TMP1]], 0
+; CHECK-NEXT:    ret i1 [[TMP2]]
 ;
   %sat = call i8 @llvm.uadd.sat.i8(i8 %a, i8 %b)
   %cmp = icmp ne i8 %sat, 0
   ret i1 %cmp
 }
 
 define i1 @scalar_usub_eq_zero(i8 %a, i8 %b) {
 ; CHECK-LABEL: @scalar_usub_eq_zero(
-; CHECK-NEXT:    [[SAT:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 [[B:%.*]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[SAT]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ule i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sat = call i8 @llvm.usub.sat.i8(i8 %a, i8 %b)
   %cmp = icmp eq i8 %sat, 0
   ret i1 %cmp
 }
 
 define i1 @scalar_usub_ne_zero(i8 %a, i8 %b) {
 ; CHECK-LABEL: @scalar_usub_ne_zero(
-; CHECK-NEXT:    [[SAT:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[A:%.*]], i8 [[B:%.*]])
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i8 [[SAT]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %sat = call i8 @llvm.usub.sat.i8(i8 %a, i8 %b)
   %cmp = icmp ne i8 %sat, 0
   ret i1 %cmp
 }
 
 ; Raw IR tests