diff options
Diffstat (limited to 'include/llvm/Attributes.h')
| -rw-r--r-- | include/llvm/Attributes.h | 127 |
1 files changed, 63 insertions, 64 deletions
diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h index 92cdc95096..3adbf25115 100644 --- a/include/llvm/Attributes.h +++ b/include/llvm/Attributes.h @@ -1,4 +1,4 @@ -//===-- llvm/Attributes.h - Container for ParamAttrs ---*---------- C++ -*-===// +//===-- llvm/Attributes.h - Container for Attributes ---*---------- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,29 +7,29 @@ // //===----------------------------------------------------------------------===// // -// This file contains the simple types necessary to represent the parameter +// This file contains the simple types necessary to represent the // attributes associated with functions and their calls. // //===----------------------------------------------------------------------===// -#ifndef LLVM_PARAMETER_ATTRIBUTES_H -#define LLVM_PARAMETER_ATTRIBUTES_H +#ifndef LLVM_ATTRIBUTES_H +#define LLVM_ATTRIBUTES_H #include <string> namespace llvm { class Type; -/// Attributes - A bitset of attributes for a parameter. +/// Attributes - A bitset of attributes. typedef unsigned Attributes; -namespace ParamAttr { +namespace Attribute { /// Function parameters and results can have attributes to indicate how they /// should be treated by optimizations and code generation. This enumeration -/// lists the attributes that can be associated with parameters or function -/// results. -/// @brief Function parameter attributes. +/// lists the attributes that can be associated with parameters, function +/// results or the function itself. +/// @brief Function attributes. const Attributes None = 0; ///< No attributes have been set const Attributes ZExt = 1<<0; ///< Zero extended before/after call @@ -43,6 +43,9 @@ 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 NoInline = 1<<11; // inline=never +const Attributes AlwaysInline = 1<<12; // inline=always +const Attributes OptimizeForSize = 1<<13; // opt_size const Attributes Alignment = 0xffff<<16; ///< Alignment of parameter (16 bits) // 0 = unknown, else in clear (not log) @@ -74,27 +77,23 @@ inline Attributes constructAlignmentFromInt(unsigned i) { /// The set of Attributes 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 +/// @brief Convert attribute bits to text std::string getAsString(Attributes Attrs); -} // end namespace ParamAttr - -namespace FnAttr { -/// Function notes are implemented as attributes stored at index ~0 in -/// parameter attribute list. -const Attributes None = 0; -const Attributes NoInline = 1<<0; // inline=never -const Attributes AlwaysInline = 1<<1; // inline=always -const Attributes OptimizeForSize = 1<<2; // opt_size -} // end namespace FnAttr - -/// This is just a pair of values to associate a set of parameter attributes -/// with a parameter index. -struct FnAttributeWithIndex { +} // end namespace Attribute + +namespace Attribute { +} // end namespace Attribute + +/// This is just a pair of values to associate a set of attributes +/// with an index. +struct AttributeWithIndex { Attributes Attrs; ///< The attributes that are set, or'd together. unsigned Index; ///< Index of the parameter for which the attributes apply. + ///< Index 0 is used for return value attributes. + ///< Index ~0U is used for function attributes. - static FnAttributeWithIndex get(unsigned Idx, Attributes Attrs) { - FnAttributeWithIndex P; + static AttributeWithIndex get(unsigned Idx, Attributes Attrs) { + AttributeWithIndex P; P.Index = Idx; P.Attrs = Attrs; return P; @@ -102,66 +101,66 @@ struct FnAttributeWithIndex { }; //===----------------------------------------------------------------------===// -// PAListPtr Smart Pointer +// AttrListPtr Smart Pointer //===----------------------------------------------------------------------===// class AttributeListImpl; -/// PAListPtr - This class manages the ref count for the opaque +/// AttrListPtr - This class manages the ref count for the opaque /// AttributeListImpl 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. - AttributeListImpl *PAList; +class AttrListPtr { + /// AttrList - The attributes that we are managing. This can be null + /// to represent the empty attributes list. + AttributeListImpl *AttrList; public: - PAListPtr() : PAList(0) {} - PAListPtr(const PAListPtr &P); - const PAListPtr &operator=(const PAListPtr &RHS); - ~PAListPtr(); + AttrListPtr() : AttrList(0) {} + AttrListPtr(const AttrListPtr &P); + const AttrListPtr &operator=(const AttrListPtr &RHS); + ~AttrListPtr(); //===--------------------------------------------------------------------===// - // Parameter Attribute List Construction and Mutation + // Attribute List Construction and Mutation //===--------------------------------------------------------------------===// - /// get - Return a ParamAttrs list with the specified parameter in it. - static PAListPtr get(const FnAttributeWithIndex *Attr, unsigned NumAttrs); + /// get - Return a Attributes list with the specified parameter in it. + static AttrListPtr get(const AttributeWithIndex *Attr, unsigned NumAttrs); - /// get - Return a ParamAttr list with the parameters specified by the + /// get - Return a Attribute list with the parameters specified by the /// consecutive random access iterator range. template <typename Iter> - static PAListPtr get(const Iter &I, const Iter &E) { - if (I == E) return PAListPtr(); // Empty list. + static AttrListPtr get(const Iter &I, const Iter &E) { + if (I == E) return AttrListPtr(); // Empty list. return get(&*I, static_cast<unsigned>(E-I)); } /// addAttr - Add the specified attribute at the specified index to this - /// attribute list. Since parameter attribute lists are immutable, this + /// attribute list. Since attribute lists are immutable, this /// returns the new list. - PAListPtr addAttr(unsigned Idx, Attributes Attrs) const; + AttrListPtr addAttr(unsigned Idx, Attributes Attrs) const; /// removeAttr - Remove the specified attribute at the specified index from - /// this attribute list. Since parameter attribute lists are immutable, this + /// this attribute list. Since attribute lists are immutable, this /// returns the new list. - PAListPtr removeAttr(unsigned Idx, Attributes Attrs) const; + AttrListPtr removeAttr(unsigned Idx, Attributes Attrs) const; //===--------------------------------------------------------------------===// - // Parameter Attribute List Accessors + // Attribute List Accessors //===--------------------------------------------------------------------===// - /// getParamAttrs - The parameter attributes for the specified parameter are - /// returned. Parameters for the result are denoted with Idx = 0. - Attributes getParamAttrs(unsigned Idx) const; + /// getAttributes - The attributes for the specified index are + /// returned. Attributes for the result are denoted with Idx = 0. + Attributes getAttributes(unsigned Idx) const; /// paramHasAttr - Return true if the specified parameter index has the /// specified attribute set. bool paramHasAttr(unsigned Idx, Attributes Attr) const { - return getParamAttrs(Idx) & Attr; + return getAttributes(Idx) & Attr; } /// getParamAlignment - Return the alignment for the specified function /// parameter. unsigned getParamAlignment(unsigned Idx) const { - return (getParamAttrs(Idx) & ParamAttr::Alignment) >> 16; + return (getAttributes(Idx) & Attribute::Alignment) >> 16; } /// hasAttrSomewhere - Return true if the specified attribute is set for at @@ -169,29 +168,29 @@ public: bool hasAttrSomewhere(Attributes 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; } + bool operator==(const AttrListPtr &RHS) const { return AttrList == RHS.AttrList; } + bool operator!=(const AttrListPtr &RHS) const { return AttrList != RHS.AttrList; } void dump() const; //===--------------------------------------------------------------------===// - // Parameter Attribute List Introspection + // Attribute List Introspection //===--------------------------------------------------------------------===// /// getRawPointer - Return a raw pointer that uniquely identifies this - /// parameter attribute list. + /// attribute list. void *getRawPointer() const { - return PAList; + return AttrList; } - // Parameter attributes are stored as a dense set of slots, where there is one + // 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. + /// isEmpty - Return true if there are no attributes. /// bool isEmpty() const { - return PAList == 0; + return AttrList == 0; } /// getNumSlots - Return the number of slots used in this attribute list. @@ -199,12 +198,12 @@ public: /// (including the function itself). unsigned getNumSlots() const; - /// getSlot - Return the FnAttributeWithIndex at the specified slot. This - /// holds a parameter number plus a set of attributes. - const FnAttributeWithIndex &getSlot(unsigned Slot) const; + /// getSlot - Return the AttributeWithIndex at the specified slot. This + /// holds a index number plus a set of attributes. + const AttributeWithIndex &getSlot(unsigned Slot) const; private: - explicit PAListPtr(AttributeListImpl *L); + explicit AttrListPtr(AttributeListImpl *L); }; } // End llvm namespace |