TBD: initial impl, need to split out langref

Author: erikdesjardins

llvm/docs/LangRef.rst

@@ -1173,6 +1173,23 @@ Currently, only the following parameter attributes are defined:
     site. If the alignment is not specified, then the code generator
     makes a target-specific assumption.
 
+.. _attr_range:
+
+``range(<meta>)``
+    This indicates the possible ranges the parameter can take.
+    If the parameter is not in the specified range,
+    :ref:`poison value <poisonvalues>` is passed instead.
+    This attribute must reference a single metadata node, with the same format
+    and behavior as used for :ref:`range metadata <range-metadata>`.
+
+.. code-block:: llvm
+
+    define void @f(i8 range(!0) %a) {
+      ; %a can only be 0, 1, 3, 4 or 5
+    }
+
+    !0 = !{ i8 0, i8 2, i8 3, i8 6 }
+
 .. _attr_inalloca:
 
 ``inalloca(<ty>)``

llvm/include/llvm-c/Core.h

@@ -642,6 +642,17 @@ LLVMAttributeRef LLVMCreateTypeAttribute(LLVMContextRef C, unsigned KindID,
  */
 LLVMTypeRef LLVMGetTypeAttributeValue(LLVMAttributeRef A);
 
+/**
+ * Create a metadata attribute
+ */
+LLVMAttributeRef LLVMCreateMetadataAttribute(LLVMContextRef C, unsigned KindID,
+                                             LLVMMetadataRef type_ref);
+
+/**
+ * Get the metadata attribute's value.
+ */
+LLVMMetadataRef LLVMGetMetadataAttributeValue(LLVMAttributeRef A);
+
 /**
  * Create a string attribute.
  */
@@ -665,6 +676,7 @@ const char *LLVMGetStringAttributeValue(LLVMAttributeRef A, unsigned *Length);
 LLVMBool LLVMIsEnumAttribute(LLVMAttributeRef A);
 LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A);
 LLVMBool LLVMIsTypeAttribute(LLVMAttributeRef A);
