Factor some of the constants+context related code out into a separate header, to...

[oota-llvm.git] / include / llvm / Attributes.h

diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h
index 5cb581ae9631eb60e49032217a0f31576134f363..49f6057f31aed7ec7e31abd239cec29fdbd7d7bc 100644 (file)
--- a/include/llvm/Attributes.h
+++ b/include/llvm/Attributes.h
@@ -51,15 +51,22 @@ 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.
+                                     // 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 | NoCapture;
 
-/// @brief Attributes that only apply to function.
+/// @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;
+  NoInline | AlwaysInline | OptimizeForSize | StackProtect | StackProtectReq |
+  NoRedZone | NoImplicitFloat | Naked;
 
 /// @brief Parameter attributes that do not apply to vararg call arguments.
 const Attributes VarArgsIncompatible = StructRet;
@@ -78,10 +85,25 @@ 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) {
+  // 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.");
-  return Log2_32(i) << 16;
+  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. 
@@ -166,7 +188,7 @@ public:
 
   /// 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
@@ -178,7 +200,7 @@ public:
   /// 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