11 #ifndef LLVM_ANALYSIS_REGIONITERATOR_H
12 #define LLVM_ANALYSIS_REGIONITERATOR_H
33 template<
class NodeType,
class BlockT,
class RegionT>
35 NodeType, ptrdiff_t> {
36 typedef std::iterator<std::forward_iterator_tag, NodeType, ptrdiff_t> super;
39 typedef typename BlockTraits::ChildIteratorType SuccIterTy;
60 void advanceRegionSucc() {
61 assert(Node.
getInt() == ItRgBegin &&
"Cannot advance region successor!");
68 bool isRegionMode()
const {
return Node.
getInt() != ItBB; }
72 NodeType* getISucc(BlockT* BB)
const {
74 succ = getNode()->getParent()->getNode(BB);
75 assert(succ &&
"BB not in Region or entered subregion!");
80 inline BlockT* getRegionSucc()
const {
81 assert(Node.
getInt() == ItRgBegin &&
"Cannot get the region successor!");
82 return getNode()->template getNodeAs<RegionT>()->getExit();
86 inline bool isExit(BlockT* BB)
const {
87 return getNode()->getParent()->getExit() == BB;
96 : Node(node, node->isSubRegion() ? ItRgBegin : ItBB),
101 while (BlockTraits::child_end(node->getEntry()) != BItor && isExit(*BItor))
104 if (isRegionMode() && isExit(getRegionSucc()))
110 : Node(node, node->isSubRegion() ? ItRgEnd : ItBB),
114 assert(isRegionMode() == x.isRegionMode() &&
"Broken iterator!");
118 return BItor == x.BItor;
124 BlockT *BB = isRegionMode() ? getRegionSucc() : *BItor;
125 assert(!isExit(BB) &&
"Iterator out of range!");
137 while (BItor != BlockTraits::child_end(getNode()->getEntry())
157 template<
class NodeType,
class BlockT,
class RegionT>
159 :
public std::iterator<std::forward_iterator_tag, NodeType, ptrdiff_t> {
160 typedef std::iterator<std::forward_iterator_tag, NodeType, ptrdiff_t> super;
162 typedef typename BlockTraits::ChildIteratorType SuccIterTy;
178 assert(!Node->isSubRegion()
179 &&
"Subregion node not allowed in flat iterating mode!");
180 assert(Node->getParent() &&
"A BB node must have a parent!");
183 while (BlockTraits::child_end(Node->getEntry()) != Itor
184 && Node->getParent()->getExit() == *Itor)
192 assert(!Node->isSubRegion()
193 &&
"Subregion node not allowed in flat iterating mode!");
197 assert(Node->getParent() == x.Node->getParent()
198 &&
"Cannot compare iterators of different regions!");
200 return Itor == x.Itor && Node == x.Node;
209 RegionT *Parent = Node->getParent();
213 assert(Parent->getExit() != BB &&
"iterator out of range!");
215 return Parent->getBBNode(BB);
222 while (Itor !=
succ_end(Node->getEntry())
223 && Node->getParent()->getExit() == *Itor);
235 template<
class NodeType,
class BlockT,
class RegionT>
240 template<
class NodeType,
class BlockT,
class RegionT>
252 #define RegionNodeGraphTraits(NodeT, BlockT, RegionT) \
253 template<> struct GraphTraits<NodeT*> { \
254 typedef NodeT NodeType; \
255 typedef RNSuccIterator<NodeType, BlockT, RegionT> ChildIteratorType; \
256 static NodeType *getEntryNode(NodeType* N) { return N; } \
257 static inline ChildIteratorType child_begin(NodeType *N) { \
258 return RNSuccIterator<NodeType, BlockT, RegionT>(N); \
260 static inline ChildIteratorType child_end(NodeType *N) { \
261 return RNSuccIterator<NodeType, BlockT, RegionT>(N, true); \
264 template<> struct GraphTraits<FlatIt<NodeT*>> { \
265 typedef NodeT NodeType; \
266 typedef RNSuccIterator<FlatIt<NodeT>, BlockT, RegionT > ChildIteratorType; \
267 static NodeType *getEntryNode(NodeType* N) { return N; } \
268 static inline ChildIteratorType child_begin(NodeType *N) { \
269 return RNSuccIterator<FlatIt<NodeType>, BlockT, RegionT>(N); \
271 static inline ChildIteratorType child_end(NodeType *N) { \
272 return RNSuccIterator<FlatIt<NodeType>, BlockT, RegionT>(N, true); \
276 #define RegionGraphTraits(RegionT, NodeT) \
277 template<> struct GraphTraits<RegionT*> \
278 : public GraphTraits<NodeT*> { \
279 typedef df_iterator<NodeType*> nodes_iterator; \
280 static NodeType *getEntryNode(RegionT* R) { \
281 return R->getNode(R->getEntry()); \
283 static nodes_iterator nodes_begin(RegionT* R) { \
284 return nodes_iterator::begin(getEntryNode(R)); \
286 static nodes_iterator nodes_end(RegionT* R) { \
287 return nodes_iterator::end(getEntryNode(R)); \
290 template<> struct GraphTraits<FlatIt<RegionT*> > \
291 : public GraphTraits<FlatIt<NodeT*> > { \
292 typedef df_iterator<NodeType*, SmallPtrSet<NodeType*, 8>, false, \
293 GraphTraits<FlatIt<NodeType*> > > nodes_iterator; \
294 static NodeType *getEntryNode(RegionT* R) { \
295 return R->getBBNode(R->getEntry()); \
297 static nodes_iterator nodes_begin(RegionT* R) { \
298 return nodes_iterator::begin(getEntryNode(R)); \
300 static nodes_iterator nodes_end(RegionT* R) { \
301 return nodes_iterator::end(getEntryNode(R)); \
const_iterator end(StringRef path)
Get end iterator over path.
static NodeType * getEntryNode(RegionInfo *RI)
static nodes_iterator nodes_begin(RegionInfo *RI)
Hierarchical RegionNode successor iterator.
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
pointer operator*() const
static NodeType * getEntryNode(RegionInfoPass *RI)
const_iterator begin(StringRef path)
Get begin iterator over path.
RegionT * getTopLevelRegion() const
bool operator!=(const Self &x) const
static nodes_iterator nodes_end(RegionInfo *RI)
NodeType
ISD::NodeType enum - This enum defines the target-independent operators for a SelectionDAG.
RegionInfo & getRegionInfo()
static nodes_iterator nodes_begin(RegionInfoPass *RI)
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
RNSuccIterator< FlatIt< NodeType >, BlockT, RegionT > Self
RegionNodeGraphTraits(RegionNode, BasicBlock, Region)
pointer operator*() const
void setInt(IntType IntVal)
Interval::succ_iterator succ_end(Interval *I)
RNSuccIterator(NodeType *node, bool)
Create an end iterator.
RNSuccIterator(NodeType *node)
Create begin iterator of a RegionNode.
bool operator!=(const Self &x) const
bool operator==(const Self &x) const
Flat RegionNode iterator.
RNSuccIterator(NodeType *node, bool)
Create an end iterator.
PointerTy getPointer() const
FlatIt< RegionNode * >::UnknownGraphTypeError NodeType
RegionGraphTraits(Region, RegionNode)
df_iterator< NodeType *, SmallPtrSet< NodeType *, 8 >, false, GraphTraits< FlatIt< NodeType * > > > nodes_iterator
Marker class to iterate over the elements of a Region in flat mode.
static nodes_iterator nodes_end(RegionInfoPass *RI)
bool operator==(const Self &x) const
df_iterator< NodeType *, SmallPtrSet< NodeType *, 8 >, false, GraphTraits< FlatIt< NodeType * > > > nodes_iterator
RNSuccIterator(NodeType *node)
Create the iterator from a RegionNode.
RNSuccIterator< NodeType, BlockT, RegionT > Self