[InstSimplify] Simplify `(shl nsw nuw X, BitWidth - 1)` -> `0`

[goldstein.w.n]

Summary

https://alive2.llvm.org/ce/z/uFy5zT

[goldstein.w.n]

Split tests

[nikic]

LG

llvm/lib/Analysis/InstructionSimplify.cpp

1448

Spurious space after *.

[spatel]

llvm/lib/Analysis/InstructionSimplify.cpp

1466

This could use an explanatory code comment, so we don't have to refer back to the no-wrap definitions:

// "nuw" guarantees that only zeros are shifted out, and "nsw" guarantees 
// that the sign-bit does not change, so the only input that does not 
// produce poison is 0, and "0 << (bitwidth-1) --> 0".

[goldstein.w.n]

Add comment, fix style

[goldstein.w.n]

Rebase

llvm/lib/Analysis/InstructionSimplify.cpp

 /// Given operands for an Shl, see if we can fold the result.
 /// If not, this returns null.
 static Value *simplifyShlInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW,
                               const SimplifyQuery &Q, unsigned MaxRecurse) {
   if (Value *V =
           simplifyShift(Instruction::Shl, Op0, Op1, IsNSW, Q, MaxRecurse))
     return V;
 
+  Type *Ty = Op0->getType();
   // undef << X -> 0
   // undef << X -> undef if (if it's NSW/NUW)
   if (Q.isUndefValue(Op0))
-    return IsNSW || IsNUW ? Op0 : Constant::getNullValue(Op0->getType());
+    return IsNSW || IsNUW ? Op0 : Constant::getNullValue(Ty);
 
   // (X >> A) << A -> X
   Value *X;
   if (Q.IIQ.UseInstrInfo &&
       match(Op0, m_Exact(m_Shr(m_Value(X), m_Specific(Op1)))))
     return X;
 
   // shl nuw i8 C, %x  ->  C  iff C has sign bit set.
   if (IsNUW && match(Op0, m_Negative()))
     return Op0;
   // NOTE: could use computeKnownBits() / LazyValueInfo,
   // but the cost-benefit analysis suggests it isn't worth it.
 
+  // "nuw" guarantees that only zeros are shifted out, and "nsw" guarantees
+  // that the sign-bit does not change, so the only input that does not
+  // produce poison is 0, and "0 << (bitwidth-1) --> 0".
+  if (IsNSW && IsNUW &&
+      match(Op1, m_SpecificInt(Ty->getScalarSizeInBits() - 1)))
+    return Constant::getNullValue(Ty);
+
   return nullptr;
 }
 
 Value *llvm::simplifyShlInst(Value *Op0, Value *Op1, bool IsNSW, bool IsNUW,
                              const SimplifyQuery &Q) {
   return ::simplifyShlInst(Op0, Op1, IsNSW, IsNUW, Q, RecursionLimit);
 }
 

llvm/test/Transforms/InstSimplify/shift.ll

 ;
   %vc = lshr <vscale x 4 x i16> %va, shufflevector (<vscale x 4 x i16> insertelement (<vscale x 4 x i16> poison, i16 16, i32 0), <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer)
   ret <vscale x 4 x i16> %vc
 }
 
 ; shl nsw+nuw is 0
 define i8 @shl_nsw_nuw_7_eq_0(i8 %x) {
 ; CHECK-LABEL: @shl_nsw_nuw_7_eq_0(
-; CHECK-NEXT:    [[Y:%.*]] = shl nuw nsw i8 [[X:%.*]], 7
-; CHECK-NEXT:    ret i8 [[Y]]
+; CHECK-NEXT:    ret i8 0
 ;
   %y = shl nsw nuw i8 %x, 7
   ret i8 %y
 }
 
 ; Make sure we match the element width
 define <2 x i8> @shl_vec_nsw_nuw_7_eq_0(<2 x i8> %x) {
 ; CHECK-LABEL: @shl_vec_nsw_nuw_7_eq_0(
-; CHECK-NEXT:    [[Y:%.*]] = shl nuw nsw <2 x i8> [[X:%.*]], <i8 7, i8 7>
-; CHECK-NEXT:    ret <2 x i8> [[Y]]
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %y = shl nsw nuw <2 x i8> %x, <i8 7, i8 7>
   ret <2 x i8> %y
 }
 
 ; negative test (missing nuw)
 define i8 @shl_nsw_7_fail_missing_nuw(i8 %x) {
 ; CHECK-LABEL: @shl_nsw_7_fail_missing_nuw(