[ConstraintElim] Support add nsw with negative constants.

[fhahn]

Summary

add nsw with negative constants can be used for reasoning, if the
first operand is larger or equal to the subtracted constant. Then the
value won't cross 0.

Add a precondition to ensure that.

[nikic]

Looks like gep-arithmetic-add.ll fails in pre-commit CI.

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

371

Is this correct if C is INT_MIN?

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

static Decomposition decompose(Value *V,
   ConstantInt *CI;
   if (match(V, m_NUWAdd(m_Value(Op0), m_Value(Op1)))) {
     return MergeResults(Op0, Op1, IsSigned);
   }
   if (match(V, m_NSWAdd(m_Value(Op0), m_Value(Op1)))) {
     if (!isKnownNonNegative(Op0, DL, /*Depth=*/MaxAnalysisRecursionDepth - 1))
       Preconditions.emplace_back(CmpInst::ICMP_SGE, Op0,
                                  ConstantInt::get(Op0->getType(), 0));
-    if (!isKnownNonNegative(Op1, DL, /*Depth=*/MaxAnalysisRecursionDepth - 1))
+    if (auto *C = dyn_cast<ConstantInt>(Op1)) {
+      if (C->isNegative()) {
+        Preconditions.emplace_back(
+            CmpInst::ICMP_SGE, Op0,
+            ConstantInt::get(Op1->getType(), C->getValue() * -1));
+        IsSigned = true;
+      }
+    } else if (!isKnownNonNegative(Op1, DL,
+                                   /*Depth=*/MaxAnalysisRecursionDepth - 1))
       Preconditions.emplace_back(CmpInst::ICMP_SGE, Op1,
                                  ConstantInt::get(Op1->getType(), 0));
 
     return MergeResults(Op0, Op1, IsSigned);
   }
 
   if (match(V, m_Add(m_Value(Op0), m_ConstantInt(CI))) && CI->isNegative() &&
       canUseSExt(CI)) {

llvm/test/Transforms/ConstraintElimination/add-nsw.ll

 
 define i1 @add_neg_1_known_sge_ult_1(i32 %a) {
 ; CHECK-LABEL: @add_neg_1_known_sge_ult_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_SGE:%.*]] = icmp sge i32 [[A:%.*]], 1
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A_SGE]])
 ; CHECK-NEXT:    [[SUB:%.*]] = add nsw i32 [[A]], -1
 ; CHECK-NEXT:    [[C:%.*]] = icmp ult i32 [[SUB]], [[A]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %a.sge = icmp sge i32 %a, 1
   call void @llvm.assume(i1 %a.sge)
   %sub = add nsw i32 %a, -1
   %c = icmp ult i32 %sub, %a
   ret i1 %c
 }
 
 define i1 @add_neg_1_known_sge_uge_1(i32 %a) {
 ; CHECK-LABEL: @add_neg_1_known_sge_uge_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_SGE:%.*]] = icmp sge i32 [[A:%.*]], 1
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A_SGE]])
 ; CHECK-NEXT:    [[SUB:%.*]] = add nsw i32 [[A]], -1
 ; CHECK-NEXT:    [[C:%.*]] = icmp uge i32 [[SUB]], 0
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %a.sge = icmp sge i32 %a, 1
   call void @llvm.assume(i1 %a.sge)
   %sub = add nsw i32 %a, -1
   %c = icmp uge i32 %sub, 0
   ret i1 %c
 }

 
 define i1 @add_neg_3_known_sge_ult_1(i32 %a) {
 ; CHECK-LABEL: @add_neg_3_known_sge_ult_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_SGE:%.*]] = icmp sge i32 [[A:%.*]], 3
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A_SGE]])
 ; CHECK-NEXT:    [[SUB:%.*]] = add nsw i32 [[A]], -3
 ; CHECK-NEXT:    [[C:%.*]] = icmp ult i32 [[SUB]], [[A]]
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %a.sge = icmp sge i32 %a, 3
   call void @llvm.assume(i1 %a.sge)
   %sub = add nsw i32 %a, -3
   %c = icmp ult i32 %sub, %a
   ret i1 %c
 }
 
 define i1 @add_neg_3_known_sge_uge_1(i32 %a) {
 ; CHECK-LABEL: @add_neg_3_known_sge_uge_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_SGE:%.*]] = icmp sge i32 [[A:%.*]], 4
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A_SGE]])
 ; CHECK-NEXT:    [[SUB:%.*]] = add nsw i32 [[A]], -3
 ; CHECK-NEXT:    [[C:%.*]] = icmp uge i32 [[SUB]], 0
-; CHECK-NEXT:    ret i1 [[C]]
+; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %a.sge = icmp sge i32 %a, 4
   call void @llvm.assume(i1 %a.sge)
   %sub = add nsw i32 %a, -3
   %c = icmp uge i32 %sub, 0
   ret i1 %c
 }