mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-19 19:29:31 +00:00
will soon be renamed) into their own file. The new file should not emit DEBUG output or have other side effects. The LiveInterval class also now doesn't know whether its working on registers or some other thing. In the future we will want to use the LiveInterval class and friends to do stack packing. In addition to a code simplification, this will allow us to do it more easily. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@15134 91177308-0d34-0410-b5e6-96231b3b80d8
152 lines
4.4 KiB
C++
152 lines
4.4 KiB
C++
//===-- LiveInterval.cpp - Live Interval Representation -------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the LiveRange and LiveInterval classes. Given some
|
|
// numbering of each the machine instructions an interval [i, j) is said to be a
|
|
// live interval for register v if there is no instruction with number j' > j
|
|
// such that v is live at j' abd there is no instruction with number i' < i such
|
|
// that v is live at i'. In this implementation intervals can have holes,
|
|
// i.e. an interval might look like [1,20), [50,65), [1000,1001). Each
|
|
// individual range is represented as an instance of LiveRange, and the whole
|
|
// interval is represented as an instance of LiveInterval.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "LiveInterval.h"
|
|
#include "Support/STLExtras.h"
|
|
#include <ostream>
|
|
using namespace llvm;
|
|
|
|
// An example for liveAt():
|
|
//
|
|
// this = [1,4), liveAt(0) will return false. The instruction defining
|
|
// this spans slots [0,3]. The interval belongs to an spilled
|
|
// definition of the variable it represents. This is because slot 1 is
|
|
// used (def slot) and spans up to slot 3 (store slot).
|
|
//
|
|
bool LiveInterval::liveAt(unsigned index) const {
|
|
LiveRange dummy(index, index+1);
|
|
Ranges::const_iterator r = std::upper_bound(ranges.begin(),
|
|
ranges.end(),
|
|
dummy);
|
|
if (r == ranges.begin())
|
|
return false;
|
|
|
|
--r;
|
|
return index >= r->start && index < r->end;
|
|
}
|
|
|
|
// An example for overlaps():
|
|
//
|
|
// 0: A = ...
|
|
// 4: B = ...
|
|
// 8: C = A + B ;; last use of A
|
|
//
|
|
// The live intervals should look like:
|
|
//
|
|
// A = [3, 11)
|
|
// B = [7, x)
|
|
// C = [11, y)
|
|
//
|
|
// A->overlaps(C) should return false since we want to be able to join
|
|
// A and C.
|
|
bool LiveInterval::overlaps(const LiveInterval& other) const {
|
|
Ranges::const_iterator i = ranges.begin();
|
|
Ranges::const_iterator ie = ranges.end();
|
|
Ranges::const_iterator j = other.ranges.begin();
|
|
Ranges::const_iterator je = other.ranges.end();
|
|
if (i->start < j->start) {
|
|
i = std::upper_bound(i, ie, *j);
|
|
if (i != ranges.begin()) --i;
|
|
}
|
|
else if (j->start < i->start) {
|
|
j = std::upper_bound(j, je, *i);
|
|
if (j != other.ranges.begin()) --j;
|
|
}
|
|
|
|
while (i != ie && j != je) {
|
|
if (i->start == j->start)
|
|
return true;
|
|
|
|
if (i->start > j->start) {
|
|
swap(i, j);
|
|
swap(ie, je);
|
|
}
|
|
assert(i->start < j->start);
|
|
|
|
if (i->end > j->start)
|
|
return true;
|
|
++i;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void LiveInterval::addRange(LiveRange LR) {
|
|
Ranges::iterator it =
|
|
ranges.insert(std::upper_bound(ranges.begin(), ranges.end(), LR), LR);
|
|
|
|
mergeRangesBackward(mergeRangesForward(it));
|
|
}
|
|
|
|
void LiveInterval::join(const LiveInterval& other) {
|
|
Ranges::iterator cur = ranges.begin();
|
|
isDefinedOnce &= other.isDefinedOnce;
|
|
|
|
for (Ranges::const_iterator i = other.ranges.begin(),
|
|
e = other.ranges.end(); i != e; ++i) {
|
|
cur = ranges.insert(std::upper_bound(cur, ranges.end(), *i), *i);
|
|
cur = mergeRangesBackward(mergeRangesForward(cur));
|
|
}
|
|
weight += other.weight;
|
|
}
|
|
|
|
LiveInterval::Ranges::iterator
|
|
LiveInterval::mergeRangesForward(Ranges::iterator it) {
|
|
Ranges::iterator n;
|
|
while ((n = next(it)) != ranges.end()) {
|
|
if (n->start > it->end)
|
|
break;
|
|
it->end = std::max(it->end, n->end);
|
|
n = ranges.erase(n);
|
|
}
|
|
return it;
|
|
}
|
|
|
|
LiveInterval::Ranges::iterator
|
|
LiveInterval::mergeRangesBackward(Ranges::iterator it) {
|
|
while (it != ranges.begin()) {
|
|
Ranges::iterator p = prior(it);
|
|
if (it->start > p->end)
|
|
break;
|
|
|
|
it->start = std::min(it->start, p->start);
|
|
it->end = std::max(it->end, p->end);
|
|
it = ranges.erase(p);
|
|
}
|
|
|
|
return it;
|
|
}
|
|
|
|
std::ostream& llvm::operator<<(std::ostream& os, const LiveRange &LR) {
|
|
return os << "[" << LR.start << "," << LR.end << ")";
|
|
}
|
|
|
|
std::ostream& llvm::operator<<(std::ostream& os, const LiveInterval& li) {
|
|
os << "%reg" << li.reg << ',' << li.weight;
|
|
if (li.empty())
|
|
return os << "EMPTY";
|
|
|
|
os << " = ";
|
|
for (LiveInterval::Ranges::const_iterator i = li.ranges.begin(),
|
|
e = li.ranges.end(); i != e; ++i)
|
|
os << *i;
|
|
return os;
|
|
}
|