Intrinsics: Allow tablegen to mark parameters with dereferenceable

[arsenm]

Summary

Also increases the alignment of llvm.amdgcn.implicitarg.ptr to 8 to
match clang.

[arsenm]

Revert implicitarg.ptr changes since not-HSA has different alignment for no reason. Also with the size differences between amdhsa and different CO versions we're already wrong for emitting 256 unconditionally

[foad]

I think the tablegen functionality should be a separate patch from the amdgpu changes.

[arsenm]

In D142823#4093357, @foad wrote:

I think the tablegen functionality should be a separate patch from the amdgpu changes.

Maybe, but then it’s untested in the patch which adds it

[foad]

In D142823#4093363, @arsenm wrote:

In D142823#4093357, @foad wrote:

I think the tablegen functionality should be a separate patch from the amdgpu changes.

Maybe, but then it’s untested in the patch which adds it

Not if you add a test. There are some already like test/TableGen/immarg.td and test/TableGen/intrin-side-effects.td.

[arsenm]

Split out amdgpu parts

[nikic]

LGTM

[arsenm]

1717c18664d5880f78db85eb0075a2c1379df2d9

llvm/include/llvm/IR/Intrinsics.td

class NonNull<AttrIndex idx> : IntrinsicProperty {
   int ArgNo = idx.Value;
 }
 
 class Align<AttrIndex idx, int align> : IntrinsicProperty {
   int ArgNo = idx.Value;
   int Align = align;
 }
 
