-/* Title: MethodLiveVarInfo.h
+/* Title: MethodLiveVarInfo.h -*- C++ -*-
Author: Ruchira Sasanka
Date: Jun 30, 01
Purpose:
#include "llvm/BasicBlock.h"
#include "llvm/Instruction.h"
#include "llvm/Method.h"
-#include "llvm/CFG.h"
#include "LiveVarMap.h"
#include "BBLiveVar.h"
#ifndef LLVM_BASICBLOCK_H
#define LLVM_BASICBLOCK_H
-#include "llvm/Value.h" // Get the definition of Value
+#include "llvm/Value.h"
#include "llvm/ValueHolder.h"
#include "llvm/Support/GraphTraits.h"
-
-#include "llvm/CFGdecls.h" // TODO FIXME: remove
+#include "llvm/InstrTypes.h"
+#include <iterator>
class Instruction;
class Method;
class MachineCodeForBasicBlock;
class BasicBlock : public Value { // Basic blocks are data objects also
+ template <class _Ptr, class _USE_iterator> class PredIterator;
+ template <class _Term, class _BB> class SuccIterator;
public:
typedef ValueHolder<Instruction, BasicBlock, Method> InstListType;
private :
typedef reverse_iterator<const_iterator> const_reverse_iterator;
typedef reverse_iterator<iterator> reverse_iterator;
- typedef cfg::succ_iterator succ_iterator; // Include CFG.h to use these
- typedef cfg::pred_iterator pred_iterator;
- typedef cfg::succ_const_iterator succ_const_iterator;
- typedef cfg::pred_const_iterator pred_const_iterator;
+ // Predecessor and successor iterators...
+ typedef PredIterator<BasicBlock, Value::use_iterator> pred_iterator;
+ typedef PredIterator<const BasicBlock,
+ Value::use_const_iterator> pred_const_iterator;
+ typedef SuccIterator<TerminatorInst*, BasicBlock> succ_iterator;
+ typedef SuccIterator<const TerminatorInst*,
+ const BasicBlock> succ_const_iterator;
+ // Ctor, dtor
BasicBlock(const string &Name = "", Method *Parent = 0);
~BasicBlock();
// Specialize setName to take care of symbol table majik
virtual void setName(const string &name, SymbolTable *ST = 0);
+ // getParent - Return the enclosing method, or null if none
const Method *getParent() const { return InstList.getParent(); }
Method *getParent() { return InstList.getParent(); }
//
TerminatorInst *getTerminator();
const TerminatorInst *const getTerminator() const;
-
// Machine code accessor...
inline MachineCodeForBasicBlock& getMachineInstrVec() const {
//===--------------------------------------------------------------------===//
// Instruction iterator methods
+ //
inline iterator begin() { return InstList.begin(); }
inline const_iterator begin() const { return InstList.begin(); }
inline iterator end () { return InstList.end(); }
// the basic block).
//
BasicBlock *splitBasicBlock(iterator I);
+
+
+ //===--------------------------------------------------------------------===//
+ // Predecessor and Successor Iterators
+ //
+ template <class _Ptr, class _USE_iterator> // Predecessor Iterator
+ class PredIterator : public std::bidirectional_iterator<_Ptr, ptrdiff_t> {
+ _Ptr *BB;
+ _USE_iterator It;
+ public:
+ typedef PredIterator<_Ptr,_USE_iterator> _Self;
+
+ inline void advancePastConstPool() {
+ // TODO: This is bad
+ // Loop to ignore constant pool references
+ while (It != BB->use_end() &&
+ ((!(*It)->isInstruction()) ||
+ !(((Instruction*)(*It))->isTerminator())))
+ ++It;
+ }
+
+ inline PredIterator(_Ptr *bb) : BB(bb), It(bb->use_begin()) {
+ advancePastConstPool();
+ }
+ inline PredIterator(_Ptr *bb, bool) : BB(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 {
+ return (*It)->castInstructionAsserting()->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;
+ }
+ };
+
+ inline pred_iterator pred_begin() { return pred_iterator(this); }
+ inline pred_const_iterator pred_begin() const {
+ return pred_const_iterator(this);
+ }
+ inline pred_iterator pred_end() { return pred_iterator(this, true); }
+ inline pred_const_iterator pred_end() const {
+ return pred_const_iterator(this, true);
+ }
+
+ template <class _Term, class _BB> // Successor Iterator
+ class SuccIterator : public std::bidirectional_iterator<_BB, ptrdiff_t> {
+ const _Term Term;
+ unsigned idx;
+ public:
+ typedef SuccIterator<_Term, _BB> _Self;
+ // TODO: This can be random access iterator, need operator+ and stuff tho
+
+ inline SuccIterator(_Term T) : Term(T), idx(0) { // begin iterator
+ assert(T && "getTerminator returned null!");
+ }
+ inline SuccIterator(_Term T, bool) // end iterator
+ : Term(T), idx(Term->getNumSuccessors()) {
+ assert(T && "getTerminator returned null!");
+ }
+
+ 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;
+ }
+ };
+
+ inline succ_iterator succ_begin() { return succ_iterator(getTerminator()); }
+ inline succ_const_iterator succ_begin() const {
+ return succ_const_iterator(getTerminator());
+ }
+ inline succ_iterator succ_end() {return succ_iterator(getTerminator(), true);}
+ inline succ_const_iterator succ_end() const {
+ return succ_const_iterator(getTerminator(), true);
+ }
};
-#include "llvm/CFG.h" // TODO FIXME when succ iterators are in BB.h
+
+//===--------------------------------------------------------------------===//
+// GraphTraits specializations for basic block graphs (CFGs)
+//===--------------------------------------------------------------------===//
// Provide specializations of GraphTraits to be able to treat a method as a
// graph of basic blocks...
static NodeType *getEntryNode(BasicBlock *BB) { return BB; }
static inline ChildIteratorType child_begin(NodeType *N) {
- return cfg::succ_begin(N);
+ return N->succ_begin();
}
static inline ChildIteratorType child_end(NodeType *N) {
- return cfg::succ_end(N);
+ return N->succ_end();
}
};
static NodeType *getEntryNode(const BasicBlock *BB) { return BB; }
static inline ChildIteratorType child_begin(NodeType *N) {
- return cfg::succ_begin(N);
+ return N->succ_begin();
}
static inline ChildIteratorType child_end(NodeType *N) {
- return cfg::succ_end(N);
+ return N->succ_end();
}
};
typedef BasicBlock::pred_iterator ChildIteratorType;
static NodeType *getEntryNode(Inverse<BasicBlock *> G) { return G.Graph; }
static inline ChildIteratorType child_begin(NodeType *N) {
- return cfg::pred_begin(N);
+ return N->pred_begin();
}
static inline ChildIteratorType child_end(NodeType *N) {
- return cfg::pred_end(N);
+ return N->pred_end();
}
};
return G.Graph;
}
static inline ChildIteratorType child_begin(NodeType *N) {
- return cfg::pred_begin(N);
+ return N->pred_begin();
}
static inline ChildIteratorType child_end(NodeType *N) {
- return cfg::pred_end(N);
+ return N->pred_end();
}
};
+++ /dev/null
-//===-- llvm/CFG.h - CFG definitions and useful classes ----------*- C++ -*--=//
-//
-// This file contains the class definitions useful for operating on the control
-// flow graph.
-//
-// Currently it contains functionality for these three applications:
-//
-// 1. Iterate over the predecessors of a basic block:
-// pred_iterator, pred_const_iterator, pred_begin, pred_end
-// 2. Iterate over the successors of a basic block:
-// succ_iterator, succ_const_iterator, succ_begin, succ_end
-// 3. Iterate over the basic blocks of a method in depth first ordering or
-// reverse depth first order. df_iterator, df_const_iterator,
-// df_begin, df_end. df_begin takes an arg to specify reverse or not.
-// 4. Iterator over the basic blocks of a method in post order.
-// 5. Iterator over a method in reverse post order.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CFG_H
-#define LLVM_CFG_H
-
-#include "llvm/CFGdecls.h" // See this file for concise interface info
-#include "llvm/BasicBlock.h"
-#include "llvm/InstrTypes.h"
-#include "llvm/Type.h"
-#include <iterator>
-
-namespace cfg {
-
-//===----------------------------------------------------------------------===//
-// Implementation
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-// Basic Block Predecessor Iterator
-//
-
-template <class _Ptr, class _USE_iterator> // Predecessor Iterator
-class PredIterator : public std::bidirectional_iterator<_Ptr, ptrdiff_t> {
- _Ptr *BB;
- _USE_iterator It;
-public:
- typedef PredIterator<_Ptr,_USE_iterator> _Self;
-
- inline void advancePastConstPool() {
- // TODO: This is bad
- // Loop to ignore constant pool references
- while (It != BB->use_end() &&
- ((!(*It)->isInstruction()) ||
- !(((Instruction*)(*It))->isTerminator())))
- ++It;
- }
-
- inline PredIterator(_Ptr *bb) : BB(bb), It(bb->use_begin()) {
- advancePastConstPool();
- }
- inline PredIterator(_Ptr *bb, bool) : BB(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 {
- return (*It)->castInstructionAsserting()->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;
- }
-};
-
-inline pred_iterator pred_begin( BasicBlock *BB) {
- return pred_iterator(BB);
-}
-inline pred_const_iterator pred_begin(const BasicBlock *BB) {
- return pred_const_iterator(BB);
-}
-inline pred_iterator pred_end( BasicBlock *BB) {
- return pred_iterator(BB,true);
-}
-inline pred_const_iterator pred_end(const BasicBlock *BB) {
- return pred_const_iterator(BB,true);
-}
-
-
-//===----------------------------------------------------------------------===//
-// Basic Block Successor Iterator
-//
-
-template <class _Term, class _BB> // Successor Iterator
-class SuccIterator : public std::bidirectional_iterator<_BB, ptrdiff_t> {
- const _Term Term;
- unsigned idx;
-public:
- typedef SuccIterator<_Term, _BB> _Self;
- // TODO: This can be random access iterator, need operator+ and stuff tho
-
- inline SuccIterator(_Term T) : Term(T), idx(0) { // begin iterator
- assert(T && "getTerminator returned null!");
- }
- inline SuccIterator(_Term T, bool) // end iterator
- : Term(T), idx(Term->getNumSuccessors()) {
- assert(T && "getTerminator returned null!");
- }
-
- 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;
- }
-};
-
-inline succ_iterator succ_begin( BasicBlock *BB) {
- return succ_iterator(BB->getTerminator());
-}
-inline succ_const_iterator succ_begin(const BasicBlock *BB) {
- return succ_const_iterator(BB->getTerminator());
-}
-inline succ_iterator succ_end( BasicBlock *BB) {
- return succ_iterator(BB->getTerminator(),true);
-}
-inline succ_const_iterator succ_end(const BasicBlock *BB) {
- return succ_const_iterator(BB->getTerminator(),true);
-}
-
-} // End namespace cfg
-
-#endif
+++ /dev/null
-//===-- llvm/CFGdecls.h - CFG forward declarations ---------------*- C++ -*--=//
-//
-// This file contains forward declarations for CFG functions and data
-// structures. This is used to reduce compile time dependencies among files.
-// Any users of these functions must include CFG.h to get their full
-// definitions.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CFG_DECLS_H
-#define LLVM_CFG_DECLS_H
-
-#include "llvm/Value.h"
-class TerminatorInst;
-class BasicBlock;
-class Method;
-
-//===----------------------------------------------------------------------===//
-// Interface
-//===----------------------------------------------------------------------===//
-
-namespace cfg {
-
-//===--------------------------------------------------------------------===//
-// 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, Value::use_iterator> pred_iterator;
-typedef PredIterator<const BasicBlock,
- Value::use_const_iterator> pred_const_iterator;
-
-inline pred_iterator pred_begin( BasicBlock *BB);
-inline pred_const_iterator pred_begin(const BasicBlock *BB);
-inline pred_iterator pred_end ( BasicBlock *BB);
-inline pred_const_iterator pred_end (const BasicBlock *BB);
-
-
-//===--------------------------------------------------------------------===//
-// 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( BasicBlock *BB);
-inline succ_const_iterator succ_begin(const BasicBlock *BB);
-inline succ_iterator succ_end ( BasicBlock *BB);
-inline succ_const_iterator succ_end (const BasicBlock *BB);
-
-#if 0
-//===--------------------------------------------------------------------===//
-// <Reverse> Depth First CFG iterator code
-//===--------------------------------------------------------------------===//
-//
-// This is used to visit basic blocks in a method in either depth first, or
-// reverse depth first ordering, depending on the value passed to the df_begin
-// method.
-//
-struct BasicBlockGraph;
-struct ConstBasicBlockGraph;
-struct InverseBasicBlockGraph;
-struct ConstInverseBasicBlockGraph;
-struct TypeGraph;
-
-// Forward declare iterator class template...
-template<class GraphInfo> class DFIterator;
-
-// Normal Depth First Iterator Definitions (Forward and Reverse)
-typedef DFIterator< BasicBlockGraph> df_iterator;
-typedef DFIterator<ConstBasicBlockGraph> df_const_iterator;
-
-inline df_iterator df_begin( Method *M, bool Reverse = false);
-inline df_const_iterator df_begin(const Method *M, bool Reverse = false);
-inline df_iterator df_end ( Method *M);
-inline df_const_iterator df_end (const Method *M);
-
-inline df_iterator df_begin( BasicBlock *BB, bool Reverse = false);
-inline df_const_iterator df_begin(const BasicBlock *BB, bool Reverse = false);
-inline df_iterator df_end ( BasicBlock *BB);
-inline df_const_iterator df_end (const BasicBlock *BB);
-
-
-// Inverse Depth First Iterator Definitions (Forward and Reverse) - Traverse
-// predecessors instead of successors...
-//
-typedef DFIterator< InverseBasicBlockGraph> idf_iterator;
-typedef DFIterator<ConstInverseBasicBlockGraph> idf_const_iterator;
-
-inline idf_iterator idf_begin( BasicBlock *BB, bool Reverse = false);
-inline idf_const_iterator idf_begin(const BasicBlock *BB, bool Reverse = false);
-inline idf_iterator idf_end ( BasicBlock *BB);
-inline idf_const_iterator idf_end (const BasicBlock *BB);
-
-
-// Depth First Iterator Definitions for Types. This lets you iterator over
-// (possibly cyclic) type graphs in dfo
-//
-typedef DFIterator<TypeGraph> tdf_iterator;
-
-inline tdf_iterator tdf_begin(const Type *T, bool Reverse = false);
-inline tdf_iterator tdf_end (const Type *T);
-
-
-//===--------------------------------------------------------------------===//
-// Post Order CFG iterator code
-//===--------------------------------------------------------------------===//
-//
-// This is used to visit basic blocks in a method in standard post order.
-//
-
-// Forward declare iterator class template...
-template<class BBType, class SuccItTy> class POIterator;
-
-typedef POIterator<BasicBlock, succ_iterator> po_iterator;
-typedef POIterator<const BasicBlock,
- succ_const_iterator> po_const_iterator;
-
-inline po_iterator po_begin( Method *M);
-inline po_const_iterator po_begin(const Method *M);
-inline po_iterator po_end ( Method *M);
-inline po_const_iterator po_end (const Method *M);
-
-inline po_iterator po_begin( BasicBlock *BB);
-inline po_const_iterator po_begin(const BasicBlock *BB);
-inline po_iterator po_end ( BasicBlock *BB);
-inline po_const_iterator po_end (const BasicBlock *BB);
-#endif
-
-} // End namespace cfg
-
-#endif
-/* Title: MethodLiveVarInfo.h
+/* Title: MethodLiveVarInfo.h -*- C++ -*-
Author: Ruchira Sasanka
Date: Jun 30, 01
Purpose:
#include "llvm/BasicBlock.h"
#include "llvm/Instruction.h"
#include "llvm/Method.h"
-#include "llvm/CFG.h"
#include "LiveVarMap.h"
#include "BBLiveVar.h"
#include "llvm/Analysis/Interval.h"
#include "llvm/BasicBlock.h"
-using namespace cfg;
-
//===----------------------------------------------------------------------===//
// Interval Implementation
//===----------------------------------------------------------------------===//
// isLoop - Find out if there is a back edge in this interval...
//
-bool Interval::isLoop() const {
+bool cfg::Interval::isLoop() const {
// There is a loop in this interval iff one of the predecessors of the header
// node lives in the interval.
- for (BasicBlock::pred_iterator I = pred_begin(HeaderNode),
- E = pred_end(HeaderNode); I != E; ++I) {
+ for (BasicBlock::pred_iterator I = HeaderNode->pred_begin(),
+ E = HeaderNode->pred_end(); I != E; ++I) {
if (contains(*I)) return true;
}
return false;
// whose POId is lower
- cfg::pred_const_iterator PredBBI = cfg::pred_begin(BaseBB);
+ BasicBlock::pred_const_iterator PredBBI = BaseBB->pred_begin();
- for( ; PredBBI != cfg::pred_end(BaseBB) ; PredBBI++) {
+ for( ; PredBBI != BaseBB->pred_end() ; PredBBI++) {
assert( *PredBBI ); // assert that the predecessor is valid
BBLiveVar *PredLVBB = LVMap[*PredBBI];
-/* Title: BBLiveVar.h
+/* Title: BBLiveVar.h -*- C++ -*-
Author: Ruchira Sasanka
Date: Jun 30, 01
Purpose: This is a wrapper class for BasicBlock which is used by live
#include "llvm/BasicBlock.h"
#include "llvm/Instruction.h"
-#include "llvm/CFG.h"
#include "llvm/Type.h"
#include "llvm/iOther.h"
df_iterator<const Method*> It = df_begin(M), End = df_end(M);
for ( ; It != End; ++It) {
const BasicBlock *BB = *It;
- pred_const_iterator PI = pred_begin(BB), PEnd = pred_end(BB);
+ BasicBlock::pred_const_iterator PI = BB->pred_begin(),
+ PEnd = BB->pred_end();
if (PI != PEnd) { // Is there SOME predecessor?
// Loop until we get to a predecessor that has had it's dom set filled
// in at least once. We are guaranteed to have this because we are
idf_iterator<const BasicBlock*> It = idf_begin(Root), End = idf_end(Root);
for ( ; It != End; ++It) {
const BasicBlock *BB = *It;
- succ_const_iterator PI = succ_begin(BB), PEnd = succ_end(BB);
+ BasicBlock::succ_const_iterator PI = BB->succ_begin(),
+ PEnd = BB->succ_end();
if (PI != PEnd) { // Is there SOME predecessor?
// Loop until we get to a successor that has had it's dom set filled
// in at least once. We are guaranteed to have this because we are
const BasicBlock *BB = Node->getNode();
DomSetType &S = Frontiers[BB]; // The new set to fill in...
- for (succ_const_iterator SI = succ_begin(BB), SE = succ_end(BB);
- SI != SE; ++SI) {
+ for (BasicBlock::succ_const_iterator SI = BB->succ_begin(),
+ SE = BB->succ_end(); SI != SE; ++SI) {
// Does Node immediately dominate this successor?
if (DT[*SI]->getIDom() != Node)
S.insert(*SI);
DomSetType &S = Frontiers[BB]; // The new set to fill in...
if (!Root) return S;
- for (pred_const_iterator SI = pred_begin(BB), SE = pred_end(BB);
- SI != SE; ++SI) {
+ for (BasicBlock::pred_const_iterator SI = BB->pred_begin(),
+ SE = BB->pred_end(); SI != SE; ++SI) {
// Does Node immediately dominate this predeccessor?
if (DT[*SI]->getIDom() != Node)
S.insert(*SI);
// whose POId is lower
- cfg::pred_const_iterator PredBBI = cfg::pred_begin(BaseBB);
+ BasicBlock::pred_const_iterator PredBBI = BaseBB->pred_begin();
- for( ; PredBBI != cfg::pred_end(BaseBB) ; PredBBI++) {
+ for( ; PredBBI != BaseBB->pred_end() ; PredBBI++) {
assert( *PredBBI ); // assert that the predecessor is valid
BBLiveVar *PredLVBB = LVMap[*PredBBI];
-/* Title: BBLiveVar.h
+/* Title: BBLiveVar.h -*- C++ -*-
Author: Ruchira Sasanka
Date: Jun 30, 01
Purpose: This is a wrapper class for BasicBlock which is used by live
#include "llvm/BasicBlock.h"
#include "llvm/Instruction.h"
-#include "llvm/CFG.h"
#include "llvm/Type.h"
#include "llvm/iOther.h"
}
// Recursively traverse successors of this basic block.
- cfg::succ_iterator SI = cfg::succ_begin(BB), SE = cfg::succ_end(BB);
+ BasicBlock::succ_iterator SI = BB->succ_begin(), SE = BB->succ_end();
for (; SI != SE; ++SI) {
BasicBlock *Succ = *SI;
BasicBlock *Repl = fixupCFG(Succ, VisitedBlocks, AliveBlocks);
BasicBlock *ReturnBB = 0; // Default to nothing live down here
// Recursively traverse successors of this basic block.
- cfg::succ_iterator SI = cfg::succ_begin(BB), SE = cfg::succ_end(BB);
+ BasicBlock::succ_iterator SI = BB->succ_begin(), SE = BB->succ_end();
for (; SI != SE; ++SI) {
BasicBlock *RetBB = fixupCFG(*SI, VisitedBlocks, AliveBlocks);
if (RetBB) {
#include "llvm/iTerminators.h"
#include "llvm/iOther.h"
#include "llvm/Assembly/Writer.h"
-#include "llvm/CFG.h"
#include <algorithm>
-using namespace cfg;
-
struct ConstPoolDCE {
enum { EndOffs = 0 };
static bool isDCEable(const ConstPoolVal *CPV) {
// things in a basic block, if they are present.
//
static bool RemoveSingularPHIs(BasicBlock *BB) {
- pred_iterator PI(pred_begin(BB));
- if (PI == pred_end(BB) || ++PI != pred_end(BB))
+ BasicBlock::pred_iterator PI(BB->pred_begin());
+ if (PI == BB->pred_end() || ++PI != BB->pred_end())
return false; // More than one predecessor...
Instruction *I = BB->front();
if (!I->isPHINode()) return false; // No PHI nodes
//cerr << "Killing PHIs from " << BB;
- //cerr << "Pred #0 = " << *pred_begin(BB);
+ //cerr << "Pred #0 = " << *BB->pred_begin();
//cerr << "Method == " << BB->getParent();
// If there is more than one predecessor, and there are PHI nodes in
// the successor, then we need to add incoming edges for the PHI nodes
//
- const vector<BasicBlock*> BBPreds(pred_begin(BB), pred_end(BB));
+ const vector<BasicBlock*> BBPreds(BB->pred_begin(), BB->pred_end());
BasicBlock::iterator I = Succ->begin();
do { // Loop over all of the PHI nodes in the successor BB
// Remove basic blocks that have no predecessors... which are unreachable.
- if (pred_begin(BB) == pred_end(BB) &&
+ if (BB->pred_begin() == BB->pred_end() &&
!BB->hasConstantPoolReferences()) {
//cerr << "Removing BB: \n" << BB;
// Loop through all of our successors and make sure they know that one
// of their predecessors is going away.
- for_each(succ_begin(BB), succ_end(BB),
+ for_each(BB->succ_begin(), BB->succ_end(),
std::bind2nd(std::mem_fun(&BasicBlock::removePredecessor), BB));
while (!BB->empty()) {
// Check to see if this block has no instructions and only a single
// successor. If so, replace block references with successor.
- succ_iterator SI(succ_begin(BB));
- if (SI != succ_end(BB) && ++SI == succ_end(BB)) { // One succ?
+ BasicBlock::succ_iterator SI(BB->succ_begin());
+ if (SI != BB->succ_end() && ++SI == BB->succ_end()) { // One succ?
Instruction *I = BB->front();
if (I->isTerminator()) { // Terminator is the only instruction!
- BasicBlock *Succ = *succ_begin(BB); // There is exactly one successor
+ BasicBlock *Succ = *BB->succ_begin(); // There is exactly one successor
//cerr << "Killing Trivial BB: \n" << BB;
if (Succ != BB) { // Arg, don't hurt infinite loops!
// Merge basic blocks into their predecessor if there is only one pred,
// and if there is only one successor of the predecessor.
- pred_iterator PI(pred_begin(BB));
- if (PI != pred_end(BB) && *PI != BB && // Not empty? Not same BB?
- ++PI == pred_end(BB) && !BB->hasConstantPoolReferences()) {
- BasicBlock *Pred = *pred_begin(BB);
+ BasicBlock::pred_iterator PI(BB->pred_begin());
+ if (PI != BB->pred_end() && *PI != BB && // Not empty? Not same BB?
+ ++PI == BB->pred_end() && !BB->hasConstantPoolReferences()) {
+ BasicBlock *Pred = *BB->pred_begin();
TerminatorInst *Term = Pred->getTerminator();
assert(Term != 0 && "malformed basic block without terminator!");
// Does the predecessor block only have a single successor?
- succ_iterator SI(succ_begin(Pred));
- if (++SI == succ_end(Pred)) {
+ BasicBlock::succ_iterator SI(Pred->succ_begin());
+ if (++SI == Pred->succ_end()) {
//cerr << "Merging: " << BB << "into: " << Pred;
// Delete the unconditianal branch from the predecessor...
#include "llvm/Support/STLExtras.h"
#include "llvm/SymbolTable.h"
#include "llvm/iOther.h"
-#include "llvm/CFG.h"
#include <algorithm>
#include "llvm/Analysis/LoopDepth.h"
// Figure out which predecessors I have to play with... there should be
// exactly two... one of which is a loop predecessor, and one of which is not.
//
- cfg::pred_iterator PI = cfg::pred_begin(Header);
- assert(PI != cfg::pred_end(Header) && "Header node should have 2 preds!");
+ BasicBlock::pred_iterator PI = Header->pred_begin();
+ assert(PI != Header->pred_end() && "Header node should have 2 preds!");
BasicBlock *Pred1 = *PI; ++PI;
- assert(PI != cfg::pred_end(Header) && "Header node should have 2 preds!");
+ assert(PI != Header->pred_end() && "Header node should have 2 preds!");
BasicBlock *Pred2 = *PI;
- assert(++PI == cfg::pred_end(Header) && "Header node should have 2 preds!");
+ assert(++PI == Header->pred_end() && "Header node should have 2 preds!");
// Make Pred1 be the loop entrance predecessor, Pred2 be the Loop predecessor
if (Int->contains(Pred1)) swap(Pred1, Pred2);
#include "llvm/Method.h"
#include "llvm/SymbolTable.h"
#include "llvm/Type.h"
-#include "llvm/CFG.h"
#include "llvm/iOther.h"
#include "llvm/CodeGen/MachineInstr.h"
// called while the predecessor still refers to this block.
//
void BasicBlock::removePredecessor(BasicBlock *Pred) {
- using cfg::pred_begin; using cfg::pred_end; using cfg::pred_iterator;
- assert(find(pred_begin(this), pred_end(this), Pred) != pred_end(this) &&
+ assert(find(pred_begin(), pred_end(), Pred) != pred_end() &&
"removePredecessor: BB is not a predecessor!");
if (!front()->isPHINode()) return; // Quick exit.
- pred_iterator PI(pred_begin(this)), EI(pred_end(this));
+ pred_iterator PI(pred_begin()), EI(pred_end());
unsigned max_idx;
// Loop over the rest of the predecessors until we run out, or until we find
df_iterator<const Method*> It = df_begin(M), End = df_end(M);
for ( ; It != End; ++It) {
const BasicBlock *BB = *It;
- pred_const_iterator PI = pred_begin(BB), PEnd = pred_end(BB);
+ BasicBlock::pred_const_iterator PI = BB->pred_begin(),
+ PEnd = BB->pred_end();
if (PI != PEnd) { // Is there SOME predecessor?
// Loop until we get to a predecessor that has had it's dom set filled
// in at least once. We are guaranteed to have this because we are
idf_iterator<const BasicBlock*> It = idf_begin(Root), End = idf_end(Root);
for ( ; It != End; ++It) {
const BasicBlock *BB = *It;
- succ_const_iterator PI = succ_begin(BB), PEnd = succ_end(BB);
+ BasicBlock::succ_const_iterator PI = BB->succ_begin(),
+ PEnd = BB->succ_end();
if (PI != PEnd) { // Is there SOME predecessor?
// Loop until we get to a successor that has had it's dom set filled
// in at least once. We are guaranteed to have this because we are
const BasicBlock *BB = Node->getNode();
DomSetType &S = Frontiers[BB]; // The new set to fill in...
- for (succ_const_iterator SI = succ_begin(BB), SE = succ_end(BB);
- SI != SE; ++SI) {
+ for (BasicBlock::succ_const_iterator SI = BB->succ_begin(),
+ SE = BB->succ_end(); SI != SE; ++SI) {
// Does Node immediately dominate this successor?
if (DT[*SI]->getIDom() != Node)
S.insert(*SI);
DomSetType &S = Frontiers[BB]; // The new set to fill in...
if (!Root) return S;
- for (pred_const_iterator SI = pred_begin(BB), SE = pred_end(BB);
- SI != SE; ++SI) {
+ for (BasicBlock::pred_const_iterator SI = BB->pred_begin(),
+ SE = BB->pred_end(); SI != SE; ++SI) {
// Does Node immediately dominate this predeccessor?
if (DT[*SI]->getIDom() != Node)
S.insert(*SI);
projects / oota-llvm.git / commitdiff