GlobalISel: Add MIPatternMatch for G_ICMP/G_FCMP

[paquette]

LGTM

[arsenm]

c77bbea9a671cf30d9f650383d8c5c189fe6c868

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

 //===----------------------------------------------------------------------===//
 #ifndef LLVM_GMIR_PATTERNMATCH_H
 #define LLVM_GMIR_PATTERNMATCH_H
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/CodeGen/GlobalISel/Utils.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/IR/InstrTypes.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 Class> struct bind_ty {
   template <typename ITy> bool match(const MachineRegisterInfo &MRI, ITy &&V) {
     return bind_helper<Class>::bind(MRI, VR, V);
   }
 };
 
 inline bind_ty<Register> m_Reg(Register &R) { return R; }
 inline bind_ty<MachineInstr *> m_MInstr(MachineInstr *&MI) { return MI; }
 inline bind_ty<LLT> m_Type(LLT &Ty) { return Ty; }
+inline bind_ty<CmpInst::Predicate> m_Pred(CmpInst::Predicate &P) { return P; }
+inline operand_type_match m_Pred() { return operand_type_match(); }
 
 // Helper for matching G_FCONSTANT
 inline bind_ty<const ConstantFP *> m_GFCst(const ConstantFP *&C) { return C; }
 
 // General helper for all the binary generic MI such as G_ADD/G_SUB etc
 template <typename LHS_P, typename RHS_P, unsigned Opcode,
           bool Commutable = false>
 struct BinaryOp_match {
inline UnaryOp_match<SrcTy, TargetOpcode::G_FNEG> m_GFNeg(const SrcTy &Src) {
   return UnaryOp_match<SrcTy, TargetOpcode::G_FNEG>(Src);
 }
 
 template <typename SrcTy>
 inline UnaryOp_match<SrcTy, TargetOpcode::COPY> m_Copy(SrcTy &&Src) {
   return UnaryOp_match<SrcTy, TargetOpcode::COPY>(std::forward<SrcTy>(Src));
 }
 
+// General helper for generic MI compares, i.e. G_ICMP and G_FCMP
+// TODO: Allow checking a specific predicate.
+template <typename Pred_P, typename LHS_P, typename RHS_P, unsigned Opcode>
+struct CompareOp_match {
+  Pred_P P;
+  LHS_P L;
+  RHS_P R;
+
+  CompareOp_match(const Pred_P &Pred, const LHS_P &LHS, const RHS_P &RHS)
+      : P(Pred), L(LHS), R(RHS) {}
+
+  template <typename OpTy>
+  bool match(const MachineRegisterInfo &MRI, OpTy &&Op) {
+    MachineInstr *TmpMI;
+    if (!mi_match(Op, MRI, m_MInstr(TmpMI)) || TmpMI->getOpcode() != Opcode)
+      return false;
+
+    auto TmpPred =
+        static_cast<CmpInst::Predicate>(TmpMI->getOperand(1).getPredicate());
+    if (!P.match(MRI, TmpPred))
+      return false;
+
+    return L.match(MRI, TmpMI->getOperand(2).getReg()) &&
+           R.match(MRI, TmpMI->getOperand(3).getReg());
+  }
+};
+
+template <typename Pred, typename LHS, typename RHS>
+inline CompareOp_match<Pred, LHS, RHS, TargetOpcode::G_ICMP>
+m_GICmp(const Pred &P, const LHS &L, const RHS &R) {
+  return CompareOp_match<Pred, LHS, RHS, TargetOpcode::G_ICMP>(P, L, R);
+}
+
+template <typename Pred, typename LHS, typename RHS>
+inline CompareOp_match<Pred, LHS, RHS, TargetOpcode::G_FCMP>
+m_GFCmp(const Pred &P, const LHS &L, const RHS &R) {
+  return CompareOp_match<Pred, LHS, RHS, TargetOpcode::G_FCMP>(P, L, R);
+}
+
 // Helper for checking if a Reg is of specific type.
 struct CheckType {
   LLT Ty;
   CheckType(const LLT &Ty) : Ty(Ty) {}
 
   bool match(const MachineRegisterInfo &MRI, Register Reg) {
     return MRI.getType(Reg) == Ty;
   }
 };
 
 inline CheckType m_SpecificType(LLT Ty) { return Ty; }
 
 } // namespace GMIPatternMatch
 } // namespace llvm
 
 #endif

llvm/unittests/CodeGen/GlobalISel/PatternMatchTest.cpp

TEST_F(GISelMITest, MatchBinaryOp) {
   // Try to match OR.
   match = mi_match(MIBOr.getReg(0), *MRI,
                    m_GOr(m_Reg(Src0), m_Reg(Src1)));
   EXPECT_TRUE(match);
   EXPECT_EQ(Src0, Copies[0]);
   EXPECT_EQ(Src1, Copies[1]);
 }
 
+TEST_F(GISelMITest, MatchICmp) {
+  setUp();
+  if (!TM)
+    return;
+
+  const LLT s1 = LLT::scalar(1);
+  auto CmpEq = B.buildICmp(CmpInst::ICMP_EQ, s1, Copies[0], Copies[1]);
+
+  // Check match any predicate.
+  bool match =
+      mi_match(CmpEq.getReg(0), *MRI, m_GICmp(m_Pred(), m_Reg(), m_Reg()));
+  EXPECT_TRUE(match);
+
+  // Check we get the predicate and registers.
+  CmpInst::Predicate Pred;
+  Register Reg0;
+  Register Reg1;
+  match = mi_match(CmpEq.getReg(0), *MRI,
+                   m_GICmp(m_Pred(Pred), m_Reg(Reg0), m_Reg(Reg1)));
+  EXPECT_TRUE(match);
+  EXPECT_EQ(CmpInst::ICMP_EQ, Pred);
+  EXPECT_EQ(Copies[0], Reg0);
+  EXPECT_EQ(Copies[1], Reg1);
+}
+
+TEST_F(GISelMITest, MatchFCmp) {
+  setUp();
+  if (!TM)
+    return;
+
+  const LLT s1 = LLT::scalar(1);
+  auto CmpEq = B.buildFCmp(CmpInst::FCMP_OEQ, s1, Copies[0], Copies[1]);
+
+  // Check match any predicate.
+  bool match =
+      mi_match(CmpEq.getReg(0), *MRI, m_GFCmp(m_Pred(), m_Reg(), m_Reg()));
+  EXPECT_TRUE(match);
+
+  // Check we get the predicate and registers.
+  CmpInst::Predicate Pred;
+  Register Reg0;
+  Register Reg1;
+  match = mi_match(CmpEq.getReg(0), *MRI,
+                   m_GFCmp(m_Pred(Pred), m_Reg(Reg0), m_Reg(Reg1)));
+  EXPECT_TRUE(match);
+  EXPECT_EQ(CmpInst::FCMP_OEQ, Pred);
+  EXPECT_EQ(Copies[0], Reg0);
+  EXPECT_EQ(Copies[1], Reg1);
+}
+
 TEST_F(GISelMITest, MatchFPUnaryOp) {
   setUp();
   if (!TM)
     return;
 
   // Truncate s64 to s32.
   LLT s32 = LLT::scalar(32);
   auto Copy0s32 = B.buildFPTrunc(s32, Copies[0]);