* Move BasicBlock and Method graph stuff to new "llvm/Support/CFG.h" file

* Move Method::inst_* to new "llvm/Support/InstIterator.h" file
* Method.h no longer #includes BasicBlock.h

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1743 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/BasicBlock.h b/include/llvm/BasicBlock.h
index b846a8478da4b0665b9937ecbbd4f3234af83e71..bcaf1cfc82d3ea33163cb70c5f7a017a41c3fefe 100644 (file)
--- a/include/llvm/BasicBlock.h
+++ b/include/llvm/BasicBlock.h
@@ -3,11 +3,9 @@
 // This file contains the declaration of the BasicBlock class, which represents
 // a single basic block in the VM.
 //
-// Note that basic blocks themselves are Def's, because they are referenced
+// Note that basic blocks themselves are Value's, because they are referenced
 // by instructions like branches and can go in switch tables and stuff...
 //
-// This may see wierd at first, but it's really pretty cool.  :)
-//
 //===----------------------------------------------------------------------===//
 //
 // Note that well formed basic blocks are formed of a list of instructions 
@@ -24,7 +22,6 @@
 
 #include "llvm/ValueHolder.h"
 #include "llvm/InstrTypes.h"
-#include "Support/GraphTraits.h"
 #include <iterator>
 
 class Instruction;
@@ -253,71 +250,4 @@ public:
   }
 };
 
-
-//===--------------------------------------------------------------------===//
-// GraphTraits specializations for basic block graphs (CFGs)
-//===--------------------------------------------------------------------===//
-
-// Provide specializations of GraphTraits to be able to treat a method as a 
-// graph of basic blocks...
-
-template <> struct GraphTraits<BasicBlock*> {
-  typedef BasicBlock NodeType;
-  typedef BasicBlock::succ_iterator ChildIteratorType;
-
-  static NodeType *getEntryNode(BasicBlock *BB) { return BB; }
-  static inline ChildIteratorType child_begin(NodeType *N) { 
-    return N->succ_begin(); 
-  }
-  static inline ChildIteratorType child_end(NodeType *N) { 
-    return N->succ_end(); 
-  }
-};
-
-template <> struct GraphTraits<const BasicBlock*> {
-  typedef const BasicBlock NodeType;
-  typedef BasicBlock::succ_const_iterator ChildIteratorType;
-
-  static NodeType *getEntryNode(const BasicBlock *BB) { return BB; }
-
-  static inline ChildIteratorType child_begin(NodeType *N) { 
-    return N->succ_begin(); 
-  }
-  static inline ChildIteratorType child_end(NodeType *N) { 
-    return N->succ_end(); 
-  }
-};
-
-// Provide specializations of GraphTraits to be able to treat a method as a 
-// graph of basic blocks... and to walk it in inverse order.  Inverse order for
-// a method is considered to be when traversing the predecessor edges of a BB
-// instead of the successor edges.
-//
-template <> struct GraphTraits<Inverse<BasicBlock*> > {
-  typedef BasicBlock NodeType;
-  typedef BasicBlock::pred_iterator ChildIteratorType;
-  static NodeType *getEntryNode(Inverse<BasicBlock *> G) { return G.Graph; }
-  static inline ChildIteratorType child_begin(NodeType *N) { 
-    return N->pred_begin(); 
-  }
-  static inline ChildIteratorType child_end(NodeType *N) { 
-    return N->pred_end(); 
-  }
-};
-
-template <> struct GraphTraits<Inverse<const BasicBlock*> > {
-  typedef const BasicBlock NodeType;
-  typedef BasicBlock::pred_const_iterator ChildIteratorType;
-  static NodeType *getEntryNode(Inverse<const BasicBlock*> G) {
-    return G.Graph; 
-  }
-  static inline ChildIteratorType child_begin(NodeType *N) { 
-    return N->pred_begin(); 
-  }
-  static inline ChildIteratorType child_end(NodeType *N) { 
-    return N->pred_end(); 
-  }
-};
-
-
 #endif

diff --git a/include/llvm/Function.h b/include/llvm/Function.h
index 93b9dc6d7abfe5f6e09e0b8c0e5409a3abb598d1..23ebc31a4fa450eeaccc79e24f9d6c480f872da1 100644 (file)
--- a/include/llvm/Function.h
+++ b/include/llvm/Function.h
@@ -12,8 +12,8 @@
 #define LLVM_METHOD_H
 
 #include "llvm/SymTabValue.h"
-#include "llvm/BasicBlock.h"
 #include "llvm/GlobalValue.h"
+#include "llvm/ValueHolder.h"
 
 class Instruction;
 class BasicBlock;
@@ -103,134 +103,6 @@ public:
   // delete.
   //
   void dropAllReferences();
