[PatternMatch] define m_Not using m_Xor and cst_pred_ty

[spatel]

Summary

As the tests show, using cst_pred_ty in the definition allows us to match vectors with undef elements.

This appears to do what I was hoping for with maximal reuse of the existing code, but my grasp of C++ templates is too weak to know if I've broken any laws here.

My initial patch just replaced the lines in the existing not_match struct like this:

-- if (isAllOnes(O->getOperand(1)) 
++ if (m_AllOnes().match(O->getOperand(1)))

...and that seems to work too, but this way removes more code (assuming it's ok).

This is a continuation to make all pattern matchers allow undef elements in vectors:
https://reviews.llvm.org/rL325437
https://reviews.llvm.org/rL325466
D43792

[arsenm]

LGTM

llvm/trunk/include/llvm/IR/PatternMatch.h

template <typename OpTy> bool match(OpTy *V) {
     return false;
   }
 };
 
 /// Matches LoadInst.
 template <typename OpTy> inline LoadClass_match<OpTy> m_Load(const OpTy &Op) {
   return LoadClass_match<OpTy>(Op);
 }
+
 //===----------------------------------------------------------------------===//
 // Matchers for unary operators
 //
 
-template <typename LHS_t> struct not_match {
-  LHS_t L;
-
-  not_match(const LHS_t &LHS) : L(LHS) {}
-
-  template <typename OpTy> bool match(OpTy *V) {
-    if (auto *O = dyn_cast<Operator>(V))
-      if (O->getOpcode() == Instruction::Xor) {
-        if (isAllOnes(O->getOperand(1)))
-          return L.match(O->getOperand(0));
-        if (isAllOnes(O->getOperand(0)))
-          return L.match(O->getOperand(1));
-      }
-    return false;
-  }
-
-private:
-  bool isAllOnes(Value *V) {
-    return isa<Constant>(V) && cast<Constant>(V)->isAllOnesValue();
-  }
-};
-
-template <typename LHS> inline not_match<LHS> m_Not(const LHS &L) { return L; }
-
 template <typename LHS_t> struct neg_match {
   LHS_t L;
 
   neg_match(const LHS_t &LHS) : L(LHS) {}
 
   template <typename OpTy> bool match(OpTy *V) {
     if (auto *O = dyn_cast<Operator>(V))
       if (O->getOpcode() == Instruction::Sub)

 
 /// Matches an Xor with LHS and RHS in either order.
 template <typename LHS, typename RHS>
 inline BinaryOp_match<LHS, RHS, Instruction::Xor, true> m_c_Xor(const LHS &L,
                                                                 const RHS &R) {
   return BinaryOp_match<LHS, RHS, Instruction::Xor, true>(L, R);
 }
 
+/// Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
+template <typename ValTy>
+inline BinaryOp_match<ValTy, cst_pred_ty<is_all_ones>, Instruction::Xor, true>
+m_Not(const ValTy &V) {
+  return m_c_Xor(V, m_AllOnes());
+}
+
 /// Matches an SMin with LHS and RHS in either order.
 template <typename LHS, typename RHS>
 inline MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty, true>
 m_c_SMin(const LHS &L, const RHS &R) {
   return MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty, true>(L, R);
 }
 /// Matches an SMax with LHS and RHS in either order.
 template <typename LHS, typename RHS>

llvm/trunk/test/Transforms/InstCombine/sub.ll

 ; CHECK-NEXT:    ret <2 x i8> [[SUB]]
 ;
   %nx = xor <2 x i8> %x, <i8 -1, i8 -1>
   %ny = xor <2 x i8> %y, <i8 -1, i8 -1>
   %sub = sub <2 x i8> %nx, %ny
   ret <2 x i8> %sub
 }
 
-; FIXME:
 define <2 x i8> @notnotsub_vec_undef_elts(<2 x i8> %x, <2 x i8> %y) {
 ; CHECK-LABEL: @notnotsub_vec_undef_elts(
-; CHECK-NEXT:    [[NX:%.*]] = xor <2 x i8> [[X:%.*]], <i8 undef, i8 -1>
-; CHECK-NEXT:    [[NY:%.*]] = xor <2 x i8> [[Y:%.*]], <i8 -1, i8 undef>
-; CHECK-NEXT:    [[SUB:%.*]] = sub <2 x i8> [[NX]], [[NY]]
+; CHECK-NEXT:    [[SUB:%.*]] = sub <2 x i8> [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    ret <2 x i8> [[SUB]]
 ;
   %nx = xor <2 x i8> %x, <i8 undef, i8 -1>
   %ny = xor <2 x i8> %y, <i8 -1, i8 undef>
   %sub = sub <2 x i8> %nx, %ny
   ret <2 x i8> %sub
 }
 

llvm/trunk/test/Transforms/InstCombine/vector-xor.ll

;
   %1 = xor  <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %x
   %2 = ashr <4 x i32> %1, %y
   %3 = xor  <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %2
   ret <4 x i32> %3
 }
 
 define <4 x i32> @test_v4i32_not_ashr_not_undef(<4 x i32> %x, <4 x i32> %y) {
 ; CHECK-LABEL: @test_v4i32_not_ashr_not_undef(
-; CHECK-NEXT:    [[TMP1:%.*]] = xor <4 x i32> [[X:%.*]], <i32 -1, i32 -1, i32 -1, i32 undef>
-; CHECK-NEXT:    [[TMP2:%.*]] = ashr <4 x i32> [[TMP1]], [[Y:%.*]]
-; CHECK-NEXT:    [[TMP3:%.*]] = xor <4 x i32> [[TMP2]], <i32 -1, i32 -1, i32 undef, i32 -1>
-; CHECK-NEXT:    ret <4 x i32> [[TMP3]]
+; CHECK-NEXT:    [[TMP1:%.*]] = ashr <4 x i32> [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    ret <4 x i32> [[TMP1]]
 ;
   %1 = xor  <4 x i32> <i32 -1, i32 -1, i32 -1, i32 undef>, %x
   %2 = ashr <4 x i32> %1, %y
   %3 = xor  <4 x i32> <i32 -1, i32 -1, i32 undef, i32 -1>, %2
   ret <4 x i32> %3
 }
 
 ; ~(C >>s Y) --> ~C >>u Y (when inverting the replicated sign bits)

 ;
   %1 = ashr <4 x i32> <i32 -3, i32 -5, i32 -7, i32 -9>, %a0
   %2 = xor  <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %1
   ret <4 x i32> %2
 }
 
 define <4 x i32> @test_v4i32_not_ashr_negative_const_undef(<4 x i32> %a0) {
 ; CHECK-LABEL: @test_v4i32_not_ashr_negative_const_undef(
-; CHECK-NEXT:    [[TMP1:%.*]] = ashr <4 x i32> <i32 -3, i32 -5, i32 undef, i32 -9>, [[A0:%.*]]
-; CHECK-NEXT:    [[TMP2:%.*]] = xor <4 x i32> [[TMP1]], <i32 -1, i32 -1, i32 -1, i32 undef>
-; CHECK-NEXT:    ret <4 x i32> [[TMP2]]
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr <4 x i32> <i32 2, i32 4, i32 undef, i32 8>, [[A0:%.*]]
+; CHECK-NEXT:    ret <4 x i32> [[TMP1]]
 ;
   %1 = ashr <4 x i32> <i32 -3, i32 -5, i32 undef, i32 -9>, %a0
   %2 = xor  <4 x i32> <i32 -1, i32 -1, i32 -1, i32 undef>, %1
   ret <4 x i32> %2
 }
 
 ; ~(C >>u Y) --> ~C >>s Y (when inverting the replicated sign bits)
 

 ;
   %1 = lshr <4 x i32> <i32  3, i32  5, i32  7, i32  9>, %a0
   %2 = xor  <4 x i32> <i32 -1, i32 -1, i32 -1, i32 -1>, %1
   ret <4 x i32> %2
 }
 
 define <4 x i32> @test_v4i32_not_lshr_nonnegative_const_undef(<4 x i32> %a0) {
 ; CHECK-LABEL: @test_v4i32_not_lshr_nonnegative_const_undef(
-; CHECK-NEXT:    [[TMP1:%.*]] = lshr <4 x i32> <i32 3, i32 5, i32 undef, i32 9>, [[A0:%.*]]
-; CHECK-NEXT:    [[TMP2:%.*]] = xor <4 x i32> [[TMP1]], <i32 -1, i32 -1, i32 -1, i32 undef>
-; CHECK-NEXT:    ret <4 x i32> [[TMP2]]
+; CHECK-NEXT:    [[TMP1:%.*]] = ashr <4 x i32> <i32 -4, i32 -6, i32 undef, i32 -10>, [[A0:%.*]]
+; CHECK-NEXT:    ret <4 x i32> [[TMP1]]
 ;
   %1 = lshr <4 x i32> <i32  3, i32  5, i32 undef, i32  9>, %a0
   %2 = xor  <4 x i32> <i32 -1, i32 -1, i32 -1, i32 undef>, %1
   ret <4 x i32> %2
 }
 
 ; ~(C-X) == X-C-1 == X+(-C-1)