X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAttributes.h;h=da6188b1a8eae693100f0157f445771db5528acd;hb=0f899c78e18e39a8ccd08386aaa493a1b9a712a3;hp=b2117dd6be76432f933b1f76d408daed63cc863e;hpb=65ac2fa8802676a5f7b2402f92dea6129d1f1903;p=oota-llvm.git diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h index b2117dd6be7..da6188b1a8e 100644 --- a/include/llvm/Attributes.h +++ b/include/llvm/Attributes.h @@ -1,4 +1,4 @@ -//===-- llvm/Attributes.h - Container for Attributes ---*---------- C++ -*-===// +//===-- llvm/Attributes.h - Container for Attributes ------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -15,6 +15,7 @@ #ifndef LLVM_ATTRIBUTES_H #define LLVM_ATTRIBUTES_H +#include "llvm/Support/MathExtras.h" #include #include @@ -23,12 +24,12 @@ class Type; /// Attributes - A bitset of attributes. typedef unsigned Attributes; - + 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, function +/// 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, function /// results or the function itself. /// @brief Function attributes. @@ -44,25 +45,45 @@ 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) - +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 +const Attributes InlineHint = 1<<25; ///< source said inlining was + ///desirable +const Attributes StackAlignment = 7<<26; ///< Alignment of stack for + ///function (3 bits) stored as log2 + ///of alignment with +1 bias + ///0 means unaligned (different from + ///alignstack(1)) +const Attributes Hotpatch = 1<<29; ///< Function should have special + ///'hotpatch' sequence in prologue + /// @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. -const Attributes FunctionOnly = NoReturn | NoUnwind | ReadNone | ReadOnly | - NoInline | AlwaysInline | OptimizeForSize; +/// @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 | InlineHint | StackAlignment | + Hotpatch; /// @brief Parameter attributes that do not apply to vararg call arguments. const Attributes VarArgsIncompatible = StructRet; /// @brief Attributes that are mutually incompatible. const Attributes MutuallyIncompatible[4] = { - ByVal | InReg | Nest | StructRet, + ByVal | InReg | Nest | StructRet, ZExt | SExt, ReadNone | ReadOnly, NoInline | AlwaysInline @@ -74,24 +95,62 @@ 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); +} + +/// This turns an int stack alignment (which must be a power of 2) into +/// the form used internally in Attributes. +inline Attributes constructStackAlignmentFromInt(unsigned i) { + // 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 <= 0x100 && "Alignment too large."); + return (Log2_32(i)+1) << 26; +} + +/// This returns the stack alignment field of an attribute as a byte alignment +/// value. +inline unsigned getStackAlignmentFromAttrs(Attributes A) { + Attributes StackAlign = A & Attribute::StackAlignment; + if (StackAlign == 0) + return 0; + + return 1U << ((StackAlign >> 26) - 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. +/// the mnemonics for the assembly writer. /// @brief Convert attribute bits to text std::string getAsString(Attributes Attrs); } // end namespace Attribute /// This is just a pair of values to associate a set of attributes -/// with an index. +/// 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 AttributeWithIndex get(unsigned Idx, Attributes Attrs) { AttributeWithIndex P; P.Index = Idx; @@ -99,14 +158,14 @@ struct AttributeWithIndex { return P; } }; - + //===----------------------------------------------------------------------===// // AttrListPtr Smart Pointer //===----------------------------------------------------------------------===// class AttributeListImpl; - -/// AttrListPtr - 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 AttrListPtr { /// AttrList - The attributes that we are managing. This can be null @@ -117,14 +176,14 @@ public: AttrListPtr(const AttrListPtr &P); const AttrListPtr &operator=(const AttrListPtr &RHS); ~AttrListPtr(); - + //===--------------------------------------------------------------------===// // Attribute List Construction and Mutation //===--------------------------------------------------------------------===// - + /// get - Return a Attributes list with the specified parameter in it. static AttrListPtr get(const AttributeWithIndex *Attr, unsigned NumAttrs); - + /// get - Return a Attribute list with the parameters specified by the /// consecutive random access iterator range. template @@ -137,84 +196,86 @@ public: /// attribute list. Since attribute lists are immutable, this /// returns the new list. AttrListPtr addAttr(unsigned Idx, Attributes Attrs) const; - + /// removeAttr - Remove the specified attribute at the specified index from /// this attribute list. Since attribute lists are immutable, this /// returns the new list. AttrListPtr removeAttr(unsigned Idx, Attributes Attrs) const; - + //===--------------------------------------------------------------------===// // Attribute List Accessors //===--------------------------------------------------------------------===// /// getParamAttributes - The attributes for the specified index are - /// returned. + /// 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. + /// returned. Attributes getRetAttributes() const { return getAttributes(0); } /// getFnAttributes - The function attributes are returned. Attributes getFnAttributes() const { - return getAttributes(~0); + return getAttributes(~0U); } - + /// paramHasAttr - Return true if the specified parameter index has the /// specified attribute set. bool paramHasAttr(unsigned Idx, Attributes Attr) const { - return getAttributes(Idx) & Attr; + return (getAttributes(Idx) & Attr) != 0; } - + /// getParamAlignment - Return the alignment for the specified function /// parameter. unsigned getParamAlignment(unsigned Idx) const { - return (getAttributes(Idx) & Attribute::Alignment) >> 16; + return Attribute::getAlignmentFromAttrs(getAttributes(Idx)); } - + /// hasAttrSomewhere - Return true if the specified attribute is set for at /// least one parameter or for the return value. bool hasAttrSomewhere(Attributes Attr) const; /// operator==/!= - Provide equality predicates. - bool operator==(const AttrListPtr &RHS) const { return AttrList == RHS.AttrList; } - bool operator!=(const AttrListPtr &RHS) const { return AttrList != RHS.AttrList; } - + bool operator==(const AttrListPtr &RHS) const + { return AttrList == RHS.AttrList; } + bool operator!=(const AttrListPtr &RHS) const + { return AttrList != RHS.AttrList; } + void dump() const; //===--------------------------------------------------------------------===// // Attribute List Introspection //===--------------------------------------------------------------------===// - + /// getRawPointer - Return a raw pointer that uniquely identifies this - /// attribute list. + /// attribute list. void *getRawPointer() const { return AttrList; } - + // 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 there are no attributes. /// bool isEmpty() const { return AttrList == 0; } - - /// getNumSlots - Return the number of slots used in this attribute list. + + /// 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 AttributeWithIndex at the specified slot. This /// holds a index number plus a set of attributes. const AttributeWithIndex &getSlot(unsigned Slot) const; - + private: explicit AttrListPtr(AttributeListImpl *L);