X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FParameterAttributes.h;h=919c460337ad4eb09d83d879034b179899a3e3f5;hb=e089160d1065d83986fd97fae7f0af08c03e7d47;hp=dcfe09514117ffb0200c82b00bde4a52ae56a9de;hpb=febca3499e5624361142dda2cb3c2ea806bfcdb6;p=oota-llvm.git diff --git a/include/llvm/ParameterAttributes.h b/include/llvm/ParameterAttributes.h index dcfe0951411..919c460337a 100644 --- a/include/llvm/ParameterAttributes.h +++ b/include/llvm/ParameterAttributes.h @@ -2,25 +2,27 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by Reid Spencer and is distributed under the -// University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // -// 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 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 @@ -28,184 +30,174 @@ namespace ParamAttr { /// lists the attributes that can be associated with parameters or function /// results. /// @brief Function parameter attributes. -enum Attributes { - None = 0, ///< No attributes have been set - ZExt = 1 << 0, ///< zero extended before/after call - SExt = 1 << 1, ///< sign extended before/after call - NoReturn = 1 << 2, ///< mark the function as not returning - InReg = 1 << 3, ///< force argument to be passed in register - StructRet = 1 << 4, ///< hidden pointer to structure to return - NoUnwind = 1 << 5, ///< Function doesn't unwind stack - NoAlias = 1 << 6 ///< Considered to not alias after call. +typedef ParameterAttributes Attributes; + +const Attributes None = 0; ///< No attributes have been set +const Attributes ZExt = 1<<0; ///< Zero extended before/after call +const Attributes SExt = 1<<1; ///< Sign extended before/after call +const Attributes NoReturn = 1<<2; ///< Mark the function as not returning +const Attributes InReg = 1<<3; ///< Force argument to be passed in register +const Attributes StructRet = 1<<4; ///< Hidden pointer to structure to return +const Attributes NoUnwind = 1<<5; ///< Function doesn't unwind stack +const Attributes NoAlias = 1<<6; ///< Considered to not alias after call +const Attributes ByVal = 1<<7; ///< Pass structure by value +const Attributes Nest = 1<<8; ///< Nested function static chain +const Attributes ReadNone = 1<<9; ///< Function does not access memory +const Attributes ReadOnly = 1<<10; ///< Function only reads from memory +const Attributes Alignment = 0xffff<<16; ///< Alignment of parameter (16 bits) + // 0 = unknown, else in clear (not log) + +/// @brief Attributes that only apply to function parameters. +const Attributes ParameterOnly = ByVal | InReg | Nest | StructRet; + +/// @brief Attributes that only apply to function return values. +const Attributes ReturnOnly = NoReturn | NoUnwind | ReadNone | ReadOnly; + +/// @brief Parameter attributes that do not apply to vararg call arguments. +const Attributes VarArgsIncompatible = StructRet; + +/// @brief Attributes that are mutually incompatible. +const Attributes MutuallyIncompatible[3] = { + ByVal | InReg | Nest | StructRet, + ZExt | SExt, + ReadNone | ReadOnly }; +/// @brief Which attributes cannot be applied to a type. +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 + + /// 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 { - uint16_t attrs; ///< The attributes that are set, |'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(unsigned Idx, ParameterAttributes Attrs) { + ParamAttrsWithIndex P; + P.Index = Idx; + P.Attrs = Attrs; + return P; + } }; + +//===----------------------------------------------------------------------===// +// PAListPtr Smart Pointer +//===----------------------------------------------------------------------===// -/// @brief A vector of attribute/index pairs. -typedef SmallVector ParamAttrsVector; - -/// @brief A more friendly way to reference the attributes. -typedef ParamAttr::Attributes ParameterAttributes; - -/// 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(); // 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) - : attrs(attrVec), refCount(0) {} - - 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 vector is used in the construction of - /// 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 ParamAttrsList *get(const ParamAttrsVector &attrVec); - - /// @} - /// @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 - uint16_t 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; - } - - /// 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(uint16_t 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; - } - - uint16_t 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(); } - - /// 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++; } - - /// 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; - } - - /// @} - /// @name Implementation Details - /// @{ - public: - void Profile(FoldingSetNodeID &ID) const; - void dump() const; - - /// @} - /// @name Data - /// @{ - private: - ParamAttrsVector attrs; ///< The list of attributes - mutable unsigned refCount; ///< The number of references to this object - /// @} +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)); + } + + /// 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; + + /// 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; + + //===--------------------------------------------------------------------===// + // 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