X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FIR%2FAttributeImpl.h;h=0448dc17409e9e063ccbc34d39b96864fa46b601;hb=95d71357275a05a4bfc346f5b513688e26531a91;hp=2633608926fbc5b3bdbb75a770f99fdfe1f34370;hpb=22bd64173981bf1251c4b3bfc684207340534ba3;p=oota-llvm.git diff --git a/lib/IR/AttributeImpl.h b/lib/IR/AttributeImpl.h index 2633608926f..0448dc17409 100644 --- a/lib/IR/AttributeImpl.h +++ b/lib/IR/AttributeImpl.h @@ -13,11 +13,12 @@ /// //===----------------------------------------------------------------------===// -#ifndef LLVM_ATTRIBUTESIMPL_H -#define LLVM_ATTRIBUTESIMPL_H +#ifndef LLVM_LIB_IR_ATTRIBUTEIMPL_H +#define LLVM_LIB_IR_ATTRIBUTEIMPL_H #include "llvm/ADT/FoldingSet.h" #include "llvm/IR/Attributes.h" +#include namespace llvm { @@ -29,83 +30,241 @@ class LLVMContext; /// \brief This class represents a single, uniqued attribute. That attribute /// could be a single enum, a tuple, or a string. class AttributeImpl : public FoldingSetNode { - Constant *Data; - SmallVector Vals; + 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, + IntAttrEntry, + StringAttrEntry + }; + + AttributeImpl(AttrEntryKind KindID) : KindID(KindID) {} + public: - explicit AttributeImpl(LLVMContext &C, uint64_t data); - explicit AttributeImpl(LLVMContext &C, Attribute::AttrKind data); - AttributeImpl(LLVMContext &C, Attribute::AttrKind data, - ArrayRef values); - AttributeImpl(LLVMContext &C, StringRef data); - - ArrayRef getValues() const { - return Vals; - } + virtual ~AttributeImpl(); - bool contains(Attribute::AttrKind Kind) const; - bool contains(StringRef Kind) const; + bool isEnumAttribute() const { return KindID == EnumAttrEntry; } + bool isIntAttribute() const { return KindID == IntAttrEntry; } + 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; - bool hasAttributes() const; - bool hasAttributes(const Attribute &A) const; + StringRef getKindAsString() const; + StringRef getValueAsString() const; - uint64_t getAlignment() const; - uint64_t getStackAlignment() const; + /// \brief Used when sorting the attributes. + bool operator<(const AttributeImpl &AI) const; - bool operator==(Attribute::AttrKind Kind) const { - return contains(Kind); + void Profile(FoldingSetNodeID &ID) const { + if (isEnumAttribute()) + Profile(ID, getKindAsEnum(), 0); + else if (isIntAttribute()) + Profile(ID, getKindAsEnum(), getValueAsInt()); + else + Profile(ID, getKindAsString(), getValueAsString()); + } + static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind, + uint64_t Val) { + ID.AddInteger(Kind); + if (Val) ID.AddInteger(Val); } - bool operator!=(Attribute::AttrKind Kind) const { - return !contains(Kind); + static void Profile(FoldingSetNodeID &ID, StringRef Kind, StringRef Values) { + ID.AddString(Kind); + if (!Values.empty()) ID.AddString(Values); } - bool operator==(StringRef Kind) const { - return contains(Kind); + // FIXME: Remove this! + 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 { + virtual void anchor(); + 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 IntAttributeImpl : public EnumAttributeImpl { + void anchor() override; + uint64_t Val; + +public: + IntAttributeImpl(Attribute::AttrKind Kind, uint64_t Val) + : EnumAttributeImpl(IntAttrEntry, Kind), Val(Val) { + assert( + (Kind == Attribute::Alignment || Kind == Attribute::StackAlignment || + Kind == Attribute::Dereferenceable) && + "Wrong kind for int attribute!"); } - bool operator!=(StringRef Kind) const { - return !contains(Kind); + + uint64_t 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) {} + + 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 { + unsigned NumAttrs; ///< Number of attributes in this node. + + 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)); } - uint64_t getBitMask() const; // FIXME: Remove. + // AttributesSetNode is uniqued, these should not be publicly available. + void operator=(const AttributeSetNode &) LLVM_DELETED_FUNCTION; + AttributeSetNode(const AttributeSetNode &) LLVM_DELETED_FUNCTION; +public: + static AttributeSetNode *get(LLVMContext &C, ArrayRef Attrs); - static uint64_t getAttrMask(Attribute::AttrKind Val); + bool hasAttribute(Attribute::AttrKind Kind) const; + bool hasAttribute(StringRef Kind) const; + bool hasAttributes() const { return NumAttrs != 0; } + + Attribute getAttribute(Attribute::AttrKind Kind) const; + Attribute getAttribute(StringRef Kind) const; + + unsigned getAlignment() const; + unsigned getStackAlignment() const; + uint64_t getDereferenceableBytes() const; + std::string getAsString(bool InAttrGrp) const; + + 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, Data, Vals); + Profile(ID, makeArrayRef(begin(), end())); } - static void Profile(FoldingSetNodeID &ID, Constant *Data, - ArrayRef Vals) { - ID.AddPointer(Data); - for (ArrayRef::iterator I = Vals.begin(), E = Vals.end(); - I != E; ++I) - ID.AddPointer(*I); + static void Profile(FoldingSetNodeID &ID, ArrayRef AttrList) { + for (unsigned I = 0, E = AttrList.size(); I != E; ++I) + AttrList[I].Profile(ID); } }; //===----------------------------------------------------------------------===// /// \class -/// \brief This class represents a set of attributes. +/// \brief This class represents a set of attributes that apply to the function, +/// return type, and parameters. class AttributeSetImpl : public FoldingSetNode { + friend class AttributeSet; + + LLVMContext &Context; + + typedef std::pair IndexAttrPair; + 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: - LLVMContext &Context; - SmallVector Attrs; + AttributeSetImpl(LLVMContext &C, + ArrayRef > Attrs) + : Context(C), NumAttrs(Attrs.size()) { +#ifndef NDEBUG + if (Attrs.size() >= 2) { + for (const std::pair *i = Attrs.begin() + 1, + *e = Attrs.end(); + i != e; ++i) { + assert((i-1)->first <= i->first && "Attribute set not ordered!"); + } + } +#endif + // 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 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 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, *getNode(Slot)); + } - AttributeSetImpl(LLVMContext &C, ArrayRef attrs) - : Context(C), Attrs(attrs.begin(), attrs.end()) {} + /// \brief Retrieve the attribute set node for the given "slot" in the + /// AttrNode list. + AttributeSetNode *getSlotNode(unsigned Slot) const { + return getNode(Slot)->second; + } + + 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, Attrs); + Profile(ID, makeArrayRef(getNode(0), getNumAttributes())); } - static void Profile(FoldingSetNodeID &ID, ArrayRef Attrs){ - for (unsigned i = 0, e = Attrs.size(); i != e; ++i) { - ID.AddInteger(Attrs[i].Attrs.getBitMask()); - ID.AddInteger(Attrs[i].Index); + static void Profile(FoldingSetNodeID &ID, + ArrayRef > Nodes) { + for (unsigned i = 0, e = Nodes.size(); i != e; ++i) { + ID.AddInteger(Nodes[i].first); + ID.AddPointer(Nodes[i].second); } } + + // FIXME: This atrocity is temporary. + uint64_t Raw(unsigned Index) const; + + void dump() const; }; } // end llvm namespace