summaryrefslogtreecommitdiff
path: root/unittests/IR/PatternMatch.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'unittests/IR/PatternMatch.cpp')
-rw-r--r--unittests/IR/PatternMatch.cpp194
1 files changed, 194 insertions, 0 deletions
diff --git a/unittests/IR/PatternMatch.cpp b/unittests/IR/PatternMatch.cpp
index 5c13ba6ecd90..6b5686d53c66 100644
--- a/unittests/IR/PatternMatch.cpp
+++ b/unittests/IR/PatternMatch.cpp
@@ -65,6 +65,56 @@ TEST_F(PatternMatchTest, OneUse) {
EXPECT_FALSE(m_OneUse(m_Value()).match(Leaf));
}
+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)));
+ }
+ {
+ const Value *tX = X;
+ EXPECT_TRUE(match(X, m_Deferred(tX)));
+ EXPECT_FALSE(match(Y, m_Deferred(tX)));
+ }
+ {
+ Value *const tX = X;
+ EXPECT_TRUE(match(X, m_Deferred(tX)));
+ EXPECT_FALSE(match(Y, m_Deferred(tX)));
+ }
+ {
+ const Value *const tX = X;
+ EXPECT_TRUE(match(X, m_Deferred(tX)));
+ EXPECT_FALSE(match(Y, m_Deferred(tX)));
+ }
+
+ {
+ Value *tX = nullptr;
+ EXPECT_TRUE(match(IRB.CreateAnd(X, X), m_And(m_Value(tX), m_Deferred(tX))));
+ EXPECT_EQ(tX, X);
+ }
+ {
+ Value *tX = nullptr;
+ EXPECT_FALSE(
+ match(IRB.CreateAnd(X, Y), m_c_And(m_Value(tX), m_Deferred(tX))));
+ }
+
+ auto checkMatch = [X, Y](Value *Pattern) {
+ Value *tX = nullptr, *tY = nullptr;
+ EXPECT_TRUE(match(
+ Pattern, m_c_And(m_Value(tX), m_c_And(m_Deferred(tX), m_Value(tY)))));
+ EXPECT_EQ(tX, X);
+ EXPECT_EQ(tY, Y);
+ };
+
+ checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(X, Y)));
+ checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(Y, X)));
+ checkMatch(IRB.CreateAnd(IRB.CreateAnd(X, Y), X));
+ checkMatch(IRB.CreateAnd(IRB.CreateAnd(Y, X), X));
+}
+
TEST_F(PatternMatchTest, FloatingPointOrderedMin) {
Type *FltTy = IRB.getFloatTy();
Value *L = ConstantFP::get(FltTy, 1.0);
@@ -340,6 +390,150 @@ TEST_F(PatternMatchTest, OverflowingBinOps) {
EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
}
+TEST_F(PatternMatchTest, LoadStoreOps) {
+ // Create this load/store sequence:
+ //
+ // %p = alloca i32*
+ // %0 = load i32*, i32** %p
+ // store i32 42, i32* %0
+
+ Value *Alloca = IRB.CreateAlloca(IRB.getInt32Ty());
+ Value *LoadInst = IRB.CreateLoad(Alloca);
+ Value *FourtyTwo = IRB.getInt32(42);
+ Value *StoreInst = IRB.CreateStore(FourtyTwo, Alloca);
+ Value *MatchLoad, *MatchStoreVal, *MatchStorePointer;
+
+ EXPECT_TRUE(m_Load(m_Value(MatchLoad)).match(LoadInst));
+ EXPECT_EQ(Alloca, MatchLoad);
+
+ EXPECT_TRUE(m_Load(m_Specific(Alloca)).match(LoadInst));
+
+ EXPECT_FALSE(m_Load(m_Value(MatchLoad)).match(Alloca));
+
+ EXPECT_TRUE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer))
+ .match(StoreInst));
+ EXPECT_EQ(FourtyTwo, MatchStoreVal);
+ EXPECT_EQ(Alloca, MatchStorePointer);
+
+ EXPECT_FALSE(m_Store(m_Value(MatchStoreVal), m_Value(MatchStorePointer))
+ .match(Alloca));
+
+ EXPECT_TRUE(m_Store(m_SpecificInt(42), m_Specific(Alloca))
+ .match(StoreInst));
+ EXPECT_FALSE(m_Store(m_SpecificInt(42), m_Specific(FourtyTwo))
+ .match(StoreInst));
+ EXPECT_FALSE(m_Store(m_SpecificInt(43), m_Specific(Alloca))
+ .match(StoreInst));
+}
+
+TEST_F(PatternMatchTest, VectorOps) {
+ // Build up small tree of vector operations
+ //
+ // Val = 0 + 1
+ // Val2 = Val + 3
+ // VI1 = insertelement <2 x i8> undef, i8 1, i32 0 = <1, undef>
+ // VI2 = insertelement <2 x i8> %VI1, i8 %Val2, i8 %Val = <1, 4>
+ // VI3 = insertelement <2 x i8> %VI1, i8 %Val2, i32 1 = <1, 4>
+ // VI4 = insertelement <2 x i8> %VI1, i8 2, i8 %Val = <1, 2>
+ //
+ // SI1 = shufflevector <2 x i8> %VI1, <2 x i8> undef, zeroinitializer
+ // SI2 = shufflevector <2 x i8> %VI3, <2 x i8> %VI4, <2 x i8> <i8 0, i8 2>
+ // SI3 = shufflevector <2 x i8> %VI3, <2 x i8> undef, zeroinitializer
+ // SI4 = shufflevector <2 x i8> %VI4, <2 x i8> undef, zeroinitializer
+ //
+ // SP1 = VectorSplat(2, i8 2)
+ // SP2 = VectorSplat(2, i8 %Val)
+ Type *VecTy = VectorType::get(IRB.getInt8Ty(), 2);
+ Type *i32 = IRB.getInt32Ty();
+ Type *i32VecTy = VectorType::get(i32, 2);
+
+ Value *Val = IRB.CreateAdd(IRB.getInt8(0), IRB.getInt8(1));
+ Value *Val2 = IRB.CreateAdd(Val, IRB.getInt8(3));
+
+ SmallVector<Constant *, 2> VecElemIdxs;
+ VecElemIdxs.push_back(ConstantInt::get(i32, 0));
+ VecElemIdxs.push_back(ConstantInt::get(i32, 2));
+ auto *IdxVec = ConstantVector::get(VecElemIdxs);
+
+ Value *UndefVec = UndefValue::get(VecTy);
+ Value *VI1 = IRB.CreateInsertElement(UndefVec, IRB.getInt8(1), (uint64_t)0);
+ Value *VI2 = IRB.CreateInsertElement(VI1, Val2, Val);
+ Value *VI3 = IRB.CreateInsertElement(VI1, Val2, (uint64_t)1);
+ Value *VI4 = IRB.CreateInsertElement(VI1, IRB.getInt8(2), Val);
+
+ Value *EX1 = IRB.CreateExtractElement(VI4, Val);
+ Value *EX2 = IRB.CreateExtractElement(VI4, (uint64_t)0);
+ Value *EX3 = IRB.CreateExtractElement(IdxVec, (uint64_t)1);
+
+ Value *Zero = ConstantAggregateZero::get(i32VecTy);
+ Value *SI1 = IRB.CreateShuffleVector(VI1, UndefVec, Zero);
+ Value *SI2 = IRB.CreateShuffleVector(VI3, VI4, IdxVec);
+ Value *SI3 = IRB.CreateShuffleVector(VI3, UndefVec, Zero);
+ Value *SI4 = IRB.CreateShuffleVector(VI4, UndefVec, Zero);
+
+ Value *SP1 = IRB.CreateVectorSplat(2, IRB.getInt8(2));
+ Value *SP2 = IRB.CreateVectorSplat(2, Val);
+
+ Value *A = nullptr, *B = nullptr, *C = nullptr;
+
+ // Test matching insertelement
+ EXPECT_TRUE(match(VI1, m_InsertElement(m_Value(), m_Value(), m_Value())));
+ EXPECT_TRUE(
+ match(VI1, m_InsertElement(m_Undef(), m_ConstantInt(), m_ConstantInt())));
+ EXPECT_TRUE(
+ match(VI1, m_InsertElement(m_Undef(), m_ConstantInt(), m_Zero())));
+ EXPECT_TRUE(
+ match(VI1, m_InsertElement(m_Undef(), m_SpecificInt(1), m_Zero())));
+ EXPECT_TRUE(match(VI2, m_InsertElement(m_Value(), m_Value(), m_Value())));
+ EXPECT_FALSE(
+ match(VI2, m_InsertElement(m_Value(), m_Value(), m_ConstantInt())));
+ EXPECT_FALSE(
+ match(VI2, m_InsertElement(m_Value(), m_ConstantInt(), m_Value())));
+ EXPECT_FALSE(match(VI2, m_InsertElement(m_Constant(), m_Value(), m_Value())));
+ EXPECT_TRUE(match(VI3, m_InsertElement(m_Value(A), m_Value(B), m_Value(C))));
+ EXPECT_TRUE(A == VI1);
+ EXPECT_TRUE(B == Val2);
+ EXPECT_TRUE(isa<ConstantInt>(C));
+ A = B = C = nullptr; // reset
+
+ // Test matching extractelement
+ EXPECT_TRUE(match(EX1, m_ExtractElement(m_Value(A), m_Value(B))));
+ EXPECT_TRUE(A == VI4);
+ EXPECT_TRUE(B == Val);
+ A = B = C = nullptr; // reset
+ EXPECT_FALSE(match(EX1, m_ExtractElement(m_Value(), m_ConstantInt())));
+ EXPECT_TRUE(match(EX2, m_ExtractElement(m_Value(), m_ConstantInt())));
+ EXPECT_TRUE(match(EX3, m_ExtractElement(m_Constant(), m_ConstantInt())));
+
+ // Test matching shufflevector
+ EXPECT_TRUE(match(SI1, m_ShuffleVector(m_Value(), m_Undef(), m_Zero())));
+ EXPECT_TRUE(match(SI2, m_ShuffleVector(m_Value(A), m_Value(B), m_Value(C))));
+ EXPECT_TRUE(A == VI3);
+ EXPECT_TRUE(B == VI4);
+ EXPECT_TRUE(C == IdxVec);
+ A = B = C = nullptr; // reset
+
+ // Test matching the vector splat pattern
+ EXPECT_TRUE(match(
+ SI1,
+ m_ShuffleVector(m_InsertElement(m_Undef(), m_SpecificInt(1), m_Zero()),
+ m_Undef(), m_Zero())));
+ EXPECT_FALSE(match(
+ SI3, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(), m_Zero()),
+ m_Undef(), m_Zero())));
+ EXPECT_FALSE(match(
+ SI4, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(), m_Zero()),
+ m_Undef(), m_Zero())));
+ EXPECT_TRUE(match(
+ SP1,
+ m_ShuffleVector(m_InsertElement(m_Undef(), m_SpecificInt(2), m_Zero()),
+ m_Undef(), m_Zero())));
+ EXPECT_TRUE(match(
+ SP2, m_ShuffleVector(m_InsertElement(m_Undef(), m_Value(A), m_Zero()),
+ m_Undef(), m_Zero())));
+ EXPECT_TRUE(A == Val);
+}
+
template <typename T> struct MutableConstTest : PatternMatchTest { };
typedef ::testing::Types<std::tuple<Value*, Instruction*>,
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-09 06:06:27 +0000