Convert 'struct' to 'class' in various places to adhere to the coding standards

[oota-llvm.git] / include / llvm / Analysis / LoopInfo.h

diff --git a/include/llvm/Analysis/LoopInfo.h b/include/llvm/Analysis/LoopInfo.h
index 84865d3a6aee64fcb1ae4b8dafe8dd49f1c06ff0..32351ea55ce70d35104c5cde3d7acb8973231cfc 100644 (file)
--- a/include/llvm/Analysis/LoopInfo.h
+++ b/include/llvm/Analysis/LoopInfo.h
@@ -13,12 +13,17 @@
 //
 // This analysis calculates the nesting structure of loops in a function.  For
 // each natural loop identified, this analysis identifies natural loops
-// contained entirely within the function, the basic blocks the make up the
-// loop, the nesting depth of the loop, and the successor blocks of the loop.
+// contained entirely within the loop and the basic blocks the make up the loop.
 //
-// It can calculate on the fly a variety of different bits of information, such
-// as whether there is a preheader for the loop, the number of back edges to the
-// header, and whether or not a particular block branches out of the loop.
+// It can calculate on the fly various bits of information, for example:
+//
+//  * whether there is a preheader for the loop
+//  * the number of back edges to the header
+//  * whether or not a particular block branches out of the loop
+//  * the successor blocks of the loop
+//  * the loop depth
+//  * the trip count
+//  * etc...
 //
 //===----------------------------------------------------------------------===//
 
@@ -26,15 +31,14 @@
 #define LLVM_ANALYSIS_LOOP_INFO_H
 
 #include "llvm/Pass.h"
-#include "Support/GraphTraits.h"
-#include <set>
+#include "llvm/ADT/GraphTraits.h"
 
 namespace llvm {
 
-class DominatorSet;
+struct DominatorSet;
 class LoopInfo;
 class PHINode;
-  class Instruction;
+class Instruction;
 
 //===----------------------------------------------------------------------===//
 /// Loop class - Instances of this class are used to represent loops that are 
@@ -44,20 +48,23 @@ class Loop {
   Loop *ParentLoop;
   std::vector<Loop*> SubLoops;       // Loops contained entirely within this one
   std::vector<BasicBlock*> Blocks;   // First entry is the header node
-  unsigned LoopDepth;                // Nesting depth of this loop
 
   Loop(const Loop &);                  // DO NOT IMPLEMENT
   const Loop &operator=(const Loop &); // DO NOT IMPLEMENT
 public:
   /// Loop ctor - This creates an empty loop.
-  Loop() : ParentLoop(0), LoopDepth(0) {
-  }
+  Loop() : ParentLoop(0) {}
   ~Loop() {
     for (unsigned i = 0, e = SubLoops.size(); i != e; ++i)
       delete SubLoops[i];
   }
 
-  unsigned getLoopDepth() const { return LoopDepth; }
+  unsigned getLoopDepth() const {
+    unsigned D = 0;
+    for (const Loop *CurLoop = this; CurLoop; CurLoop = CurLoop->ParentLoop)
+      ++D;
+    return D;
+  }
   BasicBlock *getHeader() const { return Blocks.front(); }
   Loop *getParentLoop() const { return ParentLoop; }
 
@@ -74,6 +81,9 @@ public:
   /// getBlocks - Get a list of the basic blocks which make up this loop.
   ///
   const std::vector<BasicBlock*> &getBlocks() const { return Blocks; }
+  typedef std::vector<BasicBlock*>::const_iterator block_iterator;
+  block_iterator block_begin() const { return Blocks.begin(); }
+  block_iterator block_end() const { return Blocks.end(); }
 
   /// isLoopExit - True if terminator in the block can branch to another block
   /// that is outside of the current loop.
@@ -84,6 +94,10 @@ public:
   ///
   unsigned getNumBackEdges() const;
 
+  /// isLoopInvariant - Return true if the specified value is loop invariant
+  ///
+  bool isLoopInvariant(Value *V) const;
+
   //===--------------------------------------------------------------------===//
   // APIs for simple analysis of the loop.
   //
@@ -171,12 +185,7 @@ public:
 private:
   friend class LoopInfo;
   Loop(BasicBlock *BB) : ParentLoop(0) {
-    Blocks.push_back(BB); LoopDepth = 0;
-  }
-  void setLoopDepth(unsigned Level) {
-    LoopDepth = Level;
-    for (unsigned i = 0, e = SubLoops.size(); i != e; ++i)
-      SubLoops[i]->setLoopDepth(Level+1);
+    Blocks.push_back(BB);
   }
 };
 
@@ -204,14 +213,14 @@ public:
   /// getLoopFor - Return the inner most loop that BB lives in.  If a basic
   /// block is in no loop (for example the entry node), null is returned.
   ///
-  const Loop *getLoopFor(const BasicBlock *BB) const {
+  Loop *getLoopFor(const BasicBlock *BB) const {
     std::map<BasicBlock *, Loop*>::const_iterator I=BBMap.find((BasicBlock*)BB);
     return I != BBMap.end() ? I->second : 0;
   }
 
   /// operator[] - same as getLoopFor...
   ///
-  inline const Loop *operator[](const BasicBlock *BB) const {
+  const Loop *operator[](const BasicBlock *BB) const {
     return getLoopFor(BB);
   }
 
@@ -252,6 +261,13 @@ public:
   /// list with the indicated loop.
   void changeTopLevelLoop(Loop *OldLoop, Loop *NewLoop);
 
+  /// addTopLevelLoop - This adds the specified loop to the collection of
+  /// top-level loops.
+  void addTopLevelLoop(Loop *New) {
+    assert(New->getParentLoop() == 0 && "Loop already in subloop!");
+    TopLevelLoops.push_back(New);
+  }
+
   /// removeBlock - This method completely removes BB from all data structures,
   /// including all of the Loop objects it is nested in and our mapping from
   /// BasicBlocks to loops.