[Attributes] Implement type attributes.

[mjacob]

Summary

This will be useful for adding an explicit value type to the byval
attribute, which is needed for opaque pointer types.

It is yet to be decided whether this is the right approach. Discussion
will be continued on llvm-dev in parallel.

[mjacob]

Ping.

Should I rebase this patch and D16516?

include/llvm/IR/Attributes.h

public:
   Attribute() : pImpl(nullptr) {}
 
   //===--------------------------------------------------------------------===//
   // Attribute Construction
   //===--------------------------------------------------------------------===//
 
   /// \brief Return a uniquified Attribute object.
   static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val = 0);
+  static Attribute get(LLVMContext &Context, AttrKind Kind, Type *Ty);
   static Attribute get(LLVMContext &Context, StringRef Kind,
                        StringRef Val = StringRef());
 
   /// \brief Return a uniquified Attribute object that has the specific
   /// alignment set.
   static Attribute getWithAlignment(LLVMContext &Context, uint64_t Align);
   static Attribute getWithStackAlignment(LLVMContext &Context, uint64_t Align);
   static Attribute getWithDereferenceableBytes(LLVMContext &Context,
                                               uint64_t Bytes);
   static Attribute getWithDereferenceableOrNullBytes(LLVMContext &Context,
                                                      uint64_t Bytes);
 
   //===--------------------------------------------------------------------===//
   // Attribute Accessors
   //===--------------------------------------------------------------------===//
 
   /// \brief Return true if the attribute is an Attribute::AttrKind type.
   bool isEnumAttribute() const;
 
   /// \brief Return true if the attribute is an integer attribute.
   bool isIntAttribute() const;
 
+  /// \brief Return true if the attribute is a type attribute.
+  bool isTypeAttribute() const;
+
   /// \brief Return true if the attribute is a string (target-dependent)
   /// attribute.
   bool isStringAttribute() const;
 
   /// \brief Return true if the attribute is present.
   bool hasAttribute(AttrKind Val) const;
 
   /// \brief Return true if the target-dependent attribute is present.
   bool hasAttribute(StringRef Val) const;
 
   /// \brief Return the attribute's kind as an enum (Attribute::AttrKind). This
   /// requires the attribute to be an enum or integer attribute.
   Attribute::AttrKind getKindAsEnum() const;
 
   /// \brief Return the attribute's value as an integer. This requires that the
   /// attribute be an integer attribute.
   uint64_t getValueAsInt() const;
 
+  /// \brief Return the attribute's value as a type. This requires that the
+  /// attribute is a type attribute.
+  Type *getValueAsType() const;
+
   /// \brief Return the attribute's kind as a string. This requires the
   /// attribute to be a string attribute.
   StringRef getKindAsString() const;
 
   /// \brief Return the attribute's value as a string. This requires the
   /// attribute to be a string attribute.
   StringRef getValueAsString() const;
 

lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
           if (Kind == Attribute::Alignment)
             B.addAlignmentAttr(Record[++i]);
           else if (Kind == Attribute::StackAlignment)
             B.addStackAlignmentAttr(Record[++i]);
           else if (Kind == Attribute::Dereferenceable)
             B.addDereferenceableAttr(Record[++i]);
           else if (Kind == Attribute::DereferenceableOrNull)
             B.addDereferenceableOrNullAttr(Record[++i]);
