[PatternMatch] Add m_Store pattern match helper

[SjoerdMeijer]

Summary

Looks like we don't add tests for this, but I am planning on using it in D48128

[lebedev.ri]

The tests can go into unittests/IR/PatternMatch.cpp.

[dmgreen]

include/llvm/IR/PatternMatch.h

1206 ↗

(On Diff #151704)

Are you sure you want the pointer operand, and not the value being stored? (Or maybe both?)

[SjoerdMeijer]

Ah, thanks! Will add tests there, and check if I want the pointer operand.

[SjoerdMeijer]

Thanks for the suggestions:

• added unittests,
• now storing both the pointer and value operand (looks most convenient to me).

[dmgreen]

unittests/IR/PatternMatch.cpp

403 ↗

(On Diff #151728)

Can you remove these, just using m_Value() as the above tests? Or maybe better to test that they are the correct values (i.e EXPECT_EQ(Alloca, MatchStorePointer);)

[SjoerdMeijer]

Tweaked the unittests a bit more.

[dmgreen]

LGTM. This looks simple enough. Perhaps wait enough for anyone on a different time zone to object.

[lebedev.ri]

unittests/IR/PatternMatch.cpp

411–417 ↗

(On Diff #151902)

Can you add a basic sanity test to show that it works with m_Specific(), too?

[SjoerdMeijer]

Thanks, more tests added.

[SjoerdMeijer]

Thanks a lot for the reviews. I will wait a day before committing.

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

 };
 
 /// Matches LoadInst.
 template <typename OpTy> inline LoadClass_match<OpTy> m_Load(const OpTy &Op) {
   return LoadClass_match<OpTy>(Op);
 }
 
 //===----------------------------------------------------------------------===//
+// Matcher for StoreInst classes
+//
+
+template <typename ValueOp_t, typename PointerOp_t> struct StoreClass_match {
+  ValueOp_t ValueOp;
+  PointerOp_t PointerOp;
+
+  StoreClass_match(const ValueOp_t &ValueOpMatch,
+                   const PointerOp_t &PointerOpMatch) :
+    ValueOp(ValueOpMatch), PointerOp(PointerOpMatch)  {}
+
+  template <typename OpTy> bool match(OpTy *V) {
+    if (auto *LI = dyn_cast<StoreInst>(V))
+      return ValueOp.match(LI->getValueOperand()) &&
+             PointerOp.match(LI->getPointerOperand());
+    return false;
+  }
+};
+
+/// Matches StoreInst.
+template <typename ValueOpTy, typename PointerOpTy>
+inline StoreClass_match<ValueOpTy, PointerOpTy>
+m_Store(const ValueOpTy &ValueOp, const PointerOpTy &PointerOp) {
+  return StoreClass_match<ValueOpTy, PointerOpTy>(ValueOp, PointerOp);
+}
+
+//===----------------------------------------------------------------------===//
 // Matchers for unary operators
 //
 
 template <typename LHS_t> struct neg_match {
   LHS_t L;
 
   neg_match(const LHS_t &LHS) : L(LHS) {}
 

llvm/trunk/unittests/IR/PatternMatch.cpp

TEST_F(PatternMatchTest, OverflowingBinOps) {
   EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNSWMul(L, R)));
   EXPECT_FALSE(m_NUWMul(m_Value(), m_Value()).match(IRB.CreateNUWAdd(L, R)));
   EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(IRB.CreateShl(L, R)));
   EXPECT_FALSE(m_NUWShl(m_Value(), m_Value()).match(
       IRB.CreateShl(L, R, "", /* NUW */ false, /* NSW */ true)));
   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>