[InstSimplify] allow undefs in icmp with vector constant folds

[spatel]

Summary

I think this is safe, but I've been wrong before...
This is the main icmp simplification shortcoming seen in D84655.

Alive2 agrees that the basic examples are correct at least:

define <2 x i1> @src(<2 x i8> %x) {
%0:
  %r = icmp sle <2 x i8> { undef, 128 }, %x
  ret <2 x i1> %r
}
=>
define <2 x i1> @tgt(<2 x i8> %x) {
%0:
  ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!

define <2 x i1> @src(<2 x i32> %X) {
%0:
  %A = or <2 x i32> %X, { 63, 63 }
  %B = icmp ult <2 x i32> %A, { undef, 50 }
  ret <2 x i1> %B
}
=>
define <2 x i1> @tgt(<2 x i32> %X) {
%0:
  ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!

https://alive2.llvm.org/ce/z/omt2ee
https://alive2.llvm.org/ce/z/GW4nP_

[aqjune]

Looks good to me.
I'm not familiar with the use of m_APIntAllowUndef, so one more accept would be enough IMO.

[nikic]

LG as well.

llvm/lib/Analysis/InstructionSimplify.cpp

static Value *simplifyICmpWithConstant(CmpInst::Predicate Pred, Value *LHS,
   if (match(LHS, m_BitCast(m_UIToFP(m_Value(X))))) {
     if (Pred == ICmpInst::ICMP_SLT && match(RHS, m_Zero()))
       return ConstantInt::getFalse(ITy);
     if (Pred == ICmpInst::ICMP_SGT && match(RHS, m_AllOnes()))
       return ConstantInt::getTrue(ITy);
   }
 
   const APInt *C;
-  if (!match(RHS, m_APInt(C)))
+  if (!match(RHS, m_APIntAllowUndef(C)))
     return nullptr;
 
   // Rule out tautological comparisons (eg., ult 0 or uge 0).
   ConstantRange RHS_CR = ConstantRange::makeExactICmpRegion(Pred, *C);
   if (RHS_CR.isEmptySet())
     return ConstantInt::getFalse(ITy);
   if (RHS_CR.isFullSet())
     return ConstantInt::getTrue(ITy);

llvm/test/Transforms/InstSimplify/icmp-constant.ll

 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 ;
   %cmp = icmp ule <2 x i8> %x, <i8 255, i8 255>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @tautological_ule_vec_partial_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @tautological_ule_vec_partial_undef(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ule <2 x i8> [[X:%.*]], <i8 -1, i8 undef>
-; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 ;
   %cmp = icmp ule <2 x i8> %x, <i8 255, i8 undef>
   ret <2 x i1> %cmp
 }
 
 define i1 @tautological_ugt(i8 %x) {
 ; CHECK-LABEL: @tautological_ugt(
 ; CHECK-NEXT:    ret i1 false
 ;
   %cmp = icmp ugt i8 %x, 255
   ret i1 %cmp
 }
 
 define <2 x i1> @tautological_ugt_vec(<2 x i8> %x) {
 ; CHECK-LABEL: @tautological_ugt_vec(
 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 ;
   %cmp = icmp ugt <2 x i8> %x, <i8 255, i8 255>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @tautological_ugt_vec_partial_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @tautological_ugt_vec_partial_undef(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt <2 x i8> [[X:%.*]], <i8 undef, i8 -1>
-; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 ;
   %cmp = icmp ugt <2 x i8> %x, <i8 undef, i8 255>
   ret <2 x i1> %cmp
 }
 
 ; 'urem x, C2' produces [0, C2)
 define i1 @urem3(i32 %X) {
 ; CHECK-LABEL: @urem3(

 ;
   %A = urem <2 x i32> %X, <i32 10, i32 10>
   %B = icmp ult <2 x i32> %A, <i32 15, i32 15>
   ret <2 x i1> %B
 }
 
 define <2 x i1> @urem3_vec_partial_undef(<2 x i32> %X) {
 ; CHECK-LABEL: @urem3_vec_partial_undef(
-; CHECK-NEXT:    [[A:%.*]] = urem <2 x i32> [[X:%.*]], <i32 10, i32 10>
-; CHECK-NEXT:    [[B:%.*]] = icmp ult <2 x i32> [[A]], <i32 undef, i32 15>
-; CHECK-NEXT:    ret <2 x i1> [[B]]
+; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 ;
   %A = urem <2 x i32> %X, <i32 10, i32 10>
   %B = icmp ult <2 x i32> %A, <i32 undef, i32 15>
   ret <2 x i1> %B
 }
 
 ;'srem x, C2' produces (-|C2|, |C2|)
 define i1 @srem1(i32 %X) {

 ;
   %A = srem <2 x i32> %X, <i32 -5, i32 -5>
   %B = icmp sgt <2 x i32> %A, <i32 5, i32 5>
   ret <2 x i1> %B
 }
 
 define <2 x i1> @srem1_vec_partial_undef(<2 x i32> %X) {
 ; CHECK-LABEL: @srem1_vec_partial_undef(
-; CHECK-NEXT:    [[A:%.*]] = srem <2 x i32> [[X:%.*]], <i32 -5, i32 -5>
-; CHECK-NEXT:    [[B:%.*]] = icmp sgt <2 x i32> [[A]], <i32 5, i32 undef>
-; CHECK-NEXT:    ret <2 x i1> [[B]]
+; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 ;
   %A = srem <2 x i32> %X, <i32 -5, i32 -5>
   %B = icmp sgt <2 x i32> %A, <i32 5, i32 undef>
   ret <2 x i1> %B
 }
 
 ;'udiv C2, x' produces [0, C2]
 define i1 @udiv5(i32 %X) {

 ;
   %sub = shl nuw <2 x i32> <i32 4, i32 4>, %X
   %cmp = icmp ugt <2 x i32> %sub, <i32 3, i32 3>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @shl5_vec_partial_undef(<2 x i32> %X) {
 ; CHECK-LABEL: @shl5_vec_partial_undef(
-; CHECK-NEXT:    [[SUB:%.*]] = shl nuw <2 x i32> <i32 4, i32 4>, [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt <2 x i32> [[SUB]], <i32 undef, i32 3>
-; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 ;
   %sub = shl nuw <2 x i32> <i32 4, i32 4>, %X
   %cmp = icmp ugt <2 x i32> %sub, <i32 undef, i32 3>
   ret <2 x i1> %cmp
 }
 
 ; 'shl nsw C2, x' produces [C2 << CLO(C2)-1, C2]
 define i1 @shl2(i32 %X) {

 ;
   %A = or <2 x i32> %X, <i32 62, i32 62>
   %B = icmp ult <2 x i32> %A, <i32 50, i32 50>
   ret <2 x i1> %B
 }
 
 define <2 x i1> @or1_vec_partial_undef(<2 x i32> %X) {
 ; CHECK-LABEL: @or1_vec_partial_undef(
-; CHECK-NEXT:    [[A:%.*]] = or <2 x i32> [[X:%.*]], <i32 62, i32 62>
-; CHECK-NEXT:    [[B:%.*]] = icmp ult <2 x i32> [[A]], <i32 undef, i32 50>
-; CHECK-NEXT:    ret <2 x i1> [[B]]
+; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 ;
   %A = or <2 x i32> %X, <i32 62, i32 62>
   %B = icmp ult <2 x i32> %A, <i32 undef, i32 50>
   ret <2 x i1> %B
 }
 
 ; Single bit OR.
 define i1 @or2_true(i8 %x) {