mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-03 18:29:48 +00:00
The old naming scheme (load/use/def/store) can be traced back to an old linear scan article, but the names don't match how slots are actually used. The load and store slots are not needed after the deferred spill code insertion framework was deleted. The use and def slots don't make any sense because we are using half-open intervals as is customary in C code, but the names suggest closed intervals. In reality, these slots were used to distinguish early-clobber defs from normal defs. The new naming scheme also has 4 slots, but the names match how the slots are really used. This is a purely mechanical renaming, but some of the code makes a lot more sense now. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@144503 91177308-0d34-0410-b5e6-96231b3b80d8
594 lines
21 KiB
C++
594 lines
21 KiB
C++
//===-- llvm/CodeGen/LiveInterval.h - Interval representation ---*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file 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' and 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.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CODEGEN_LIVEINTERVAL_H
|
|
#define LLVM_CODEGEN_LIVEINTERVAL_H
|
|
|
|
#include "llvm/ADT/IntEqClasses.h"
|
|
#include "llvm/Support/Allocator.h"
|
|
#include "llvm/Support/AlignOf.h"
|
|
#include "llvm/CodeGen/SlotIndexes.h"
|
|
#include <cassert>
|
|
#include <climits>
|
|
|
|
namespace llvm {
|
|
class LiveIntervals;
|
|
class MachineInstr;
|
|
class MachineRegisterInfo;
|
|
class TargetRegisterInfo;
|
|
class raw_ostream;
|
|
|
|
/// VNInfo - Value Number Information.
|
|
/// This class holds information about a machine level values, including
|
|
/// definition and use points.
|
|
///
|
|
class VNInfo {
|
|
private:
|
|
enum {
|
|
HAS_PHI_KILL = 1,
|
|
REDEF_BY_EC = 1 << 1,
|
|
IS_PHI_DEF = 1 << 2,
|
|
IS_UNUSED = 1 << 3
|
|
};
|
|
|
|
MachineInstr *copy;
|
|
unsigned char flags;
|
|
|
|
public:
|
|
typedef BumpPtrAllocator Allocator;
|
|
|
|
/// The ID number of this value.
|
|
unsigned id;
|
|
|
|
/// The index of the defining instruction (if isDefAccurate() returns true).
|
|
SlotIndex def;
|
|
|
|
/// VNInfo constructor.
|
|
VNInfo(unsigned i, SlotIndex d, MachineInstr *c)
|
|
: copy(c), flags(0), id(i), def(d)
|
|
{ }
|
|
|
|
/// VNInfo construtor, copies values from orig, except for the value number.
|
|
VNInfo(unsigned i, const VNInfo &orig)
|
|
: copy(orig.copy), flags(orig.flags), id(i), def(orig.def)
|
|
{ }
|
|
|
|
/// Copy from the parameter into this VNInfo.
|
|
void copyFrom(VNInfo &src) {
|
|
flags = src.flags;
|
|
copy = src.copy;
|
|
def = src.def;
|
|
}
|
|
|
|
/// Used for copying value number info.
|
|
unsigned getFlags() const { return flags; }
|
|
void setFlags(unsigned flags) { this->flags = flags; }
|
|
|
|
/// Merge flags from another VNInfo
|
|
void mergeFlags(const VNInfo *VNI) {
|
|
flags = (flags | VNI->flags) & ~IS_UNUSED;
|
|
}
|
|
|
|
/// For a register interval, if this VN was definied by a copy instr
|
|
/// getCopy() returns a pointer to it, otherwise returns 0.
|
|
/// For a stack interval the behaviour of this method is undefined.
|
|
MachineInstr* getCopy() const { return copy; }
|
|
/// For a register interval, set the copy member.
|
|
/// This method should not be called on stack intervals as it may lead to
|
|
/// undefined behavior.
|
|
void setCopy(MachineInstr *c) { copy = c; }
|
|
|
|
/// isDefByCopy - Return true when this value was defined by a copy-like
|
|
/// instruction as determined by MachineInstr::isCopyLike.
|
|
bool isDefByCopy() const { return copy != 0; }
|
|
|
|
/// Returns true if one or more kills are PHI nodes.
|
|
/// Obsolete, do not use!
|
|
bool hasPHIKill() const { return flags & HAS_PHI_KILL; }
|
|
/// Set the PHI kill flag on this value.
|
|
void setHasPHIKill(bool hasKill) {
|
|
if (hasKill)
|
|
flags |= HAS_PHI_KILL;
|
|
else
|
|
flags &= ~HAS_PHI_KILL;
|
|
}
|
|
|
|
/// Returns true if this value is re-defined by an early clobber somewhere
|
|
/// during the live range.
|
|
bool hasRedefByEC() const { return flags & REDEF_BY_EC; }
|
|
/// Set the "redef by early clobber" flag on this value.
|
|
void setHasRedefByEC(bool hasRedef) {
|
|
if (hasRedef)
|
|
flags |= REDEF_BY_EC;
|
|
else
|
|
flags &= ~REDEF_BY_EC;
|
|
}
|
|
|
|
/// Returns true if this value is defined by a PHI instruction (or was,
|
|
/// PHI instrucions may have been eliminated).
|
|
bool isPHIDef() const { return flags & IS_PHI_DEF; }
|
|
/// Set the "phi def" flag on this value.
|
|
void setIsPHIDef(bool phiDef) {
|
|
if (phiDef)
|
|
flags |= IS_PHI_DEF;
|
|
else
|
|
flags &= ~IS_PHI_DEF;
|
|
}
|
|
|
|
/// Returns true if this value is unused.
|
|
bool isUnused() const { return flags & IS_UNUSED; }
|
|
/// Set the "is unused" flag on this value.
|
|
void setIsUnused(bool unused) {
|
|
if (unused)
|
|
flags |= IS_UNUSED;
|
|
else
|
|
flags &= ~IS_UNUSED;
|
|
}
|
|
};
|
|
|
|
/// LiveRange structure - This represents a simple register range in the
|
|
/// program, with an inclusive start point and an exclusive end point.
|
|
/// These ranges are rendered as [start,end).
|
|
struct LiveRange {
|
|
SlotIndex start; // Start point of the interval (inclusive)
|
|
SlotIndex end; // End point of the interval (exclusive)
|
|
VNInfo *valno; // identifier for the value contained in this interval.
|
|
|
|
LiveRange(SlotIndex S, SlotIndex E, VNInfo *V)
|
|
: start(S), end(E), valno(V) {
|
|
|
|
assert(S < E && "Cannot create empty or backwards range");
|
|
}
|
|
|
|
/// contains - Return true if the index is covered by this range.
|
|
///
|
|
bool contains(SlotIndex I) const {
|
|
return start <= I && I < end;
|
|
}
|
|
|
|
/// containsRange - Return true if the given range, [S, E), is covered by
|
|
/// this range.
|
|
bool containsRange(SlotIndex S, SlotIndex E) const {
|
|
assert((S < E) && "Backwards interval?");
|
|
return (start <= S && S < end) && (start < E && E <= end);
|
|
}
|
|
|
|
bool operator<(const LiveRange &LR) const {
|
|
return start < LR.start || (start == LR.start && end < LR.end);
|
|
}
|
|
bool operator==(const LiveRange &LR) const {
|
|
return start == LR.start && end == LR.end;
|
|
}
|
|
|
|
void dump() const;
|
|
void print(raw_ostream &os) const;
|
|
|
|
private:
|
|
LiveRange(); // DO NOT IMPLEMENT
|
|
};
|
|
|
|
template <> struct isPodLike<LiveRange> { static const bool value = true; };
|
|
|
|
raw_ostream& operator<<(raw_ostream& os, const LiveRange &LR);
|
|
|
|
|
|
inline bool operator<(SlotIndex V, const LiveRange &LR) {
|
|
return V < LR.start;
|
|
}
|
|
|
|
inline bool operator<(const LiveRange &LR, SlotIndex V) {
|
|
return LR.start < V;
|
|
}
|
|
|
|
/// LiveInterval - This class represents some number of live ranges for a
|
|
/// register or value. This class also contains a bit of register allocator
|
|
/// state.
|
|
class LiveInterval {
|
|
public:
|
|
|
|
typedef SmallVector<LiveRange,4> Ranges;
|
|
typedef SmallVector<VNInfo*,4> VNInfoList;
|
|
|
|
const unsigned reg; // the register or stack slot of this interval.
|
|
float weight; // weight of this interval
|
|
Ranges ranges; // the ranges in which this register is live
|
|
VNInfoList valnos; // value#'s
|
|
|
|
struct InstrSlots {
|
|
enum {
|
|
LOAD = 0,
|
|
USE = 1,
|
|
DEF = 2,
|
|
STORE = 3,
|
|
NUM = 4
|
|
};
|
|
|
|
};
|
|
|
|
LiveInterval(unsigned Reg, float Weight)
|
|
: reg(Reg), weight(Weight) {}
|
|
|
|
typedef Ranges::iterator iterator;
|
|
iterator begin() { return ranges.begin(); }
|
|
iterator end() { return ranges.end(); }
|
|
|
|
typedef Ranges::const_iterator const_iterator;
|
|
const_iterator begin() const { return ranges.begin(); }
|
|
const_iterator end() const { return ranges.end(); }
|
|
|
|
typedef VNInfoList::iterator vni_iterator;
|
|
vni_iterator vni_begin() { return valnos.begin(); }
|
|
vni_iterator vni_end() { return valnos.end(); }
|
|
|
|
typedef VNInfoList::const_iterator const_vni_iterator;
|
|
const_vni_iterator vni_begin() const { return valnos.begin(); }
|
|
const_vni_iterator vni_end() const { return valnos.end(); }
|
|
|
|
/// advanceTo - Advance the specified iterator to point to the LiveRange
|
|
/// containing the specified position, or end() if the position is past the
|
|
/// end of the interval. If no LiveRange contains this position, but the
|
|
/// position is in a hole, this method returns an iterator pointing to the
|
|
/// LiveRange immediately after the hole.
|
|
iterator advanceTo(iterator I, SlotIndex Pos) {
|
|
assert(I != end());
|
|
if (Pos >= endIndex())
|
|
return end();
|
|
while (I->end <= Pos) ++I;
|
|
return I;
|
|
}
|
|
|
|
/// find - Return an iterator pointing to the first range that ends after
|
|
/// Pos, or end(). This is the same as advanceTo(begin(), Pos), but faster
|
|
/// when searching large intervals.
|
|
///
|
|
/// If Pos is contained in a LiveRange, that range is returned.
|
|
/// If Pos is in a hole, the following LiveRange is returned.
|
|
/// If Pos is beyond endIndex, end() is returned.
|
|
iterator find(SlotIndex Pos);
|
|
|
|
const_iterator find(SlotIndex Pos) const {
|
|
return const_cast<LiveInterval*>(this)->find(Pos);
|
|
}
|
|
|
|
void clear() {
|
|
valnos.clear();
|
|
ranges.clear();
|
|
}
|
|
|
|
bool hasAtLeastOneValue() const { return !valnos.empty(); }
|
|
|
|
bool containsOneValue() const { return valnos.size() == 1; }
|
|
|
|
unsigned getNumValNums() const { return (unsigned)valnos.size(); }
|
|
|
|
/// getValNumInfo - Returns pointer to the specified val#.
|
|
///
|
|
inline VNInfo *getValNumInfo(unsigned ValNo) {
|
|
return valnos[ValNo];
|
|
}
|
|
inline const VNInfo *getValNumInfo(unsigned ValNo) const {
|
|
return valnos[ValNo];
|
|
}
|
|
|
|
/// containsValue - Returns true if VNI belongs to this interval.
|
|
bool containsValue(const VNInfo *VNI) const {
|
|
return VNI && VNI->id < getNumValNums() && VNI == getValNumInfo(VNI->id);
|
|
}
|
|
|
|
/// getNextValue - Create a new value number and return it. MIIdx specifies
|
|
/// the instruction that defines the value number.
|
|
VNInfo *getNextValue(SlotIndex def, MachineInstr *CopyMI,
|
|
VNInfo::Allocator &VNInfoAllocator) {
|
|
VNInfo *VNI =
|
|
new (VNInfoAllocator) VNInfo((unsigned)valnos.size(), def, CopyMI);
|
|
valnos.push_back(VNI);
|
|
return VNI;
|
|
}
|
|
|
|
/// Create a copy of the given value. The new value will be identical except
|
|
/// for the Value number.
|
|
VNInfo *createValueCopy(const VNInfo *orig,
|
|
VNInfo::Allocator &VNInfoAllocator) {
|
|
VNInfo *VNI =
|
|
new (VNInfoAllocator) VNInfo((unsigned)valnos.size(), *orig);
|
|
valnos.push_back(VNI);
|
|
return VNI;
|
|
}
|
|
|
|
/// RenumberValues - Renumber all values in order of appearance and remove
|
|
/// unused values.
|
|
void RenumberValues(LiveIntervals &lis);
|
|
|
|
/// isOnlyLROfValNo - Return true if the specified live range is the only
|
|
/// one defined by the its val#.
|
|
bool isOnlyLROfValNo(const LiveRange *LR) {
|
|
for (const_iterator I = begin(), E = end(); I != E; ++I) {
|
|
const LiveRange *Tmp = I;
|
|
if (Tmp != LR && Tmp->valno == LR->valno)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// MergeValueNumberInto - This method is called when two value nubmers
|
|
/// are found to be equivalent. This eliminates V1, replacing all
|
|
/// LiveRanges with the V1 value number with the V2 value number. This can
|
|
/// cause merging of V1/V2 values numbers and compaction of the value space.
|
|
VNInfo* MergeValueNumberInto(VNInfo *V1, VNInfo *V2);
|
|
|
|
/// MergeValueInAsValue - Merge all of the live ranges of a specific val#
|
|
/// in RHS into this live interval as the specified value number.
|
|
/// The LiveRanges in RHS are allowed to overlap with LiveRanges in the
|
|
/// current interval, it will replace the value numbers of the overlaped
|
|
/// live ranges with the specified value number.
|
|
void MergeRangesInAsValue(const LiveInterval &RHS, VNInfo *LHSValNo);
|
|
|
|
/// MergeValueInAsValue - Merge all of the live ranges of a specific val#
|
|
/// in RHS into this live interval as the specified value number.
|
|
/// The LiveRanges in RHS are allowed to overlap with LiveRanges in the
|
|
/// current interval, but only if the overlapping LiveRanges have the
|
|
/// specified value number.
|
|
void MergeValueInAsValue(const LiveInterval &RHS,
|
|
const VNInfo *RHSValNo, VNInfo *LHSValNo);
|
|
|
|
/// Copy - Copy the specified live interval. This copies all the fields
|
|
/// except for the register of the interval.
|
|
void Copy(const LiveInterval &RHS, MachineRegisterInfo *MRI,
|
|
VNInfo::Allocator &VNInfoAllocator);
|
|
|
|
bool empty() const { return ranges.empty(); }
|
|
|
|
/// beginIndex - Return the lowest numbered slot covered by interval.
|
|
SlotIndex beginIndex() const {
|
|
assert(!empty() && "Call to beginIndex() on empty interval.");
|
|
return ranges.front().start;
|
|
}
|
|
|
|
/// endNumber - return the maximum point of the interval of the whole,
|
|
/// exclusive.
|
|
SlotIndex endIndex() const {
|
|
assert(!empty() && "Call to endIndex() on empty interval.");
|
|
return ranges.back().end;
|
|
}
|
|
|
|
bool expiredAt(SlotIndex index) const {
|
|
return index >= endIndex();
|
|
}
|
|
|
|
bool liveAt(SlotIndex index) const {
|
|
const_iterator r = find(index);
|
|
return r != end() && r->start <= index;
|
|
}
|
|
|
|
/// killedAt - Return true if a live range ends at index. Note that the kill
|
|
/// point is not contained in the half-open live range. It is usually the
|
|
/// getDefIndex() slot following its last use.
|
|
bool killedAt(SlotIndex index) const {
|
|
const_iterator r = find(index.getRegSlot(true));
|
|
return r != end() && r->end == index;
|
|
}
|
|
|
|
/// killedInRange - Return true if the interval has kills in [Start,End).
|
|
/// Note that the kill point is considered the end of a live range, so it is
|
|
/// not contained in the live range. If a live range ends at End, it won't
|
|
/// be counted as a kill by this method.
|
|
bool killedInRange(SlotIndex Start, SlotIndex End) const;
|
|
|
|
/// getLiveRangeContaining - Return the live range that contains the
|
|
/// specified index, or null if there is none.
|
|
const LiveRange *getLiveRangeContaining(SlotIndex Idx) const {
|
|
const_iterator I = FindLiveRangeContaining(Idx);
|
|
return I == end() ? 0 : &*I;
|
|
}
|
|
|
|
/// getLiveRangeContaining - Return the live range that contains the
|
|
/// specified index, or null if there is none.
|
|
LiveRange *getLiveRangeContaining(SlotIndex Idx) {
|
|
iterator I = FindLiveRangeContaining(Idx);
|
|
return I == end() ? 0 : &*I;
|
|
}
|
|
|
|
/// getVNInfoAt - Return the VNInfo that is live at Idx, or NULL.
|
|
VNInfo *getVNInfoAt(SlotIndex Idx) const {
|
|
const_iterator I = FindLiveRangeContaining(Idx);
|
|
return I == end() ? 0 : I->valno;
|
|
}
|
|
|
|
/// getVNInfoBefore - Return the VNInfo that is live up to but not
|
|
/// necessarilly including Idx, or NULL. Use this to find the reaching def
|
|
/// used by an instruction at this SlotIndex position.
|
|
VNInfo *getVNInfoBefore(SlotIndex Idx) const {
|
|
const_iterator I = FindLiveRangeContaining(Idx.getPrevSlot());
|
|
return I == end() ? 0 : I->valno;
|
|
}
|
|
|
|
/// FindLiveRangeContaining - Return an iterator to the live range that
|
|
/// contains the specified index, or end() if there is none.
|
|
iterator FindLiveRangeContaining(SlotIndex Idx) {
|
|
iterator I = find(Idx);
|
|
return I != end() && I->start <= Idx ? I : end();
|
|
}
|
|
|
|
const_iterator FindLiveRangeContaining(SlotIndex Idx) const {
|
|
const_iterator I = find(Idx);
|
|
return I != end() && I->start <= Idx ? I : end();
|
|
}
|
|
|
|
/// findDefinedVNInfo - Find the by the specified
|
|
/// index (register interval) or defined
|
|
VNInfo *findDefinedVNInfoForRegInt(SlotIndex Idx) const;
|
|
|
|
|
|
/// overlaps - Return true if the intersection of the two live intervals is
|
|
/// not empty.
|
|
bool overlaps(const LiveInterval& other) const {
|
|
if (other.empty())
|
|
return false;
|
|
return overlapsFrom(other, other.begin());
|
|
}
|
|
|
|
/// overlaps - Return true if the live interval overlaps a range specified
|
|
/// by [Start, End).
|
|
bool overlaps(SlotIndex Start, SlotIndex End) const;
|
|
|
|
/// overlapsFrom - Return true if the intersection of the two live intervals
|
|
/// is not empty. The specified iterator is a hint that we can begin
|
|
/// scanning the Other interval starting at I.
|
|
bool overlapsFrom(const LiveInterval& other, const_iterator I) const;
|
|
|
|
/// addRange - Add the specified LiveRange to this interval, merging
|
|
/// intervals as appropriate. This returns an iterator to the inserted live
|
|
/// range (which may have grown since it was inserted.
|
|
void addRange(LiveRange LR) {
|
|
addRangeFrom(LR, ranges.begin());
|
|
}
|
|
|
|
/// extendInBlock - If this interval is live before Kill in the basic block
|
|
/// that starts at StartIdx, extend it to be live up to Kill, and return
|
|
/// the value. If there is no live range before Kill, return NULL.
|
|
VNInfo *extendInBlock(SlotIndex StartIdx, SlotIndex Kill);
|
|
|
|
/// join - Join two live intervals (this, and other) together. This applies
|
|
/// mappings to the value numbers in the LHS/RHS intervals as specified. If
|
|
/// the intervals are not joinable, this aborts.
|
|
void join(LiveInterval &Other,
|
|
const int *ValNoAssignments,
|
|
const int *RHSValNoAssignments,
|
|
SmallVector<VNInfo*, 16> &NewVNInfo,
|
|
MachineRegisterInfo *MRI);
|
|
|
|
/// isInOneLiveRange - Return true if the range specified is entirely in the
|
|
/// a single LiveRange of the live interval.
|
|
bool isInOneLiveRange(SlotIndex Start, SlotIndex End) const {
|
|
const_iterator r = find(Start);
|
|
return r != end() && r->containsRange(Start, End);
|
|
}
|
|
|
|
/// removeRange - Remove the specified range from this interval. Note that
|
|
/// the range must be a single LiveRange in its entirety.
|
|
void removeRange(SlotIndex Start, SlotIndex End,
|
|
bool RemoveDeadValNo = false);
|
|
|
|
void removeRange(LiveRange LR, bool RemoveDeadValNo = false) {
|
|
removeRange(LR.start, LR.end, RemoveDeadValNo);
|
|
}
|
|
|
|
/// removeValNo - Remove all the ranges defined by the specified value#.
|
|
/// Also remove the value# from value# list.
|
|
void removeValNo(VNInfo *ValNo);
|
|
|
|
/// getSize - Returns the sum of sizes of all the LiveRange's.
|
|
///
|
|
unsigned getSize() const;
|
|
|
|
/// Returns true if the live interval is zero length, i.e. no live ranges
|
|
/// span instructions. It doesn't pay to spill such an interval.
|
|
bool isZeroLength(SlotIndexes *Indexes) const {
|
|
for (const_iterator i = begin(), e = end(); i != e; ++i)
|
|
if (Indexes->getNextNonNullIndex(i->start).getBaseIndex() <
|
|
i->end.getBaseIndex())
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/// isSpillable - Can this interval be spilled?
|
|
bool isSpillable() const {
|
|
return weight != HUGE_VALF;
|
|
}
|
|
|
|
/// markNotSpillable - Mark interval as not spillable
|
|
void markNotSpillable() {
|
|
weight = HUGE_VALF;
|
|
}
|
|
|
|
/// ComputeJoinedWeight - Set the weight of a live interval after
|
|
/// Other has been merged into it.
|
|
void ComputeJoinedWeight(const LiveInterval &Other);
|
|
|
|
bool operator<(const LiveInterval& other) const {
|
|
const SlotIndex &thisIndex = beginIndex();
|
|
const SlotIndex &otherIndex = other.beginIndex();
|
|
return (thisIndex < otherIndex ||
|
|
(thisIndex == otherIndex && reg < other.reg));
|
|
}
|
|
|
|
void print(raw_ostream &OS, const TargetRegisterInfo *TRI = 0) const;
|
|
void dump() const;
|
|
|
|
private:
|
|
|
|
Ranges::iterator addRangeFrom(LiveRange LR, Ranges::iterator From);
|
|
void extendIntervalEndTo(Ranges::iterator I, SlotIndex NewEnd);
|
|
Ranges::iterator extendIntervalStartTo(Ranges::iterator I, SlotIndex NewStr);
|
|
void markValNoForDeletion(VNInfo *V);
|
|
|
|
LiveInterval& operator=(const LiveInterval& rhs); // DO NOT IMPLEMENT
|
|
|
|
};
|
|
|
|
inline raw_ostream &operator<<(raw_ostream &OS, const LiveInterval &LI) {
|
|
LI.print(OS);
|
|
return OS;
|
|
}
|
|
|
|
/// ConnectedVNInfoEqClasses - Helper class that can divide VNInfos in a
|
|
/// LiveInterval into equivalence clases of connected components. A
|
|
/// LiveInterval that has multiple connected components can be broken into
|
|
/// multiple LiveIntervals.
|
|
///
|
|
/// Given a LiveInterval that may have multiple connected components, run:
|
|
///
|
|
/// unsigned numComps = ConEQ.Classify(LI);
|
|
/// if (numComps > 1) {
|
|
/// // allocate numComps-1 new LiveIntervals into LIS[1..]
|
|
/// ConEQ.Distribute(LIS);
|
|
/// }
|
|
|
|
class ConnectedVNInfoEqClasses {
|
|
LiveIntervals &LIS;
|
|
IntEqClasses EqClass;
|
|
|
|
// Note that values a and b are connected.
|
|
void Connect(unsigned a, unsigned b);
|
|
|
|
unsigned Renumber();
|
|
|
|
public:
|
|
explicit ConnectedVNInfoEqClasses(LiveIntervals &lis) : LIS(lis) {}
|
|
|
|
/// Classify - Classify the values in LI into connected components.
|
|
/// Return the number of connected components.
|
|
unsigned Classify(const LiveInterval *LI);
|
|
|
|
/// getEqClass - Classify creates equivalence classes numbered 0..N. Return
|
|
/// the equivalence class assigned the VNI.
|
|
unsigned getEqClass(const VNInfo *VNI) const { return EqClass[VNI->id]; }
|
|
|
|
/// Distribute - Distribute values in LIV[0] into a separate LiveInterval
|
|
/// for each connected component. LIV must have a LiveInterval for each
|
|
/// connected component. The LiveIntervals in Liv[1..] must be empty.
|
|
/// Instructions using LIV[0] are rewritten.
|
|
void Distribute(LiveInterval *LIV[], MachineRegisterInfo &MRI);
|
|
|
|
};
|
|
|
|
}
|
|
#endif
|