Try again to revert the bad patch. The tree was reverted for some unknown reason

before the last time.

--- Reverse-merging r171442 into '.':
U    include/llvm/IR/Attributes.h
U    lib/IR/Attributes.cpp
U    lib/IR/AttributeImpl.h

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@171448 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/IR/Attributes.h b/include/llvm/IR/Attributes.h
index 434b6932d64ff7fc60ff8952a504d63559922877..c28f0bd09075de6a5c97f29c25792905e8782129 100644 (file)
--- a/include/llvm/IR/Attributes.h
+++ b/include/llvm/IR/Attributes.h
@@ -17,7 +17,8 @@
 #define LLVM_ATTRIBUTES_H
 
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/DenseSet.h"
+#include "llvm/Support/MathExtras.h"
+#include <cassert>
 #include <string>
 
 namespace llvm {
@@ -151,25 +152,6 @@ public:
   std::string getAsString() const;
 };
 
-//===----------------------------------------------------------------------===//
-/// \class
-/// \brief Provide DenseMapInfo for Attribute::AttrKind.
-template<> struct DenseMapInfo<Attribute::AttrKind> {
-  static inline Attribute::AttrKind getEmptyKey() {
-    return Attribute::AttrKind(-1);
-  }
-  static inline Attribute::AttrKind getTombstoneKey() {
-    return Attribute::AttrKind(~0UL - 1L);
-  }
-  static unsigned getHashValue(const Attribute::AttrKind &Val) {
-    return (unsigned)(Val * 37UL);
-  }
-  static bool isEqual(const Attribute::AttrKind &LHS,
-                      const Attribute::AttrKind &RHS) {
-    return LHS == RHS;
-  }
-};
-
 //===----------------------------------------------------------------------===//
 /// \class
 /// \brief This class is used in conjunction with the Attribute::get method to
