1 //===- llvm/CodeGen/MachineInstrBundleIterator.h ----------------*- 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 // Defines an iterator class that bundles MachineInstr. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H 15 #define LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H 16 17 #include "llvm/ADT/ilist.h" 18 #include "llvm/ADT/simple_ilist.h" 19 #include <cassert> 20 #include <iterator> 21 #include <type_traits> 22 23 namespace llvm { 24 25 template <class T, bool IsReverse> struct MachineInstrBundleIteratorTraits; 26 template <class T> struct MachineInstrBundleIteratorTraits<T, false> { 27 using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>; 28 using instr_iterator = typename list_type::iterator; 29 using nonconst_instr_iterator = typename list_type::iterator; 30 using const_instr_iterator = typename list_type::const_iterator; 31 }; 32 template <class T> struct MachineInstrBundleIteratorTraits<T, true> { 33 using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>; 34 using instr_iterator = typename list_type::reverse_iterator; 35 using nonconst_instr_iterator = typename list_type::reverse_iterator; 36 using const_instr_iterator = typename list_type::const_reverse_iterator; 37 }; 38 template <class T> struct MachineInstrBundleIteratorTraits<const T, false> { 39 using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>; 40 using instr_iterator = typename list_type::const_iterator; 41 using nonconst_instr_iterator = typename list_type::iterator; 42 using const_instr_iterator = typename list_type::const_iterator; 43 }; 44 template <class T> struct MachineInstrBundleIteratorTraits<const T, true> { 45 using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>; 46 using instr_iterator = typename list_type::const_reverse_iterator; 47 using nonconst_instr_iterator = typename list_type::reverse_iterator; 48 using const_instr_iterator = typename list_type::const_reverse_iterator; 49 }; 50 51 template <bool IsReverse> struct MachineInstrBundleIteratorHelper; 52 template <> struct MachineInstrBundleIteratorHelper<false> { 53 /// Get the beginning of the current bundle. 54 template <class Iterator> static Iterator getBundleBegin(Iterator I) { 55 if (!I.isEnd()) 56 while (I->isBundledWithPred()) 57 --I; 58 return I; 59 } 60 61 /// Get the final node of the current bundle. 62 template <class Iterator> static Iterator getBundleFinal(Iterator I) { 63 if (!I.isEnd()) 64 while (I->isBundledWithSucc()) 65 ++I; 66 return I; 67 } 68 69 /// Increment forward ilist iterator. 70 template <class Iterator> static void increment(Iterator &I) { 71 I = std::next(getBundleFinal(I)); 72 } 73 74 /// Decrement forward ilist iterator. 75 template <class Iterator> static void decrement(Iterator &I) { 76 I = getBundleBegin(std::prev(I)); 77 } 78 }; 79 80 template <> struct MachineInstrBundleIteratorHelper<true> { 81 /// Get the beginning of the current bundle. 82 template <class Iterator> static Iterator getBundleBegin(Iterator I) { 83 return MachineInstrBundleIteratorHelper<false>::getBundleBegin( 84 I.getReverse()) 85 .getReverse(); 86 } 87 88 /// Get the final node of the current bundle. 89 template <class Iterator> static Iterator getBundleFinal(Iterator I) { 90 return MachineInstrBundleIteratorHelper<false>::getBundleFinal( 91 I.getReverse()) 92 .getReverse(); 93 } 94 95 /// Increment reverse ilist iterator. 96 template <class Iterator> static void increment(Iterator &I) { 97 I = getBundleBegin(std::next(I)); 98 } 99 100 /// Decrement reverse ilist iterator. 101 template <class Iterator> static void decrement(Iterator &I) { 102 I = std::prev(getBundleFinal(I)); 103 } 104 }; 105 106 /// MachineBasicBlock iterator that automatically skips over MIs that are 107 /// inside bundles (i.e. walk top level MIs only). 108 template <typename Ty, bool IsReverse = false> 109 class MachineInstrBundleIterator : MachineInstrBundleIteratorHelper<IsReverse> { 110 using Traits = MachineInstrBundleIteratorTraits<Ty, IsReverse>; 111 using instr_iterator = typename Traits::instr_iterator; 112 113 instr_iterator MII; 114 115 public: 116 using value_type = typename instr_iterator::value_type; 117 using difference_type = typename instr_iterator::difference_type; 118 using pointer = typename instr_iterator::pointer; 119 using reference = typename instr_iterator::reference; 120 using const_pointer = typename instr_iterator::const_pointer; 121 using const_reference = typename instr_iterator::const_reference; 122 using iterator_category = std::bidirectional_iterator_tag; 123 124 private: 125 using nonconst_instr_iterator = typename Traits::nonconst_instr_iterator; 126 using const_instr_iterator = typename Traits::const_instr_iterator; 127 using nonconst_iterator = 128 MachineInstrBundleIterator<typename nonconst_instr_iterator::value_type, 129 IsReverse>; 130 using reverse_iterator = MachineInstrBundleIterator<Ty, !IsReverse>; 131 132 public: 133 MachineInstrBundleIterator(instr_iterator MI) : MII(MI) { 134 assert((!MI.getNodePtr() || MI.isEnd() || !MI->isBundledWithPred()) && 135 "It's not legal to initialize MachineInstrBundleIterator with a " 136 "bundled MI"); 137 } 138 139 MachineInstrBundleIterator(reference MI) : MII(MI) { 140 assert(!MI.isBundledWithPred() && "It's not legal to initialize " 141 "MachineInstrBundleIterator with a " 142 "bundled MI"); 143 } 144 145 MachineInstrBundleIterator(pointer MI) : MII(MI) { 146 // FIXME: This conversion should be explicit. 147 assert((!MI || !MI->isBundledWithPred()) && "It's not legal to initialize " 148 "MachineInstrBundleIterator " 149 "with a bundled MI"); 150 } 151 152 // Template allows conversion from const to nonconst. 153 template <class OtherTy> 154 MachineInstrBundleIterator( 155 const MachineInstrBundleIterator<OtherTy, IsReverse> &I, 156 typename std::enable_if<std::is_convertible<OtherTy *, Ty *>::value, 157 void *>::type = nullptr) 158 : MII(I.getInstrIterator()) {} 159 160 MachineInstrBundleIterator() : MII(nullptr) {} 161 162 /// Explicit conversion between forward/reverse iterators. 163 /// 164 /// Translate between forward and reverse iterators without changing range 165 /// boundaries. The resulting iterator will dereference (and have a handle) 166 /// to the previous node, which is somewhat unexpected; but converting the 167 /// two endpoints in a range will give the same range in reverse. 168 /// 169 /// This matches std::reverse_iterator conversions. 170 explicit MachineInstrBundleIterator( 171 const MachineInstrBundleIterator<Ty, !IsReverse> &I) 172 : MachineInstrBundleIterator(++I.getReverse()) {} 173 174 /// Get the bundle iterator for the given instruction's bundle. 175 static MachineInstrBundleIterator getAtBundleBegin(instr_iterator MI) { 176 return MachineInstrBundleIteratorHelper<IsReverse>::getBundleBegin(MI); 177 } 178 179 reference operator*() const { return *MII; } 180 pointer operator->() const { return &operator*(); } 181 182 /// Check for null. 183 bool isValid() const { return MII.getNodePtr(); } 184 185 friend bool operator==(const MachineInstrBundleIterator &L, 186 const MachineInstrBundleIterator &R) { 187 return L.MII == R.MII; 188 } 189 friend bool operator==(const MachineInstrBundleIterator &L, 190 const const_instr_iterator &R) { 191 return L.MII == R; // Avoid assertion about validity of R. 192 } 193 friend bool operator==(const const_instr_iterator &L, 194 const MachineInstrBundleIterator &R) { 195 return L == R.MII; // Avoid assertion about validity of L. 196 } 197 friend bool operator==(const MachineInstrBundleIterator &L, 198 const nonconst_instr_iterator &R) { 199 return L.MII == R; // Avoid assertion about validity of R. 200 } 201 friend bool operator==(const nonconst_instr_iterator &L, 202 const MachineInstrBundleIterator &R) { 203 return L == R.MII; // Avoid assertion about validity of L. 204 } 205 friend bool operator==(const MachineInstrBundleIterator &L, const_pointer R) { 206 return L == const_instr_iterator(R); // Avoid assertion about validity of R. 207 } 208 friend bool operator==(const_pointer L, const MachineInstrBundleIterator &R) { 209 return const_instr_iterator(L) == R; // Avoid assertion about validity of L. 210 } 211 friend bool operator==(const MachineInstrBundleIterator &L, 212 const_reference R) { 213 return L == &R; // Avoid assertion about validity of R. 214 } 215 friend bool operator==(const_reference L, 216 const MachineInstrBundleIterator &R) { 217 return &L == R; // Avoid assertion about validity of L. 218 } 219 220 friend bool operator!=(const MachineInstrBundleIterator &L, 221 const MachineInstrBundleIterator &R) { 222 return !(L == R); 223 } 224 friend bool operator!=(const MachineInstrBundleIterator &L, 225 const const_instr_iterator &R) { 226 return !(L == R); 227 } 228 friend bool operator!=(const const_instr_iterator &L, 229 const MachineInstrBundleIterator &R) { 230 return !(L == R); 231 } 232 friend bool operator!=(const MachineInstrBundleIterator &L, 233 const nonconst_instr_iterator &R) { 234 return !(L == R); 235 } 236 friend bool operator!=(const nonconst_instr_iterator &L, 237 const MachineInstrBundleIterator &R) { 238 return !(L == R); 239 } 240 friend bool operator!=(const MachineInstrBundleIterator &L, const_pointer R) { 241 return !(L == R); 242 } 243 friend bool operator!=(const_pointer L, const MachineInstrBundleIterator &R) { 244 return !(L == R); 245 } 246 friend bool operator!=(const MachineInstrBundleIterator &L, 247 const_reference R) { 248 return !(L == R); 249 } 250 friend bool operator!=(const_reference L, 251 const MachineInstrBundleIterator &R) { 252 return !(L == R); 253 } 254 255 // Increment and decrement operators... 256 MachineInstrBundleIterator &operator--() { 257 this->decrement(MII); 258 return *this; 259 } 260 MachineInstrBundleIterator &operator++() { 261 this->increment(MII); 262 return *this; 263 } 264 MachineInstrBundleIterator operator--(int) { 265 MachineInstrBundleIterator Temp = *this; 266 --*this; 267 return Temp; 268 } 269 MachineInstrBundleIterator operator++(int) { 270 MachineInstrBundleIterator Temp = *this; 271 ++*this; 272 return Temp; 273 } 274 275 instr_iterator getInstrIterator() const { return MII; } 276 277 nonconst_iterator getNonConstIterator() const { return MII.getNonConst(); } 278 279 /// Get a reverse iterator to the same node. 280 /// 281 /// Gives a reverse iterator that will dereference (and have a handle) to the 282 /// same node. Converting the endpoint iterators in a range will give a 283 /// different range; for range operations, use the explicit conversions. 284 reverse_iterator getReverse() const { return MII.getReverse(); } 285 }; 286 287 } // end namespace llvm 288 289 #endif // LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H 290
