[InstSimplify] add nuw %x, -1 -> -1 fold.

[lebedev.ri]

Summary

%ret = add nuw i8 %x, C
From langref:

nuw and nsw stand for “No Unsigned Wrap” and “No Signed Wrap”,
respectively. If the nuw and/or nsw keywords are present,
the result value of the add is a poison value if unsigned
and/or signed overflow, respectively, occurs.

So if C is -1, %x can only be 0, and the result is always -1.

I'm not sure we want to use KnownBits/LVI here, because there is
exactly one possible value (all bits set, -1), so some other pass
should take care of replacing the known-all-ones with constant -1.

The test/Transforms/InstCombine/set-lowbits-mask-canonicalize.ll change *is* confusing.
What happening is, before this: (omitting nuw for simplicity)

1. First, InstCombine D47428/rL334127 folds shl i32 1, %NBits) to shl nuw i32 -1, %NBits
2. Then, InstSimplify D47883/rL334222 folds shl nuw i32 -1, %NBits to -1,
3. -1 is inverted to 0.

But now:

1. *This* InstSimplify fold %ret = add nuw i32 %setbit, -1 -> -1 happens first, before InstCombine D47428/rL334127 fold could happen.

Thus we now end up with the opposite constant,
and it is all good: https://rise4fun.com/Alive/OA9

https://rise4fun.com/Alive/sldC
Was mentioned in D47428 review.
Follow-up for D47883.

[spatel]

test/Transforms/InstSimplify/constantfold-add-nuw-allones-to-allones.ll

68 ↗

