diff --git a/include/llvm/Support/CFG.h b/include/llvm/Support/CFG.h index badb846bac3..231531a7ae7 100644 --- a/include/llvm/Support/CFG.h +++ b/include/llvm/Support/CFG.h @@ -27,22 +27,22 @@ namespace llvm { //===--------------------------------------------------------------------===// template // Predecessor Iterator -class PredIterator : public bidirectional_iterator<_Ptr, ptrdiff_t> { - typedef bidirectional_iterator<_Ptr, ptrdiff_t> super; +class PredIterator : public forward_iterator<_Ptr, ptrdiff_t> { + typedef forward_iterator<_Ptr, ptrdiff_t> super; _Ptr *BB; _USE_iterator It; public: typedef PredIterator<_Ptr,_USE_iterator> _Self; typedef typename super::pointer pointer; - inline void advancePastConstants() { + inline void advancePastNonTerminators() { // Loop to ignore non terminator uses (for example PHI nodes)... while (It != BB->use_end() && !isa(*It)) ++It; } inline PredIterator(_Ptr *bb) : BB(bb), It(bb->use_begin()) { - advancePastConstants(); + advancePastNonTerminators(); } inline PredIterator(_Ptr *bb, bool) : BB(bb), It(bb->use_end()) {} @@ -57,18 +57,13 @@ public: inline _Self& operator++() { // Preincrement assert(It != BB->use_end() && "pred_iterator out of range!"); - ++It; advancePastConstants(); + ++It; advancePastNonTerminators(); return *this; } inline _Self operator++(int) { // Postincrement _Self tmp = *this; ++*this; return tmp; } - - inline _Self& operator--() { --It; return *this; } // Predecrement - inline _Self operator--(int) { // Postdecrement - _Self tmp = *this; --*this; return tmp; - } }; typedef PredIterator pred_iterator; diff --git a/include/llvm/Use.h b/include/llvm/Use.h index 26923a26dad..bbf523574cd 100644 --- a/include/llvm/Use.h +++ b/include/llvm/Use.h @@ -16,11 +16,11 @@ #ifndef LLVM_USE_H #define LLVM_USE_H -#include "llvm/ADT/ilist" +#include "llvm/Support/Casting.h" +#include "llvm/ADT/iterator" namespace llvm { -template struct ilist_traits; class Value; class User; @@ -62,43 +62,28 @@ public: Value *operator->() { return Val; } const Value *operator->() const { return Val; } + Use *getNext() const { return Next; } private: - // NOTE!! The Next/Prev fields MUST stay at the start of this structure. The - // end-token for the ilist is allocated as JUST the next/prev pair to reduce - // memory usage instead of allocating an entire Use. - struct NextPrevPtrs { - Use *Next, *Prev; - } UseLinks; - + Use *Next, **Prev; Value *Val; User *U; - friend struct ilist_traits; + + void addToList(Use **List) { + Next = *List; + if (Next) Next->Prev = &Next; + Prev = List; + *List = this; + } + void removeFromList() { + *Prev = Next; + if (Next) Next->Prev = Prev; + } + + friend class Value; }; -template<> -struct ilist_traits { - static Use *getPrev(Use *N) { return N->UseLinks.Prev; } - static Use *getNext(Use *N) { return N->UseLinks.Next; } - static const Use *getPrev(const Use *N) { return N->UseLinks.Prev; } - static const Use *getNext(const Use *N) { return N->UseLinks.Next; } - static void setPrev(Use *N, Use *Prev) { N->UseLinks.Prev = Prev; } - static void setNext(Use *N, Use *Next) { N->UseLinks.Next = Next; } - - /// createSentinel - this is used to create the end marker for the use list. - /// Note that we only allocate a UseLinks structure, which is just enough to - /// hold the next/prev pointers. This saves us 8 bytes of memory for every - /// Value allocated. - static Use *createSentinel() { return (Use*)new Use::NextPrevPtrs(); } - static void destroySentinel(Use *S) { delete (Use::NextPrevPtrs*)S; } - - void addNodeToList(Use *NTy) {} - void removeNodeFromList(Use *NTy) {} - void transferNodesFromList(iplist &L2, - ilist_iterator first, - ilist_iterator last) {} -}; - - +// simplify_type - Allow clients to treat uses just like values when using +// casting operators. template<> struct simplify_type { typedef Value* SimpleType; static SimpleType getSimplifiedValue(const Use &Val) { @@ -112,64 +97,49 @@ template<> struct simplify_type { } }; -struct UseListIteratorWrapper : public iplist::iterator { - typedef iplist::iterator Super; - UseListIteratorWrapper() {} - UseListIteratorWrapper(const Super &RHS) : Super(RHS) {} - UseListIteratorWrapper &operator=(const Super &RHS) { - Super::operator=(RHS); - return *this; + +template // UserTy == 'User' or 'const User' +class value_use_iterator : public forward_iterator { + typedef forward_iterator super; + typedef value_use_iterator _Self; + + Use *U; + value_use_iterator(Use *u) : U(u) {} + friend class Value; +public: + typedef typename super::reference reference; + typedef typename super::pointer pointer; + + value_use_iterator(const _Self &I) : U(I.U) {} + value_use_iterator() {} + + bool operator==(const _Self &x) const { + return U == x.U; + } + bool operator!=(const _Self &x) const { + return !operator==(x); } - inline User *operator*() const; - User *operator->() const { return operator*(); } - - UseListIteratorWrapper operator--() { return Super::operator--(); } - UseListIteratorWrapper operator++() { return Super::operator++(); } - - UseListIteratorWrapper operator--(int) { // postdecrement operators... - UseListIteratorWrapper tmp = *this; - --*this; - return tmp; + // Iterator traversal: forward iteration only + _Self &operator++() { // Preincrement + assert(U && "Cannot increment end iterator!"); + U = U->getNext(); + return *this; } - UseListIteratorWrapper operator++(int) { // postincrement operators... - UseListIteratorWrapper tmp = *this; - ++*this; - return tmp; - } -}; - -struct UseListConstIteratorWrapper : public iplist::const_iterator { - typedef iplist::const_iterator Super; - UseListConstIteratorWrapper() {} - UseListConstIteratorWrapper(const Super &RHS) : Super(RHS) {} - - // Allow conversion from non-const to const iterators - UseListConstIteratorWrapper(const UseListIteratorWrapper &RHS) : Super(RHS) {} - UseListConstIteratorWrapper(const iplist::iterator &RHS) : Super(RHS) {} - - UseListConstIteratorWrapper &operator=(const Super &RHS) { - Super::operator=(RHS); - return *this; + _Self operator++(int) { // Postincrement + _Self tmp = *this; ++*this; return tmp; } - inline const User *operator*() const; - const User *operator->() const { return operator*(); } - - UseListConstIteratorWrapper operator--() { return Super::operator--(); } - UseListConstIteratorWrapper operator++() { return Super::operator++(); } - - UseListConstIteratorWrapper operator--(int) { // postdecrement operators... - UseListConstIteratorWrapper tmp = *this; - --*this; - return tmp; - } - UseListConstIteratorWrapper operator++(int) { // postincrement operators... - UseListConstIteratorWrapper tmp = *this; - ++*this; - return tmp; + // Retrieve a reference to the current SCC + UserTy *operator*() const { + assert(U && "Cannot increment end iterator!"); + return U->getUser(); } + + UserTy *operator->() const { return operator*(); } + + Use &getUse() const { return *U; } }; } // End llvm namespace diff --git a/include/llvm/Value.h b/include/llvm/Value.h index 90bbe6fe91c..46257cc7a34 100644 --- a/include/llvm/Value.h +++ b/include/llvm/Value.h @@ -43,7 +43,7 @@ class SymbolTable; class Value { unsigned SubclassID; // Subclass identifier (for isa/dyn_cast) PATypeHolder Ty; - iplist Uses; + Use *UseList; std::string Name; void operator=(const Value &); // Do not implement @@ -86,33 +86,39 @@ public: //---------------------------------------------------------------------- // Methods for handling the vector of uses of this Value. // - typedef UseListIteratorWrapper use_iterator; - typedef UseListConstIteratorWrapper use_const_iterator; - typedef iplist::size_type size_type; + typedef value_use_iterator use_iterator; + typedef value_use_iterator use_const_iterator; - size_type use_size() const { return Uses.size(); } - bool use_empty() const { return Uses.empty(); } - use_iterator use_begin() { return Uses.begin(); } - use_const_iterator use_begin() const { return Uses.begin(); } - use_iterator use_end() { return Uses.end(); } - use_const_iterator use_end() const { return Uses.end(); } - User *use_back() { return Uses.back().getUser(); } - const User *use_back() const { return Uses.back().getUser(); } + bool use_empty() const { return UseList == 0; } + use_iterator use_begin() { return use_iterator(UseList); } + use_const_iterator use_begin() const { return use_const_iterator(UseList); } + use_iterator use_end() { return use_iterator(0); } + use_const_iterator use_end() const { return use_const_iterator(0); } + User *use_back() { return *use_begin(); } + const User *use_back() const { return *use_begin(); } /// hasOneUse - Return true if there is exactly one user of this value. This /// is specialized because it is a common request and does not require /// traversing the whole use list. /// bool hasOneUse() const { - iplist::const_iterator I = Uses.begin(), E = Uses.end(); + use_const_iterator I = use_begin(), E = use_end(); if (I == E) return false; return ++I == E; } + /// hasNUses - Return true if this Value has exactly N users. + /// + bool hasNUses(unsigned N) const; + + /// getNumUses - This method computes the number of uses of this Value. This + /// is a linear time operation. Use hasOneUse or hasNUses to check for + /// specific values. + unsigned getNumUses() const; + /// addUse/killUse - These two methods should only be used by the Use class. /// - void addUse(Use &U) { Uses.push_back(&U); } - void killUse(Use &U) { Uses.remove(&U); } + void addUse(Use &U) { U.addToList(&UseList); } /// getValueType - Return an ID for the concrete type of this object. This is /// used to implement the classof checks. This should not be used for any @@ -157,16 +163,6 @@ inline std::ostream &operator<<(std::ostream &OS, const Value &V) { return OS; } - -inline User *UseListIteratorWrapper::operator*() const { - return Super::operator*().getUser(); -} - -inline const User *UseListConstIteratorWrapper::operator*() const { - return Super::operator*().getUser(); -} - - void Use::init(Value *v, User *user) { Val = v; U = user; @@ -174,11 +170,11 @@ void Use::init(Value *v, User *user) { } Use::~Use() { - if (Val) Val->killUse(*this); + if (Val) removeFromList(); } void Use::set(Value *V) { - if (Val) Val->killUse(*this); + if (Val) removeFromList(); Val = V; if (V) V->addUse(*this); }