[MIPatternMatch]: Add mi_match for MachineInstr

[Petar.Avramovic]

Summary

This utility allows more efficient start of pattern match.
Often MachineInstr(MI) is available and instead of using
mi_match(MI.getOperand(0).getReg(), MRI, ...) followed by
MRI.getVRegDef(Reg) that gives back MI we now use
mi_match(MI, MRI, ...).

[arsenm]

Probably should have some unit tests for this

[paquette]

llvm/include/llvm/CodeGen/GlobalISel/MIPatternMatch.h

192

Maybe simpler?

[paquette]

Can we have testcases which check what happens with

• An instruction with 0 defs
• An instruction with > 1 def

?

[Petar.Avramovic]

Added tests for instructions with 0 and 2 defs.

[Petar.Avramovic]

Ping.

[foad]

I don't fully understand the C++ but this looks like a useful enhancement to me.

llvm/include/llvm/CodeGen/GlobalISel/MIPatternMatch.h

 namespace llvm {
 namespace MIPatternMatch {
 
 template <typename Reg, typename Pattern>
 bool mi_match(Reg R, const MachineRegisterInfo &MRI, Pattern &&P) {
   return P.match(MRI, R);
 }
 
+template <typename Pattern>
+bool mi_match(MachineInstr &MI, const MachineRegisterInfo &MRI, Pattern &&P) {
+  return P.match(MRI, &MI);
+}
+
 // TODO: Extend for N use.
 template <typename SubPatternT> struct OneUse_match {
   SubPatternT SubPat;
   OneUse_match(const SubPatternT &SP) : SubPat(SP) {}
 
   bool match(const MachineRegisterInfo &MRI, Register Reg) {
     return MRI.hasOneUse(Reg) && SubPat.match(MRI, Reg);
   }

 template <> struct bind_helper<MachineInstr *> {
   static bool bind(const MachineRegisterInfo &MRI, MachineInstr *&MI,
                    Register Reg) {
     MI = MRI.getVRegDef(Reg);
     if (MI)
       return true;
     return false;
   }
+  static bool bind(const MachineRegisterInfo &MRI, MachineInstr *&MI,
+                   MachineInstr *Inst) {
+    MI = Inst;
+    return MI;
+  }
 };
 
 template <> struct bind_helper<LLT> {
   static bool bind(const MachineRegisterInfo &MRI, LLT Ty, Register Reg) {
     Ty = MRI.getType(Reg);
     if (Ty.isValid())
       return true;
     return false;

llvm/unittests/CodeGen/GlobalISel/PatternMatchTest.cpp

if (!TM)
     return;
   auto MIBCst = B.buildConstant(LLT::scalar(64), 42);
   int64_t Cst;
   bool match = mi_match(MIBCst.getReg(0), *MRI, m_ICst(Cst));
   EXPECT_TRUE(match);
   EXPECT_EQ(Cst, 42);
 }
 
+TEST_F(AArch64GISelMITest, MachineInstrPtrBind) {
+  setUp();
+  if (!TM)
+    return;
+  auto MIBAdd = B.buildAdd(LLT::scalar(64), Copies[0], Copies[1]);
+  // Test 'MachineInstr *' bind.
+  // Default mi_match.
+  MachineInstr *MIPtr = MIBAdd.getInstr();
+  bool match = mi_match(MIPtr, *MRI, m_GAdd(m_Reg(), m_Reg()));
+  EXPECT_TRUE(match);
+  // Specialized mi_match for MachineInstr &.
+  MachineInstr &MI = *MIBAdd.getInstr();
+  match = mi_match(MI, *MRI, m_GAdd(m_Reg(), m_Reg()));
+  EXPECT_TRUE(match);
+  // MachineInstrBuilder has automatic conversion to MachineInstr *.
+  match = mi_match(MIBAdd, *MRI, m_GAdd(m_Reg(), m_Reg()));
+  EXPECT_TRUE(match);
+  // Match instruction without def.
+  auto MIBBrcond = B.buildBrCond(Copies[0], B.getMBB());
+  MachineInstr *MatchedMI;
+  match = mi_match(MIBBrcond, *MRI, m_MInstr(MatchedMI));
+  EXPECT_TRUE(match);
+  EXPECT_TRUE(MIBBrcond.getInstr() == MatchedMI);
+  // Match instruction with two defs.
+  auto MIBUAddO =
+      B.buildUAddo(LLT::scalar(64), LLT::scalar(1), Copies[0], Copies[1]);
+  match = mi_match(MIBUAddO, *MRI, m_MInstr(MatchedMI));
+  EXPECT_TRUE(match);
+  EXPECT_TRUE(MIBUAddO.getInstr() == MatchedMI);
+}
+
 TEST_F(AArch64GISelMITest, MatchBinaryOp) {
   setUp();
   if (!TM)
     return;
   LLT s32 = LLT::scalar(32);
   LLT s64 = LLT::scalar(64);
   LLT p0 = LLT::pointer(0, 64);
   auto MIBAdd = B.buildAdd(s64, Copies[0], Copies[1]);