+        } else if (Record[i] == 5) { // Type attribute
+          Attribute::AttrKind Kind;
+          if (std::error_code EC = parseAttrKind(Record[++i], &Kind))
+            return EC;
         } else {                     // String attribute
           assert((Record[i] == 3 || Record[i] == 4) &&
                  "Invalid attribute group entry");
           bool HasValue = (Record[i++] == 4);
           SmallString<64> KindStr;
           SmallString<64> ValStr;
 
           while (Record[i] != 0 && i != e)

lib/Bitcode/Writer/BitcodeWriter.cpp

for (unsigned i = 0, e = AS.getNumSlots(); i != e; ++i) {
         Attribute Attr = *I;
         if (Attr.isEnumAttribute()) {
           Record.push_back(0);
           Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
         } else if (Attr.isIntAttribute()) {
           Record.push_back(1);
           Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
           Record.push_back(Attr.getValueAsInt());
+        } else if (Attr.isTypeAttribute()) {
+          Record.push_back(5);
+          Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
+          Record.push_back(VE.getTypeID(Attr.getValueAsType()));
         } else {
           StringRef Kind = Attr.getKindAsString();
           StringRef Val = Attr.getValueAsString();
 
           Record.push_back(Val.empty() ? 3 : 4);
           Record.append(Kind.begin(), Kind.end());
           Record.push_back(0);
           if (!Val.empty()) {
static void WriteModule(const Module *M, BitstreamWriter &Stream,
   Stream.EmitRecord(bitc::MODULE_CODE_VERSION, Vals);
 
   // Analyze the module, enumerating globals, functions, etc.
   ValueEnumerator VE(*M, ShouldPreserveUseListOrder);
 
   // Emit blockinfo, which defines the standard abbreviations etc.
   WriteBlockInfo(VE, Stream);
 
+  // Emit information describing all of the types in the module.
+  WriteTypeTable(VE, Stream);
+
   // Emit information about attribute groups.
   WriteAttributeGroupTable(VE, Stream);
 
   // Emit information about parameter attributes.
   WriteAttributeTable(VE, Stream);
 
-  // Emit information describing all of the types in the module.
-  WriteTypeTable(VE, Stream);
-
   writeComdats(VE, Stream);
 
   // Emit top-level description of module, including target triple, inline asm,
   // descriptors for global variables, and function prototype info.
   uint64_t VSTOffsetPlaceholder = WriteModuleInfo(M, VE, Stream);
 
   // Emit constants.
   WriteModuleConstants(VE, Stream);

lib/IR/AttributeImpl.h

class AttributeImpl : public FoldingSetNode {
   // AttributesImpl is uniqued, these should not be publicly available.
   void operator=(const AttributeImpl &) = delete;
   AttributeImpl(const AttributeImpl &) = delete;
 
 protected:
   enum AttrEntryKind {
     EnumAttrEntry,
     IntAttrEntry,
+    TypeAttrEntry,
     StringAttrEntry
   };
 
   AttributeImpl(AttrEntryKind KindID) : KindID(KindID) {}
 
 public:
   virtual ~AttributeImpl();
 
   bool isEnumAttribute() const { return KindID == EnumAttrEntry; }
   bool isIntAttribute() const { return KindID == IntAttrEntry; }
+  bool isTypeAttribute() const { return KindID == TypeAttrEntry; }
   bool isStringAttribute() const { return KindID == StringAttrEntry; }
 
   bool hasAttribute(Attribute::AttrKind A) const;
   bool hasAttribute(StringRef Kind) const;
 
   Attribute::AttrKind getKindAsEnum() const;
   uint64_t getValueAsInt() const;
+  Type *getValueAsType() const;
 
   StringRef getKindAsString() const;
   StringRef getValueAsString() const;
 
   /// \brief Used when sorting the attributes.
   bool operator<(const AttributeImpl &AI) const;
 
   void Profile(FoldingSetNodeID &ID) const {
     if (isEnumAttribute())
-      Profile(ID, getKindAsEnum(), 0);
+      Profile(ID, getKindAsEnum(), (uint64_t) 0);
     else if (isIntAttribute())
       Profile(ID, getKindAsEnum(), getValueAsInt());
+    else if (isTypeAttribute())
+      Profile(ID, getKindAsEnum(), getValueAsType());
     else
       Profile(ID, getKindAsString(), getValueAsString());
   }
   static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind,
                       uint64_t Val) {
     ID.AddInteger(Kind);
     if (Val) ID.AddInteger(Val);
   }
+  static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind,
+                      Type *Ty) {
+    ID.AddInteger(Kind);
+    if (Ty) ID.AddPointer(Ty);
+  }
   static void Profile(FoldingSetNodeID &ID, StringRef Kind, StringRef Values) {
     ID.AddString(Kind);
     if (!Values.empty()) ID.AddString(Values);
   }
 
   // FIXME: Remove this!
   static uint64_t getAttrMask(Attribute::AttrKind Val);
 };
assert((Kind == Attribute::Alignment || Kind == Attribute::StackAlignment ||
             Kind == Attribute::Dereferenceable ||
             Kind == Attribute::DereferenceableOrNull) &&
            "Wrong kind for int attribute!");
   }
 
   uint64_t getValue() const { return Val; }
 };
 
+class TypeAttributeImpl : public EnumAttributeImpl {
+  void anchor() override;
+  Type *Val;
+
+public:
+  TypeAttributeImpl(Attribute::AttrKind Kind, Type *Val)
+      : EnumAttributeImpl(TypeAttrEntry, Kind), Val(Val) {
+    assert((Kind == Attribute::ByVal) && "Wrong kind for type attribute!");
+  }
+
+  Type *getValue() const { return Val; }
+};
+
 class StringAttributeImpl : public AttributeImpl {
   virtual void anchor();
   std::string Kind;
   std::string Val;
 
 public:
   StringAttributeImpl(StringRef Kind, StringRef Val = StringRef())
       : AttributeImpl(StringAttrEntry), Kind(Kind), Val(Val) {}

lib/IR/Attributes.cpp

else
       PA = new IntAttributeImpl(Kind, Val);
     pImpl->AttrsSet.InsertNode(PA, InsertPoint);
   }
 
   // Return the Attribute that we found or created.
   return Attribute(PA);
 }
 
+Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
+                         Type *Ty) {
+  LLVMContextImpl *pImpl = Context.pImpl;
+  FoldingSetNodeID ID;
+  ID.AddInteger(Kind);
+  if (Ty) ID.AddPointer(Ty);
+
+  void *InsertPoint;
+  AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
+
+  if (!PA) {
+    // If we didn't find any existing attributes of the same shape then create a
+    // new one and insert it.
+    if (!Ty)
+      PA = new EnumAttributeImpl(Kind);
+    else
+      PA = new TypeAttributeImpl(Kind, Ty);
+    pImpl->AttrsSet.InsertNode(PA, InsertPoint);
+  }
+
+  // Return the Attribute that we found or created.
+  return Attribute(PA);
+}
+
 Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) {
   LLVMContextImpl *pImpl = Context.pImpl;
   FoldingSetNodeID ID;
   ID.AddString(Kind);
   if (!Val.empty()) ID.AddString(Val);
 
   void *InsertPoint;
   AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);

 bool Attribute::isEnumAttribute() const {
   return pImpl && pImpl->isEnumAttribute();
 }
 
 bool Attribute::isIntAttribute() const {
   return pImpl && pImpl->isIntAttribute();
 }
 
+bool Attribute::isTypeAttribute() const {
+  return pImpl && pImpl->isTypeAttribute();
+}
+
 bool Attribute::isStringAttribute() const {
   return pImpl && pImpl->isStringAttribute();
 }
 
 Attribute::AttrKind Attribute::getKindAsEnum() const {
   if (!pImpl) return None;
-  assert((isEnumAttribute() || isIntAttribute()) &&
+  assert((isEnumAttribute() || isIntAttribute() || isTypeAttribute()) &&
          "Invalid attribute type to get the kind as an enum!");
   return pImpl->getKindAsEnum();
 }
 
 uint64_t Attribute::getValueAsInt() const {
   if (!pImpl) return 0;
   assert(isIntAttribute() &&
          "Expected the attribute to be an integer attribute!");
   return pImpl->getValueAsInt();
 }
 
+Type *Attribute::getValueAsType() const {
+  if (!pImpl) return nullptr;
+  assert(isTypeAttribute() &&
+         "Invalid attribute type to get the value as a type!");
+  return pImpl->getValueAsType();
+}
+
 StringRef Attribute::getKindAsString() const {
   if (!pImpl) return StringRef();
   assert(isStringAttribute() &&
          "Invalid attribute type to get the kind as a string!");
   return pImpl->getKindAsString();
 }
 
 StringRef Attribute::getValueAsString() const {

 //===----------------------------------------------------------------------===//
 // AttributeImpl Definition
 //===----------------------------------------------------------------------===//
 
 // Pin the vtables to this file.
 AttributeImpl::~AttributeImpl() {}
 void EnumAttributeImpl::anchor() {}
 void IntAttributeImpl::anchor() {}
+void TypeAttributeImpl::anchor() {}
 void StringAttributeImpl::anchor() {}
 
 bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
   if (isStringAttribute()) return false;
   return getKindAsEnum() == A;
 }
 
 bool AttributeImpl::hasAttribute(StringRef Kind) const {
   if (!isStringAttribute()) return false;
   return getKindAsString() == Kind;
 }
 
 Attribute::AttrKind AttributeImpl::getKindAsEnum() const {
-  assert(isEnumAttribute() || isIntAttribute());
+  assert(isEnumAttribute() || isIntAttribute() || isTypeAttribute());
   return static_cast<const EnumAttributeImpl *>(this)->getEnumKind();
 }
 
 uint64_t AttributeImpl::getValueAsInt() const {
   assert(isIntAttribute());
   return static_cast<const IntAttributeImpl *>(this)->getValue();
 }
 
+Type *AttributeImpl::getValueAsType() const {
+  assert(isTypeAttribute());
+  return static_cast<const TypeAttributeImpl *>(this)->getValue();
+}
+
 StringRef AttributeImpl::getKindAsString() const {
   assert(isStringAttribute());
   return static_cast<const StringAttributeImpl *>(this)->getStringKind();
 }
 
 StringRef AttributeImpl::getValueAsString() const {
   assert(isStringAttribute());
   return static_cast<const StringAttributeImpl *>(this)->getStringValue();
 }
 
 bool AttributeImpl::operator<(const AttributeImpl &AI) const {
   // This sorts the attributes with Attribute::AttrKinds coming first (sorted
   // relative to their enum value) and then strings.
   if (isEnumAttribute()) {
     if (AI.isEnumAttribute()) return getKindAsEnum() < AI.getKindAsEnum();
     if (AI.isIntAttribute()) return true;
+    if (AI.isTypeAttribute()) return true;
     if (AI.isStringAttribute()) return true;
   }
 
   if (isIntAttribute()) {
     if (AI.isEnumAttribute()) return false;
     if (AI.isIntAttribute()) return getValueAsInt() < AI.getValueAsInt();
+    if (AI.isTypeAttribute()) return true;
+    if (AI.isStringAttribute()) return true;
+  }
+
+  if (isTypeAttribute()) {
+    if (AI.isEnumAttribute()) return false;
+    if (AI.isIntAttribute()) return false;
+    if (AI.isTypeAttribute()) return getValueAsType() < AI.getValueAsType();
     if (AI.isStringAttribute()) return true;
   }
 
   if (AI.isEnumAttribute()) return false;
   if (AI.isIntAttribute()) return false;
+  if (AI.isTypeAttribute()) return false;
   if (getKindAsString() == AI.getKindAsString())
     return getValueAsString() < AI.getValueAsString();
   return getKindAsString() < AI.getKindAsString();
 }
 
 uint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) {
   // FIXME: Remove this.
   switch (Val) {
if (A.getSlotIndex(I) == Index) {
       Slot = I;
       break;
     }
 
   assert(Slot != ~0U && "Couldn't find index in AttributeSet!");
 
   for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) {
     Attribute Attr = *I;
-    if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
+    if (Attr.isEnumAttribute() || Attr.isIntAttribute() ||
+        Attr.isTypeAttribute()) {
       removeAttribute(Attr.getKindAsEnum());
     } else {
       assert(Attr.isStringAttribute() && "Invalid attribute type!");
       removeAttribute(Attr.getKindAsString());
     }
   }
 
   return *this;

lib/Linker/IRMover.cpp

GlobalValue *IRLinker::copyGlobalValueProto(const GlobalValue *SGV,
   if (ForDefinition)
     NewGV->setLinkage(SGV->getLinkage());
   else if (SGV->hasExternalWeakLinkage() || SGV->hasWeakLinkage() ||
            SGV->hasLinkOnceLinkage())
     NewGV->setLinkage(GlobalValue::ExternalWeakLinkage);
 
   NewGV->copyAttributesFrom(SGV);
 
+  // Fix up type attributes.
+  if (auto *NewF = dyn_cast<Function>(NewGV)) {
+    AttributeSet Attrs = cast<Function>(SGV)->getAttributes();
+    for (unsigned Slot = 0; Slot < Attrs.getNumSlots(); ++Slot) {
+      for (auto I = Attrs.begin(Slot), E = Attrs.end(Slot); I != E; ++I) {
+        Attribute A = *I;
+        if (!A.isTypeAttribute())
+          continue;
+        Attribute NewA = Attribute::get(NewF->getContext(), A.getKindAsEnum(),
+                                        TypeMap.get(A.getValueAsType()));
+        Attrs = Attrs.addAttribute(NewF->getContext(), Attrs.getSlotIndex(Slot),
+                                   NewA);
+      }
+    }
+    NewF->setAttributes(Attrs);
+  }
+
   // Remove these copied constants in case this stays a declaration, since
   // they point to the source module. If the def is linked the values will
   // be mapped in during linkFunctionBody.
   if (auto *NewF = dyn_cast<Function>(NewGV)) {
     NewF->setPersonalityFn(nullptr);
     NewF->setPrefixData(nullptr);
     NewF->setPrologueData(nullptr);
   }