[MIPatternMatch]: Add ICstRegMatch

[Petar.Avramovic]

Summary

Matches G_CONSTANT and returns its def register.

[Petar.Avramovic]

Ping.

[foad]

Looks reasonable but should have at least one unit test.

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

110

Move all of this up to line 69 ish, just after m_ICst(int64_t &)?

[Petar.Avramovic]

Add unit test.

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

if (auto MaybeCst = getConstantVRegSExtVal(Reg, MRI)) {
       return true;
     }
     return false;
   }
 };
 
 inline ConstantMatch m_ICst(int64_t &Cst) { return ConstantMatch(Cst); }
 
+struct ICstRegMatch {
+  Register &CR;
+  ICstRegMatch(Register &C) : CR(C) {}
+  bool match(const MachineRegisterInfo &MRI, Register Reg) {
+    if (auto MaybeCst = getConstantVRegValWithLookThrough(
+            Reg, MRI, /*LookThroughInstrs*/ true,
+            /*HandleFConstants*/ false)) {
+      CR = MaybeCst->VReg;
+      return true;
+    }
+    return false;
+  }
+};
+
+inline ICstRegMatch m_ICst(Register &Reg) { return ICstRegMatch(Reg); }
+
 /// Matcher for a specific constant value.
 struct SpecificConstantMatch {
   int64_t RequestedVal;
   SpecificConstantMatch(int64_t RequestedVal) : RequestedVal(RequestedVal) {}
   bool match(const MachineRegisterInfo &MRI, Register Reg) {
     int64_t MatchedVal;
     return mi_match(Reg, MRI, m_ICst(MatchedVal)) && MatchedVal == RequestedVal;
   }
 };
 
 /// Matches a constant equal to \p RequestedValue.
 inline SpecificConstantMatch m_SpecificICst(int64_t RequestedValue) {
   return SpecificConstantMatch(RequestedValue);
 }
 
 ///{
 /// Convenience matchers for specific integer values.
 inline SpecificConstantMatch m_ZeroInt() { return SpecificConstantMatch(0); }
 inline SpecificConstantMatch m_AllOnesInt() {
   return SpecificConstantMatch(-1);
 }
 ///}
 
 // TODO: Rework this for different kinds of MachineOperand.
 // Currently assumes the Src for a match is a register.
 // We might want to support taking in some MachineOperands and call getReg on
 // that.
 
 struct operand_type_match {
   bool match(const MachineRegisterInfo &MRI, Register Reg) { return true; }
   bool match(const MachineRegisterInfo &MRI, MachineOperand *MO) {
     return MO->isReg();

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, MatchIntConstantRegister) {
+  setUp();
+  if (!TM)
+    return;
+  auto MIBCst = B.buildConstant(LLT::scalar(64), 42);
+  Register Src0;
+  bool match = mi_match(MIBCst.getReg(0), *MRI, m_ICst(Src0));
+  EXPECT_TRUE(match);
+  EXPECT_EQ(Src0, MIBCst.getReg(0));
+}
+
 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]);