X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAttributes.h;h=49f6057f31aed7ec7e31abd239cec29fdbd7d7bc;hb=295643b8050d4c45b06032690d707e7281e82c92;hp=0e416944694ca8f92ac83a5e52bcb77af39e3c8f;hpb=20bcaff6a7f93a9894f7233c449b016bafe93b26;p=oota-llvm.git diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h index 0e416944694..49f6057f31a 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,31 @@ // //===----------------------------------------------------------------------===// // -// 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 "llvm/Support/MathExtras.h" +#include #include 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,23 +45,38 @@ 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) - +const Attributes NoInline = 1<<11; ///< inline=never +const Attributes AlwaysInline = 1<<12; ///< inline=always +const Attributes OptimizeForSize = 1<<13; ///< opt_size +const Attributes StackProtect = 1<<14; ///< Stack protection. +const Attributes StackProtectReq = 1<<15; ///< Stack protection required. +const Attributes Alignment = 31<<16; ///< Alignment of parameter (5 bits) + // stored as log2 of alignment with +1 bias + // 0 means unaligned different from align 1 +const Attributes NoCapture = 1<<21; ///< Function creates no aliases of pointer +const Attributes NoRedZone = 1<<22; /// disable redzone +const Attributes NoImplicitFloat = 1<<23; /// disable implicit floating point + /// instructions. +const Attributes Naked = 1<<24; ///< Naked function + /// @brief Attributes that only apply to function parameters. -const Attributes ParameterOnly = ByVal | Nest | StructRet; +const Attributes ParameterOnly = ByVal | Nest | StructRet | NoCapture; -/// @brief Attributes that only apply to function return values. -const Attributes ReturnOnly = NoReturn | NoUnwind | ReadNone | ReadOnly; +/// @brief Attributes that may be applied to the function itself. These cannot +/// be used on return values or function parameters. +const Attributes FunctionOnly = NoReturn | NoUnwind | ReadNone | ReadOnly | + NoInline | AlwaysInline | OptimizeForSize | StackProtect | StackProtectReq | + NoRedZone | NoImplicitFloat | Naked; /// @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, +const Attributes MutuallyIncompatible[4] = { + ByVal | InReg | Nest | StructRet, ZExt | SExt, - ReadNone | ReadOnly + ReadNone | ReadOnly, + NoInline | AlwaysInline }; /// @brief Which attributes cannot be applied to a type. @@ -68,33 +85,42 @@ Attributes typeIncompatible(const Type *Ty); /// This turns an int alignment (a power of 2, normally) into the /// form used internally in Attributes. inline Attributes constructAlignmentFromInt(unsigned i) { - return (i << 16); + // Default alignment, allow the target to define how to align it. + if (i == 0) + return 0; + + assert(isPowerOf2_32(i) && "Alignment must be a power of two."); + assert(i <= 0x40000000 && "Alignment too large."); + return (Log2_32(i)+1) << 16; } +/// This returns the alignment field of an attribute as a byte alignment value. +inline unsigned getAlignmentFromAttrs(Attributes A) { + Attributes Align = A & Attribute::Alignment; + if (Align == 0) + return 0; + + return 1U << ((Align >> 16) - 1); +} + + /// 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 ParamAttrsWithIndex { +} // 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 ParamAttrsWithIndex get(unsigned Idx, Attributes Attrs) { - ParamAttrsWithIndex P; + static AttributeWithIndex get(unsigned Idx, Attributes Attrs) { + AttributeWithIndex P; P.Index = Idx; P.Attrs = Attrs; return P; @@ -102,66 +128,79 @@ struct ParamAttrsWithIndex { }; //===----------------------------------------------------------------------===// -// PAListPtr Smart Pointer +// AttrListPtr Smart Pointer //===----------------------------------------------------------------------===// -class ParamAttributeListImpl; +class AttributeListImpl; -/// 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; +/// AttrListPtr - This class manages the ref count for the opaque +/// AttributeListImpl object and provides accessors for it. +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 ParamAttrsWithIndex *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 - 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(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; + /// getParamAttributes - The attributes for the specified index are + /// returned. + Attributes getParamAttributes(unsigned Idx) const { + assert (Idx && Idx != ~0U && "Invalid parameter index!"); + return getAttributes(Idx); + } + + /// getRetAttributes - The attributes for the ret value are + /// returned. + Attributes getRetAttributes() const { + return getAttributes(0); + } + + /// getFnAttributes - The function attributes are returned. + Attributes getFnAttributes() const { + return getAttributes(~0U); + } /// 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 Attribute::getAlignmentFromAttrs(getAttributes(Idx)); } /// hasAttrSomewhere - Return true if the specified attribute is set for at @@ -169,29 +208,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 +238,17 @@ public: /// (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; + /// 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(ParamAttributeListImpl *L); + explicit AttrListPtr(AttributeListImpl *L); + + /// getAttributes - The attributes for the specified index are + /// returned. Attributes for the result are denoted with Idx = 0. + Attributes getAttributes(unsigned Idx) const; + }; } // End llvm namespace