Supply a default 'operator=' method.

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

diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h
index 268fc5a8e1cd68a3225102118fdb37297a37b1c3..afb2e564f0ea721485c62cc1b8557896f71899a0 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>
@@ -89,14 +88,17 @@ public:
     ZExt            = 27   ///< Zero extended before/after call
   };
 private:
-  AttributesImpl Attrs;
+  AttributesImpl *Attrs;
 
   explicit Attributes(AttributesImpl *A);
 public:
   Attributes() : Attrs(0) {}
-  explicit Attributes(uint64_t Val);
-  explicit Attributes(LLVMContext &C, AttrVal Val);
+  explicit Attributes(LLVMContext &C, ArrayRef<AttrVal> Vals);
   Attributes(const Attributes &A);
+  Attributes &operator=(const Attributes &A) {
+    Attrs = A.Attrs;
+    return *this;
+  }
 
   class Builder {
     friend class Attributes;
@@ -105,6 +107,7 @@ public:
     Builder() : Bits(0) {}
     explicit Builder(uint64_t B) : Bits(B) {}
     Builder(const Attributes &A) : Bits(A.Raw()) {}
+    Builder(const Builder &B) : Bits(B.Bits) {}
 
     void clear() { Bits = 0; }
 
@@ -166,16 +169,13 @@ 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(Builder &B);
   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.hasAttributes();
-  }
+  bool hasAttributes() const;
 
   /// @brief Return true if the attributes are a non-null intersection.
   bool hasAttributes(const Attributes &A) const;
@@ -224,21 +224,13 @@ public:
       hasAttribute(Attributes::AddressSafety);
   }
 
-  bool isEmptyOrSingleton() const;
-
-  // This is a "safe bool() operator".
-  operator const void *() const { return Attrs.Bits ? this : 0; }
   bool operator == (const Attributes &A) const {
-    return Attrs.Bits == A.Attrs.Bits;
+    return Attrs == A.Attrs;
   }
   bool operator != (const Attributes &A) const {
-    return Attrs.Bits != A.Attrs.Bits;
+    return Attrs != A.Attrs;
   }
 
-  Attributes operator & (const Attributes &A) const;
-  Attributes &operator |= (const Attributes &A);
-  Attributes &operator &= (const Attributes &A);
-
   uint64_t Raw() const;
 
   /// @brief Which attributes cannot be applied to a type.
@@ -269,7 +261,8 @@ public:
   /// containing the LLVM attributes that have been decoded from the given
   /// integer.  This function must stay in sync with
   /// 'encodeLLVMAttributesForBitcode'.
-  static Attributes decodeLLVMAttributesForBitcode(uint64_t EncodedAttrs) {
+  static Attributes decodeLLVMAttributesForBitcode(LLVMContext &C,
+                                                   uint64_t EncodedAttrs) {
     // The alignment is stored as a 16-bit raw value from bits 31--16.  We shift
     // the bits above 31 down by 11 bits.
     unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16;
@@ -280,7 +273,7 @@ public:
     if (Alignment)
       B.addAlignmentAttr(Alignment);
     B.addRawValue((EncodedAttrs & (0xfffULL << 32)) >> 11);
-    return Attributes::get(B);
+    return Attributes::get(C, B);
   }
 
   /// getAsString - The set of Attributes set in Attributes is converted to a
@@ -302,7 +295,7 @@ struct AttributeWithIndex {
                      ///< Index 0 is used for return value attributes.
                      ///< Index ~0U is used for function attributes.
 
-  static AttributeWithIndex get(unsigned Idx,
+  static AttributeWithIndex get(LLVMContext &C, unsigned Idx,
                                 ArrayRef<Attributes::AttrVal> Attrs) {
     Attributes::Builder B;
 
@@ -312,7 +305,7 @@ struct AttributeWithIndex {
 
     AttributeWithIndex P;
     P.Index = Idx;
-    P.Attrs = Attributes::get(B);
+    P.Attrs = Attributes::get(C, B);
     return P;
   }
   static AttributeWithIndex get(unsigned Idx, Attributes Attrs) {
@@ -351,7 +344,7 @@ public:
   /// addAttr - Add the specified attribute at the specified index to this
   /// attribute list.  Since attribute lists are immutable, this
   /// returns the new list.
-  AttrListPtr addAttr(unsigned Idx, Attributes Attrs) const;
+  AttrListPtr addAttr(LLVMContext &C, unsigned Idx, Attributes Attrs) const;
 
   /// removeAttr - Remove the specified attribute at the specified index from
   /// this attribute list.  Since attribute lists are immutable, this