+LLVMBool LLVMIsMetadataAttribute(LLVMAttributeRef A);
 
 /**
  * Obtain a Type from a context by its registered name.

llvm/include/llvm/AsmParser/LLParser.h

@@ -352,6 +352,8 @@ namespace llvm {
                                     bool inAttrGrp, LocTy &BuiltinLoc);
     bool parseRequiredTypeAttr(AttrBuilder &B, lltok::Kind AttrToken,
                                Attribute::AttrKind AttrKind);
+    bool parseRequiredMetadataAttr(AttrBuilder &B, lltok::Kind AttrToken,
+                                   Attribute::AttrKind AttrKind);
 
     // Module Summary Index Parsing.
     bool skipModuleSummaryEntry();

llvm/include/llvm/Bitcode/LLVMBitCodes.h

@@ -710,6 +710,7 @@ enum AttributeKindCodes {
   ATTR_KIND_FNRETTHUNK_EXTERN = 84,
   ATTR_KIND_SKIP_PROFILE = 85,
   ATTR_KIND_MEMORY = 86,
+  ATTR_KIND_RANGE = 87,
 };
 
 enum ComdatSelectionKindCodes {

llvm/include/llvm/IR/Attributes.h

@@ -21,6 +21,7 @@
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/llvm-config.h"
+#include "llvm/IR/Metadata.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
@@ -105,6 +106,9 @@ class Attribute {
   static bool isTypeAttrKind(AttrKind Kind) {
     return Kind >= FirstTypeAttr && Kind <= LastTypeAttr;
   }
+  static bool isMetadataAttrKind(AttrKind Kind) {
+    return Kind >= FirstMetadataAttr && Kind <= LastMetadataAttr;
+  }
 
   static bool canUseAsFnAttr(AttrKind Kind);
   static bool canUseAsParamAttr(AttrKind Kind);
@@ -127,6 +131,7 @@ class Attribute {
   static Attribute get(LLVMContext &Context, StringRef Kind,
                        StringRef Val = StringRef());
   static Attribute get(LLVMContext &Context, AttrKind Kind, Type *Ty);
+  static Attribute get(LLVMContext &Context, AttrKind Kind, Metadata *Meta);
 
   /// Return a uniquified Attribute object that has the specific
   /// alignment set.
@@ -181,6 +186,9 @@ class Attribute {
   /// Return true if the attribute is a type attribute.
   bool isTypeAttribute() const;
 
+  /// Return true if the attribute is a metadata attribute.
+  bool isMetadataAttribute() const;
+
   /// Return true if the attribute is any kind of attribute.
   bool isValid() const { return pImpl; }
 
@@ -214,6 +222,10 @@ class Attribute {
   /// a type attribute.
   Type *getValueAsType() const;
 
+  /// Return the attribute's value as Metadata. This requires the attribute to be
+  /// a metadata attribute.
+  Metadata *getValueAsMetadata() const;
+
   /// Returns the alignment field of an attribute as a byte alignment
   /// value.
   MaybeAlign getAlignment() const;
@@ -376,6 +388,7 @@ class AttributeSet {
   Type *getPreallocatedType() const;
   Type *getInAllocaType() const;
   Type *getElementType() const;
+  MDNode *getRangeMetadata() const;
   std::optional<std::pair<unsigned, std::optional<unsigned>>> getAllocSizeArgs()
       const;
   unsigned getVScaleRangeMin() const;
@@ -856,6 +869,9 @@ class AttributeList {
   /// Return the elementtype type for the specified function parameter.
   Type *getParamElementType(unsigned ArgNo) const;
 
+  /// Return the range metadata for the specified function parameter.
+  MDNode *getParamRangeMetadata(unsigned ArgNo) const;
+
   /// Get the stack alignment of the function.
   MaybeAlign getFnStackAlignment() const;
 
@@ -1157,6 +1173,11 @@ class AttrBuilder {
   std::optional<std::pair<unsigned, std::optional<unsigned>>> getAllocSizeArgs()
       const;
 
+  /// Retrieve metadata for the given metadata attribute.
+  Metadata *getMetadataAttr(Attribute::AttrKind Kind) const;
+
+  MDNode *getRangeMetadata() const { return cast<MDNode>(getMetadataAttr(Attribute::Range)); }
+
   /// Add integer attribute with raw value (packed/encoded if necessary).
   AttrBuilder &addRawIntAttr(Attribute::AttrKind Kind, uint64_t Value);
 
@@ -1236,6 +1257,12 @@ class AttrBuilder {
   /// Add memory effect attribute.
   AttrBuilder &addMemoryAttr(MemoryEffects ME);
 
+  /// Add a metadata attribute with the given metadata.
+  AttrBuilder &addMetadataAttr(Attribute::AttrKind Kind, Metadata *Meta);
+
+  /// Add a range attribute with the given range metadata.
+  AttrBuilder &addRangeAttr(MDNode *Meta);
+
   ArrayRef<Attribute> attrs() const { return Attrs; }
 
   bool operator==(const AttrBuilder &B) const;

llvm/include/llvm/IR/Attributes.td

@@ -38,6 +38,9 @@ class IntAttr<string S, list<AttrProperty> P> : Attr<S, P>;
 /// Type attribute.
 class TypeAttr<string S, list<AttrProperty> P> : Attr<S, P>;
 
+/// Type attribute.
+class MetadataAttr<string S, list<AttrProperty> P> : Attr<S, P>;
+
 /// StringBool attribute.
 class StrBoolAttr<string S> : Attr<S, []>;
 
@@ -206,6 +209,9 @@ def OptimizeNone : EnumAttr<"optnone", [FnAttr]>;
 /// Similar to byval but without a copy.
 def Preallocated : TypeAttr<"preallocated", [FnAttr, ParamAttr]>;
 
+/// Valid range for parameter.
+def Range : MetadataAttr<"range", [ParamAttr]>;
+
 /// Function does not access memory.
 def ReadNone : EnumAttr<"readnone", [ParamAttr]>;
 

llvm/include/llvm/IR/InstrTypes.h

@@ -1800,6 +1800,10 @@ class CallBase : public Instruction {
     return Attrs.getParamElementType(ArgNo);
   }
 
+  Metadata *getParamRangeMetadata(unsigned ArgNo) const {
+    return Attrs.getParamRangeMetadata(ArgNo);
+  }
+
   /// Extract the number of dereferenceable bytes for a call or
   /// parameter (0=unknown).
   uint64_t getRetDereferenceableBytes() const {

llvm/lib/AsmParser/LLParser.cpp

@@ -1409,6 +1409,9 @@ bool LLParser::parseEnumAttribute(Attribute::AttrKind Attr, AttrBuilder &B,
   if (Attribute::isTypeAttrKind(Attr))
     return parseRequiredTypeAttr(B, Lex.getKind(), Attr);
 
+  if (Attribute::isMetadataAttrKind(Attr))
+    return parseRequiredMetadataAttr(B, Lex.getKind(), Attr);
+
   switch (Attr) {
   case Attribute::Alignment: {
     MaybeAlign Alignment;
@@ -2792,6 +2795,24 @@ bool LLParser::parseRequiredTypeAttr(AttrBuilder &B, lltok::Kind AttrToken,
   return false;
 }
 
+/// parseRequiredMetadataAttr
+///   ::= attrname(<meta>)
+bool LLParser::parseRequiredMetadataAttr(AttrBuilder &B, lltok::Kind AttrToken,
+                                         Attribute::AttrKind AttrKind) {
+  Metadata *Meta = nullptr;
+  if (!EatIfPresent(AttrToken))
+    return true;
+  if (!EatIfPresent(lltok::lparen))
+    return error(Lex.getLoc(), "expected '('");
+  if (parseMetadata(Meta, nullptr))
+    return true;
+  if (!EatIfPresent(lltok::rparen))
+    return error(Lex.getLoc(), "expected ')'");
+
+  B.addMetadataAttr(AttrKind, Meta);
+  return false;
+}
+
 /// parseOptionalOperandBundles
 ///    ::= /*empty*/
 ///    ::= '[' OperandBundle [, OperandBundle ]* ']'

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

