X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAttributes.h;h=c28f0bd09075de6a5c97f29c25792905e8782129;hb=7f00f87767036e74445aad0164eea13cf2642610;hp=aac5d9ef4a0efef975dab519c22628dd06473362;hpb=76b67df11e5cdb87e954a0ad7d1cd7fd4a502be1;p=oota-llvm.git diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h index aac5d9ef4a0..c28f0bd0907 100644 --- a/include/llvm/Attributes.h +++ b/include/llvm/Attributes.h @@ -6,223 +6,188 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -// -// This file contains the simple types necessary to represent the -// attributes associated with functions and their calls. -// +/// +/// \file +/// \brief This file contains the simple types necessary to represent the +/// attributes associated with functions and their calls. +/// //===----------------------------------------------------------------------===// #ifndef LLVM_ATTRIBUTES_H #define LLVM_ATTRIBUTES_H -#include "llvm/Support/MathExtras.h" #include "llvm/ADT/ArrayRef.h" +#include "llvm/Support/MathExtras.h" #include #include namespace llvm { class AttrBuilder; -class AttributesImpl; +class AttributeImpl; class LLVMContext; class Type; -/// Attributes - A bitset of attributes. -class Attributes { +//===----------------------------------------------------------------------===// +/// \class +/// \brief Functions, function parameters, and return types can have attributes +/// to indicate how they should be treated by optimizations and code +/// generation. This class represents one of those attributes. It's light-weight +/// and should be passed around by-value. +class Attribute { public: - /// 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. - /// - /// Note that uwtable is about the ABI or the user mandating an entry in the + /// This enumeration lists the attributes that can be associated with + /// parameters, function results or the function itself. + /// + /// Note: uwtable is about the ABI or the user mandating an entry in the /// unwind table. The nounwind attribute is about an exception passing by the /// function. - /// + /// /// In a theoretical system that uses tables for profiling and sjlj for /// exceptions, they would be fully independent. In a normal system that uses /// tables for both, the semantics are: - /// + /// /// nil = Needs an entry because an exception might pass by. /// nounwind = No need for an entry /// uwtable = Needs an entry because the ABI says so and because /// an exception might pass by. /// uwtable + nounwind = Needs an entry because the ABI says so. - enum AttrVal { + enum AttrKind { // IR-Level Attributes - None = 0, ///< No attributes have been set - AddressSafety = 1, ///< Address safety checking is on. - Alignment = 2, ///< Alignment of parameter (5 bits) + None, ///< No attributes have been set + AddressSafety, ///< Address safety checking is on. + Alignment, ///< Alignment of parameter (5 bits) ///< stored as log2 of alignment with +1 bias - ///< 0 means unaligned different from align 1 - AlwaysInline = 3, ///< inline=always - ByVal = 4, ///< Pass structure by value - InlineHint = 5, ///< Source said inlining was desirable - InReg = 6, ///< Force argument to be passed in register - Naked = 7, ///< Naked function - Nest = 8, ///< Nested function static chain - NoAlias = 9, ///< Considered to not alias after call - NoCapture = 10, ///< Function creates no aliases of pointer - NoImplicitFloat = 11, ///< Disable implicit floating point insts - NoInline = 12, ///< inline=never - NonLazyBind = 13, ///< Function is called early and/or + ///< 0 means unaligned (different from align(1)) + AlwaysInline, ///< inline=always + ByVal, ///< Pass structure by value + InlineHint, ///< Source said inlining was desirable + InReg, ///< Force argument to be passed in register + MinSize, ///< Function must be optimized for size first + Naked, ///< Naked function + Nest, ///< Nested function static chain + NoAlias, ///< Considered to not alias after call + NoCapture, ///< Function creates no aliases of pointer + NoDuplicate, ///< Call cannot be duplicated + NoImplicitFloat, ///< Disable implicit floating point insts + NoInline, ///< inline=never + NonLazyBind, ///< Function is called early and/or ///< often, so lazy binding isn't worthwhile - NoRedZone = 14, ///< Disable redzone - NoReturn = 15, ///< Mark the function as not returning - NoUnwind = 16, ///< Function doesn't unwind stack - OptimizeForSize = 17, ///< opt_size - ReadNone = 18, ///< Function does not access memory - ReadOnly = 19, ///< Function only reads from memory - ReturnsTwice = 20, ///< Function can return twice - SExt = 21, ///< Sign extended before/after call - StackAlignment = 22, ///< Alignment of stack for function (3 bits) + NoRedZone, ///< Disable redzone + NoReturn, ///< Mark the function as not returning + NoUnwind, ///< Function doesn't unwind stack + OptimizeForSize, ///< opt_size + ReadNone, ///< Function does not access memory + ReadOnly, ///< Function only reads from memory + ReturnsTwice, ///< Function can return twice + SExt, ///< Sign extended before/after call + StackAlignment, ///< Alignment of stack for function (3 bits) ///< stored as log2 of alignment with +1 bias 0 ///< means unaligned (different from - ///< alignstack={1)) - StackProtect = 23, ///< Stack protection. - StackProtectReq = 24, ///< Stack protection required. - StructRet = 25, ///< Hidden pointer to structure to return - UWTable = 26, ///< Function must be in a unwind table - ZExt = 27 ///< Zero extended before/after call + ///< alignstack=(1)) + StackProtect, ///< Stack protection. + StackProtectReq, ///< Stack protection required. + StructRet, ///< Hidden pointer to structure to return + UWTable, ///< Function must be in a unwind table + ZExt ///< Zero extended before/after call }; private: - AttributesImpl *Attrs; - Attributes(AttributesImpl *A) : Attrs(A) {} + AttributeImpl *pImpl; + Attribute(AttributeImpl *A) : pImpl(A) {} public: - Attributes() : Attrs(0) {} - Attributes(const Attributes &A) : Attrs(A.Attrs) {} - Attributes &operator=(const Attributes &A) { - Attrs = A.Attrs; - return *this; - } + Attribute() : pImpl(0) {} - /// get - Return a uniquified Attributes object. This takes the uniquified - /// value from the Builder and wraps it in the Attributes class. - static Attributes get(LLVMContext &Context, ArrayRef Vals); - static Attributes get(LLVMContext &Context, AttrBuilder &B); + /// \brief Return a uniquified Attribute object. This takes the uniquified + /// value from the Builder and wraps it in the Attribute class. + static Attribute get(LLVMContext &Context, ArrayRef Vals); + static Attribute get(LLVMContext &Context, AttrBuilder &B); - /// @brief Return true if the attribute is present. - bool hasAttribute(AttrVal Val) const; + /// \brief Return true if the attribute is present. + bool hasAttribute(AttrKind Val) const; - /// @brief Return true if attributes exist + /// \brief Return true if attributes exist bool hasAttributes() const; - /// @brief Return true if the attributes are a non-null intersection. - bool hasAttributes(const Attributes &A) const; + /// \brief Return true if the attributes are a non-null intersection. + bool hasAttributes(const Attribute &A) const; - /// @brief Returns the alignment field of an attribute as a byte alignment + /// \brief Returns the alignment field of an attribute as a byte alignment /// value. unsigned getAlignment() const; - /// @brief Returns the stack alignment field of an attribute as a byte + /// \brief Returns the stack alignment field of an attribute as a byte /// alignment value. unsigned getStackAlignment() const; - /// @brief Parameter attributes that do not apply to vararg call arguments. - bool hasIncompatibleWithVarArgsAttrs() const { - return hasAttribute(Attributes::StructRet); - } - - /// @brief Attributes that only apply to function parameters. - bool hasParameterOnlyAttrs() const { - return hasAttribute(Attributes::ByVal) || - hasAttribute(Attributes::Nest) || - hasAttribute(Attributes::StructRet) || - hasAttribute(Attributes::NoCapture); - } + bool operator==(AttrKind K) const; + bool operator!=(AttrKind K) const; - /// @brief Attributes that may be applied to the function itself. These cannot - /// be used on return values or function parameters. - bool hasFunctionOnlyAttrs() const { - return hasAttribute(Attributes::NoReturn) || - hasAttribute(Attributes::NoUnwind) || - hasAttribute(Attributes::ReadNone) || - hasAttribute(Attributes::ReadOnly) || - hasAttribute(Attributes::NoInline) || - hasAttribute(Attributes::AlwaysInline) || - hasAttribute(Attributes::OptimizeForSize) || - hasAttribute(Attributes::StackProtect) || - hasAttribute(Attributes::StackProtectReq) || - hasAttribute(Attributes::NoRedZone) || - hasAttribute(Attributes::NoImplicitFloat) || - hasAttribute(Attributes::Naked) || - hasAttribute(Attributes::InlineHint) || - hasAttribute(Attributes::StackAlignment) || - hasAttribute(Attributes::UWTable) || - hasAttribute(Attributes::NonLazyBind) || - hasAttribute(Attributes::ReturnsTwice) || - hasAttribute(Attributes::AddressSafety); + // FIXME: Remove these 'operator' methods. + bool operator==(const Attribute &A) const { + return pImpl == A.pImpl; } - - bool operator==(const Attributes &A) const { - return Attrs == A.Attrs; - } - bool operator!=(const Attributes &A) const { - return Attrs != A.Attrs; + bool operator!=(const Attribute &A) const { + return pImpl != A.pImpl; } - uint64_t Raw() const; + uint64_t getBitMask() const; - /// @brief Which attributes cannot be applied to a type. - static Attributes typeIncompatible(Type *Ty); + /// \brief Which attributes cannot be applied to a type. + static Attribute typeIncompatible(Type *Ty); - /// encodeLLVMAttributesForBitcode - This returns an integer containing an - /// encoding of all the LLVM attributes found in the given attribute bitset. - /// Any change to this encoding is a breaking change to bitcode compatibility. - static uint64_t encodeLLVMAttributesForBitcode(Attributes Attrs); + /// \brief This returns an integer containing an encoding of all the LLVM + /// attributes found in the given attribute bitset. Any change to this + /// encoding is a breaking change to bitcode compatibility. + static uint64_t encodeLLVMAttributesForBitcode(Attribute Attrs); - /// decodeLLVMAttributesForBitcode - This returns an attribute bitset - /// containing the LLVM attributes that have been decoded from the given - /// integer. This function must stay in sync with - /// 'encodeLLVMAttributesForBitcode'. - static Attributes decodeLLVMAttributesForBitcode(LLVMContext &C, - uint64_t EncodedAttrs); + /// \brief This returns an attribute bitset containing the LLVM attributes + /// that have been decoded from the given integer. This function must stay in + /// sync with 'encodeLLVMAttributesForBitcode'. + static Attribute decodeLLVMAttributesForBitcode(LLVMContext &C, + uint64_t EncodedAttrs); - /// getAsString - 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 attribute bits to text + /// \brief The Attribute is converted to a string of equivalent mnemonic. This + /// is, presumably, for writing out the mnemonics for the assembly writer. std::string getAsString() const; }; //===----------------------------------------------------------------------===// -/// AttrBuilder - This class is used in conjunction with the Attributes::get -/// method to create an Attributes object. The object itself is uniquified. The -/// Builder's value, however, is not. So this can be used as a quick way to test -/// for equality, presence of attributes, etc. +/// \class +/// \brief This class is used in conjunction with the Attribute::get method to +/// create an Attribute object. The object itself is uniquified. The Builder's +/// value, however, is not. So this can be used as a quick way to test for +/// equality, presence of attributes, etc. class AttrBuilder { - friend class Attributes; uint64_t Bits; public: AttrBuilder() : Bits(0) {} explicit AttrBuilder(uint64_t B) : Bits(B) {} - AttrBuilder(const Attributes &A) : Bits(A.Raw()) {} - AttrBuilder(const AttrBuilder &B) : Bits(B.Bits) {} + AttrBuilder(const Attribute &A) : Bits(A.getBitMask()) {} void clear() { Bits = 0; } /// addAttribute - Add an attribute to the builder. - AttrBuilder &addAttribute(Attributes::AttrVal Val); + AttrBuilder &addAttribute(Attribute::AttrKind Val); /// removeAttribute - Remove an attribute from the builder. - AttrBuilder &removeAttribute(Attributes::AttrVal Val); + AttrBuilder &removeAttribute(Attribute::AttrKind Val); /// addAttribute - Add the attributes from A to the builder. - AttrBuilder &addAttributes(const Attributes &A); + AttrBuilder &addAttributes(const Attribute &A); /// removeAttribute - Remove the attributes from A from the builder. - AttrBuilder &removeAttributes(const Attributes &A); + AttrBuilder &removeAttributes(const Attribute &A); - /// hasAttribute - Return true if the builder has the specified attribute. - bool hasAttribute(Attributes::AttrVal A) const; + /// \brief Return true if the builder has the specified attribute. + bool contains(Attribute::AttrKind A) const; /// hasAttributes - Return true if the builder has IR-level attributes. bool hasAttributes() const; /// hasAttributes - Return true if the builder has any attribute that's in the /// specified attribute. - bool hasAttributes(const Attributes &A) const; + bool hasAttributes(const Attribute &A) const; /// hasAlignmentAttr - Return true if the builder has an alignment attribute. bool hasAlignmentAttr() const; @@ -234,11 +199,11 @@ public: uint64_t getStackAlignment() const; /// addAlignmentAttr - This turns an int alignment (which must be a power of - /// 2) into the form used internally in Attributes. + /// 2) into the form used internally in Attribute. AttrBuilder &addAlignmentAttr(unsigned Align); /// addStackAlignmentAttr - This turns an int stack alignment (which must be a - /// power of 2) into the form used internally in Attributes. + /// power of 2) into the form used internally in Attribute. AttrBuilder &addStackAlignmentAttr(unsigned Align); /// addRawValue - Add the raw value to the internal representation. @@ -247,26 +212,30 @@ public: /// @brief Remove attributes that are used on functions only. void removeFunctionOnlyAttrs() { - removeAttribute(Attributes::NoReturn) - .removeAttribute(Attributes::NoUnwind) - .removeAttribute(Attributes::ReadNone) - .removeAttribute(Attributes::ReadOnly) - .removeAttribute(Attributes::NoInline) - .removeAttribute(Attributes::AlwaysInline) - .removeAttribute(Attributes::OptimizeForSize) - .removeAttribute(Attributes::StackProtect) - .removeAttribute(Attributes::StackProtectReq) - .removeAttribute(Attributes::NoRedZone) - .removeAttribute(Attributes::NoImplicitFloat) - .removeAttribute(Attributes::Naked) - .removeAttribute(Attributes::InlineHint) - .removeAttribute(Attributes::StackAlignment) - .removeAttribute(Attributes::UWTable) - .removeAttribute(Attributes::NonLazyBind) - .removeAttribute(Attributes::ReturnsTwice) - .removeAttribute(Attributes::AddressSafety); + removeAttribute(Attribute::NoReturn) + .removeAttribute(Attribute::NoUnwind) + .removeAttribute(Attribute::ReadNone) + .removeAttribute(Attribute::ReadOnly) + .removeAttribute(Attribute::NoInline) + .removeAttribute(Attribute::AlwaysInline) + .removeAttribute(Attribute::OptimizeForSize) + .removeAttribute(Attribute::StackProtect) + .removeAttribute(Attribute::StackProtectReq) + .removeAttribute(Attribute::NoRedZone) + .removeAttribute(Attribute::NoImplicitFloat) + .removeAttribute(Attribute::Naked) + .removeAttribute(Attribute::InlineHint) + .removeAttribute(Attribute::StackAlignment) + .removeAttribute(Attribute::UWTable) + .removeAttribute(Attribute::NonLazyBind) + .removeAttribute(Attribute::ReturnsTwice) + .removeAttribute(Attribute::AddressSafety) + .removeAttribute(Attribute::MinSize) + .removeAttribute(Attribute::NoDuplicate); } + uint64_t getBitMask() const { return Bits; } + bool operator==(const AttrBuilder &B) { return Bits == B.Bits; } @@ -276,31 +245,20 @@ public: }; //===----------------------------------------------------------------------===// -// AttributeWithIndex -//===----------------------------------------------------------------------===// - -/// AttributeWithIndex - This is just a pair of values to associate a set of -/// attributes with an index. +/// \class +/// \brief 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. + Attribute 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(LLVMContext &C, unsigned Idx, - ArrayRef Attrs) { - AttrBuilder B; - - for (ArrayRef::iterator I = Attrs.begin(), - E = Attrs.end(); I != E; ++I) - B.addAttribute(*I); - - AttributeWithIndex P; - P.Index = Idx; - P.Attrs = Attributes::get(C, B); - return P; + ArrayRef Attrs) { + return get(Idx, Attribute::get(C, Attrs)); } - static AttributeWithIndex get(unsigned Idx, Attributes Attrs) { + static AttributeWithIndex get(unsigned Idx, Attribute Attrs) { AttributeWithIndex P; P.Index = Idx; P.Attrs = Attrs; @@ -309,130 +267,133 @@ struct AttributeWithIndex { }; //===----------------------------------------------------------------------===// -// AttrListPtr Smart Pointer +// AttributeSet Smart Pointer //===----------------------------------------------------------------------===// -class AttributeListImpl; +class AttributeSetImpl; -/// AttrListPtr - This class manages the ref count for the opaque -/// AttributeListImpl object and provides accessors for it. -class AttrListPtr { +//===----------------------------------------------------------------------===// +/// \class +/// \brief This class manages the ref count for the opaque AttributeSetImpl +/// object and provides accessors for it. +class AttributeSet { public: enum AttrIndex { ReturnIndex = 0U, FunctionIndex = ~0U }; private: - /// AttrList - The attributes that we are managing. This can be null - /// to represent the empty attributes list. - AttributeListImpl *AttrList; + /// \brief The attributes that we are managing. This can be null to represent + /// the empty attributes list. + AttributeSetImpl *AttrList; + + /// \brief The attributes for the specified index are returned. Attributes + /// for the result are denoted with Idx = 0. + Attribute getAttributes(unsigned Idx) const; + + explicit AttributeSet(AttributeSetImpl *LI) : AttrList(LI) {} public: - AttrListPtr() : AttrList(0) {} - AttrListPtr(const AttrListPtr &P); - const AttrListPtr &operator=(const AttrListPtr &RHS); - ~AttrListPtr(); + AttributeSet() : AttrList(0) {} + AttributeSet(const AttributeSet &P) : AttrList(P.AttrList) {} + const AttributeSet &operator=(const AttributeSet &RHS); //===--------------------------------------------------------------------===// // Attribute List Construction and Mutation //===--------------------------------------------------------------------===// - /// get - Return a Attributes list with the specified parameters in it. - static AttrListPtr get(ArrayRef Attrs); + /// \brief Return an AttributeSet with the specified parameters in it. + static AttributeSet get(LLVMContext &C, ArrayRef Attrs); - /// addAttr - Add the specified attribute at the specified index to this - /// attribute list. Since attribute lists are immutable, this - /// returns the new list. - AttrListPtr addAttr(LLVMContext &C, unsigned Idx, Attributes Attrs) const; + /// \brief Add the specified attribute at the specified index to this + /// attribute list. Since attribute lists are immutable, this returns the new + /// list. + AttributeSet addAttr(LLVMContext &C, unsigned Idx, Attribute 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(LLVMContext &C, unsigned Idx, Attributes Attrs) const; + /// \brief Remove the specified attribute at the specified index from this + /// attribute list. Since attribute lists are immutable, this returns the new + /// list. + AttributeSet removeAttr(LLVMContext &C, unsigned Idx, Attribute Attrs) const; //===--------------------------------------------------------------------===// // Attribute List Accessors //===--------------------------------------------------------------------===// - /// getParamAttributes - The attributes for the specified index are - /// returned. - Attributes getParamAttributes(unsigned Idx) const { + + /// \brief The attributes for the specified index are returned. + Attribute getParamAttributes(unsigned Idx) const { return getAttributes(Idx); } - /// getRetAttributes - The attributes for the ret value are - /// returned. - Attributes getRetAttributes() const { + /// \brief The attributes for the ret value are returned. + Attribute getRetAttributes() const { return getAttributes(ReturnIndex); } - /// getFnAttributes - The function attributes are returned. - Attributes getFnAttributes() const { + /// \brief The function attributes are returned. + Attribute getFnAttributes() const { return getAttributes(FunctionIndex); } - /// paramHasAttr - Return true if the specified parameter index has the - /// specified attribute set. - bool paramHasAttr(unsigned Idx, Attributes Attr) const { - return getAttributes(Idx).hasAttributes(Attr); - } - - /// getParamAlignment - Return the alignment for the specified function - /// parameter. + /// \brief Return the alignment for the specified function parameter. unsigned getParamAlignment(unsigned Idx) const { return getAttributes(Idx).getAlignment(); } - /// hasAttrSomewhere - Return true if the specified attribute is set for at - /// least one parameter or for the return value. - bool hasAttrSomewhere(Attributes::AttrVal Attr) const; + /// \brief Return true if the attribute exists at the given index. + bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const; - unsigned getNumAttrs() const; - Attributes &getAttributesAtIndex(unsigned i) const; + /// \brief Return true if attribute exists at the given index. + bool hasAttributes(unsigned Index) 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; } + /// \brief Get the stack alignment. + unsigned getStackAlignment(unsigned Index) const; - void dump() const; + /// \brief Return the attributes at the index as a string. + std::string getAsString(unsigned Index) const; + + uint64_t getBitMask(unsigned Index) const; + + /// \brief Return true if the specified attribute is set for at least one + /// parameter or for the return value. + bool hasAttrSomewhere(Attribute::AttrKind Attr) const; + + /// operator==/!= - Provide equality predicates. + bool operator==(const AttributeSet &RHS) const { + return AttrList == RHS.AttrList; + } + bool operator!=(const AttributeSet &RHS) const { + return AttrList != RHS.AttrList; + } //===--------------------------------------------------------------------===// // Attribute List Introspection //===--------------------------------------------------------------------===// - /// getRawPointer - Return a raw pointer that uniquely identifies this - /// attribute list. + /// \brief Return a raw pointer that uniquely identifies this 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. + // 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. - /// + /// \brief Return true if there are no attributes. bool isEmpty() const { return AttrList == 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). + /// \brief 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. + /// \brief 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); - - /// getAttributes - The attributes for the specified index are - /// returned. Attributes for the result are denoted with Idx = 0. - Attributes getAttributes(unsigned Idx) const; + void dump() const; }; -} // End llvm namespace +} // end llvm namespace #endif