[GISel]: Some more pattern match opcodes

[aditya_nandakumar]

Summary

Some more matchers for opcodes.

[aemerson]

LGTM.

[aditya_nandakumar]

r333685

include/llvm/CodeGen/GlobalISel/MIPatternMatch.h

 
 template <typename LHS, typename RHS>
 inline BinaryOp_match<LHS, RHS, TargetOpcode::G_FMUL, true>
 m_GFMul(const LHS &L, const RHS &R) {
   return BinaryOp_match<LHS, RHS, TargetOpcode::G_FMUL, true>(L, R);
 }
 
 template <typename LHS, typename RHS>
+inline BinaryOp_match<LHS, RHS, TargetOpcode::G_FSUB, false>
+m_GFSub(const LHS &L, const RHS &R) {
+  return BinaryOp_match<LHS, RHS, TargetOpcode::G_FSUB, false>(L, R);
+}
+
+template <typename LHS, typename RHS>
 inline BinaryOp_match<LHS, RHS, TargetOpcode::G_AND, true>
 m_GAnd(const LHS &L, const RHS &R) {
   return BinaryOp_match<LHS, RHS, TargetOpcode::G_AND, true>(L, R);
 }
 
 template <typename LHS, typename RHS>
 inline BinaryOp_match<LHS, RHS, TargetOpcode::G_OR, true> m_GOr(const LHS &L,
                                                                 const RHS &R) {

 }
 
 template <typename SrcTy>
 inline UnaryOp_match<SrcTy, TargetOpcode::G_FABS> m_GFabs(const SrcTy &Src) {
   return UnaryOp_match<SrcTy, TargetOpcode::G_FABS>(Src);
 }
 
 template <typename SrcTy>
+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));
 }
 
 // Helper for checking if a Reg is of specific type.
 struct CheckType {
   LLT Ty;
   CheckType(const LLT &Ty) : Ty(Ty) {}

unittests/CodeGen/GlobalISel/PatternMatchTest.cpp

auto MIBFMul = B.buildInstr(TargetOpcode::G_FMUL, s64, Copies[0],
                               B.buildConstant(s64, 42));
   // Match and test commutativity for FMUL.
   match = mi_match(MIBFMul->getOperand(0).getReg(), MRI,
                    m_GFMul(m_ICst(Cst), m_Reg(Src0)));
   ASSERT_TRUE(match);
   ASSERT_EQ(Cst, 42);
   ASSERT_EQ(Src0, Copies[0]);
 
+  // FSUB
+  auto MIBFSub = B.buildInstr(TargetOpcode::G_FSUB, s64, Copies[0],
+                              B.buildConstant(s64, 42));
+  match = mi_match(MIBFSub->getOperand(0).getReg(), MRI,
+                   m_GFSub(m_Reg(Src0), m_Reg()));
+  ASSERT_TRUE(match);
+  ASSERT_EQ(Src0, Copies[0]);
+
   // Build AND %0, %1
   auto MIBAnd = B.buildAnd(s64, Copies[0], Copies[1]);
   // Try to match AND.
   match = mi_match(MIBAnd->getOperand(0).getReg(), MRI,
                    m_GAnd(m_Reg(Src0), m_Reg(Src1)));
   ASSERT_TRUE(match);
   ASSERT_EQ(Src0, Copies[0]);
   ASSERT_EQ(Src1, Copies[1]);
TEST(PatternMatchInstr, MatchFPUnaryOp) {
   // Truncate s64 to s32.
   LLT s32 = LLT::scalar(32);
   auto Copy0s32 = B.buildFPTrunc(s32, Copies[0]);
 
   // Match G_FABS.
   auto MIBFabs = B.buildInstr(TargetOpcode::G_FABS, s32, Copy0s32);
   bool match = mi_match(MIBFabs->getOperand(0).getReg(), MRI, m_GFabs(m_Reg()));
   ASSERT_TRUE(match);
+
   unsigned Src;
+  auto MIBFNeg = B.buildInstr(TargetOpcode::G_FNEG, s32, Copy0s32);
+  match = mi_match(MIBFNeg->getOperand(0).getReg(), MRI, m_GFNeg(m_Reg(Src)));
+  ASSERT_TRUE(match);
+  ASSERT_EQ(Src, Copy0s32->getOperand(0).getReg());
+
   match = mi_match(MIBFabs->getOperand(0).getReg(), MRI, m_GFabs(m_Reg(Src)));
   ASSERT_TRUE(match);
   ASSERT_EQ(Src, Copy0s32->getOperand(0).getReg());
 
   // Build and match FConstant.
   auto MIBFCst = B.buildFConstant(s32, .5);
   const ConstantFP *TmpFP{};
   match = mi_match(MIBFCst->getOperand(0).getReg(), MRI, m_GFCst(TmpFP));