@@ -1995,6 +1995,8 @@ static Attribute::AttrKind getAttrFromCode(uint64_t Code) {
     return Attribute::OptimizeNone;
   case bitc::ATTR_KIND_READ_NONE:
     return Attribute::ReadNone;
+  case bitc::ATTR_KIND_RANGE:
+    return Attribute::Range;
   case bitc::ATTR_KIND_READ_ONLY:
     return Attribute::ReadOnly;
   case bitc::ATTR_KIND_RETURNED:
@@ -2229,6 +2231,15 @@ Error BitcodeReader::parseAttributeGroupBlock() {
             return error("Not a type attribute");
 
           B.addTypeAttr(Kind, HasType ? getTypeByID(Record[++i]) : nullptr);
+        } else if (Record[i] == 7 || Record[i] == 8) {
+          bool HasMetadata = Record[i] == 8;
+          Attribute::AttrKind Kind;
+          if (Error Err = parseAttrKind(Record[++i], &Kind))
+            return Err;
+          if (!Attribute::isMetadataAttrKind(Kind))
+            return error("Not a metadata attribute");
+
+          B.addMetadataAttr(Kind, HasMetadata ? MDLoader->getMetadataFwdRefOrLoad(Record[++i]) : nullptr);
         } else {
           return error("Invalid attribute group entry");
         }

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

@@ -735,6 +735,8 @@ static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
     return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE;
   case Attribute::OptimizeNone:
     return bitc::ATTR_KIND_OPTIMIZE_NONE;
+  case Attribute::Range:
+    return bitc::ATTR_KIND_RANGE;
   case Attribute::ReadNone:
     return bitc::ATTR_KIND_READ_NONE;
   case Attribute::ReadOnly:
@@ -848,13 +850,20 @@ void ModuleBitcodeWriter::writeAttributeGroupTable() {
           Record.append(Val.begin(), Val.end());
           Record.push_back(0);
         }
-      } else {
-        assert(Attr.isTypeAttribute());
+      } else if (Attr.isTypeAttribute()) {
         Type *Ty = Attr.getValueAsType();
         Record.push_back(Ty ? 6 : 5);
         Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
         if (Ty)
           Record.push_back(VE.getTypeID(Attr.getValueAsType()));
+      } else if (Attr.isMetadataAttribute()) {
+        Metadata *Meta = Attr.getValueAsMetadata();
+        Record.push_back(Meta ? 8 : 7);
+        Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
+        if (Meta)
+          Record.push_back(VE.getMetadataID(Meta));
+      } else {
+        llvm_unreachable("Trying to encode unknown attribute kind");
       }
     }
 

