33 #ifndef LLVM_ANALYSIS_INTERVALITERATOR_H
34 #define LLVM_ANALYSIS_INTERVALITERATOR_H
69 Int->
Nodes.push_back(BB);
88 template<
class NodeTy,
class OrigContainer_t,
class GT = GraphTraits<NodeTy*>,
89 class IGT = GraphTraits<Inverse<NodeTy*> > >
91 std::vector<std::pair<Interval*, typename Interval::succ_iterator> > IntStack;
92 std::set<BasicBlock*> Visited;
93 OrigContainer_t *OrigContainer;
102 if (!ProcessInterval(&M->
front())) {
108 : IntStack(std::move(x.IntStack)), Visited(std::move(x.Visited)),
109 OrigContainer(x.OrigContainer), IOwnMem(x.IOwnMem) {
122 while (!IntStack.empty()) {
129 return IntStack == x.IntStack;
139 assert(!IntStack.empty() &&
"Attempting to use interval iterator at end!");
144 EndIt =
succ_end(IntStack.back().first);
145 while (SuccIt != EndIt) {
148 if (Done)
return *
this;
152 if (IOwnMem)
delete IntStack.back().first;
156 }
while (!IntStack.empty());
175 bool ProcessInterval(NodeTy *Node) {
177 if (!Visited.insert(Header).second)
183 for (
typename GT::ChildIteratorType
I = GT::child_begin(Node),
184 E = GT::child_end(Node);
I !=
E; ++
I)
187 IntStack.push_back(std::make_pair(Int,
succ_begin(Int)));
200 void ProcessNode(
Interval *Int, NodeTy *Node) {
201 assert(Int &&
"Null interval == bad!");
202 assert(Node &&
"Null Node == bad!");
206 if (Visited.count(NodeHeader)) {
207 if (Int->contains(NodeHeader)) {
210 if (!Int->isSuccessor(NodeHeader))
211 Int->Successors.push_back(NodeHeader);
214 for (
typename IGT::ChildIteratorType
I = IGT::child_begin(Node),
215 E = IGT::child_end(Node);
I !=
E; ++
I) {
216 if (!Int->contains(*
I)) {
217 if (!Int->isSuccessor(NodeHeader))
218 Int->Successors.push_back(NodeHeader);
226 Visited.insert(NodeHeader);
228 if (Int->isSuccessor(NodeHeader)) {
230 Int->Successors.erase(
std::remove(Int->Successors.begin(),
231 Int->Successors.end(), NodeHeader),
232 Int->Successors.end());
237 for (
typename GT::ChildIteratorType It = GT::child_begin(Node),
238 End = GT::child_end(Node); It !=
End; ++It)
250 bool DeleteInts =
true) {
function_interval_iterator intervals_end(Function *)
const Interval * operator->() const
Interval Class - An Interval is a set of nodes defined such that every node in the interval has all o...
std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
bool operator==(const IntervalIterator &x) const
BasicBlock * getNodeHeader(BasicBlock *BB)
IntervalIterator< Interval, IntervalPartition > interval_part_interval_iterator
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...
function_interval_iterator intervals_begin(Function *F, bool DeleteInts=true)
void addNodeToInterval(Interval *Int, BasicBlock *BB)
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
Interval::succ_iterator succ_end(Interval *I)
LLVM Basic Block Representation.
bool operator!=(const IntervalIterator &x) const
static const unsigned End
const Interval * operator*() const
std::vector< BasicBlock * > Nodes
Nodes - The basic blocks in this interval.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
BasicBlock * getSourceGraphNode(Function *, BasicBlock *BB)
std::pair< uint32_t, uint32_t > Interval
IntervalIterator< BasicBlock, Function > function_interval_iterator
IntervalIterator(Function *M, bool OwnMemory)
Interval * getRootInterval()
BasicBlock * getHeaderNode() const
IntervalIterator operator++(int)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
const BasicBlock & front() const
IntervalIterator(IntervalIterator &&x)
IntervalIterator(IntervalPartition &IP, bool OwnMemory)
std::vector< BasicBlock * >::iterator succ_iterator
IntervalIterator & operator++()
std::forward_iterator_tag iterator_category
Interval * getBlockInterval(BasicBlock *BB)