diff options
| -rw-r--r-- | include/llvm/BasicBlock.h | 153 |
1 files changed, 0 insertions, 153 deletions
diff --git a/include/llvm/BasicBlock.h b/include/llvm/BasicBlock.h index 5230e87d8d..0828e0777c 100644 --- a/include/llvm/BasicBlock.h +++ b/include/llvm/BasicBlock.h @@ -24,8 +24,6 @@ #include "llvm/Value.h" // Get the definition of Value #include "llvm/ValueHolder.h" -#include "llvm/InstrTypes.h" -#include <list> class Instruction; class Method; @@ -93,157 +91,6 @@ public: // the basic block). // BasicBlock *splitBasicBlock(InstListType::iterator I); - - //===--------------------------------------------------------------------===// - // Predecessor iterator code - //===--------------------------------------------------------------------===// - // - // This is used to figure out what basic blocks we could be coming from. - // - - // Forward declare iterator class template... - template <class _Ptr, class _USE_iterator> class PredIterator; - - typedef PredIterator<BasicBlock*, use_iterator> pred_iterator; - typedef PredIterator<const BasicBlock*, - use_const_iterator> pred_const_iterator; - - inline pred_iterator pred_begin() ; - inline pred_const_iterator pred_begin() const; - inline pred_iterator pred_end() ; - inline pred_const_iterator pred_end() const; - - //===--------------------------------------------------------------------===// - // Successor iterator code - //===--------------------------------------------------------------------===// - // - // This is used to figure out what basic blocks we could be going to... - // - - // Forward declare iterator class template... - template <class _Term, class _BB> class SuccIterator; - - typedef SuccIterator<TerminatorInst*, BasicBlock*> succ_iterator; - typedef SuccIterator<const TerminatorInst*, - const BasicBlock*> succ_const_iterator; - - inline succ_iterator succ_begin() ; - inline succ_const_iterator succ_begin() const; - inline succ_iterator succ_end() ; - inline succ_const_iterator succ_end() const; - - //===--------------------------------------------------------------------===// - // END of interesting code... - //===--------------------------------------------------------------------===// - // - // Thank god C++ compilers are good at stomping out tons of templated code... - // - template <class _Ptr, class _USE_iterator> // Predecessor Iterator - class PredIterator { - const _Ptr ThisBB; - _USE_iterator It; - public: - typedef PredIterator<_Ptr,_USE_iterator> _Self; - - typedef bidirectional_iterator_tag iterator_category; - typedef _Ptr pointer; - - inline void advancePastConstPool() { - // Loop to ignore constant pool references - while (It != ThisBB->use_end() && - ((*It)->getValueType() != Value::InstructionVal)) - ++It; - } - - inline PredIterator(_Ptr BB) : ThisBB(BB), It(BB->use_begin()) { - advancePastConstPool(); - } - inline PredIterator(_Ptr BB, bool) : ThisBB(BB), It(BB->use_end()) {} - - inline bool operator==(const _Self& x) const { return It == x.It; } - inline bool operator!=(const _Self& x) const { return !operator==(x); } - - inline pointer operator*() const { - assert ((*It)->getValueType() == Value::InstructionVal); - return ((Instruction *)(*It))->getParent(); - } - inline pointer *operator->() const { return &(operator*()); } - - inline _Self& operator++() { // Preincrement - ++It; advancePastConstPool(); - 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; - } - }; - - template <class _Term, class _BB> // Successor Iterator - class SuccIterator { - const _Term Term; - unsigned idx; - public: - typedef SuccIterator<_Term, _BB> _Self; - typedef forward_iterator_tag iterator_category; - typedef _BB pointer; - - inline SuccIterator(_Term T) : Term(T), idx(0) {} // begin iterator - inline SuccIterator(_Term T, bool) - : Term(T), idx(Term->getNumSuccessors()) {} // end iterator - - inline bool operator==(const _Self& x) const { return idx == x.idx; } - inline bool operator!=(const _Self& x) const { return !operator==(x); } - - inline pointer operator*() const { return Term->getSuccessor(idx); } - inline pointer *operator->() const { return &(operator*()); } - - inline _Self& operator++() { ++idx; return *this; } // Preincrement - inline _Self operator++(int) { // Postincrement - _Self tmp = *this; ++*this; return tmp; - } - - inline _Self& operator--() { --idx; return *this; } // Predecrement - inline _Self operator--(int) { // Postdecrement - _Self tmp = *this; --*this; return tmp; - } - }; }; - -//===--------------------------------------------------------------------===// -// Implement some stuff prototyped above... -//===--------------------------------------------------------------------===// - -inline BasicBlock::pred_iterator BasicBlock::pred_begin() { - return pred_iterator(this); -} -inline BasicBlock::pred_const_iterator BasicBlock::pred_begin() const { - return pred_const_iterator(this); -} -inline BasicBlock::pred_iterator BasicBlock::pred_end() { - return pred_iterator(this,true); -} -inline BasicBlock::pred_const_iterator BasicBlock::pred_end() const { - return pred_const_iterator(this,true); -} - -inline BasicBlock::succ_iterator BasicBlock::succ_begin() { - return succ_iterator(getTerminator()); -} -inline BasicBlock::succ_const_iterator BasicBlock::succ_begin() const { - return succ_const_iterator(getTerminator()); -} -inline BasicBlock::succ_iterator BasicBlock::succ_end() { - return succ_iterator(getTerminator(),true); -} -inline BasicBlock::succ_const_iterator BasicBlock::succ_end() const { - return succ_const_iterator(getTerminator(),true); -} - #endif |