Line data Source code
1 : //===- InstIterator.h - Classes for inst iteration --------------*- 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 file contains definitions of two iterators for iterating over the
11 : // instructions in a function. This is effectively a wrapper around a two level
12 : // iterator that can probably be genericized later.
13 : //
14 : // Note that this iterator gets invalidated any time that basic blocks or
15 : // instructions are moved around.
16 : //
17 : //===----------------------------------------------------------------------===//
18 :
19 : #ifndef LLVM_IR_INSTITERATOR_H
20 : #define LLVM_IR_INSTITERATOR_H
21 :
22 : #include "llvm/ADT/iterator_range.h"
23 : #include "llvm/IR/BasicBlock.h"
24 : #include "llvm/IR/Function.h"
25 : #include "llvm/IR/SymbolTableListTraits.h"
26 : #include <iterator>
27 :
28 : namespace llvm {
29 :
30 : // This class implements inst_begin() & inst_end() for
31 : // inst_iterator and const_inst_iterator's.
32 : //
33 : template <class BB_t, class BB_i_t, class BI_t, class II_t> class InstIterator {
34 : using BBty = BB_t;
35 : using BBIty = BB_i_t;
36 : using BIty = BI_t;
37 : using IIty = II_t;
38 : BB_t *BBs; // BasicBlocksType
39 : BB_i_t BB; // BasicBlocksType::iterator
40 : BI_t BI; // BasicBlock::iterator
41 :
42 : public:
43 : using iterator_category = std::bidirectional_iterator_tag;
44 : using value_type = IIty;
45 : using difference_type = signed;
46 : using pointer = IIty *;
47 : using reference = IIty &;
48 :
49 : // Default constructor
50 : InstIterator() = default;
51 :
52 : // Copy constructor...
53 : template<typename A, typename B, typename C, typename D>
54 : InstIterator(const InstIterator<A,B,C,D> &II)
55 : : BBs(II.BBs), BB(II.BB), BI(II.BI) {}
56 :
57 : template<typename A, typename B, typename C, typename D>
58 579 : InstIterator(InstIterator<A,B,C,D> &II)
59 34990 : : BBs(II.BBs), BB(II.BB), BI(II.BI) {}
60 :
61 1856507 : template<class M> InstIterator(M &m)
62 3713014 : : BBs(&m.getBasicBlockList()), BB(BBs->begin()) { // begin ctor
63 1856507 : if (BB != BBs->end()) {
64 1851001 : BI = BB->begin();
65 : advanceToNextBB();
66 : }
67 1856507 : }
68 0 :
69 1 : template<class M> InstIterator(M &m, bool)
70 2 : : BBs(&m.getBasicBlockList()), BB(BBs->end()) { // end ctor
71 0 : }
72 :
73 : // Accessors to get at the underlying iterators...
74 0 : inline BBIty &getBasicBlockIterator() { return BB; }
75 0 : inline BIty &getInstructionIterator() { return BI; }
76 0 :
77 135977649 : inline reference operator*() const { return *BI; }
78 0 : inline pointer operator->() const { return &operator*(); }
79 :
80 : inline bool operator==(const InstIterator &y) const {
81 137789894 : return BB == y.BB && (BB == BBs->end() || BI == y.BI);
82 : }
83 : inline bool operator!=(const InstIterator& y) const {
84 : return !operator==(y);
85 : }
86 :
87 137184168 : InstIterator& operator++() {
88 : ++BI;
89 : advanceToNextBB();
90 137184168 : return *this;
91 0 : }
92 0 : inline InstIterator operator++(int) {
93 39451 : InstIterator tmp = *this; ++*this; return tmp;
94 : }
95 0 :
96 : InstIterator& operator--() {
97 54 : while (BB == BBs->end() || BI == BB->begin()) {
98 : --BB;
99 0 : BI = BB->end();
100 : }
101 0 : --BI;
102 : return *this;
103 : }
104 0 : inline InstIterator operator--(int) {
105 : InstIterator tmp = *this; --*this; return tmp;
106 0 : }
107 :
108 : inline bool atEnd() const { return BB == BBs->end(); }
109 0 :
110 : private:
111 0 : inline void advanceToNextBB() {
112 : // The only way that the II could be broken is if it is now pointing to
113 : // the end() of the current BasicBlock and there are successor BBs.
114 149439794 : while (BI == BB->end()) {
115 : ++BB;
116 24437994 : if (BB == BBs->end()) break;
117 10404625 : BI = BB->begin();
118 : }
119 : }
120 : };
121 :
122 : using inst_iterator =
123 : InstIterator<SymbolTableList<BasicBlock>, Function::iterator,
124 : BasicBlock::iterator, Instruction>;
125 : using const_inst_iterator =
126 : InstIterator<const SymbolTableList<BasicBlock>,
127 : Function::const_iterator, BasicBlock::const_iterator,
128 : const Instruction>;
129 : using inst_range = iterator_range<inst_iterator>;
130 : using const_inst_range = iterator_range<const_inst_iterator>;
131 :
132 46162 : inline inst_iterator inst_begin(Function *F) { return inst_iterator(*F); }
133 : inline inst_iterator inst_end(Function *F) { return inst_iterator(*F, true); }
134 : inline inst_range instructions(Function *F) {
135 : return inst_range(inst_begin(F), inst_end(F));
136 : }
137 : inline const_inst_iterator inst_begin(const Function *F) {
138 449059 : return const_inst_iterator(*F);
139 : }
140 0 : inline const_inst_iterator inst_end(const Function *F) {
141 0 : return const_inst_iterator(*F, true);
142 : }
143 : inline const_inst_range instructions(const Function *F) {
144 : return const_inst_range(inst_begin(F), inst_end(F));
145 : }
146 1360887 : inline inst_iterator inst_begin(Function &F) { return inst_iterator(F); }
147 : inline inst_iterator inst_end(Function &F) { return inst_iterator(F, true); }
148 : inline inst_range instructions(Function &F) {
149 : return inst_range(inst_begin(F), inst_end(F));
150 : }
151 : inline const_inst_iterator inst_begin(const Function &F) {
152 9 : return const_inst_iterator(F);
153 : }
154 : inline const_inst_iterator inst_end(const Function &F) {
155 : return const_inst_iterator(F, true);
156 : }
157 : inline const_inst_range instructions(const Function &F) {
158 : return const_inst_range(inst_begin(F), inst_end(F));
159 : }
160 :
161 : } // end namespace llvm
162 :
163 : #endif // LLVM_IR_INSTITERATOR_H
|
