[GlobalISel] Teach GlobalISelEmitter to treat used iPTRAny operands as pointer operands

[paquette]

Summary

Overloaded intrinsics can use iPTRAny in used/input operands. The GlobalISelEmitter doesn't know that these are pointers, so it treats them as scalars. As a result, these intrinsics can't be imported.

This teaches the GlobalISelEmitter to recognize these as pointers rather than scalars.

[arsenm]

llvm/test/TableGen/GlobalISelEmitterOverloadedPtr.td

6

A lot of tests have the same fake target boilerplate. Should these be merged into a template target to include?

llvm/utils/TableGen/GlobalISelEmitter.cpp

3499

instrinsic

[paquette]

llvm/test/TableGen/GlobalISelEmitterOverloadedPtr.td

6

I think that's a good idea, but I'm not quite sure how to get TableGen to do it.

[paquette]

Fix typo

[arsenm]

llvm/test/TableGen/GlobalISelEmitterOverloadedPtr.td

6

I think just an include will work, although I'm not sure where to put it

[paquette]

llvm/test/TableGen/GlobalISelEmitterOverloadedPtr.td

6

I managed to get it working locally, but it makes the patch kind of large. I think it would be better to do in a follow-up.

[arsenm]

llvm/utils/TableGen/GlobalISelEmitter.cpp

3523

Why isn't this part of isOperandAPointer?

[paquette]

llvm/utils/TableGen/GlobalISelEmitter.cpp

3523

Because to get at II, you need to use Src, which is a TreePatternNode. Since isOperandAPointer is a member function of CodeGenInstruction, it feels better to me personally to keep it concerned with things local to CodeGenInstruction.

Now that I'm looking at it again though, I think it could be moved to CodeGenIntrinsic.

[paquette]

Move the check for iPTRAny into CodeGenIntrinsic.

[paquette]

Rebase changes after rL368757

[arsenm]

LGTM

llvm/utils/TableGen/GlobalISelEmitter.cpp

3495–3496

startswith G_INTRINSIC?

llvm/test/TableGen/GlobalISelEmitterOverloadedPtr.td