(On Diff #150408)

That's an interesting one. I think I conservatively returned a new, fully defined vector constant in all cases when I was enhancing the pattern matchers to account for undef elements.

But this looks correct - add with an undef operand returns undef, so we can propagate the existing constant vector value.

[spatel]

LGTM.

lib/Analysis/InstructionSimplify.cpp

530 ↗

(On Diff #150408)

Possible cosmetic cleanup since we're here:
isNSW -> IsNSW
isNUW -> IsNUW

569–572 ↗

(On Diff #150408)

Better to put this above the previous fold, so wrapping-based folds are next to each other?

[lebedev.ri]

In D47908#1126520, @spatel wrote:

LGTM.

Thank you for the review!

llvm/trunk/lib/Analysis/InstructionSimplify.cpp

static Value *SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
 
   // add nsw/nuw (xor Y, signmask), signmask --> Y
   // The no-wrapping add guarantees that the top bit will be set by the add.
   // Therefore, the xor must be clearing the already set sign bit of Y.
   if ((isNSW || isNUW) && match(Op1, m_SignMask()) &&
       match(Op0, m_Xor(m_Value(Y), m_SignMask())))
     return Y;
 
+  // add nuw %x, -1  ->  -1, because %x can only be 0.
+  if (isNUW && match(Op1, m_AllOnes()))
+    return Op1; // Which is -1.
+
   /// i1 add -> xor.
   if (MaxRecurse && Op0->getType()->isIntOrIntVectorTy(1))
     if (Value *V = SimplifyXorInst(Op0, Op1, Q, MaxRecurse-1))
       return V;
 
   // Try some generic simplifications for associative operations.
   if (Value *V = SimplifyAssociativeBinOp(Instruction::Add, Op0, Op1, Q,
                                           MaxRecurse))

llvm/trunk/test/Transforms/InstCombine/set-lowbits-mask-canonicalize.ll

 ;
   %setbit = shl i32 1, %NBits
   %ret = add nsw i32 %setbit, -1
   ret i32 %ret
 }
 
 define i32 @shl_add_nuw(i32 %NBits) {
 ; CHECK-LABEL: @shl_add_nuw(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 -1
 ;
   %setbit = shl i32 1, %NBits
   %ret = add nuw i32 %setbit, -1
   ret i32 %ret
 }
 
 define i32 @shl_add_nsw_nuw(i32 %NBits) {
 ; CHECK-LABEL: @shl_add_nsw_nuw(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 -1
 ;
   %setbit = shl i32 1, %NBits
   %ret = add nuw nsw i32 %setbit, -1
   ret i32 %ret
 }
 
 ; shl is nsw
 

 ;
   %setbit = shl nsw i32 1, %NBits
   %ret = add nsw i32 %setbit, -1
   ret i32 %ret
 }
 
 define i32 @shl_nsw_add_nuw(i32 %NBits) {
 ; CHECK-LABEL: @shl_nsw_add_nuw(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 -1
 ;
   %setbit = shl nsw i32 1, %NBits
   %ret = add nuw i32 %setbit, -1
   ret i32 %ret
 }
 
 define i32 @shl_nsw_add_nsw_nuw(i32 %NBits) {
 ; CHECK-LABEL: @shl_nsw_add_nsw_nuw(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 -1
 ;
   %setbit = shl nsw i32 1, %NBits
   %ret = add nuw nsw i32 %setbit, -1
   ret i32 %ret
 }
 
 ; shl is nuw
 

 ;
   %setbit = shl nuw i32 1, %NBits
   %ret = add nsw i32 %setbit, -1
   ret i32 %ret
 }
 
 define i32 @shl_nuw_add_nuw(i32 %NBits) {
 ; CHECK-LABEL: @shl_nuw_add_nuw(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 -1
 ;
   %setbit = shl nuw i32 1, %NBits
   %ret = add nuw i32 %setbit, -1
   ret i32 %ret
 }
 
 define i32 @shl_nuw_add_nsw_nuw(i32 %NBits) {
 ; CHECK-LABEL: @shl_nuw_add_nsw_nuw(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 -1
 ;
   %setbit = shl nuw i32 1, %NBits
   %ret = add nuw nsw i32 %setbit, -1
   ret i32 %ret
 }
 
 ; shl is nuw nsw
 

 ;
   %setbit = shl nuw nsw i32 1, %NBits
   %ret = add nsw i32 %setbit, -1
   ret i32 %ret
 }
 
 define i32 @shl_nsw_nuw_add_nuw(i32 %NBits) {
 ; CHECK-LABEL: @shl_nsw_nuw_add_nuw(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 -1
 ;
   %setbit = shl nuw nsw i32 1, %NBits
   %ret = add nuw i32 %setbit, -1
   ret i32 %ret
 }
 
 define i32 @shl_nsw_nuw_add_nsw_nuw(i32 %NBits) {
 ; CHECK-LABEL: @shl_nsw_nuw_add_nsw_nuw(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 -1
 ;
   %setbit = shl nuw nsw i32 1, %NBits
   %ret = add nuw nsw i32 %setbit, -1
   ret i32 %ret
 }
 
 ; ============================================================================ ;
 ; Vectors

llvm/trunk/test/Transforms/InstSimplify/constantfold-add-nuw-allones-to-allones.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 ; %ret = add nuw i8 %x, C
 ; nuw means no unsigned wrap, from -1 to 0.
 ; So if C is -1, %x can only be 0, and the result is always -1.
 
 define i8 @add_nuw (i8 %x) {
 ; CHECK-LABEL: @add_nuw(
-; CHECK-NEXT:    [[RET:%.*]] = add nuw i8 [[X:%.*]], -1
-; CHECK-NEXT:    ret i8 [[RET]]
+; CHECK-NEXT:    ret i8 -1
 ;
   %ret = add nuw i8 %x, -1
   ; nuw here means that %x can only be 0
   ret i8 %ret
 }
 
 define i8 @add_nuw_nsw (i8 %x) {
 ; CHECK-LABEL: @add_nuw_nsw(
-; CHECK-NEXT:    [[RET:%.*]] = add nuw nsw i8 [[X:%.*]], -1
-; CHECK-NEXT:    ret i8 [[RET]]
+; CHECK-NEXT:    ret i8 -1
 ;
   %ret = add nuw nsw i8 %x, -1
   ; nuw here means that %x can only be 0
   ret i8 %ret
 }
 
 define i8 @add_nuw_commute (i8 %x) {
 ; CHECK-LABEL: @add_nuw_commute(
-; CHECK-NEXT:    [[RET:%.*]] = add nuw i8 -1, [[X:%.*]]
-; CHECK-NEXT:    ret i8 [[RET]]
+; CHECK-NEXT:    ret i8 -1
 ;
   %ret = add nuw i8 -1, %x ; swapped
   ; nuw here means that %x can only be 0
   ret i8 %ret
 }
 
 ; ============================================================================ ;
 ; Positive tests with value range known

 }
 
 ; ============================================================================ ;
 ; Vectors
 ; ============================================================================ ;
 
 define <2 x i8> @add_vec(<2 x i8> %x) {
 ; CHECK-LABEL: @add_vec(
-; CHECK-NEXT:    [[RET:%.*]] = add nuw <2 x i8> [[X:%.*]], <i8 -1, i8 -1>
-; CHECK-NEXT:    ret <2 x i8> [[RET]]
+; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 ;
   %ret = add nuw <2 x i8> %x, <i8 -1, i8 -1>
   ret <2 x i8> %ret
 }
 
 define <3 x i8> @add_vec_undef(<3 x i8> %x) {
 ; CHECK-LABEL: @add_vec_undef(
-; CHECK-NEXT:    [[RET:%.*]] = add nuw <3 x i8> [[X:%.*]], <i8 -1, i8 undef, i8 -1>
-; CHECK-NEXT:    ret <3 x i8> [[RET]]
+; CHECK-NEXT:    ret <3 x i8> <i8 -1, i8 undef, i8 -1>
 ;
   %ret = add nuw <3 x i8> %x, <i8 -1, i8 undef, i8 -1>
   ret <3 x i8> %ret
 }
 
 ; ============================================================================ ;
 ; Negative tests. Should not be folded.
 ; ============================================================================ ;