From ec454546ecc78d3c60e7395b5fbdb0c6b74c6fc9 Mon Sep 17 00:00:00 2001 From: Bill Wendling Date: Mon, 28 Jan 2013 21:55:20 +0000 Subject: [PATCH] Remove the AttributeWithIndex class. The AttributeWithIndex class exposed the interior structure of the AttributeSet class. That was gross. Remove it and all of the code that relied upon it. llvm-svn: 173722 --- llvm/include/llvm/IR/Attributes.h | 31 ++++---- llvm/lib/IR/AttributeImpl.h | 19 ++--- llvm/lib/IR/Attributes.cpp | 146 ++++++++++++++++++-------------------- 3 files changed, 85 insertions(+), 111 deletions(-) diff --git a/llvm/include/llvm/IR/Attributes.h b/llvm/include/llvm/IR/Attributes.h index e6de2bf..46a4444 100644 --- a/llvm/include/llvm/IR/Attributes.h +++ b/llvm/include/llvm/IR/Attributes.h @@ -177,22 +177,7 @@ template<> struct DenseMapInfo { class AttrBuilder; class AttributeSetImpl; - -//===----------------------------------------------------------------------===// -/// \class -/// \brief This is just a pair of values to associate a set of attributes with -/// an index. -struct AttributeWithIndex { - Attribute Attrs; ///< The attributes that are set, or'd together. - unsigned Index; ///< Index of the parameter for which the attributes apply. - - static AttributeWithIndex get(unsigned Idx, Attribute Attrs) { - AttributeWithIndex P; - P.Index = Idx; - P.Attrs = Attrs; - return P; - } -}; +class AttributeSetNode; //===----------------------------------------------------------------------===// /// \class @@ -216,9 +201,17 @@ private: /// for the result are denoted with Idx = 0. Attribute getAttributes(unsigned Idx) const; - /// \brief Create an AttributeSet from the AttributeWithIndex structures. - /// N.B. this is only temporary. It will be disappearing in the future. - static AttributeSet get(LLVMContext &C, ArrayRef Attrs); + /// \brief Create an AttributeSet with the specified parameters in it. + static AttributeSet get(LLVMContext &C, + ArrayRef > Attrs); + static AttributeSet get(LLVMContext &C, + ArrayRef > Attrs); + + static AttributeSet getImpl(LLVMContext &C, + ArrayRef > Attrs); + explicit AttributeSet(AttributeSetImpl *LI) : pImpl(LI) {} public: diff --git a/llvm/lib/IR/AttributeImpl.h b/llvm/lib/IR/AttributeImpl.h index 8d5de77..457b6ab 100644 --- a/llvm/lib/IR/AttributeImpl.h +++ b/llvm/lib/IR/AttributeImpl.h @@ -115,7 +115,6 @@ class AttributeSetImpl : public FoldingSetNode { friend class AttributeSet; LLVMContext &Context; - SmallVector AttrList; typedef std::pair IndexAttrPair; SmallVector AttrNodes; @@ -124,13 +123,13 @@ class AttributeSetImpl : public FoldingSetNode { void operator=(const AttributeSetImpl &) LLVM_DELETED_FUNCTION; AttributeSetImpl(const AttributeSetImpl &) LLVM_DELETED_FUNCTION; public: - AttributeSetImpl(LLVMContext &C, ArrayRef attrs); + AttributeSetImpl(LLVMContext &C, + ArrayRef > attrs) + : Context(C), AttrNodes(attrs.begin(), attrs.end()) {} /// \brief Get the context that created this AttributeSetImpl. LLVMContext &getContext() { return Context; } - ArrayRef getAttributes() const { return AttrList; } - /// \brief Return the number of attributes this AttributeSet contains. unsigned getNumAttributes() const { return AttrNodes.size(); } @@ -147,7 +146,7 @@ public: /// parameter/ function which the attributes apply to. AttributeSet getSlotAttributes(unsigned Slot) const { // FIXME: This needs to use AttrNodes instead. - return AttributeSet::get(Context, AttrList[Slot]); + return AttributeSet::get(Context, AttrNodes[Slot]); } typedef AttributeSetNode::iterator iterator; @@ -164,16 +163,8 @@ public: { return AttrNodes[Idx].second->end(); } void Profile(FoldingSetNodeID &ID) const { - Profile(ID, AttrList); - } - static void Profile(FoldingSetNodeID &ID, - ArrayRef AttrList) { - for (unsigned i = 0, e = AttrList.size(); i != e; ++i) { - ID.AddInteger(AttrList[i].Index); - ID.AddInteger(AttrList[i].Attrs.Raw()); - } + Profile(ID, AttrNodes); } - static void Profile(FoldingSetNodeID &ID, ArrayRef > Nodes) { for (unsigned i = 0, e = Nodes.size(); i != e; ++i) { diff --git a/llvm/lib/IR/Attributes.cpp b/llvm/lib/IR/Attributes.cpp index 3f0038b..1ac66d5 100644 --- a/llvm/lib/IR/Attributes.cpp +++ b/llvm/lib/IR/Attributes.cpp @@ -1,4 +1,4 @@ -//===-- Attribute.cpp - Implement AttributesList -------------------------===// +//===-- Attributes.cpp - Implement AttributesList -------------------------===// // // The LLVM Compiler Infrastructure // @@ -7,7 +7,8 @@ // //===----------------------------------------------------------------------===// // -// This file implements the Attribute, AttributeImpl, AttrBuilder, +// \file +// \brief This file implements the Attribute, AttributeImpl, AttrBuilder, // AttributeSetImpl, and AttributeSet classes. // //===----------------------------------------------------------------------===// @@ -540,44 +541,6 @@ AttributeSetNode *AttributeSetNode::get(LLVMContext &C, // AttributeSetImpl Definition //===----------------------------------------------------------------------===// -AttributeSetImpl:: -AttributeSetImpl(LLVMContext &C, - ArrayRef attrs) - : Context(C), AttrList(attrs.begin(), attrs.end()) { - for (unsigned I = 0, E = attrs.size(); I != E; ++I) { - const AttributeWithIndex &AWI = attrs[I]; - uint64_t Mask = AWI.Attrs.Raw(); - SmallVector Attrs; - - for (Attribute::AttrKind II = Attribute::None; - II != Attribute::EndAttrKinds; II = Attribute::AttrKind(II + 1)) { - if (uint64_t A = (Mask & AttributeImpl::getAttrMask(II))) { - AttrBuilder B; - - if (II == Attribute::Alignment) - B.addAlignmentAttr(1ULL << ((A >> 16) - 1)); - else if (II == Attribute::StackAlignment) - B.addStackAlignmentAttr(1ULL << ((A >> 26) - 1)); - else - B.addAttribute(II); - - Attrs.push_back(Attribute::get(C, B)); - } - } - - AttrNodes.push_back(std::make_pair(AWI.Index, - AttributeSetNode::get(C, Attrs))); - } - - assert(AttrNodes.size() == AttrList.size() && - "Number of attributes is different between lists!"); -#ifndef NDEBUG - for (unsigned I = 0, E = AttrNodes.size(); I != E; ++I) - assert((I == 0 || AttrNodes[I - 1].first < AttrNodes[I].first) && - "Attributes not in ascending order!"); -#endif -} - uint64_t AttributeSetImpl::Raw(uint64_t Index) const { for (unsigned I = 0, E = getNumAttributes(); I != E; ++I) { if (getSlotIndex(I) != Index) continue; @@ -587,9 +550,6 @@ uint64_t AttributeSetImpl::Raw(uint64_t Index) const { for (AttributeSetNode::const_iterator II = ASN->begin(), IE = ASN->end(); II != IE; ++II) B.addAttributes(*II); - - assert(B.Raw() == AttrList[I].Attrs.Raw() && - "Attributes aren't the same!"); return B.Raw(); } @@ -604,7 +564,8 @@ AttributeSet AttributeSet::getParamAttributes(unsigned Idx) const { // FIXME: Remove. return pImpl && hasAttributes(Idx) ? AttributeSet::get(pImpl->getContext(), - AttributeWithIndex::get(Idx, getAttributes(Idx))) : + ArrayRef >( + std::make_pair(Idx, getAttributes(Idx)))) : AttributeSet(); } @@ -612,8 +573,9 @@ AttributeSet AttributeSet::getRetAttributes() const { // FIXME: Remove. return pImpl && hasAttributes(ReturnIndex) ? AttributeSet::get(pImpl->getContext(), - AttributeWithIndex::get(ReturnIndex, - getAttributes(ReturnIndex))) : + ArrayRef >( + std::make_pair(ReturnIndex, + getAttributes(ReturnIndex)))) : AttributeSet(); } @@ -621,27 +583,15 @@ AttributeSet AttributeSet::getFnAttributes() const { // FIXME: Remove. return pImpl && hasAttributes(FunctionIndex) ? AttributeSet::get(pImpl->getContext(), - AttributeWithIndex::get(FunctionIndex, - getAttributes(FunctionIndex))) : + ArrayRef >( + std::make_pair(FunctionIndex, + getAttributes(FunctionIndex)))) : AttributeSet(); } -AttributeSet AttributeSet::get(LLVMContext &C, - ArrayRef Attrs) { - // If there are no attributes then return a null AttributesList pointer. - if (Attrs.empty()) - return AttributeSet(); - -#ifndef NDEBUG - for (unsigned i = 0, e = Attrs.size(); i != e; ++i) { - assert(Attrs[i].Attrs.hasAttributes() && - "Pointless attribute!"); - assert((!i || Attrs[i-1].Index < Attrs[i].Index) && - "Misordered AttributesList!"); - } -#endif - - // Otherwise, build a key to look up the existing attributes. +AttributeSet AttributeSet::getImpl(LLVMContext &C, + ArrayRef > Attrs) { LLVMContextImpl *pImpl = C.pImpl; FoldingSetNodeID ID; AttributeSetImpl::Profile(ID, Attrs); @@ -660,35 +610,75 @@ AttributeSet AttributeSet::get(LLVMContext &C, return AttributeSet(PA); } +AttributeSet AttributeSet::get(LLVMContext &C, + ArrayRef > Attrs){ + // If there are no attributes then return a null AttributesList pointer. + if (Attrs.empty()) + return AttributeSet(); + +#ifndef NDEBUG + for (unsigned i = 0, e = Attrs.size(); i != e; ++i) { + assert((!i || Attrs[i-1].first <= Attrs[i].first) && + "Misordered Attributes list!"); + assert(Attrs[i].second.hasAttributes() && + "Pointless attribute!"); + } +#endif + + // Create a vector if (uint64_t, AttributeSetNode*) pairs from the attributes + // list. + SmallVector, 8> AttrPairVec; + for (ArrayRef >::iterator I = Attrs.begin(), + E = Attrs.end(); I != E; ) { + uint64_t Index = I->first; + SmallVector AttrVec; + while (I->first == Index && I != E) { + AttrVec.push_back(I->second); + ++I; + } + + AttrPairVec.push_back(std::make_pair(Index, + AttributeSetNode::get(C, AttrVec))); + } + + return getImpl(C, AttrPairVec); +} + +AttributeSet AttributeSet::get(LLVMContext &C, + ArrayRef > Attrs) { + // If there are no attributes then return a null AttributesList pointer. + if (Attrs.empty()) + return AttributeSet(); + + return getImpl(C, Attrs); +} + AttributeSet AttributeSet::get(LLVMContext &C, unsigned Idx, AttrBuilder &B) { - // FIXME: This should be implemented as a loop that creates the - // AttributeWithIndexes that then are used to create the AttributeSet. if (!B.hasAttributes()) return AttributeSet(); - return get(C, AttributeWithIndex::get(Idx, Attribute::get(C, B))); + return get(C, ArrayRef >( + std::make_pair(Idx, Attribute::get(C, B)))); } AttributeSet AttributeSet::get(LLVMContext &C, unsigned Idx, ArrayRef Kind) { - // FIXME: This is temporary. Ultimately, the AttributeWithIndex will be - // replaced by an object that holds multiple Attribute::AttrKinds. - AttrBuilder B; + SmallVector, 8> Attrs; for (ArrayRef::iterator I = Kind.begin(), E = Kind.end(); I != E; ++I) - B.addAttribute(*I); - return get(C, Idx, B); + Attrs.push_back(std::make_pair(Idx, Attribute::get(C, *I))); + return get(C, Attrs); } AttributeSet AttributeSet::get(LLVMContext &C, ArrayRef Attrs) { - SmallVector AttrList; - for (ArrayRef::iterator I = Attrs.begin(), E = Attrs.end(); - I != E; ++I) { - AttributeSet AS = *I; + SmallVector, 8> AttrNodeVec; + for (unsigned I = 0, E = Attrs.size(); I != E; ++I) { + AttributeSet AS = Attrs[I]; if (!AS.pImpl) continue; - AttrList.append(AS.pImpl->AttrList.begin(), AS.pImpl->AttrList.end()); + AttrNodeVec.append(AS.pImpl->AttrNodes.begin(), AS.pImpl->AttrNodes.end()); } - return get(C, AttrList); + return get(C, AttrNodeVec); } /// \brief Return the number of slots used in this attribute list. This is the -- 2.7.4