From e22cde01a63c907cb23f425ba4f4f16ede754dbe Mon Sep 17 00:00:00 2001 From: Benjamin Kramer Date: Thu, 11 Jul 2013 12:13:16 +0000 Subject: [PATCH] Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@186075 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/IR/AttributeImpl.h | 210 ++++++++++++++++++----------------------- lib/IR/Attributes.cpp | 103 ++++++++------------ 2 files changed, 133 insertions(+), 180 deletions(-) diff --git a/lib/IR/AttributeImpl.h b/lib/IR/AttributeImpl.h index 0b6228b331e..5a72c37505e 100644 --- a/lib/IR/AttributeImpl.h +++ b/lib/IR/AttributeImpl.h @@ -27,97 +27,30 @@ class LLVMContext; //===----------------------------------------------------------------------===// /// \class -/// \brief A set of classes that contain the kind and (optional) value of the -/// attribute object. There are three main categories: enum attribute entries, -/// represented by Attribute::AttrKind; alignment attribute entries; and string -/// attribute enties, which are for target-dependent attributes. -class AttributeEntry { - unsigned char KindID; +/// \brief This class represents a single, uniqued attribute. That attribute +/// could be a single enum, a tuple, or a string. +class AttributeImpl : public FoldingSetNode { + unsigned char KindID; ///< Holds the AttrEntryKind of the attribute + + // AttributesImpl is uniqued, these should not be publicly available. + void operator=(const AttributeImpl &) LLVM_DELETED_FUNCTION; + AttributeImpl(const AttributeImpl &) LLVM_DELETED_FUNCTION; + protected: enum AttrEntryKind { EnumAttrEntry, AlignAttrEntry, StringAttrEntry }; + + AttributeImpl(AttrEntryKind KindID) : KindID(KindID) {} + public: - AttributeEntry(AttrEntryKind Kind) - : KindID(Kind) {} - virtual ~AttributeEntry() {} + virtual ~AttributeImpl(); - unsigned getKindID() const { return KindID; } - - static inline bool classof(const AttributeEntry *) { return true; } -}; - -class EnumAttributeEntry : public AttributeEntry { - Attribute::AttrKind Kind; -public: - EnumAttributeEntry(Attribute::AttrKind Kind) - : AttributeEntry(EnumAttrEntry), Kind(Kind) {} - - Attribute::AttrKind getEnumKind() const { return Kind; } - - static inline bool classof(const AttributeEntry *AE) { - return AE->getKindID() == EnumAttrEntry; - } - static inline bool classof(const EnumAttributeEntry *) { return true; } -}; - -class AlignAttributeEntry : public AttributeEntry { - Attribute::AttrKind Kind; - unsigned Align; -public: - AlignAttributeEntry(Attribute::AttrKind Kind, unsigned Align) - : AttributeEntry(AlignAttrEntry), Kind(Kind), Align(Align) {} - - Attribute::AttrKind getEnumKind() const { return Kind; } - unsigned getAlignment() const { return Align; } - - static inline bool classof(const AttributeEntry *AE) { - return AE->getKindID() == AlignAttrEntry; - } - static inline bool classof(const AlignAttributeEntry *) { return true; } -}; - -class StringAttributeEntry : public AttributeEntry { - std::string Kind; - std::string Val; -public: - StringAttributeEntry(StringRef Kind, StringRef Val = StringRef()) - : AttributeEntry(StringAttrEntry), Kind(Kind), Val(Val) {} - - StringRef getStringKind() const { return Kind; } - StringRef getStringValue() const { return Val; } - - static inline bool classof(const AttributeEntry *AE) { - return AE->getKindID() == StringAttrEntry; - } - static inline bool classof(const StringAttributeEntry *) { return true; } -}; - -//===----------------------------------------------------------------------===// -/// \class -/// \brief This class represents a single, uniqued attribute. That attribute -/// could be a single enum, a tuple, or a string. -class AttributeImpl : public FoldingSetNode { - LLVMContext &Context; ///< Global context for uniquing objects - - AttributeEntry *Entry; ///< Holds the kind and value of the attribute - - // AttributesImpl is uniqued, these should not be publicly available. - void operator=(const AttributeImpl &) LLVM_DELETED_FUNCTION; - AttributeImpl(const AttributeImpl &) LLVM_DELETED_FUNCTION; -public: - AttributeImpl(LLVMContext &C, Attribute::AttrKind Kind); - AttributeImpl(LLVMContext &C, Attribute::AttrKind Kind, unsigned Align); - AttributeImpl(LLVMContext &C, StringRef Kind, StringRef Val = StringRef()); - ~AttributeImpl(); - - LLVMContext &getContext() { return Context; } - - bool isEnumAttribute() const; - bool isAlignAttribute() const; - bool isStringAttribute() const; + bool isEnumAttribute() const { return KindID == EnumAttrEntry; } + bool isAlignAttribute() const { return KindID == AlignAttrEntry; } + bool isStringAttribute() const { return KindID == StringAttrEntry; } bool hasAttribute(Attribute::AttrKind A) const; bool hasAttribute(StringRef Kind) const; @@ -153,15 +86,65 @@ public: static uint64_t getAttrMask(Attribute::AttrKind Val); }; +//===----------------------------------------------------------------------===// +/// \class +/// \brief A set of classes that contain the value of the +/// attribute object. There are three main categories: enum attribute entries, +/// represented by Attribute::AttrKind; alignment attribute entries; and string +/// attribute enties, which are for target-dependent attributes. + +class EnumAttributeImpl : public AttributeImpl { + Attribute::AttrKind Kind; + +protected: + EnumAttributeImpl(AttrEntryKind ID, Attribute::AttrKind Kind) + : AttributeImpl(ID), Kind(Kind) {} + +public: + EnumAttributeImpl(Attribute::AttrKind Kind) + : AttributeImpl(EnumAttrEntry), Kind(Kind) {} + + Attribute::AttrKind getEnumKind() const { return Kind; } +}; + +class AlignAttributeImpl : public EnumAttributeImpl { + unsigned Align; + +public: + AlignAttributeImpl(Attribute::AttrKind Kind, unsigned Align) + : EnumAttributeImpl(AlignAttrEntry, Kind), Align(Align) { + assert( + (Kind == Attribute::Alignment || Kind == Attribute::StackAlignment) && + "Wrong kind for alignment attribute!"); + } + + unsigned getAlignment() const { return Align; } +}; + +class StringAttributeImpl : public AttributeImpl { + std::string Kind; + std::string Val; + +public: + StringAttributeImpl(StringRef Kind, StringRef Val = StringRef()) + : AttributeImpl(StringAttrEntry), Kind(Kind), Val(Val) {} + + StringRef getStringKind() const { return Kind; } + StringRef getStringValue() const { return Val; } +}; + //===----------------------------------------------------------------------===// /// \class /// \brief This class represents a group of attributes that apply to one /// element: function, return type, or parameter. class AttributeSetNode : public FoldingSetNode { - SmallVector AttrList; + unsigned NumAttrs; ///< Number of attributes in this node. - AttributeSetNode(ArrayRef Attrs) - : AttrList(Attrs.begin(), Attrs.end()) {} + AttributeSetNode(ArrayRef Attrs) : NumAttrs(Attrs.size()) { + // There's memory after the node where we can store the entries in. + std::copy(Attrs.begin(), Attrs.end(), + reinterpret_cast(this + 1)); + } // AttributesSetNode is uniqued, these should not be publicly available. void operator=(const AttributeSetNode &) LLVM_DELETED_FUNCTION; @@ -171,7 +154,7 @@ public: bool hasAttribute(Attribute::AttrKind Kind) const; bool hasAttribute(StringRef Kind) const; - bool hasAttributes() const { return !AttrList.empty(); } + bool hasAttributes() const { return NumAttrs != 0; } Attribute getAttribute(Attribute::AttrKind Kind) const; Attribute getAttribute(StringRef Kind) const; @@ -180,17 +163,12 @@ public: unsigned getStackAlignment() const; std::string getAsString(bool InAttrGrp) const; - typedef SmallVectorImpl::iterator iterator; - typedef SmallVectorImpl::const_iterator const_iterator; - - iterator begin() { return AttrList.begin(); } - iterator end() { return AttrList.end(); } - - const_iterator begin() const { return AttrList.begin(); } - const_iterator end() const { return AttrList.end(); } + typedef const Attribute *iterator; + iterator begin() const { return reinterpret_cast(this + 1); } + iterator end() const { return begin() + NumAttrs; } void Profile(FoldingSetNodeID &ID) const { - Profile(ID, AttrList); + Profile(ID, makeArrayRef(begin(), end())); } static void Profile(FoldingSetNodeID &ID, ArrayRef AttrList) { for (unsigned I = 0, E = AttrList.size(); I != E; ++I) @@ -208,58 +186,58 @@ class AttributeSetImpl : public FoldingSetNode { LLVMContext &Context; typedef std::pair IndexAttrPair; - SmallVector AttrNodes; + unsigned NumAttrs; ///< Number of entries in this set. + + /// \brief Return a pointer to the IndexAttrPair for the specified slot. + const IndexAttrPair *getNode(unsigned Slot) const { + return reinterpret_cast(this + 1) + Slot; + } // AttributesSet is uniqued, these should not be publicly available. void operator=(const AttributeSetImpl &) LLVM_DELETED_FUNCTION; AttributeSetImpl(const AttributeSetImpl &) LLVM_DELETED_FUNCTION; public: AttributeSetImpl(LLVMContext &C, - ArrayRef > attrs) - : Context(C), AttrNodes(attrs.begin(), attrs.end()) {} + ArrayRef > Attrs) + : Context(C), NumAttrs(Attrs.size()) { + // There's memory after the node where we can store the entries in. + std::copy(Attrs.begin(), Attrs.end(), + reinterpret_cast(this + 1)); + } /// \brief Get the context that created this AttributeSetImpl. LLVMContext &getContext() { return Context; } /// \brief Return the number of attributes this AttributeSet contains. - unsigned getNumAttributes() const { return AttrNodes.size(); } + unsigned getNumAttributes() const { return NumAttrs; } /// \brief Get the index of the given "slot" in the AttrNodes list. This index /// is the index of the return, parameter, or function object that the /// attributes are applied to, not the index into the AttrNodes list where the /// attributes reside. unsigned getSlotIndex(unsigned Slot) const { - return AttrNodes[Slot].first; + return getNode(Slot)->first; } /// \brief Retrieve the attributes for the given "slot" in the AttrNode list. /// \p Slot is an index into the AttrNodes list, not the index of the return / /// parameter/ function which the attributes apply to. AttributeSet getSlotAttributes(unsigned Slot) const { - return AttributeSet::get(Context, AttrNodes[Slot]); + return AttributeSet::get(Context, *getNode(Slot)); } /// \brief Retrieve the attribute set node for the given "slot" in the /// AttrNode list. AttributeSetNode *getSlotNode(unsigned Slot) const { - return AttrNodes[Slot].second; + return getNode(Slot)->second; } - typedef AttributeSetNode::iterator iterator; - typedef AttributeSetNode::const_iterator const_iterator; - - iterator begin(unsigned Slot) - { return AttrNodes[Slot].second->begin(); } - iterator end(unsigned Slot) - { return AttrNodes[Slot].second->end(); } - - const_iterator begin(unsigned Slot) const - { return AttrNodes[Slot].second->begin(); } - const_iterator end(unsigned Slot) const - { return AttrNodes[Slot].second->end(); } + typedef AttributeSetNode::iterator iterator; + iterator begin(unsigned Slot) const { return getSlotNode(Slot)->begin(); } + iterator end(unsigned Slot) const { return getSlotNode(Slot)->end(); } void Profile(FoldingSetNodeID &ID) const { - Profile(ID, AttrNodes); + Profile(ID, makeArrayRef(getNode(0), getNumAttributes())); } static void Profile(FoldingSetNodeID &ID, ArrayRef > Nodes) { diff --git a/lib/IR/Attributes.cpp b/lib/IR/Attributes.cpp index 59da815663d..c8e2f6be5c0 100644 --- a/lib/IR/Attributes.cpp +++ b/lib/IR/Attributes.cpp @@ -43,9 +43,10 @@ Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind, if (!PA) { // If we didn't find any existing attributes of the same shape then create a // new one and insert it. - PA = !Val ? - new AttributeImpl(Context, Kind) : - new AttributeImpl(Context, Kind, Val); + if (!Val) + PA = new EnumAttributeImpl(Kind); + else + PA = new AlignAttributeImpl(Kind, Val); pImpl->AttrsSet.InsertNode(PA, InsertPoint); } @@ -65,7 +66,7 @@ Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) { if (!PA) { // If we didn't find any existing attributes of the same shape then create a // new one and insert it. - PA = new AttributeImpl(Context, Kind, Val); + PA = new StringAttributeImpl(Kind, Val); pImpl->AttrsSet.InsertNode(PA, InsertPoint); } @@ -279,35 +280,7 @@ bool Attribute::operator<(Attribute A) const { // AttributeImpl Definition //===----------------------------------------------------------------------===// -AttributeImpl::AttributeImpl(LLVMContext &C, Attribute::AttrKind Kind) - : Context(C), Entry(new EnumAttributeEntry(Kind)) {} - -AttributeImpl::AttributeImpl(LLVMContext &C, Attribute::AttrKind Kind, - unsigned Align) - : Context(C) { - assert((Kind == Attribute::Alignment || Kind == Attribute::StackAlignment) && - "Wrong kind for alignment attribute!"); - Entry = new AlignAttributeEntry(Kind, Align); -} - -AttributeImpl::AttributeImpl(LLVMContext &C, StringRef Kind, StringRef Val) - : Context(C), Entry(new StringAttributeEntry(Kind, Val)) {} - -AttributeImpl::~AttributeImpl() { - delete Entry; -} - -bool AttributeImpl::isEnumAttribute() const { - return isa(Entry); -} - -bool AttributeImpl::isAlignAttribute() const { - return isa(Entry); -} - -bool AttributeImpl::isStringAttribute() const { - return isa(Entry); -} +AttributeImpl::~AttributeImpl() {} bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const { if (isStringAttribute()) return false; @@ -320,21 +293,23 @@ bool AttributeImpl::hasAttribute(StringRef Kind) const { } Attribute::AttrKind AttributeImpl::getKindAsEnum() const { - if (EnumAttributeEntry *E = dyn_cast(Entry)) - return E->getEnumKind(); - return cast(Entry)->getEnumKind(); + assert(isEnumAttribute() || isAlignAttribute()); + return static_cast(this)->getEnumKind(); } uint64_t AttributeImpl::getValueAsInt() const { - return cast(Entry)->getAlignment(); + assert(isAlignAttribute()); + return static_cast(this)->getAlignment(); } StringRef AttributeImpl::getKindAsString() const { - return cast(Entry)->getStringKind(); + assert(isStringAttribute()); + return static_cast(this)->getStringKind(); } StringRef AttributeImpl::getValueAsString() const { - return cast(Entry)->getStringValue(); + assert(isStringAttribute()); + return static_cast(this)->getStringValue(); } bool AttributeImpl::operator<(const AttributeImpl &AI) const { @@ -433,7 +408,10 @@ AttributeSetNode *AttributeSetNode::get(LLVMContext &C, // If we didn't find any existing attributes of the same shape then create a // new one and insert it. if (!PA) { - PA = new AttributeSetNode(SortedAttrs); + // Coallocate entries after the AttributeSetNode itself. + void *Mem = ::operator new(sizeof(AttributeSetNode) + + sizeof(Attribute) * SortedAttrs.size()); + PA = new (Mem) AttributeSetNode(SortedAttrs); pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint); } @@ -442,48 +420,42 @@ AttributeSetNode *AttributeSetNode::get(LLVMContext &C, } bool AttributeSetNode::hasAttribute(Attribute::AttrKind Kind) const { - for (SmallVectorImpl::const_iterator I = AttrList.begin(), - E = AttrList.end(); I != E; ++I) + for (iterator I = begin(), E = end(); I != E; ++I) if (I->hasAttribute(Kind)) return true; return false; } bool AttributeSetNode::hasAttribute(StringRef Kind) const { - for (SmallVectorImpl::const_iterator I = AttrList.begin(), - E = AttrList.end(); I != E; ++I) + for (iterator I = begin(), E = end(); I != E; ++I) if (I->hasAttribute(Kind)) return true; return false; } Attribute AttributeSetNode::getAttribute(Attribute::AttrKind Kind) const { - for (SmallVectorImpl::const_iterator I = AttrList.begin(), - E = AttrList.end(); I != E; ++I) + for (iterator I = begin(), E = end(); I != E; ++I) if (I->hasAttribute(Kind)) return *I; return Attribute(); } Attribute AttributeSetNode::getAttribute(StringRef Kind) const { - for (SmallVectorImpl::const_iterator I = AttrList.begin(), - E = AttrList.end(); I != E; ++I) + for (iterator I = begin(), E = end(); I != E; ++I) if (I->hasAttribute(Kind)) return *I; return Attribute(); } unsigned AttributeSetNode::getAlignment() const { - for (SmallVectorImpl::const_iterator I = AttrList.begin(), - E = AttrList.end(); I != E; ++I) + for (iterator I = begin(), E = end(); I != E; ++I) if (I->hasAttribute(Attribute::Alignment)) return I->getAlignment(); return 0; } unsigned AttributeSetNode::getStackAlignment() const { - for (SmallVectorImpl::const_iterator I = AttrList.begin(), - E = AttrList.end(); I != E; ++I) + for (iterator I = begin(), E = end(); I != E; ++I) if (I->hasAttribute(Attribute::StackAlignment)) return I->getStackAlignment(); return 0; @@ -491,9 +463,8 @@ unsigned AttributeSetNode::getStackAlignment() const { std::string AttributeSetNode::getAsString(bool InAttrGrp) const { std::string Str; - for (SmallVectorImpl::const_iterator I = AttrList.begin(), - E = AttrList.end(); I != E; ++I) { - if (I != AttrList.begin()) + for (iterator I = begin(), E = end(); I != E; ++I) { + if (I != begin()) Str += ' '; Str += I->getAsString(InAttrGrp); } @@ -507,10 +478,10 @@ std::string AttributeSetNode::getAsString(bool InAttrGrp) const { uint64_t AttributeSetImpl::Raw(unsigned Index) const { for (unsigned I = 0, E = getNumAttributes(); I != E; ++I) { if (getSlotIndex(I) != Index) continue; - const AttributeSetNode *ASN = AttrNodes[I].second; + const AttributeSetNode *ASN = getSlotNode(I); uint64_t Mask = 0; - for (AttributeSetNode::const_iterator II = ASN->begin(), + for (AttributeSetNode::iterator II = ASN->begin(), IE = ASN->end(); II != IE; ++II) { Attribute Attr = *II; @@ -550,7 +521,11 @@ AttributeSet::getImpl(LLVMContext &C, // If we didn't find any existing attributes of the same shape then // create a new one and insert it. if (!PA) { - PA = new AttributeSetImpl(C, Attrs); + // Coallocate entries after the AttributeSetImpl itself. + void *Mem = ::operator new(sizeof(AttributeSetImpl) + + sizeof(std::pair) * + Attrs.size()); + PA = new (Mem) AttributeSetImpl(C, Attrs); pImpl->AttrsLists.InsertNode(PA, InsertPoint); } @@ -645,9 +620,9 @@ AttributeSet AttributeSet::get(LLVMContext &C, ArrayRef Attrs) { SmallVector, 8> AttrNodeVec; for (unsigned I = 0, E = Attrs.size(); I != E; ++I) { - AttributeSet AS = Attrs[I]; - if (!AS.pImpl) continue; - AttrNodeVec.append(AS.pImpl->AttrNodes.begin(), AS.pImpl->AttrNodes.end()); + AttributeSetImpl *AS = Attrs[I].pImpl; + if (!AS) continue; + AttrNodeVec.append(AS->getNode(0), AS->getNode(AS->getNumAttributes())); } return getImpl(C, AttrNodeVec); @@ -700,7 +675,7 @@ AttributeSet AttributeSet::addAttributes(LLVMContext &C, unsigned Index, for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I) if (Attrs.getSlotIndex(I) == Index) { - for (AttributeSetImpl::const_iterator II = Attrs.pImpl->begin(I), + for (AttributeSetImpl::iterator II = Attrs.pImpl->begin(I), IE = Attrs.pImpl->end(I); II != IE; ++II) B.addAttribute(*II); break; @@ -821,7 +796,7 @@ bool AttributeSet::hasAttrSomewhere(Attribute::AttrKind Attr) const { if (pImpl == 0) return false; for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) - for (AttributeSetImpl::const_iterator II = pImpl->begin(I), + for (AttributeSetImpl::iterator II = pImpl->begin(I), IE = pImpl->end(I); II != IE; ++II) if (II->hasAttribute(Attr)) return true; @@ -937,7 +912,7 @@ AttrBuilder::AttrBuilder(AttributeSet AS, unsigned Index) for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) { if (pImpl->getSlotIndex(I) != Index) continue; - for (AttributeSetImpl::const_iterator II = pImpl->begin(I), + for (AttributeSetImpl::iterator II = pImpl->begin(I), IE = pImpl->end(I); II != IE; ++II) addAttribute(*II);