Add some consistent doxygen comments for the address space helpers.

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

diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h
index 097ee3c7aaa170c2fe6c0dc1bd1935278e77f8ba..5ace200803eb05ed02845877801eee8a5dbfcdb0 100644 (file)
--- a/include/llvm/Attributes.h
+++ b/include/llvm/Attributes.h
@@ -51,41 +51,41 @@ public:
 
   enum AttrVal {
     // 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
+    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
+    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
-    ForceSizeOpt    = 28  ///< Function must be optimized for size first
+    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;
@@ -154,7 +154,7 @@ public:
       hasAttribute(Attributes::NonLazyBind) ||
       hasAttribute(Attributes::ReturnsTwice) ||
       hasAttribute(Attributes::AddressSafety) ||
-      hasAttribute(Attributes::ForceSizeOpt);
+      hasAttribute(Attributes::MinSize);
   }
 
   bool operator==(const Attributes &A) const {
@@ -266,7 +266,7 @@ public:
       .removeAttribute(Attributes::NonLazyBind)
       .removeAttribute(Attributes::ReturnsTwice)
       .removeAttribute(Attributes::AddressSafety)
-      .removeAttribute(Attributes::ForceSizeOpt);
+      .removeAttribute(Attributes::MinSize);
   }
 
   uint64_t Raw() const { return Bits; }