-
-  //===--------------------------------------------------------------------===//
-  // Method Instruction iterator code
-  //===--------------------------------------------------------------------===//
-  // 
-  template <class _BB_t, class _BB_i_t, class _BI_t, class _II_t> 
-  class InstIterator;
-  typedef InstIterator<BasicBlocksType, iterator, 
-                      BasicBlock::iterator, Instruction*> inst_iterator;
-  typedef InstIterator<const BasicBlocksType, const_iterator, 
-                      BasicBlock::const_iterator,
-                      const Instruction*> const_inst_iterator;
-
-  // This inner class is used to implement inst_begin() & inst_end() for
-  // inst_iterator and const_inst_iterator's.
-  //
-  template <class _BB_t, class _BB_i_t, class _BI_t, class _II_t>
-  class InstIterator {
-    typedef _BB_t   BBty;
-    typedef _BB_i_t BBIty;
-    typedef _BI_t   BIty;
-    typedef _II_t   IIty;
-    _BB_t  &BBs;      // BasicBlocksType
-    _BB_i_t BB;       // BasicBlocksType::iterator
-    _BI_t   BI;       // BasicBlock::iterator
-  public:
-    typedef std::bidirectional_iterator_tag iterator_category;
-    typedef IIty                            value_type;
-    typedef unsigned                        difference_type;
-    typedef BIty                            pointer;
-    typedef IIty                            reference;
-    
-    template<class M> InstIterator(M &m) 
-      : BBs(m.getBasicBlocks()), BB(BBs.begin()) {    // begin ctor
-      if (BB != BBs.end()) {
-       BI = (*BB)->begin();
-       resyncInstructionIterator();
-      }
-    }
-
-    template<class M> InstIterator(M &m, bool) 
-      : BBs(m.getBasicBlocks()), BB(BBs.end()) {    // end ctor
-    }
-
-    // Accessors to get at the underlying iterators...
-    inline BBIty &getBasicBlockIterator()  { return BB; }
-    inline BIty  &getInstructionIterator() { return BI; }
-
-    inline IIty operator*()  const { return *BI; }
-    inline IIty operator->() const { return operator*(); }
-
-    inline bool operator==(const InstIterator &y) const { 
-      return BB == y.BB && (BB == BBs.end() || BI == y.BI);
-    }
-    inline bool operator!=(const InstIterator& y) const { 
-      return !operator==(y);
-    }
-
-    // resyncInstructionIterator - This should be called if the 
-    // InstructionIterator is modified outside of our control.  This resynchs
-    // the internals of the InstIterator to a consistent state.
-    //
-    inline void resyncInstructionIterator() {
-      // The only way that the II could be broken is if it is now pointing to
-      // the end() of the current BasicBlock and there are successor BBs.
-      while (BI == (*BB)->end()) {
-       ++BB;
-       if (BB == BBs.end()) break;
-       BI = (*BB)->begin();
-      }
-    }
-
-    InstIterator& operator++() { 
-      ++BI;
-      resyncInstructionIterator();   // Make sure it is still valid.
-      return *this; 
-    }
-    inline InstIterator operator++(int) { 
-      InstIterator tmp = *this; ++*this; return tmp; 
-    }
-    
-    InstIterator& operator--() { 
-      while (BB == BBs.end() || BI == (*BB)->begin()) {
-       --BB;
-       BI = (*BB)->end();
-      }
-      --BI;
-      return *this; 
-    }
-    inline InstIterator  operator--(int) { 
-      InstIterator tmp = *this; --*this; return tmp; 
-    }
-
-    inline bool atEnd() const { return BB == BBs.end(); }
-  };
-
-  inline inst_iterator inst_begin() { return inst_iterator(*this); }
-  inline inst_iterator inst_end()   { return inst_iterator(*this, true); }
-  inline const_inst_iterator inst_begin() const { return const_inst_iterator(*this); }
-  inline const_inst_iterator inst_end()   const { return const_inst_iterator(*this, true); }
-};
-
-// Provide specializations of GraphTraits to be able to treat a method as a 
-// graph of basic blocks... these are the same as the basic block iterators,
-// except that the root node is implicitly the first node of the method.
-//
-template <> struct GraphTraits<Method*> : public GraphTraits<BasicBlock*> {
-  static NodeType *getEntryNode(Method *M) { return M->front(); }
-};
-template <> struct GraphTraits<const Method*> :
-  public GraphTraits<const BasicBlock*> {
-  static NodeType *getEntryNode(const Method *M) { return M->front(); }
-};
-
-// Provide specializations of GraphTraits to be able to treat a method as a 
-// graph of basic blocks... and to walk it in inverse order.  Inverse order for
-// a method is considered to be when traversing the predecessor edges of a BB
-// instead of the successor edges.
-//
-template <> struct GraphTraits<Inverse<Method*> > :
-  public GraphTraits<Inverse<BasicBlock*> > {
-  static NodeType *getEntryNode(Inverse<Method *> G) { return G.Graph->front();}
-};
-template <> struct GraphTraits<Inverse<const Method*> > :
-  public GraphTraits<Inverse<const BasicBlock*> > {
-  static NodeType *getEntryNode(Inverse<const Method *> G) {
-    return G.Graph->front();
-  }
 };
 
 #endif