+// RUN: llvm-tblgen -gen-global-isel -I %p/../../include %s -o - | FileCheck %s
+
+// Boilerplate code.
+include "llvm/Target/Target.td"
+
+def MyTargetISA : InstrInfo;
+def MyTarget : Target { let InstructionSet = MyTargetISA; }
+
+let TargetPrefix = "mytarget" in {
+    def int_mytarget_anyptr : Intrinsic<[llvm_i32_ty], [llvm_anyptr_ty]>;
+}
+
+def R0 : Register<"r0"> { let Namespace = "MyTarget"; }
+def GPR32 : RegisterClass<"MyTarget", [i32], 32, (add R0)>;
+def GPR32Op : RegisterOperand<GPR32>;
+def p0 : PtrValueType <i32, 0>;
+
+class I<dag OOps, dag IOps, list<dag> Pat>
+  : Instruction {
+  let Namespace = "MyTarget";
+  let OutOperandList = OOps;
+  let InOperandList = IOps;
+  let Pattern = Pat;
+}
+
+// Ensure that llvm_anyptr_ty on an intrinsic results in a
+// GIM_CheckPointerToAny rather than a GIM_CheckType.
+//
+// CHECK: GIM_CheckCxxInsnPredicate, /*MI*/0, /*FnId*/GIPFP_MI_Predicate_frag_anyptr,
+// CHECK-NEXT: GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
+// CHECK-NEXT: // MIs[0] src
+// CHECK-NEXT: GIM_CheckPointerToAny, /*MI*/0, /*Op*/2, /*SizeInBits*/32,
+// CHECK-NEXT: GIM_CheckRegBankForClass, /*MI*/0, /*Op*/2, /*RC*/MyTarget::GPR32RegClassID,
+// CHECK-NEXT: // (intrinsic_w_chain:{ *:[i32] } 3821:{ *:[iPTR] }, GPR32:{ *:[i32] }:$src)<<P:Predicate_frag_anyptr>>  =>  (ANYLOAD:{ *:[i32] } GPR32:{ *:[i32] }:$src)
+// CHECK-NEXT: GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::ANYLOAD,
+let hasSideEffects = 1 in {
+  def ANYLOAD : I<(outs GPR32:$dst), (ins GPR32:$src1),
+            [(set GPR32:$dst, (load GPR32:$src1))]>;
+}
+
+def frag_anyptr : PatFrag<(ops node:$src),
+                   (int_mytarget_anyptr node:$src),
+                   [{ return true; // C++ code }]> {
+  let GISelPredicateCode = [{ return true; // C++ code }];
+}
+
+def : Pat<(frag_anyptr GPR32:$src),
+          (p0 (ANYLOAD GPR32:$src))>;

llvm/utils/TableGen/GlobalISelEmitter.cpp

if (!P.Def || P.getCondString().empty())
       continue;
     declareSubtargetFeature(P.Def);
     M.addRequiredFeature(P.Def);
   }
 
   return Error::success();
 }
 
+// Return true if an intrinsic \p II's ParamIdx-th entry in its ParamTypes
+// record has an iPTRAny type. If this is true, then that parameter should be
+// treated as an iPTR.
+static bool isParamAnyPtr(const CodeGenIntrinsic &II, unsigned ParamIdx) {
+  if (!II.isOverloaded)
+    return false;
+  Record *Def = II.TheDef;
+  ListInit *ParamTypes = Def->getValueAsListInit("ParamTypes");
+  if (ParamIdx < ParamTypes->size()) {
+    Record *TyEl = ParamTypes->getElementAsRecord(ParamIdx);
+    MVT::SimpleValueType VT = getValueType(TyEl->getValueAsDef("VT"));
+    if (MVT(VT) == MVT::iPTRAny)
+      return true;
+  }
+  return false;
+}
+
 Expected<InstructionMatcher &> GlobalISelEmitter::createAndImportSelDAGMatcher(
     RuleMatcher &Rule, InstructionMatcher &InsnMatcher,
     const TreePatternNode *Src, unsigned &TempOpIdx) {
   Record *SrcGIEquivOrNull = nullptr;
   const CodeGenInstruction *SrcGIOrNull = nullptr;
 
   // Start with the defined operands (i.e., the results of the root operator).
   if (Src->getExtTypes().size() > 1)
if (SrcGIOrNull->TheDef->getName() == "G_CONSTANT" ||
       // imm/fpimm still have operands but we don't need to do anything with it
       // here since we don't support ImmLeaf predicates yet. However, we still
       // need to note the hidden operand to get GIM_CheckNumOperands correct.
       InsnMatcher.addOperand(OpIdx++, "", TempOpIdx);
       return InsnMatcher;
     }
 
     // Match the used operands (i.e. the children of the operator).
+    bool IsIntrinsic =
+        SrcGIOrNull->TheDef->getName() == "G_INTRINSIC" ||
+        SrcGIOrNull->TheDef->getName() == "G_INTRINSIC_W_SIDE_EFFECTS";
+    const CodeGenIntrinsic *II = Src->getIntrinsicInfo(CGP);
+    if (IsIntrinsic && !II)
+      return failedImport("Expected IntInit containing instrinsic ID)");
+
     for (unsigned i = 0, e = Src->getNumChildren(); i != e; ++i) {
       TreePatternNode *SrcChild = Src->getChild(i);
 
       // SelectionDAG allows pointers to be represented with iN since it doesn't
       // distinguish between pointers and integers but they are different types in GlobalISel.
       // Coerce integers to pointers to address space 0 if the context indicates a pointer.
       bool OperandIsAPointer = SrcGIOrNull->isOperandAPointer(i);
 
       // For G_INTRINSIC/G_INTRINSIC_W_SIDE_EFFECTS, the operand immediately
       // following the defs is an intrinsic ID.
-      if ((SrcGIOrNull->TheDef->getName() == "G_INTRINSIC" ||
-           SrcGIOrNull->TheDef->getName() == "G_INTRINSIC_W_SIDE_EFFECTS") &&
-          i == 0) {
-        if (const CodeGenIntrinsic *II = Src->getIntrinsicInfo(CGP)) {
-          OperandMatcher &OM =
-              InsnMatcher.addOperand(OpIdx++, SrcChild->getName(), TempOpIdx);
-          OM.addPredicate<IntrinsicIDOperandMatcher>(II);
-          continue;
-        }
+      if (IsIntrinsic && i == 0) {
 
-        return failedImport("Expected IntInit containing instrinsic ID)");
-      }
+      // We could have anyptr_ty operands on an overloaded intrinsic. These are
+      // pointers.
+      // Note that we have to look at the i-1th parameter, because the
+      // intrinsic ID is not present in the ParamTypes record.
+      if (IsIntrinsic)
+        OperandIsAPointer |= isParamAnyPtr(*II, i - 1);
 
       if (auto Error =
               importChildMatcher(Rule, InsnMatcher, SrcChild, OperandIsAPointer,
                                  OpIdx++, TempOpIdx))
         return std::move(Error);
     }
   }