Correct word hyphenations
[oota-llvm.git] / include / llvm / Analysis / ConstantsScanner.h
1 //==- llvm/Analysis/ConstantsScanner.h - Iterate over constants -*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This class implements an iterator to walk through the constants referenced by
11 // a method.  This is used by the Bitcode & Assembly writers to build constant
12 // pools.
13 //
14 //===----------------------------------------------------------------------===//
15
16 #ifndef LLVM_ANALYSIS_CONSTANTSSCANNER_H
17 #define LLVM_ANALYSIS_CONSTANTSSCANNER_H
18
19 #include "llvm/Support/InstIterator.h"
20
21 namespace llvm {
22
23 class Constant;
24
25 class constant_iterator : public std::iterator<std::forward_iterator_tag,
26                                                const Constant, ptrdiff_t> {
27   const_inst_iterator InstI;                // Method instruction iterator
28   unsigned OpIdx;                           // Operand index
29
30   typedef constant_iterator _Self;
31
32   inline bool isAtConstant() const {
33     assert(!InstI.atEnd() && OpIdx < InstI->getNumOperands() &&
34            "isAtConstant called with invalid arguments!");
35     return isa<Constant>(InstI->getOperand(OpIdx));
36   }
37
38 public:
39   inline constant_iterator(const Function *F) : InstI(inst_begin(F)), OpIdx(0) {
40     // Advance to first constant... if we are not already at constant or end
41     if (InstI != inst_end(F) &&                            // InstI is valid?
42         (InstI->getNumOperands() == 0 || !isAtConstant())) // Not at constant?
43       operator++();
44   }
45
46   inline constant_iterator(const Function *F, bool)   // end ctor
47     : InstI(inst_end(F)), OpIdx(0) {
48   }
49
50   inline bool operator==(const _Self& x) const { return OpIdx == x.OpIdx &&
51                                                         InstI == x.InstI; }
52   inline bool operator!=(const _Self& x) const { return !operator==(x); }
53
54   inline pointer operator*() const {
55     assert(isAtConstant() && "Dereferenced an iterator at the end!");
56     return cast<Constant>(InstI->getOperand(OpIdx));
57   }
58   inline pointer operator->() const { return operator*(); }
59
60   inline _Self& operator++() {   // Preincrement implementation
61     ++OpIdx;
62     do {
63       unsigned NumOperands = InstI->getNumOperands();
64       while (OpIdx < NumOperands && !isAtConstant()) {
65         ++OpIdx;
66       }
67
68       if (OpIdx < NumOperands) return *this;  // Found a constant!
69       ++InstI;
70       OpIdx = 0;
71     } while (!InstI.atEnd());
72
73     return *this;  // At the end of the method
74   }
75
76   inline _Self operator++(int) { // Postincrement
77     _Self tmp = *this; ++*this; return tmp;
78   }
79
80   inline bool atEnd() const { return InstI.atEnd(); }
81 };
82
83 inline constant_iterator constant_begin(const Function *F) {
84   return constant_iterator(F);
85 }
86
87 inline constant_iterator constant_end(const Function *F) {
88   return constant_iterator(F, true);
89 }
90
91 } // End llvm namespace
92
93 #endif