[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 ↗

(On Diff #213386)

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 ↗

(On Diff #213386)

instrinsic

[paquette]

llvm/test/TableGen/GlobalISelEmitterOverloadedPtr.td

6 ↗

(On Diff #213386)

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 ↗

(On Diff #213386)

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

[paquette]

llvm/test/TableGen/GlobalISelEmitterOverloadedPtr.td

6 ↗

(On Diff #213386)

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 ↗

(On Diff #213412)

Why isn't this part of isOperandAPointer?

[paquette]

llvm/utils/TableGen/GlobalISelEmitter.cpp

3523 ↗

(On Diff #213412)

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

3486–3487 ↗

(On Diff #214946)

startswith G_INTRINSIC?

llvm/trunk/test/TableGen/GlobalISelEmitterOverloadedPtr.td

+// RUN: llvm-tblgen -gen-global-isel -I %p/../../include -I %p/Common %s -o - | FileCheck %s
+
+// Boilerplate code.
+include "llvm/Target/Target.td"
+include "GlobalISelEmitterCommon.td"
+
+let TargetPrefix = "mytarget" in {
+    def int_mytarget_anyptr : Intrinsic<[llvm_i32_ty], [llvm_anyptr_ty]>;
+}
+
+// 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] } {{[0-9]+}}:{ *:[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/trunk/utils/TableGen/CodeGenIntrinsics.h

struct CodeGenIntrinsic {
   };
 
   std::vector<std::pair<unsigned, ArgAttribute>> ArgumentAttributes;
 
   bool hasProperty(enum SDNP Prop) const {
     return Properties & (1 << Prop);
   }
 
+  /// Returns true if the parameter at \p ParamIdx is a pointer type. Returns
+  /// false if the parameter is not a pointer, or \p ParamIdx is greater than
+  /// the size of \p IS.ParamVTs.
+  ///
+  /// Note that this requires that \p IS.ParamVTs is available.
+  bool isParamAPointer(unsigned ParamIdx) const;
+
   CodeGenIntrinsic(Record *R);
 };
 
 class CodeGenIntrinsicTable {
   std::vector<CodeGenIntrinsic> Intrinsics;
 
 public:
   struct TargetSet {

llvm/trunk/utils/TableGen/CodeGenTarget.cpp

CodeGenIntrinsic::CodeGenIntrinsic(Record *R) {
   }
 
   // Also record the SDPatternOperator Properties.
   Properties = parseSDPatternOperatorProperties(R);
 
   // Sort the argument attributes for later benefit.
   llvm::sort(ArgumentAttributes);
 }
+
+bool CodeGenIntrinsic::isParamAPointer(unsigned ParamIdx) const {
+  if (ParamIdx >= IS.ParamVTs.size())
+    return false;
+  MVT ParamType = MVT(IS.ParamVTs[ParamIdx]);
+  return ParamType == MVT::iPTR || ParamType == MVT::iPTRAny;
+}

llvm/trunk/utils/TableGen/GlobalISelEmitter.cpp

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 intrinsic 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);
 
+      if (IsIntrinsic) {
         // 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)) {
+        if (i == 0) {
           OperandMatcher &OM =
               InsnMatcher.addOperand(OpIdx++, SrcChild->getName(), TempOpIdx);
           OM.addPredicate<IntrinsicIDOperandMatcher>(II);
           continue;
         }
 
-        return failedImport("Expected IntInit containing instrinsic ID)");
+        // We have to check intrinsics for llvm_anyptr_ty parameters.
+        //
+        // Note that we have to look at the i-1th parameter, because we don't
+        // have the intrinsic ID in the intrinsic's parameter list.
+        OperandIsAPointer |= II->isParamAPointer(i - 1);
       }
 
       if (auto Error =
               importChildMatcher(Rule, InsnMatcher, SrcChild, OperandIsAPointer,
                                  OpIdx++, TempOpIdx))
         return std::move(Error);
     }
   }