[IR][Patternmatch] Add m_SpecificInt_ULT() predicate

[lebedev.ri]

Summary

Match an integer or vector with every element unsigned less than the
Threshold. For vectors, this includes constants with undefined elements.

[spatel]

LGTM - not sure if it's worth generalizing or a TODO comment, but we could take a predicate as a parameter (rather than hard-coding 'ULT') and switch the APInt compare method based on that?

[lebedev.ri]

In D63811#1560875, @spatel wrote:

LGTM

Thank you for the review.

not sure if it's worth generalizing or a TODO comment, but we could take a predicate as a parameter (rather than hard-coding 'ULT') and switch the APInt compare method based on that?

Do yo propose passing ICmpInst::Predicate?
I did briefly think about it, and wasn't sure it's worth it *yet*.

[spatel]

In D63811#1560905, @lebedev.ri wrote:

In D63811#1560875, @spatel wrote:

LGTM

Thank you for the review.

not sure if it's worth generalizing or a TODO comment, but we could take a predicate as a parameter (rather than hard-coding 'ULT') and switch the APInt compare method based on that?

Do yo propose passing ICmpInst::Predicate?
I did briefly think about it, and wasn't sure it's worth it *yet*.

Yes, that's what I imagined. And yes, I have no idea if it's worth it, so a TODO comment or a mention in the commit message is enough for now.

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

struct is_lowbit_mask {
   bool isValue(const APInt &C) { return C.isMask(); }
 };
 /// Match an integer or vector with only the low bit(s) set.
 /// For vectors, this includes constants with undefined elements.
 inline cst_pred_ty<is_lowbit_mask> m_LowBitMask() {
   return cst_pred_ty<is_lowbit_mask>();
 }
 
+struct is_unsigned_less_than {
+  const APInt *Thr;
+  bool isValue(const APInt &C) { return C.ult(*Thr); }
+};
+/// Match an integer or vector with every element unsigned less than the
+/// Threshold. For vectors, this includes constants with undefined elements.
+/// FIXME: is it worth generalizing this to simply take ICmpInst::Predicate?
+inline cst_pred_ty<is_unsigned_less_than>
+m_SpecificInt_ULT(const APInt &Threshold) {
+  cst_pred_ty<is_unsigned_less_than> P;
+  P.Thr = &Threshold;
+  return P;
+}
+
 struct is_nan {
   bool isValue(const APFloat &C) { return C.isNaN(); }
 };
 /// Match an arbitrary NaN constant. This includes quiet and signalling nans.
 /// For vectors, this includes constants with undefined elements.
 inline cstfp_pred_ty<is_nan> m_NaN() {
   return cstfp_pred_ty<is_nan>();
 }

llvm/trunk/unittests/IR/PatternMatch.cpp

TEST_F(PatternMatchTest, OneUse) {
 
   EXPECT_TRUE(m_OneUse(m_Value(V)).match(One));
   EXPECT_EQ(One, V);
 
   EXPECT_FALSE(m_OneUse(m_Value()).match(Two));
   EXPECT_FALSE(m_OneUse(m_Value()).match(Leaf));
 }
 
+TEST_F(PatternMatchTest, SpecificIntULT) {
+  Type *IntTy = IRB.getInt32Ty();
+  unsigned BitWidth = IntTy->getScalarSizeInBits();
+
+  Value *Zero = ConstantInt::get(IntTy, 0);
+  Value *One = ConstantInt::get(IntTy, 1);
+  Value *NegOne = ConstantInt::get(IntTy, -1);
+
+  EXPECT_FALSE(m_SpecificInt_ULT(APInt(BitWidth, 0)).match(Zero));
+  EXPECT_FALSE(m_SpecificInt_ULT(APInt(BitWidth, 0)).match(One));
+  EXPECT_FALSE(m_SpecificInt_ULT(APInt(BitWidth, 0)).match(NegOne));
+
+  EXPECT_TRUE(m_SpecificInt_ULT(APInt(BitWidth, 1)).match(Zero));
+  EXPECT_FALSE(m_SpecificInt_ULT(APInt(BitWidth, 1)).match(One));
+  EXPECT_FALSE(m_SpecificInt_ULT(APInt(BitWidth, 1)).match(NegOne));
+
+  EXPECT_TRUE(m_SpecificInt_ULT(APInt(BitWidth, -1)).match(Zero));
+  EXPECT_TRUE(m_SpecificInt_ULT(APInt(BitWidth, -1)).match(One));
+  EXPECT_FALSE(m_SpecificInt_ULT(APInt(BitWidth, -1)).match(NegOne));
+}
+
 TEST_F(PatternMatchTest, CommutativeDeferredValue) {
   Value *X = IRB.getInt32(1);
   Value *Y = IRB.getInt32(2);
 
   {
     Value *tX = X;
     EXPECT_TRUE(match(X, m_Deferred(tX)));
     EXPECT_FALSE(match(Y, m_Deferred(tX)));