From 278bac3fba5ae8ae620c961621493e6e2ad6f953 Mon Sep 17 00:00:00 2001 From: Bill Wendling Date: Wed, 2 Jan 2013 23:45:09 +0000 Subject: [PATCH] An intermediate step in the Attributes rewrite. Modify the AttrBuilder class to store the attributes as a set instead of as a bit mask. The Attribute class will represent only one attribute instead of a collection of attributes. This is the wave of the future! git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@171427 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/IR/Attributes.h | 68 ++++++++++++++++++++++++------------ lib/IR/Attributes.cpp | 21 ++++++++++- 2 files changed, 66 insertions(+), 23 deletions(-) diff --git a/include/llvm/IR/Attributes.h b/include/llvm/IR/Attributes.h index c28f0bd0907..19df4eb33a0 100644 --- a/include/llvm/IR/Attributes.h +++ b/include/llvm/IR/Attributes.h @@ -17,8 +17,7 @@ #define LLVM_ATTRIBUTES_H #include "llvm/ADT/ArrayRef.h" -#include "llvm/Support/MathExtras.h" -#include +#include "llvm/ADT/DenseSet.h" #include namespace llvm { @@ -152,6 +151,25 @@ public: std::string getAsString() const; }; +//===----------------------------------------------------------------------===// +/// \class +/// \brief Provide DenseMapInfo for Attribute::AttrKind. +template<> struct DenseMapInfo { + 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 @@ -159,58 +177,64 @@ public: /// value, however, is not. So this can be used as a quick way to test for /// equality, presence of attributes, etc. class AttrBuilder { - uint64_t Bits; + DenseSet AttrSet; + uint64_t Alignment; + uint64_t StackAlignment; + + uint64_t Bits; // FIXME: Remove after encoding the attr list in the bc file. public: - AttrBuilder() : Bits(0) {} + AttrBuilder() : Alignment(0), StackAlignment(0), Bits(0) {} explicit AttrBuilder(uint64_t B) : Bits(B) {} AttrBuilder(const Attribute &A) : Bits(A.getBitMask()) {} - void clear() { Bits = 0; } + /// \brief Clear out the builder's internals. + void clear(); - /// addAttribute - Add an attribute to the builder. + /// \brief Add an attribute to the builder. AttrBuilder &addAttribute(Attribute::AttrKind Val); - /// removeAttribute - Remove an attribute from the builder. + /// \brief Remove an attribute from the builder. AttrBuilder &removeAttribute(Attribute::AttrKind Val); - /// addAttribute - Add the attributes from A to the builder. + /// \brief Add the attributes from A to the builder. AttrBuilder &addAttributes(const Attribute &A); - /// removeAttribute - Remove the attributes from A from the builder. + /// \brief Remove the attributes from A from the builder. AttrBuilder &removeAttributes(const Attribute &A); /// \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. + /// \brief 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 + /// \brief Return true if the builder has any attribute that's in the /// specified attribute. bool hasAttributes(const Attribute &A) const; - /// hasAlignmentAttr - Return true if the builder has an alignment attribute. + /// \brief Return true if the builder has an alignment attribute. bool hasAlignmentAttr() const; - /// getAlignment - Retrieve the alignment attribute, if it exists. + /// \brief Retrieve the alignment attribute, if it exists. uint64_t getAlignment() const; - /// getStackAlignment - Retrieve the stack alignment attribute, if it exists. + /// \brief 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 Attribute. + /// \brief This turns an int alignment (which must be a power of 2) into the + /// form used internally in Attribute. AttrBuilder &addAlignmentAttr(unsigned Align); - /// addStackAlignmentAttr - This turns an int stack alignment (which must be a - /// power of 2) into the form used internally in Attribute. + /// \brief This turns an int stack alignment (which must be a power of 2) into + /// the form used internally in Attribute. AttrBuilder &addStackAlignmentAttr(unsigned Align); - /// addRawValue - Add the raw value to the internal representation. + /// \brief 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) @@ -236,10 +260,10 @@ public: uint64_t getBitMask() const { return Bits; } - bool operator==(const AttrBuilder &B) { + bool operator==(const AttrBuilder &B) const { return Bits == B.Bits; } - bool operator!=(const AttrBuilder &B) { + bool operator!=(const AttrBuilder &B) const { return Bits != B.Bits; } }; diff --git a/lib/IR/Attributes.cpp b/lib/IR/Attributes.cpp index 427134b00f6..2e0b084ab59 100644 --- a/lib/IR/Attributes.cpp +++ b/lib/IR/Attributes.cpp @@ -233,8 +233,15 @@ std::string Attribute::getAsString() const { // AttrBuilder Implementation //===----------------------------------------------------------------------===// +void AttrBuilder::clear() { + AttrSet.clear(); + Alignment = StackAlignment = Bits = 0; +} + AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val){ Bits |= AttributeImpl::getAttrMask(Val); + + AttrSet.insert(Val); return *this; } @@ -248,19 +255,31 @@ AttrBuilder &AttrBuilder::addAlignmentAttr(unsigned Align) { assert(isPowerOf2_32(Align) && "Alignment must be a power of two."); assert(Align <= 0x40000000 && "Alignment too large."); Bits |= (Log2_32(Align) + 1) << 16; + + AttrSet.insert(Attribute::Alignment); + Alignment = Align; return *this; } -AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned Align){ +AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned Align) { // Default alignment, allow the target to define how to align it. if (Align == 0) return *this; assert(isPowerOf2_32(Align) && "Alignment must be a power of two."); assert(Align <= 0x100 && "Alignment too large."); Bits |= (Log2_32(Align) + 1) << 26; + + AttrSet.insert(Attribute::StackAlignment); + StackAlignment = Align; return *this; } AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) { Bits &= ~AttributeImpl::getAttrMask(Val); + + AttrSet.erase(Val); + if (Val == Attribute::Alignment) + Alignment = 0; + else if (Val == Attribute::StackAlignment) + StackAlignment = 0; return *this; } -- 2.34.1