[globalisel][tablegen] Import rules containing intrinsic_wo_chain.

[dsanders]

Summary

As of this patch, 1018 out of 3938 rules are currently imported.

Depends on D32275

[ab]

utils/TableGen/GlobalISelEmitter.cpp

1365

This seems very lax:

• it's not only accepting intrinsic IDs, but also any oddly-typed immediate
• it accepts the oddly-typed immediate in any position, not just the first

right?

Maybe special-case this in createAndImportSelDAGMatcher instead?

[dsanders]

utils/TableGen/GlobalISelEmitter.cpp

1365

My thinking was that it also covered oddly typed integers that were manually written in a pattern (I don't have a particular pattern in mind though). From that perspective, the comment is badly worded since it suggests it's only for intrinsics.

I'm happy to hoist it out and make it more precise or to fix the comment. Do you have a preference?

[ab]

utils/TableGen/GlobalISelEmitter.cpp

1365

I can't think of any such patterns either, so I'd err on the side of caution and hoist it out?

[dsanders]

utils/TableGen/GlobalISelEmitter.cpp

1365

Ok

[dsanders]

Refresh patch

[dsanders]

Hoist out the checks for intrinsic id's so that they are only importable when
found in the place we expect them to be.

[qcolombet]

LGTM

[dsanders]

This was reverted due to compile-time regressions so re-open it and add it to the end of the patch series that fixes that.

[dsanders]

Rebase before re-commit

include/llvm/Target/GlobalISel/SelectionDAGCompat.td

 def : GINodeEquiv<G_SITOFP, sint_to_fp>;
 def : GINodeEquiv<G_UITOFP, uint_to_fp>;
 def : GINodeEquiv<G_FADD, fadd>;
 def : GINodeEquiv<G_FSUB, fsub>;
 def : GINodeEquiv<G_FMUL, fmul>;
 def : GINodeEquiv<G_FDIV, fdiv>;
 def : GINodeEquiv<G_FREM, frem>;
 def : GINodeEquiv<G_FPOW, fpow>;
+def : GINodeEquiv<G_INTRINSIC, intrinsic_wo_chain>;
 def : GINodeEquiv<G_BR, br>;
 
 // Specifies the GlobalISel equivalents for SelectionDAG's ComplexPattern.
 // Should be used on defs that subclass GIComplexOperandMatcher<>.
 class GIComplexPatternEquiv<ComplexPattern seldag> {
   ComplexPattern SelDAGEquivalent = seldag;
 }

test/TableGen/GlobalISelEmitter.td

 // RUN: llvm-tblgen -gen-global-isel -I %p/../../include %s | FileCheck %s
 
 include "llvm/Target/Target.td"
 
 //===- Define the necessary boilerplate for our test target. --------------===//
 
 def MyTargetISA : InstrInfo;
 def MyTarget : Target { let InstructionSet = MyTargetISA; }
 
+let TargetPrefix = "mytarget" in {
+def int_mytarget_nop : Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [IntrNoMem]>;
+}
+
 def R0 : Register<"r0"> { let Namespace = "MyTarget"; }
 def GPR32 : RegisterClass<"MyTarget", [i32], 32, (add R0)>;
 def GPR32Op : RegisterOperand<GPR32>;
 
 class I<dag OOps, dag IOps, list<dag> Pat>
   : Instruction {
   let Namespace = "MyTarget";
   let OutOperandList = OOps;

 // CHECK-NEXT:    }
 // CHECK-NEXT:    return false;
 // CHECK-NEXT:  }()) { return true; }
 
 
 def ADD : I<(outs GPR32:$dst), (ins GPR32:$src1, GPR32:$src2),
             [(set GPR32:$dst, (add GPR32:$src1, GPR32:$src2))]>;
 
+//===- Test a simple pattern with an intrinsic. ---------------------------===//
+//
+
+// CHECK-LABEL: if ([&]() {
+// CHECK-NEXT:    MachineInstr *MI0 = &I;
+// CHECK-NEXT:    if (!MI0 || MI0->getNumOperands() < 3)
+// CHECK-NEXT:      return false;
+// CHECK-NEXT:    if ((MI0->getOpcode() == TargetOpcode::G_INTRINSIC) &&
+// CHECK-NEXT:        ((/* dst */ (MRI.getType(MI0->getOperand(0).getReg()) == (LLT::scalar(32))) &&
+// CHECK-NEXT:         ((&RBI.getRegBankFromRegClass(MyTarget::GPR32RegClass) == RBI.getRegBank(MI0->getOperand(0).getReg(), MRI, TRI))))) &&
+// CHECK-NEXT:        ((/* Operand 1 */ (isOperandImmEqual(MI0->getOperand(1), [[ID:[0-9]+]], MRI)))) &&
+// CHECK-NEXT:        ((/* src1 */ (MRI.getType(MI0->getOperand(2).getReg()) == (LLT::scalar(32))) &&
+// CHECK-NEXT:         ((&RBI.getRegBankFromRegClass(MyTarget::GPR32RegClass) == RBI.getRegBank(MI0->getOperand(2).getReg(), MRI, TRI)))))) {
+// CHECK-NEXT:      // (intrinsic_wo_chain:i32 [[ID]]:iPTR, GPR32:i32:$src1) => (MOV:i32 GPR32:i32:$src1)
+// CHECK-NEXT:      MachineInstrBuilder MIB = BuildMI(*I.getParent(), I, I.getDebugLoc(), TII.get(MyTarget::MOV));
+// CHECK-NEXT:      MIB.add(MI0->getOperand(0)/*dst*/);
+// CHECK-NEXT:      MIB.add(MI0->getOperand(2)/*src1*/);
+// CHECK-NEXT:      for (const auto *FromMI : {MI0, })
+// CHECK-NEXT:        for (const auto &MMO : FromMI->memoperands())
+// CHECK-NEXT:          MIB.addMemOperand(MMO);
+// CHECK-NEXT:      I.eraseFromParent();
+// CHECK-NEXT:      MachineInstr &NewI = *MIB;
+// CHECK-NEXT:      constrainSelectedInstRegOperands(NewI, TII, TRI, RBI);
+// CHECK-NEXT:      return true;
+// CHECK-NEXT:    }
+// CHECK-NEXT:    return false;
+// CHECK-NEXT:  }()) { return true; }
+
+def MOV : I<(outs GPR32:$dst), (ins GPR32:$src1),
+            [(set GPR32:$dst, (int_mytarget_nop GPR32:$src1))]>;
+
 //===- Test a nested instruction match. -----------------------------------===//
 
 // CHECK-LABEL: if ([&]() {
 // CHECK-NEXT:    PredicateBitset ExpectedFeatures = {Feature_HasABit};
 // CHECK-NEXT:    if ((AvailableFeatures & ExpectedFeatures) != ExpectedFeatures)
 // CHECK-NEXT:      return false;
 // CHECK-NEXT:    MachineInstr *MI0 = &I;
 // CHECK-NEXT:    if (!MI0 || MI0->getNumOperands() < 3)

utils/TableGen/GlobalISelEmitter.cpp

if (SrcChild->getOperator()->isSubClassOf("SDNode")) {
       if (ChildSDNI.getSDClassName() == "BasicBlockSDNode") {
         OM.addPredicate<MBBOperandMatcher>();
         return Error::success();
       }
     }
   }
 
   auto OpTyOrNone = MVTToLLT(ChildTypes.front().getConcrete());
-  if (!OpTyOrNone)
-    return failedImport("Src operand has an unsupported type");
+  // Check for intrinsics before the type check since they are not a known type.
+  if (!OpTyOrNone.hasValue() && SrcChild->isLeaf()) {
+    Init *SrcChildInit = SrcChild->getLeafValue();
+    if (IntInit *SrcChildIntInit = dyn_cast<IntInit>(SrcChildInit)) {
+      OM.addPredicate<IntOperandMatcher>(SrcChildIntInit->getValue());
+      return Error::success();
+    } else
+      return failedImport("Src operand has an unsupported type (" +
+                          to_string(*SrcChild) + ")");
+  } else if (OpTyOrNone)
     OM.addPredicate<LLTOperandMatcher>(*OpTyOrNone);
+  else
+    return failedImport("Src operand has an unsupported type (" + to_string(*SrcChild) + ")");
 
   // Check for nested instructions.
   if (!SrcChild->isLeaf()) {
     // Map the node to a gMIR instruction.
     InstructionOperandMatcher &InsnOperand =
         OM.addPredicate<InstructionOperandMatcher>();
     auto InsnMatcherOrError =
         createAndImportSelDAGMatcher(InsnOperand.getInsnMatcher(), SrcChild);