6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-22 07:32:48 +00:00
Code Issues Projects Releases Wiki Activity

Moved iterators to the new CFG.h file.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2001-06-07 21:18:35 +00:00
parent 7170838f84
commit 1f0d48113c
1 changed files with 0 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
include/llvm/BasicBlock.h
View File

@ -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