Add comments.

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

diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h
index ad33a8a9594785c5f769c9481d88063a9b1b30e7..d04ca590aaa875991859d22486c91639230a557e 100644 (file)
--- a/include/llvm/Attributes.h
+++ b/include/llvm/Attributes.h
@@ -15,7 +15,6 @@
 #ifndef LLVM_ATTRIBUTES_H
 #define LLVM_ATTRIBUTES_H
 
-#include "llvm/AttributesImpl.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/ADT/ArrayRef.h"
 #include <cassert>
@@ -53,6 +52,7 @@ public:
   /// uwtable + nounwind = Needs an entry because the ABI says so.
 
   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)
@@ -90,13 +90,26 @@ public:
   };
 private:
   AttributesImpl *Attrs;
-
-  explicit Attributes(AttributesImpl *A);
+  Attributes(AttributesImpl *A);
 public:
   Attributes() : Attrs(0) {}
-  explicit Attributes(LLVMContext &C, ArrayRef<AttrVal> Vals);
   Attributes(const Attributes &A);
+  Attributes &operator=(const Attributes &A) {
+    Attrs = A.Attrs;
+    return *this;
+  }
 
+  /// get - Return a uniquified Attributes object. This takes the uniquified
+  /// value from the Builder and wraps it in the Attributes class.
+  class Builder;
+  static Attributes get(LLVMContext &Context, ArrayRef<AttrVal> Vals);
+  static Attributes get(LLVMContext &Context, Builder &B);
+
+  //===--------------------------------------------------------------------===//
+  /// Attributes::Builder - 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 Builder {
     friend class Attributes;
     uint64_t Bits;
@@ -108,20 +121,38 @@ public:
 
     void clear() { Bits = 0; }
 
+    /// addAttribute - Add an attribute to the builder.
+    Builder &addAttribute(Attributes::AttrVal Val);
+
+    /// removeAttribute - Remove an attribute from the builder.
+    Builder &removeAttribute(Attributes::AttrVal Val);
+
+    /// addAttribute - Add the attributes from A to the builder.
+    Builder &addAttributes(const Attributes &A);
+
+    /// removeAttribute - Remove the attributes from A from the builder.
+    Builder &removeAttributes(const Attributes &A);
+
+    /// hasAttribute - Return true if the builder has the specified attribute.
     bool hasAttribute(Attributes::AttrVal 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;
+
+    /// hasAlignmentAttr - Return true if the builder has an alignment
+    /// attribute.
     bool hasAlignmentAttr() const;
 
+    /// getAlignment - Retrieve the alignment attribute, if it exists.
     uint64_t getAlignment() const;
-    uint64_t getStackAlignment() const;
 
-    Builder &addAttribute(Attributes::AttrVal Val);
-    Builder &removeAttribute(Attributes::AttrVal Val);
-
-    /// addRawValue - Add the raw value to the internal representation. This
-    /// should be used ONLY for decoding bitcode!
-    Builder &addRawValue(uint64_t Val);
+    /// getStackAlignment - Retrieve the stack alignment attribute, if it
+    /// exists.
+    uint64_t getStackAlignment() const;
 
     /// addAlignmentAttr - This turns an int alignment (which must be a power of
     /// 2) into the form used internally in Attributes.
@@ -131,8 +162,9 @@ public:
     /// a power of 2) into the form used internally in Attributes.
     Builder &addStackAlignmentAttr(unsigned Align);
 
-    Builder &addAttributes(const Attributes &A);
-    Builder &removeAttributes(const Attributes &A);
+    /// addRawValue - Add the raw value to the internal representation.
+    /// N.B. This should be used ONLY for decoding LLVM bitcode!
+    Builder &addRawValue(uint64_t Val);
 
     /// @brief Remove attributes that are used on functions only.
     void removeFunctionOnlyAttrs() {
@@ -164,17 +196,11 @@ public:
     }
   };
 
-  /// 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, Builder &B);
-
   /// @brief Return true if the attribute is present.
   bool hasAttribute(AttrVal Val) const;
 
   /// @brief Return true if attributes exist
-  bool hasAttributes() const {
-    return Attrs && Attrs->hasAttributes();
-  }
+  bool hasAttributes() const;
 
   /// @brief Return true if the attributes are a non-null intersection.
   bool hasAttributes(const Attributes &A) const;
@@ -223,10 +249,10 @@ public:
       hasAttribute(Attributes::AddressSafety);
   }
 
-  bool operator == (const Attributes &A) const {
+  bool operator==(const Attributes &A) const {
     return Attrs == A.Attrs;
   }
-  bool operator != (const Attributes &A) const {
+  bool operator!=(const Attributes &A) const {
     return Attrs != A.Attrs;
   }
 
@@ -324,6 +350,12 @@ class AttributeListImpl;
 /// AttrListPtr - This class manages the ref count for the opaque
 /// AttributeListImpl object and provides accessors for it.
 class AttrListPtr {
+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;
@@ -362,12 +394,12 @@ public:
   /// getRetAttributes - The attributes for the ret value are
   /// returned.
   Attributes getRetAttributes() const {
-    return getAttributes(0);
+    return getAttributes(ReturnIndex);
   }
 
   /// getFnAttributes - The function attributes are returned.
   Attributes getFnAttributes() const {
-    return getAttributes(~0U);
+    return getAttributes(FunctionIndex);
   }
 
   /// paramHasAttr - Return true if the specified parameter index has the