X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FParameterAttributes.h;h=919c460337ad4eb09d83d879034b179899a3e3f5;hb=e089160d1065d83986fd97fae7f0af08c03e7d47;hp=c3a52fbac320083b15f05bb7d5f76141dc3992bb;hpb=6167c3fcda817f9dbfae4d3013bd63a8f909962f;p=oota-llvm.git diff --git a/include/llvm/ParameterAttributes.h b/include/llvm/ParameterAttributes.h index c3a52fbac32..919c460337a 100644 --- a/include/llvm/ParameterAttributes.h +++ b/include/llvm/ParameterAttributes.h @@ -7,23 +7,22 @@ // //===----------------------------------------------------------------------===// // -// This file contains the types necessary to represent the parameter attributes -// associated with functions and their calls. -// -// The implementations of these classes live in lib/VMCore/Function.cpp. +// This file contains the simple types necessary to represent the parameter +// attributes associated with functions and their calls. // //===----------------------------------------------------------------------===// #ifndef LLVM_PARAMETER_ATTRIBUTES_H #define LLVM_PARAMETER_ATTRIBUTES_H -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/FoldingSet.h" -#include +#include namespace llvm { class Type; +/// ParameterAttributes - A bitset of attributes for a parameter. +typedef unsigned ParameterAttributes; + namespace ParamAttr { /// Function parameters and results can have attributes to indicate how they @@ -31,9 +30,7 @@ namespace ParamAttr { /// lists the attributes that can be associated with parameters or function /// results. /// @brief Function parameter attributes. - -/// @brief A more friendly way to reference the attributes. -typedef uint32_t Attributes; +typedef ParameterAttributes Attributes; const Attributes None = 0; ///< No attributes have been set const Attributes ZExt = 1<<0; ///< Zero extended before/after call @@ -67,217 +64,140 @@ const Attributes MutuallyIncompatible[3] = { }; /// @brief Which attributes cannot be applied to a type. -Attributes typeIncompatible (const Type *Ty); - +Attributes typeIncompatible(const Type *Ty); + +/// This turns an int alignment (a power of 2, normally) into the +/// form used internally in ParameterAttributes. +inline ParamAttr::Attributes constructAlignmentFromInt(unsigned i) { + return (i << 16); +} + +/// The set of ParameterAttributes set in Attributes is converted to a +/// string of equivalent mnemonics. This is, presumably, for writing out +/// the mnemonics for the assembly writer. +/// @brief Convert parameter attribute bits to text +std::string getAsString(ParameterAttributes Attrs); } // end namespace ParamAttr -/// @brief A more friendly way to reference the attributes. -typedef ParamAttr::Attributes ParameterAttributes; /// This is just a pair of values to associate a set of parameter attributes /// with a parameter index. -/// @brief ParameterAttributes with a parameter index. struct ParamAttrsWithIndex { - ParameterAttributes attrs; ///< The attributes that are set, or'd together - uint16_t index; ///< Index of the parameter for which the attributes apply + ParameterAttributes Attrs; ///< The attributes that are set, or'd together. + unsigned Index; ///< Index of the parameter for which the attributes apply. - static ParamAttrsWithIndex get(uint16_t idx, ParameterAttributes attrs) { + static ParamAttrsWithIndex get(unsigned Idx, ParameterAttributes Attrs) { ParamAttrsWithIndex P; - P.index = idx; - P.attrs = attrs; + P.Index = Idx; + P.Attrs = Attrs; return P; } }; + +//===----------------------------------------------------------------------===// +// PAListPtr Smart Pointer +//===----------------------------------------------------------------------===// -/// @brief A vector of attribute/index pairs. -typedef SmallVector ParamAttrsVector; - -/// This class represents a list of attribute/index pairs for parameter -/// attributes. Each entry in the list contains the index of a function -/// parameter and the associated ParameterAttributes. If a parameter's index is -/// not present in the list, then no attributes are set for that parameter. The -/// list may also be empty, but this does not occur in practice. An item in -/// the list with an index of 0 refers to the function as a whole or its result. -/// To construct a ParamAttrsList, you must first fill a ParamAttrsVector with -/// the attribute/index pairs you wish to set. The list of attributes can be -/// turned into a string of mnemonics suitable for LLVM Assembly output. -/// Various accessors are provided to obtain information about the attributes. -/// Note that objects of this class are "uniqued". The \p get method can return -/// the pointer of an existing and identical instance. Consequently, reference -/// counting is necessary in order to determine when the last reference to a -/// ParamAttrsList of a given shape is dropped. Users of this class should use -/// the addRef and dropRef methods to add/drop references. When the reference -/// count goes to zero, the ParamAttrsList object is deleted. -/// This class is used by Function, CallInst and InvokeInst to represent their -/// sets of parameter attributes. -/// @brief A List of ParameterAttributes. -class ParamAttrsList : public FoldingSetNode { - /// @name Construction - /// @{ - private: - // ParamAttrsList is uniqued, these should not be publicly available - void operator=(const ParamAttrsList &); // Do not implement - ParamAttrsList(const ParamAttrsList &); // Do not implement - ~ParamAttrsList(); // Private implementation - - /// Only the \p get method can invoke this when it wants to create a - /// new instance. - /// @brief Construct an ParamAttrsList from a ParamAttrsVector - explicit ParamAttrsList(const ParamAttrsVector &attrVec); - - public: - /// This method ensures the uniqueness of ParamAttrsList instances. The - /// argument is a vector of attribute/index pairs as represented by the - /// ParamAttrsWithIndex structure. The index values must be in strictly - /// increasing order and ParamAttr::None is not allowed. The vector is - /// used to construct the ParamAttrsList instance. If an instance with - /// identical vector pairs exists, it will be returned instead of creating - /// a new instance. - /// @brief Get a ParamAttrsList instance. - static const ParamAttrsList *get(const ParamAttrsVector &attrVec); - - /// Returns the ParamAttrsList obtained by modifying PAL using the supplied - /// list of attribute/index pairs. Any existing attributes for the given - /// index are replaced by the given attributes. If there were no attributes - /// then the new ones are inserted. Attributes can be deleted by replacing - /// them with ParamAttr::None. Index values must be strictly increasing. - /// @brief Get a new ParamAttrsList instance by modifying an existing one. - static const ParamAttrsList *getModified(const ParamAttrsList *PAL, - const ParamAttrsVector &modVec); - - /// @brief Add the specified attributes to those in PAL at index idx. - static const ParamAttrsList *includeAttrs(const ParamAttrsList *PAL, - uint16_t idx, - ParameterAttributes attrs); - - /// @brief Remove the specified attributes from those in PAL at index idx. - static const ParamAttrsList *excludeAttrs(const ParamAttrsList *PAL, - uint16_t idx, - ParameterAttributes attrs); - - /// @} - /// @name Accessors - /// @{ - public: - /// The parameter attributes for the \p indexth parameter are returned. - /// The 0th parameter refers to the return type of the function. Note that - /// the \p param_index is an index into the function's parameters, not an - /// index into this class's list of attributes. The result of getParamIndex - /// is always suitable input to this function. - /// @returns The all the ParameterAttributes for the \p indexth parameter - /// as a uint16_t of enumeration values OR'd together. - /// @brief Get the attributes for a parameter - ParameterAttributes getParamAttrs(uint16_t param_index) const; - - /// This checks to see if the \p ith function parameter has the parameter - /// attribute given by \p attr set. - /// @returns true if the parameter attribute is set - /// @brief Determine if a ParameterAttributes is set - bool paramHasAttr(uint16_t i, ParameterAttributes attr) const { - return getParamAttrs(i) & attr; - } - - /// This returns whether the given attribute is set for at least one - /// parameter or for the return value. - /// @returns true if the parameter attribute is set somewhere - /// @brief Determine if a ParameterAttributes is set somewhere - bool hasAttrSomewhere(ParameterAttributes attr) const; - - /// The set of ParameterAttributes set in Attributes is converted to a - /// string of equivalent mnemonics. This is, presumably, for writing out - /// the mnemonics for the assembly writer. - /// @brief Convert parameter attribute bits to text - static std::string getParamAttrsText(ParameterAttributes Attributes); - - /// The \p Indexth parameter attribute is converted to string. - /// @brief Get the text for the parmeter attributes for one parameter. - std::string getParamAttrsTextByIndex(uint16_t Index) const { - return getParamAttrsText(getParamAttrs(Index)); - } - - /// @brief Comparison operator for ParamAttrsList - bool operator < (const ParamAttrsList& that) const { - if (this->attrs.size() < that.attrs.size()) - return true; - if (this->attrs.size() > that.attrs.size()) - return false; - for (unsigned i = 0; i < attrs.size(); ++i) { - if (attrs[i].index < that.attrs[i].index) - return true; - if (attrs[i].index > that.attrs[i].index) - return false; - if (attrs[i].attrs < that.attrs[i].attrs) - return true; - if (attrs[i].attrs > that.attrs[i].attrs) - return false; - } - return false; - } - - /// Returns the parameter index of a particular parameter attribute in this - /// list of attributes. Note that the attr_index is an index into this - /// class's list of attributes, not the index of a parameter. The result - /// is the index of the parameter. Clients generally should not use this - /// method. It is used internally by LLVM. - /// @brief Get a parameter index - uint16_t getParamIndex(unsigned attr_index) const { - return attrs[attr_index].index; - } - - ParameterAttributes getParamAttrsAtIndex(unsigned attr_index) const { - return attrs[attr_index].attrs; - } - - /// Determines how many parameter attributes are set in this ParamAttrsList. - /// This says nothing about how many parameters the function has. It also - /// says nothing about the highest parameter index that has attributes. - /// Clients generally should not use this method. It is used internally by - /// LLVM. - /// @returns the number of parameter attributes in this ParamAttrsList. - /// @brief Return the number of parameter attributes this type has. - unsigned size() const { return attrs.size(); } - - /// @brief Return the number of references to this ParamAttrsList. - unsigned numRefs() const { return refCount; } - - /// @} - /// @name Mutators - /// @{ - public: - /// Classes retaining references to ParamAttrsList objects should call this - /// method to increment the reference count. This ensures that the - /// ParamAttrsList object will not disappear until the class drops it. - /// @brief Add a reference to this instance. - void addRef() const { refCount++; } +class ParamAttributeListImpl; + +/// PAListPtr - This class manages the ref count for the opaque +/// ParamAttributeListImpl object and provides accessors for it. +class PAListPtr { + /// PAList - The parameter attributes that we are managing. This can be null + /// to represent the empty parameter attributes list. + ParamAttributeListImpl *PAList; +public: + PAListPtr() : PAList(0) {} + PAListPtr(const PAListPtr &P); + const PAListPtr &operator=(const PAListPtr &RHS); + ~PAListPtr(); + + //===--------------------------------------------------------------------===// + // Parameter Attribute List Construction and Mutation + //===--------------------------------------------------------------------===// + + /// get - Return a ParamAttrs list with the specified parameter in it. + static PAListPtr get(const ParamAttrsWithIndex *Attr, unsigned NumAttrs); + + /// get - Return a ParamAttr list with the parameters specified by the + /// consecutive random access iterator range. + template + static PAListPtr get(const Iter &I, const Iter &E) { + if (I == E) return PAListPtr(); // Empty list. + return get(&*I, static_cast(E-I)); + } - /// Classes retaining references to ParamAttrsList objects should call this - /// method to decrement the reference count and possibly delete the - /// ParamAttrsList object. This ensures that ParamAttrsList objects are - /// cleaned up only when the last reference to them is dropped. - /// @brief Drop a reference to this instance. - void dropRef() const { - assert(refCount != 0 && "dropRef without addRef"); - if (--refCount == 0) - delete this; - } + /// addAttr - Add the specified attribute at the specified index to this + /// attribute list. Since parameter attribute lists are immutable, this + /// returns the new list. + PAListPtr addAttr(unsigned Idx, ParameterAttributes Attrs) const; + + /// removeAttr - Remove the specified attribute at the specified index from + /// this attribute list. Since parameter attribute lists are immutable, this + /// returns the new list. + PAListPtr removeAttr(unsigned Idx, ParameterAttributes Attrs) const; + + //===--------------------------------------------------------------------===// + // Parameter Attribute List Accessors + //===--------------------------------------------------------------------===// + + /// getParamAttrs - The parameter attributes for the specified parameter are + /// returned. Parameters for the result are denoted with Idx = 0. + ParameterAttributes getParamAttrs(unsigned Idx) const; + + /// paramHasAttr - Return true if the specified parameter index has the + /// specified attribute set. + bool paramHasAttr(unsigned Idx, ParameterAttributes Attr) const { + return getParamAttrs(Idx) & Attr; + } + + /// getParamAlignment - Return the alignment for the specified function + /// parameter. + unsigned getParamAlignment(unsigned Idx) const { + return (getParamAttrs(Idx) & ParamAttr::Alignment) >> 16; + } + + /// hasAttrSomewhere - Return true if the specified attribute is set for at + /// least one parameter or for the return value. + bool hasAttrSomewhere(ParameterAttributes Attr) const; - /// @} - /// @name Implementation Details - /// @{ - public: - void Profile(FoldingSetNodeID &ID) const { - Profile(ID, attrs); - } - static void Profile(FoldingSetNodeID &ID, const ParamAttrsVector &Attrs); - void dump() const; + /// operator==/!= - Provide equality predicates. + bool operator==(const PAListPtr &RHS) const { return PAList == RHS.PAList; } + bool operator!=(const PAListPtr &RHS) const { return PAList != RHS.PAList; } + + void dump() const; - /// @} - /// @name Data - /// @{ - private: - ParamAttrsVector attrs; ///< The list of attributes - mutable unsigned refCount; ///< The number of references to this object - /// @} + //===--------------------------------------------------------------------===// + // Parameter Attribute List Introspection + //===--------------------------------------------------------------------===// + + /// getRawPointer - Return a raw pointer that uniquely identifies this + /// parameter attribute list. + void *getRawPointer() const { + return PAList; + } + + // Parameter attributes are stored as a dense set of slots, where there is one + // slot for each argument that has an attribute. This allows walking over the + // dense set instead of walking the sparse list of attributes. + + /// isEmpty - Return true if no parameters have an attribute. + /// + bool isEmpty() const { + return PAList == 0; + } + + /// getNumSlots - Return the number of slots used in this attribute list. + /// This is the number of arguments that have an attribute set on them + /// (including the function itself). + unsigned getNumSlots() const; + + /// getSlot - Return the ParamAttrsWithIndex at the specified slot. This + /// holds a parameter number plus a set of attributes. + const ParamAttrsWithIndex &getSlot(unsigned Slot) const; + +private: + explicit PAListPtr(ParamAttributeListImpl *L); }; } // End llvm namespace