Reapply: IR: add optional type to 'byval' function parameters
When we switch to opaque pointer types we will need some way to describe
how many bytes a 'byval' parameter should occupy on the stack. This adds
a (for now) optional extra type parameter.
If present, the type must match the pointee type of the argument.
The original commit did not remap byval types when linking modules, which broke
LTO. This version fixes that.
Note to front-end maintainers: if this causes test failures, it's probably
because the "byval" attribute is printed after attributes without any parameter
after this change.
llvm-svn: 362128
diff --git a/llvm/lib/IR/AttributeImpl.h b/llvm/lib/IR/AttributeImpl.h
index 8ebcb04..f689847 100644
--- a/llvm/lib/IR/AttributeImpl.h
+++ b/llvm/lib/IR/AttributeImpl.h
@@ -29,6 +29,7 @@
namespace llvm {
class LLVMContext;
+class Type;
//===----------------------------------------------------------------------===//
/// \class
@@ -41,7 +42,8 @@
enum AttrEntryKind {
EnumAttrEntry,
IntAttrEntry,
- StringAttrEntry
+ StringAttrEntry,
+ TypeAttrEntry,
};
AttributeImpl(AttrEntryKind KindID) : KindID(KindID) {}
@@ -56,6 +58,7 @@
bool isEnumAttribute() const { return KindID == EnumAttrEntry; }
bool isIntAttribute() const { return KindID == IntAttrEntry; }
bool isStringAttribute() const { return KindID == StringAttrEntry; }
+ bool isTypeAttribute() const { return KindID == TypeAttrEntry; }
bool hasAttribute(Attribute::AttrKind A) const;
bool hasAttribute(StringRef Kind) const;
@@ -66,16 +69,20 @@
StringRef getKindAsString() const;
StringRef getValueAsString() const;
+ Type *getValueAsType() const;
+
/// 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(), static_cast<uint64_t>(0));
else if (isIntAttribute())
Profile(ID, getKindAsEnum(), getValueAsInt());
- else
+ else if (isStringAttribute())
Profile(ID, getKindAsString(), getValueAsString());
+ else
+ Profile(ID, getKindAsEnum(), getValueAsType());
}
static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind,
@@ -88,6 +95,12 @@
ID.AddString(Kind);
if (!Values.empty()) ID.AddString(Values);
}
+
+ static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind,
+ Type *Ty) {
+ ID.AddInteger(Kind);
+ ID.AddPointer(Ty);
+ }
};
//===----------------------------------------------------------------------===//
@@ -145,6 +158,18 @@
StringRef getStringValue() const { return Val; }
};
+class TypeAttributeImpl : public EnumAttributeImpl {
+ virtual void anchor();
+
+ Type *Ty;
+
+public:
+ TypeAttributeImpl(Attribute::AttrKind Kind, Type *Ty)
+ : EnumAttributeImpl(TypeAttrEntry, Kind), Ty(Ty) {}
+
+ Type *getTypeValue() const { return Ty; }
+};
+
//===----------------------------------------------------------------------===//
/// \class
/// This class represents a group of attributes that apply to one
@@ -189,6 +214,7 @@
uint64_t getDereferenceableOrNullBytes() const;
std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
std::string getAsString(bool InAttrGrp) const;
+ Type *getByValType() const;
using iterator = const Attribute *;
diff --git a/llvm/lib/IR/Attributes.cpp b/llvm/lib/IR/Attributes.cpp
index 0be09a0..67d35de 100644
--- a/llvm/lib/IR/Attributes.cpp
+++ b/llvm/lib/IR/Attributes.cpp
@@ -121,6 +121,27 @@
return Attribute(PA);
}
+Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
+ Type *Ty) {
+ LLVMContextImpl *pImpl = Context.pImpl;
+ FoldingSetNodeID ID;
+ ID.AddInteger(Kind);
+ 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.
+ PA = new TypeAttributeImpl(Kind, Ty);
+ pImpl->AttrsSet.InsertNode(PA, InsertPoint);
+ }
+
+ // Return the Attribute that we found or created.
+ return Attribute(PA);
+}
+
Attribute Attribute::getWithAlignment(LLVMContext &Context, uint64_t Align) {
assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
assert(Align <= 0x40000000 && "Alignment too large.");
@@ -146,6 +167,10 @@
return get(Context, DereferenceableOrNull, Bytes);
}
+Attribute Attribute::getWithByValType(LLVMContext &Context, Type *Ty) {
+ return get(Context, ByVal, Ty);
+}
+
Attribute
Attribute::getWithAllocSizeArgs(LLVMContext &Context, unsigned ElemSizeArg,
const Optional<unsigned> &NumElemsArg) {
@@ -170,9 +195,13 @@
return pImpl && pImpl->isStringAttribute();
}
+bool Attribute::isTypeAttribute() const {
+ return pImpl && pImpl->isTypeAttribute();
+}
+
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();
}
@@ -198,6 +227,14 @@
return pImpl->getValueAsString();
}
+Type *Attribute::getValueAsType() const {
+ if (!pImpl) return {};
+ assert(isTypeAttribute() &&
+ "Invalid attribute type to get the value as a type!");
+ return pImpl->getValueAsType();
+}
+
+
bool Attribute::hasAttribute(AttrKind Kind) const {
return (pImpl && pImpl->hasAttribute(Kind)) || (!pImpl && Kind == None);
}
@@ -252,8 +289,6 @@
return "argmemonly";
if (hasAttribute(Attribute::Builtin))
return "builtin";
- if (hasAttribute(Attribute::ByVal))
- return "byval";
if (hasAttribute(Attribute::Convergent))
return "convergent";
if (hasAttribute(Attribute::SwiftError))
@@ -353,6 +388,19 @@
if (hasAttribute(Attribute::ImmArg))
return "immarg";
+ if (hasAttribute(Attribute::ByVal)) {
+ std::string Result;
+ Result += "byval";
+ if (Type *Ty = getValueAsType()) {
+ raw_string_ostream OS(Result);
+ Result += '(';
+ Ty->print(OS, false, true);
+ OS.flush();
+ Result += ')';
+ }
+ return Result;
+ }
+
// FIXME: These should be output like this:
//
// align=4
@@ -451,6 +499,8 @@
void StringAttributeImpl::anchor() {}
+void TypeAttributeImpl::anchor() {}
+
bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
if (isStringAttribute()) return false;
return getKindAsEnum() == A;
@@ -462,7 +512,7 @@
}
Attribute::AttrKind AttributeImpl::getKindAsEnum() const {
- assert(isEnumAttribute() || isIntAttribute());
+ assert(isEnumAttribute() || isIntAttribute() || isTypeAttribute());
return static_cast<const EnumAttributeImpl *>(this)->getEnumKind();
}
@@ -481,6 +531,11 @@
return static_cast<const StringAttributeImpl *>(this)->getStringValue();
}
+Type *AttributeImpl::getValueAsType() const {
+ assert(isTypeAttribute());
+ return static_cast<const TypeAttributeImpl *>(this)->getTypeValue();
+}
+
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.
@@ -488,10 +543,23 @@
if (AI.isEnumAttribute()) return getKindAsEnum() < AI.getKindAsEnum();
if (AI.isIntAttribute()) return true;
if (AI.isStringAttribute()) return true;
+ if (AI.isTypeAttribute()) return true;
+ }
+
+ if (isTypeAttribute()) {
+ if (AI.isEnumAttribute()) return false;
+ if (AI.isTypeAttribute()) {
+ assert(getKindAsEnum() != AI.getKindAsEnum() &&
+ "Comparison of types would be unstable");
+ return getKindAsEnum() < AI.getKindAsEnum();
+ }
+ if (AI.isIntAttribute()) return true;
+ if (AI.isStringAttribute()) return true;
}
if (isIntAttribute()) {
if (AI.isEnumAttribute()) return false;
+ if (AI.isTypeAttribute()) return false;
if (AI.isIntAttribute()) {
if (getKindAsEnum() == AI.getKindAsEnum())
return getValueAsInt() < AI.getValueAsInt();
@@ -500,7 +568,9 @@
if (AI.isStringAttribute()) return true;
}
+ assert(isStringAttribute());
if (AI.isEnumAttribute()) return false;
+ if (AI.isTypeAttribute()) return false;
if (AI.isIntAttribute()) return false;
if (getKindAsString() == AI.getKindAsString())
return getValueAsString() < AI.getValueAsString();
@@ -608,6 +678,10 @@
return SetNode ? SetNode->getDereferenceableOrNullBytes() : 0;
}
+Type *AttributeSet::getByValType() const {
+ return SetNode ? SetNode->getByValType() : nullptr;
+}
+
std::pair<unsigned, Optional<unsigned>> AttributeSet::getAllocSizeArgs() const {
return SetNode ? SetNode->getAllocSizeArgs()
: std::pair<unsigned, Optional<unsigned>>(0, 0);
@@ -691,6 +765,9 @@
Attribute Attr;
switch (Kind) {
+ case Attribute::ByVal:
+ Attr = Attribute::getWithByValType(C, B.getByValType());
+ break;
case Attribute::Alignment:
Attr = Attribute::getWithAlignment(C, B.getAlignment());
break;
@@ -760,6 +837,13 @@
return 0;
}
+Type *AttributeSetNode::getByValType() const {
+ for (const auto I : *this)
+ if (I.hasAttribute(Attribute::ByVal))
+ return I.getValueAsType();
+ return 0;
+}
+
uint64_t AttributeSetNode::getDereferenceableBytes() const {
for (const auto I : *this)
if (I.hasAttribute(Attribute::Dereferenceable))
@@ -1258,6 +1342,11 @@
return getAttributes(ArgNo + FirstArgIndex).getAlignment();
}
+Type *AttributeList::getParamByValType(unsigned Index) const {
+ return getAttributes(Index+FirstArgIndex).getByValType();
+}
+
+
unsigned AttributeList::getStackAlignment(unsigned Index) const {
return getAttributes(Index).getStackAlignment();
}
@@ -1336,6 +1425,7 @@
TargetDepAttrs.clear();
Alignment = StackAlignment = DerefBytes = DerefOrNullBytes = 0;
AllocSizeArgs = 0;
+ ByValType = nullptr;
}
AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) {
@@ -1360,6 +1450,8 @@
Alignment = Attr.getAlignment();
else if (Kind == Attribute::StackAlignment)
StackAlignment = Attr.getStackAlignment();
+ else if (Kind == Attribute::ByVal)
+ ByValType = Attr.getValueAsType();
else if (Kind == Attribute::Dereferenceable)
DerefBytes = Attr.getDereferenceableBytes();
else if (Kind == Attribute::DereferenceableOrNull)
@@ -1382,6 +1474,8 @@
Alignment = 0;
else if (Val == Attribute::StackAlignment)
StackAlignment = 0;
+ else if (Val == Attribute::ByVal)
+ ByValType = nullptr;
else if (Val == Attribute::Dereferenceable)
DerefBytes = 0;
else if (Val == Attribute::DereferenceableOrNull)
@@ -1464,6 +1558,12 @@
return *this;
}
+AttrBuilder &AttrBuilder::addByValAttr(Type *Ty) {
+ Attrs[Attribute::ByVal] = true;
+ ByValType = Ty;
+ return *this;
+}
+
AttrBuilder &AttrBuilder::merge(const AttrBuilder &B) {
// FIXME: What if both have alignments, but they don't match?!
if (!Alignment)
@@ -1481,6 +1581,9 @@
if (!AllocSizeArgs)
AllocSizeArgs = B.AllocSizeArgs;
+ if (!ByValType)
+ ByValType = B.ByValType;
+
Attrs |= B.Attrs;
for (auto I : B.td_attrs())
@@ -1506,6 +1609,9 @@
if (B.AllocSizeArgs)
AllocSizeArgs = 0;
+ if (B.ByValType)
+ ByValType = nullptr;
+
Attrs &= ~B.Attrs;
for (auto I : B.td_attrs())
@@ -1565,7 +1671,7 @@
return false;
return Alignment == B.Alignment && StackAlignment == B.StackAlignment &&
- DerefBytes == B.DerefBytes;
+ DerefBytes == B.DerefBytes && ByValType == B.ByValType;
}
//===----------------------------------------------------------------------===//
diff --git a/llvm/lib/IR/Function.cpp b/llvm/lib/IR/Function.cpp
index b00deb6..a4a78ca 100644
--- a/llvm/lib/IR/Function.cpp
+++ b/llvm/lib/IR/Function.cpp
@@ -113,6 +113,11 @@
return getParent()->getParamAlignment(getArgNo());
}
+Type *Argument::getParamByValType() const {
+ assert(getType()->isPointerTy() && "Only pointers have byval types");
+ return getParent()->getParamByValType(getArgNo());
+}
+
uint64_t Argument::getDereferenceableBytes() const {
assert(getType()->isPointerTy() &&
"Only pointers have dereferenceable bytes");
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index d5c3287..963bf82 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -1695,6 +1695,11 @@
"'noinline and alwaysinline' are incompatible!",
V);
+ if (Attrs.hasAttribute(Attribute::ByVal) && Attrs.getByValType()) {
+ Assert(Attrs.getByValType() == cast<PointerType>(Ty)->getElementType(),
+ "Attribute 'byval' type does not match parameter!");
+ }
+
AttrBuilder IncompatibleAttrs = AttributeFuncs::typeIncompatible(Ty);
Assert(!AttrBuilder(Attrs).overlaps(IncompatibleAttrs),
"Wrong types for attribute: " +