-//===-- llvm/Attributes.h - Container for ParamAttrs ---*---------- C++ -*-===//
+//===-- llvm/Attributes.h - Container for Attributes ---*---------- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// 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 <cassert>
#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
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.
/// 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 FnAttributeWithIndex {
+} // 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;
};
//===----------------------------------------------------------------------===//
-// 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;
+ /// 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
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.
/// (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);
+
+ /// 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
projects / oota-llvm.git / blobdiff