@@ -177,61 +159,58 @@ template<> struct DenseMapInfo<Attribute::AttrKind> {
 /// value, however, is not. So this can be used as a quick way to test for
 /// equality, presence of attributes, etc.
 class AttrBuilder {
-  DenseSet<Attribute::AttrKind> AttrSet;
-  uint64_t Alignment;
-  uint64_t StackAlignment;
-
-  uint64_t Bits;  // FIXME: Remove after encoding the attr list in the bc file.
+  uint64_t Bits;
 public:
-  AttrBuilder() : Alignment(0), StackAlignment(0), Bits(0) {}
+  AttrBuilder() : Bits(0) {}
   explicit AttrBuilder(uint64_t B) : Bits(B) {}
   AttrBuilder(const Attribute &A) : Bits(A.getBitMask()) {}
 
-  /// \brief Clear out the builder's internals.
-  void clear();
+  void clear() { Bits = 0; }
 
-  /// \brief Add an attribute to the builder.
+  /// addAttribute - Add an attribute to the builder.
   AttrBuilder &addAttribute(Attribute::AttrKind Val);
 
-  /// \brief Remove an attribute from the builder.
+  /// removeAttribute - Remove an attribute from the builder.
   AttrBuilder &removeAttribute(Attribute::AttrKind Val);
 
-  /// \brief Add the attributes from A to the builder.
+  /// addAttribute - Add the attributes from A to the builder.
   AttrBuilder &addAttributes(const Attribute &A);
 
-  /// \brief Remove the attributes from A from the builder.
+  /// removeAttribute - Remove the attributes from A from the builder.
   AttrBuilder &removeAttributes(const Attribute &A);
 
-  /// \brief Return true if the builder has IR-level attributes.
+  /// \brief Return true if the builder has the specified attribute.
+  bool contains(Attribute::AttrKind A) const;
+
+  /// hasAttributes - Return true if the builder has IR-level attributes.
   bool hasAttributes() const;
 
-  /// \brief Return true if the builder has any attribute that's in the
+  /// hasAttributes - Return true if the builder has any attribute that's in the
   /// specified attribute.
   bool hasAttributes(const Attribute &A) const;
 
-  /// \brief Return true if the builder has an alignment attribute.
+  /// hasAlignmentAttr - Return true if the builder has an alignment attribute.
   bool hasAlignmentAttr() const;
 
-  /// \brief Retrieve the alignment attribute, if it exists.
+  /// getAlignment - Retrieve the alignment attribute, if it exists.
   uint64_t getAlignment() const;
 
-  /// \brief Retrieve the stack alignment attribute, if it exists.
+  /// getStackAlignment - Retrieve the stack alignment attribute, if it exists.
   uint64_t getStackAlignment() const;
 
-  /// \brief This turns an int alignment (which must be a power of 2) into the
-  /// form used internally in Attribute.
+  /// addAlignmentAttr - This turns an int alignment (which must be a power of
+  /// 2) into the form used internally in Attribute.
   AttrBuilder &addAlignmentAttr(unsigned Align);
 
-  /// \brief This turns an int stack alignment (which must be a power of 2) into
-  /// the form used internally in Attribute.
+  /// addStackAlignmentAttr - This turns an int stack alignment (which must be a
+  /// power of 2) into the form used internally in Attribute.
   AttrBuilder &addStackAlignmentAttr(unsigned Align);
 
-  /// \brief Add the raw value to the internal representation.
-  /// 
+  /// addRawValue - Add the raw value to the internal representation.
   /// N.B. This should be used ONLY for decoding LLVM bitcode!
   AttrBuilder &addRawValue(uint64_t Val);
 
-  /// \brief Remove attributes that are used on functions only.
+  /// @brief Remove attributes that are used on functions only.
   void removeFunctionOnlyAttrs() {
     removeAttribute(Attribute::NoReturn)
       .removeAttribute(Attribute::NoUnwind)
@@ -257,15 +236,12 @@ public:
 
   uint64_t getBitMask() const { return Bits; }
 
-  bool operator==(const AttrBuilder &B) const {
+  bool operator==(const AttrBuilder &B) {
     return Bits == B.Bits;
   }
-  bool operator!=(const AttrBuilder &B) const {
+  bool operator!=(const AttrBuilder &B) {
     return Bits != B.Bits;
   }
-
-  bool operator==(Attribute::AttrKind A) const;
-  bool operator!=(Attribute::AttrKind A) const;
 };
 
 //===----------------------------------------------------------------------===//

diff --git a/lib/IR/AttributeImpl.h b/lib/IR/AttributeImpl.h
index 015bb9df3e6fc529442c36ab6e057387532e9c1c..2633608926fbc5b3bdbb75a770f99fdfe1f34370 100644 (file)
--- a/lib/IR/AttributeImpl.h
+++ b/lib/IR/AttributeImpl.h
@@ -42,6 +42,9 @@ public:
     return Vals;
   }
 
+  bool contains(Attribute::AttrKind Kind) const;
+  bool contains(StringRef Kind) const;
+
   bool hasAttribute(Attribute::AttrKind A) const;
 
   bool hasAttributes() const;
@@ -50,11 +53,19 @@ public:
   uint64_t getAlignment() const;
   uint64_t getStackAlignment() const;
 
-  bool operator==(Attribute::AttrKind Kind) const;
-  bool operator!=(Attribute::AttrKind Kind) const;
+  bool operator==(Attribute::AttrKind Kind) const {
+    return contains(Kind);
+  }
+  bool operator!=(Attribute::AttrKind Kind) const {
+    return !contains(Kind);
+  }
 
-  bool operator==(StringRef Kind) const;
-  bool operator!=(StringRef Kind) const;
+  bool operator==(StringRef Kind) const {
+    return contains(Kind);
+  }
+  bool operator!=(StringRef Kind) const {
+    return !contains(Kind);
+  }
 
   uint64_t getBitMask() const;         // FIXME: Remove.
 

diff --git a/lib/IR/Attributes.cpp b/lib/IR/Attributes.cpp
index e6a5327b5fa499ff0354c8c170f9e73cf16cfd06..b847d768f3a3f7ad07cdec280194b776508f5f91 100644 (file)
--- a/lib/IR/Attributes.cpp
+++ b/lib/IR/Attributes.cpp
@@ -89,11 +89,11 @@ unsigned Attribute::getStackAlignment() const {
 }
 
 bool Attribute::operator==(AttrKind K) const {
-  return pImpl && *pImpl == K;
+  return pImpl && pImpl->contains(K);
 }
 
 bool Attribute::operator!=(AttrKind K) const {
-  return !(pImpl && *pImpl == K);
+  return !(pImpl && pImpl->contains(K));
 }
 
 uint64_t Attribute::getBitMask() const {
@@ -293,14 +293,10 @@ AttrBuilder &AttrBuilder::removeAttributes(const Attribute &A){
   return *this;
 }
 
-bool AttrBuilder::operator==(Attribute::AttrKind A) const {
+bool AttrBuilder::contains(Attribute::AttrKind A) const {
   return Bits & AttributeImpl::getAttrMask(A);
 }
 
-bool AttrBuilder::operator!=(Attribute::AttrKind A) const {
-  return !(*this == A);
-}
-
 bool AttrBuilder::hasAttributes() const {
   return Bits != 0;
 }
@@ -345,24 +341,18 @@ AttributeImpl::AttributeImpl(LLVMContext &C, StringRef data) {
   Data = ConstantDataArray::getString(C, data);
 }
 
-bool AttributeImpl::operator==(Attribute::AttrKind Kind) const {
+bool AttributeImpl::contains(Attribute::AttrKind Kind) const {
   if (ConstantInt *CI = dyn_cast<ConstantInt>(Data))
     return CI->getZExtValue() == Kind;
   return false;
 }
-bool AttributeImpl::operator!=(Attribute::AttrKind Kind) const {
-  return !(*this == Kind);
-}
 
-bool AttributeImpl::operator==(StringRef Kind) const {
+bool AttributeImpl::contains(StringRef Kind) const {
   if (ConstantDataArray *CDA = dyn_cast<ConstantDataArray>(Data))
     if (CDA->isString())
       return CDA->getAsString() == Kind;
   return false;
 }
-bool AttributeImpl::operator!=(StringRef Kind) const {
-  return !(*this == Kind);
-}
 
 uint64_t AttributeImpl::getBitMask() const {
   // FIXME: Remove this.