X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAnalysis%2FConstantsScanner.h;h=cdaf68d75a6399fac3c35648f3ce8ae79b1cceea;hb=739742650981491be0e58ed876feaeb8901f9443;hp=4c86834d214947789ca84d2edbe76db6de8900aa;hpb=1d87bcf4909b06dcd86320722653341f08b8b396;p=oota-llvm.git

diff --git a/include/llvm/Analysis/ConstantsScanner.h b/include/llvm/Analysis/ConstantsScanner.h
index 4c86834d214..cdaf68d75a6 100644
--- a/include/llvm/Analysis/ConstantsScanner.h
+++ b/include/llvm/Analysis/ConstantsScanner.h
@@ -1,7 +1,14 @@
-//==-- llvm/Analysis/ConstantsScanner.h - Iterate over constants -*- C++ -*-==//
+//==- llvm/Analysis/ConstantsScanner.h - Iterate over constants -*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
 //
 // This class implements an iterator to walk through the constants referenced by
-// a method.  This is used by the Bytecode & Assembly writers to build constant
+// a method.  This is used by the Bitcode & Assembly writers to build constant
 // pools.
 //
 //===----------------------------------------------------------------------===//
@@ -9,43 +16,44 @@
 #ifndef LLVM_ANALYSIS_CONSTANTSSCANNER_H
 #define LLVM_ANALYSIS_CONSTANTSSCANNER_H
 
-#include "llvm/Method.h"
-#include "llvm/Instruction.h"
-#include <iterator>
-class ConstPoolVal;
+#include "llvm/Support/InstIterator.h"
 
-class constant_iterator
-  : public std::forward_iterator<const ConstPoolVal, ptrdiff_t> {
-  Method::inst_const_iterator InstI;        // Method instruction iterator
+namespace llvm {
+
+class Constant;
+
+class constant_iterator : public std::iterator<std::forward_iterator_tag,
+                                               const Constant, ptrdiff_t> {
+  const_inst_iterator InstI;                // Method instruction iterator
   unsigned OpIdx;                           // Operand index
 
   typedef constant_iterator _Self;
 
   inline bool isAtConstant() const {
     assert(!InstI.atEnd() && OpIdx < InstI->getNumOperands() &&
-	   "isAtConstant called with invalid arguments!");
-    return isa<ConstPoolVal>(InstI->getOperand(OpIdx));
+           "isAtConstant called with invalid arguments!");
+    return isa<Constant>(InstI->getOperand(OpIdx));
   }
 
 public:
-  inline constant_iterator(const Method *M) : InstI(M->inst_begin()), OpIdx(0) {
+  inline constant_iterator(const Function *F) : InstI(inst_begin(F)), OpIdx(0) {
     // Advance to first constant... if we are not already at constant or end
-    if (InstI != M->inst_end() &&                          // InstI is valid?
-	(InstI->getNumOperands() == 0 || !isAtConstant())) // Not at constant?
+    if (InstI != inst_end(F) &&                            // InstI is valid?
+        (InstI->getNumOperands() == 0 || !isAtConstant())) // Not at constant?
       operator++();
   }
 
-  inline constant_iterator(const Method *M, bool)   // end ctor
-    : InstI(M->inst_end()), OpIdx(0) {
+  inline constant_iterator(const Function *F, bool)   // end ctor
+    : InstI(inst_end(F)), OpIdx(0) {
   }
 
-  inline bool operator==(const _Self& x) const { return OpIdx == x.OpIdx && 
-						        InstI == x.InstI; }
+  inline bool operator==(const _Self& x) const { return OpIdx == x.OpIdx &&
+                                                        InstI == x.InstI; }
   inline bool operator!=(const _Self& x) const { return !operator==(x); }
 
   inline pointer operator*() const {
     assert(isAtConstant() && "Dereferenced an iterator at the end!");
-    return cast<ConstPoolVal>(InstI->getOperand(OpIdx));
+    return cast<Constant>(InstI->getOperand(OpIdx));
   }
   inline pointer operator->() const { return operator*(); }
 
@@ -54,7 +62,7 @@ public:
     do {
       unsigned NumOperands = InstI->getNumOperands();
       while (OpIdx < NumOperands && !isAtConstant()) {
-	++OpIdx;
+        ++OpIdx;
       }
 
       if (OpIdx < NumOperands) return *this;  // Found a constant!
@@ -66,18 +74,20 @@ public:
   }
 
   inline _Self operator++(int) { // Postincrement
-    _Self tmp = *this; ++*this; return tmp; 
+    _Self tmp = *this; ++*this; return tmp;
   }
 
   inline bool atEnd() const { return InstI.atEnd(); }
 };
 
-inline constant_iterator constant_begin(const Method *M) {
-  return constant_iterator(M);
+inline constant_iterator constant_begin(const Function *F) {
+  return constant_iterator(F);
 }
 
-inline constant_iterator constant_end(const Method *M) {
-  return constant_iterator(M, true);
+inline constant_iterator constant_end(const Function *F) {
+  return constant_iterator(F, true);
 }
 
+} // End llvm namespace
+
 #endif