+class Dereferenceable<AttrIndex idx, int bytes> : IntrinsicProperty {
+  int ArgNo = idx.Value;
+  int Bytes = bytes;
+}
+
 // Returned - The specified argument is always the return value of the
 // intrinsic.
 class Returned<AttrIndex idx> : IntrinsicProperty {
   int ArgNo = idx.Value;
 }
 
 // ImmArg - The specified argument must be an immediate.
 class ImmArg<AttrIndex idx> : IntrinsicProperty {

llvm/test/TableGen/intrinsic-attrs.td

 // RUN: llvm-tblgen -gen-intrinsic-impl -I %p/../../include %s | FileCheck %s
 
 // Get the minimum blurb necessary to process ...
 include "llvm/CodeGen/ValueTypes.td"
 include "llvm/CodeGen/SDNodeProperties.td"
 
 class LLVMType<ValueType vt> {
   ValueType VT = vt;
   int isAny = 0;
 }
 
-def llvm_i32_ty        : LLVMType<i32>;
+def llvm_i32_ty     : LLVMType<i32>;
+def llvm_ptr_ty     : LLVMType<iPTR>;
+
+class AttrIndex<int idx> {
+  int Value = idx;
+}
+
+def FuncIndex : AttrIndex<-1>;
+def RetIndex : AttrIndex<0>;
+class ArgIndex<int argNo> : AttrIndex<!add(argNo, 1)>;
 
 class IntrinsicProperty<bit is_default = 0> {
   bit IsDefault = is_default;
 }
 
 def IntrNoMem : IntrinsicProperty;
 def IntrHasSideEffects : IntrinsicProperty;
+class Dereferenceable<AttrIndex idx, int bytes> : IntrinsicProperty {
+  int ArgNo = idx.Value;
+  int Bytes = bytes;
+}
 
 class Intrinsic<list<LLVMType> ret_types,
                 list<LLVMType> param_types = [],
                 list<IntrinsicProperty> intr_properties = [],
                 string name = "",
                 list<SDNodeProperty> sd_properties = [],
                 bit disable_default_attributes = 0> : SDPatternOperator {
   string LLVMName = name;
   string TargetPrefix = "";
   list<LLVMType> RetTypes = ret_types;
   list<LLVMType> ParamTypes = param_types;
   list<IntrinsicProperty> IntrProperties = intr_properties;
   let Properties = sd_properties;
   bit DisableDefaultAttributes = 1;
 
 
   bit isTarget = 0;
   bit DisableDefaultAttributes = disable_default_attributes;
 }
 
 // ... this intrinsic.
 def int_random_gen   : Intrinsic<[llvm_i32_ty], [], [IntrNoMem, IntrHasSideEffects]>;
 
+def int_deref_ptr_ret : Intrinsic<[llvm_ptr_ty], [], [Dereferenceable<RetIndex, 16>]>;
+
+// CHECK: static AttributeSet getIntrinsicArgAttributeSet(LLVMContext &C, unsigned ID) {
+// CHECK-NEXT:   switch (ID) {
+// CHECK-NEXT: default: llvm_unreachable("Invalid attribute set number");
+// CHECK-NEXT: case 0:
+// CHECK-NEXT:     return AttributeSet::get(C, {
+// CHECK-NEXT: Attribute::get(C, Attribute::Dereferenceable, 16),
+// CHECK-NEXT: });
+// CHECK-NEXT: }
+// CHECK-NEXT: }
+
 // CHECK: static AttributeSet getIntrinsicFnAttributeSet(
 // CHECK: case 0:
 // CHECK-NEXT: return AttributeSet::get(C, {
 // CHECK-NEXT: Attribute::get(C, Attribute::NoUnwind),
 // CHECK-NEXT: });
 
-// CHECK: 1, // llvm.random.gen
+
+// CHECK: 1, // llvm.deref.ptr.ret
+// CHECK: 2, // llvm.random.gen
+
 // CHECK: case 1:
-// CHECK-NEXT: AS[0] = {AttributeList::FunctionIndex, getIntrinsicFnAttributeSet(C, 0)};
+// CHECK-NEXT: AS[0] = {0, getIntrinsicArgAttributeSet(C, 0)};
+// CHECK-NEXT: AS[1] = {AttributeList::FunctionIndex, getIntrinsicFnAttributeSet(C, 0)};
+// CHECK-NEXT: NumAttrs = 2;
+
+// CHECK: case 2:
+// CHECK-NEXT: AS[0] = {AttributeList::FunctionIndex, getIntrinsicFnAttributeSet(C, 1)};
+// CHECK-NEXT: NumAttrs = 1;

llvm/utils/TableGen/CodeGenIntrinsics.h

enum ArgAttrKind {
     NoAlias,
     NoUndef,
     NonNull,
     Returned,
     ReadOnly,
     WriteOnly,
     ReadNone,
     ImmArg,
-    Alignment
+    Alignment,
+    Dereferenceable
   };
 
   struct ArgAttribute {
     ArgAttrKind Kind;
     uint64_t Value;
 
     ArgAttribute(ArgAttrKind K, uint64_t V) : Kind(K), Value(V) {}
 

llvm/utils/TableGen/CodeGenIntrinsics.cpp

else if (R->isSubClassOf("NoCapture")) {
     addArgAttribute(ArgNo, ReadNone);
   } else if (R->isSubClassOf("ImmArg")) {
     unsigned ArgNo = R->getValueAsInt("ArgNo");
     addArgAttribute(ArgNo, ImmArg);
   } else if (R->isSubClassOf("Align")) {
     unsigned ArgNo = R->getValueAsInt("ArgNo");
     uint64_t Align = R->getValueAsInt("Align");
     addArgAttribute(ArgNo, Alignment, Align);
+  } else if (R->isSubClassOf("Dereferenceable")) {
+    unsigned ArgNo = R->getValueAsInt("ArgNo");
+    uint64_t Bytes = R->getValueAsInt("Bytes");
+    addArgAttribute(ArgNo, Dereferenceable, Bytes);
   } else
     llvm_unreachable("Unknown property!");
 }
 
 bool CodeGenIntrinsic::isParamAPointer(unsigned ParamIdx) const {
   if (ParamIdx >= IS.ParamTys.size())
     return false;
   return (IS.ParamTys[ParamIdx]->isSubClassOf("LLVMQualPointerType") ||

llvm/utils/TableGen/IntrinsicEmitter.cpp

for (auto &Attrs : Int.ArgumentAttributes) {
           break;
         case CodeGenIntrinsic::ImmArg:
           OS << "      Attribute::get(C, Attribute::ImmArg),\n";
           break;
         case CodeGenIntrinsic::Alignment:
           OS << "      Attribute::get(C, Attribute::Alignment, "
              << Attr.Value << "),\n";
           break;
+        case CodeGenIntrinsic::Dereferenceable:
+          OS << "      Attribute::get(C, Attribute::Dereferenceable, "
+             << Attr.Value << "),\n";
+          break;
         }
       }
       OS << "    });\n";
     }
   }
   OS << "  }\n";
   OS << "}\n\n";