Change the JIT to compile eagerly by default as agreed in

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

diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h
index 57f4e17c47fea25ad2615d0f4d7cfeec9d773321..0bbdc349b1b431c257456a40fe764312a9e36d7c 100644 (file)
--- a/include/llvm/Attributes.h
+++ b/include/llvm/Attributes.h
@@ -15,6 +15,7 @@
 #ifndef LLVM_ATTRIBUTES_H
 #define LLVM_ATTRIBUTES_H
 
+#include "llvm/Support/MathExtras.h"
 #include <cassert>
 #include <string>
 
@@ -23,7 +24,7 @@ class Type;
 
 /// Attributes - A bitset of attributes.
 typedef unsigned Attributes;
-  
+
 namespace Attribute {
 
 /// Function parameters and results can have attributes to indicate how they 
@@ -44,27 +45,36 @@ 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 StackProtect    = 1<<14; // Stack protection.
-const Attributes StackProtectReq = 1<<15; // Stack protection required.
-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
+
 /// @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.
+/// @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 | InlineHint;
 
 /// @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
@@ -76,9 +86,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) {
-  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. 
@@ -163,7 +189,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
@@ -175,7 +201,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