llvm/lib/Bitcode/Writer/ValueEnumerator.cpp

@@ -1014,6 +1014,8 @@ void ValueEnumerator::EnumerateAttributes(AttributeList PAL) {
       for (Attribute Attr : AS) {
         if (Attr.isTypeAttribute())
           EnumerateType(Attr.getValueAsType());
+        else if (Attr.isMetadataAttribute())
+          EnumerateMetadata(nullptr, Attr.getValueAsMetadata());
       }
     }
   }

llvm/lib/IR/AttributeImpl.h

@@ -46,6 +46,7 @@ class AttributeImpl : public FoldingSetNode {
     IntAttrEntry,
     StringAttrEntry,
     TypeAttrEntry,
+    MetadataAttrEntry
   };
 
   AttributeImpl(AttrEntryKind KindID) : KindID(KindID) {}
@@ -59,6 +60,7 @@ class AttributeImpl : public FoldingSetNode {
   bool isIntAttribute() const { return KindID == IntAttrEntry; }
   bool isStringAttribute() const { return KindID == StringAttrEntry; }
   bool isTypeAttribute() const { return KindID == TypeAttrEntry; }
+  bool isMetadataAttribute() const { return KindID == MetadataAttrEntry; }
 
   bool hasAttribute(Attribute::AttrKind A) const;
   bool hasAttribute(StringRef Kind) const;
@@ -72,6 +74,8 @@ class AttributeImpl : public FoldingSetNode {
 
   Type *getValueAsType() const;
 
+  Metadata *getValueAsMetadata() const;
+
   /// Used when sorting the attributes.
   bool operator<(const AttributeImpl &AI) const;
 
@@ -82,8 +86,12 @@ class AttributeImpl : public FoldingSetNode {
       Profile(ID, getKindAsEnum(), getValueAsInt());
     else if (isStringAttribute())
       Profile(ID, getKindAsString(), getValueAsString());
-    else
+    else if (isTypeAttribute())
       Profile(ID, getKindAsEnum(), getValueAsType());
+    else if (isMetadataAttribute())
+      Profile(ID, getKindAsEnum(), getValueAsMetadata());
+    else
+      llvm_unreachable("invalid attribute kind");
   }
 
   static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind) {
@@ -108,6 +116,12 @@ class AttributeImpl : public FoldingSetNode {
     ID.AddInteger(Kind);
     ID.AddPointer(Ty);
   }
+
+  static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind,
+                      Metadata *Meta) {
+    ID.AddInteger(Kind);
+    ID.AddPointer(Meta);
+  }
 };
 
 static_assert(std::is_trivially_destructible<AttributeImpl>::value,
@@ -196,6 +210,16 @@ class TypeAttributeImpl : public EnumAttributeImpl {
   Type *getTypeValue() const { return Ty; }
 };
 
+class MetadataAttributeImpl : public EnumAttributeImpl {
+  Metadata *Meta;
+
+public:
+  MetadataAttributeImpl(Attribute::AttrKind Kind, Metadata *Meta)
+      : EnumAttributeImpl(MetadataAttrEntry, Kind), Meta(Meta) {}
+
+  Metadata *getMetadataValue() const { return Meta; }
+};
+
 class AttributeBitSet {
   /// Bitset with a bit for each available attribute Attribute::AttrKind.
   uint8_t AvailableAttrs[12] = {};
@@ -268,6 +292,7 @@ class AttributeSetNode final
   MemoryEffects getMemoryEffects() const;
   std::string getAsString(bool InAttrGrp) const;
   Type *getAttributeType(Attribute::AttrKind Kind) const;
+  Metadata *getAttributeMetadata(Attribute::AttrKind Kind) const;
 
   using iterator = const Attribute *;