summaryrefslogtreecommitdiffstats
path: root/llvm/lib/IR
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/lib/IR')
-rw-r--r--llvm/lib/IR/AttributeImpl.h32
-rw-r--r--llvm/lib/IR/Attributes.cpp108
-rw-r--r--llvm/lib/IR/Function.cpp5
-rw-r--r--llvm/lib/IR/Verifier.cpp5
4 files changed, 7 insertions, 143 deletions
diff --git a/llvm/lib/IR/AttributeImpl.h b/llvm/lib/IR/AttributeImpl.h
index f6898476382..8ebcb04a565 100644
--- a/llvm/lib/IR/AttributeImpl.h
+++ b/llvm/lib/IR/AttributeImpl.h
@@ -29,7 +29,6 @@
namespace llvm {
class LLVMContext;
-class Type;
//===----------------------------------------------------------------------===//
/// \class
@@ -42,8 +41,7 @@ protected:
enum AttrEntryKind {
EnumAttrEntry,
IntAttrEntry,
- StringAttrEntry,
- TypeAttrEntry,
+ StringAttrEntry
};
AttributeImpl(AttrEntryKind KindID) : KindID(KindID) {}
@@ -58,7 +56,6 @@ public:
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;
@@ -69,20 +66,16 @@ public:
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(), static_cast<uint64_t>(0));
+ Profile(ID, getKindAsEnum(), 0);
else if (isIntAttribute())
Profile(ID, getKindAsEnum(), getValueAsInt());
- else if (isStringAttribute())
- Profile(ID, getKindAsString(), getValueAsString());
else
- Profile(ID, getKindAsEnum(), getValueAsType());
+ Profile(ID, getKindAsString(), getValueAsString());
}
static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind,
@@ -95,12 +88,6 @@ public:
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);
- }
};
//===----------------------------------------------------------------------===//
@@ -158,18 +145,6 @@ public:
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
@@ -214,7 +189,6 @@ public:
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 839ef46b4f4..0be09a05e82 100644
--- a/llvm/lib/IR/Attributes.cpp
+++ b/llvm/lib/IR/Attributes.cpp
@@ -121,27 +121,6 @@ Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) {
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.");
@@ -167,10 +146,6 @@ Attribute Attribute::getWithDereferenceableOrNullBytes(LLVMContext &Context,
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) {
@@ -195,13 +170,9 @@ bool Attribute::isStringAttribute() const {
return pImpl && pImpl->isStringAttribute();
}
-bool Attribute::isTypeAttribute() const {
- return pImpl && pImpl->isTypeAttribute();
-}
-
Attribute::AttrKind Attribute::getKindAsEnum() const {
if (!pImpl) return None;
- assert((isEnumAttribute() || isIntAttribute() || isTypeAttribute()) &&
+ assert((isEnumAttribute() || isIntAttribute()) &&
"Invalid attribute type to get the kind as an enum!");
return pImpl->getKindAsEnum();
}
@@ -227,14 +198,6 @@ StringRef Attribute::getValueAsString() const {
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);
}
@@ -289,6 +252,8 @@ std::string Attribute::getAsString(bool InAttrGrp) const {
return "argmemonly";
if (hasAttribute(Attribute::Builtin))
return "builtin";
+ if (hasAttribute(Attribute::ByVal))
+ return "byval";
if (hasAttribute(Attribute::Convergent))
return "convergent";
if (hasAttribute(Attribute::SwiftError))
@@ -388,19 +353,6 @@ std::string Attribute::getAsString(bool InAttrGrp) const {
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
@@ -499,8 +451,6 @@ void IntAttributeImpl::anchor() {}
void StringAttributeImpl::anchor() {}
-void TypeAttributeImpl::anchor() {}
-
bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
if (isStringAttribute()) return false;
return getKindAsEnum() == A;
@@ -512,7 +462,7 @@ bool AttributeImpl::hasAttribute(StringRef Kind) const {
}
Attribute::AttrKind AttributeImpl::getKindAsEnum() const {
- assert(isEnumAttribute() || isIntAttribute() || isTypeAttribute());
+ assert(isEnumAttribute() || isIntAttribute());
return static_cast<const EnumAttributeImpl *>(this)->getEnumKind();
}
@@ -531,11 +481,6 @@ StringRef AttributeImpl::getValueAsString() const {
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.
@@ -543,23 +488,10 @@ bool AttributeImpl::operator<(const AttributeImpl &AI) const {
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();
@@ -568,9 +500,7 @@ bool AttributeImpl::operator<(const AttributeImpl &AI) const {
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();
@@ -678,10 +608,6 @@ uint64_t AttributeSet::getDereferenceableOrNullBytes() const {
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);
@@ -765,9 +691,6 @@ AttributeSetNode *AttributeSetNode::get(LLVMContext &C, const AttrBuilder &B) {
Attribute Attr;
switch (Kind) {
- case Attribute::ByVal:
- Attr = Attribute::getWithByValType(C, B.getByValType());
- break;
case Attribute::Alignment:
Attr = Attribute::getWithAlignment(C, B.getAlignment());
break;
@@ -837,13 +760,6 @@ unsigned AttributeSetNode::getStackAlignment() const {
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))
@@ -1342,11 +1258,6 @@ unsigned AttributeList::getParamAlignment(unsigned ArgNo) const {
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();
}
@@ -1425,7 +1336,6 @@ void AttrBuilder::clear() {
TargetDepAttrs.clear();
Alignment = StackAlignment = DerefBytes = DerefOrNullBytes = 0;
AllocSizeArgs = 0;
- ByValType = nullptr;
}
AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) {
@@ -1450,8 +1360,6 @@ AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) {
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)
@@ -1474,8 +1382,6 @@ AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
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)
@@ -1558,12 +1464,6 @@ AttrBuilder &AttrBuilder::addAllocSizeAttrFromRawRepr(uint64_t RawArgs) {
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)
diff --git a/llvm/lib/IR/Function.cpp b/llvm/lib/IR/Function.cpp
index a4a78ca4deb..b00deb677b3 100644
--- a/llvm/lib/IR/Function.cpp
+++ b/llvm/lib/IR/Function.cpp
@@ -113,11 +113,6 @@ unsigned Argument::getParamAlignment() const {
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 963bf82c989..d5c3287e713 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -1695,11 +1695,6 @@ void Verifier::verifyParameterAttrs(AttributeSet Attrs, Type *Ty,
"'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: " +
OpenPOWER on IntegriCloud