37#include "llvm/Config/llvm-config.h"
66template <
typename ImplT,
typename IteratorT,
typename CollectionT>
67class CalcLiveRangeUtilBase {
72 CalcLiveRangeUtilBase(
LiveRange *LR) : LR(LR) {}
75 using Segment = LiveRange::Segment;
91 assert(!
Def.isDead() &&
"Cannot define a value at the dead slot");
93 "If ForVNI is specified, it must match Def");
94 iterator
I =
impl().find(Def);
95 if (
I == segments().
end()) {
96 VNInfo *VNI = ForVNI ? ForVNI : LR->getNextValue(Def, *VNInfoAllocator);
97 impl().insertAtEnd(Segment(Def,
Def.getDeadSlot(), VNI));
101 Segment *S = segmentAt(
I);
103 assert((!ForVNI || ForVNI == S->valno) &&
"Value number mismatch");
104 assert(S->valno->def == S->start &&
"Inconsistent existing value def");
111 Def = std::min(Def, S->start);
113 S->start = S->valno->def =
Def;
117 VNInfo *VNI = ForVNI ? ForVNI : LR->getNextValue(Def, *VNInfoAllocator);
118 segments().insert(
I, Segment(Def,
Def.getDeadSlot(), VNI));
122 VNInfo *extendInBlock(SlotIndex StartIdx, SlotIndex Use) {
123 if (segments().
empty())
126 impl().findInsertPos(Segment(
Use.getPrevSlot(), Use,
nullptr));
127 if (
I == segments().
begin())
130 if (
I->end <= StartIdx)
133 extendSegmentEndTo(
I, Use);
138 SlotIndex StartIdx, SlotIndex Use) {
139 if (segments().
empty())
140 return std::make_pair(
nullptr,
false);
141 SlotIndex BeforeUse =
Use.getPrevSlot();
142 iterator
I =
impl().findInsertPos(Segment(BeforeUse, Use,
nullptr));
143 if (
I == segments().
begin())
144 return std::make_pair(
nullptr, LR->isUndefIn(Undefs, StartIdx, BeforeUse));
146 if (
I->end <= StartIdx)
147 return std::make_pair(
nullptr, LR->isUndefIn(Undefs, StartIdx, BeforeUse));
149 if (LR->isUndefIn(Undefs,
I->end, BeforeUse))
150 return std::make_pair(
nullptr,
true);
151 extendSegmentEndTo(
I, Use);
153 return std::make_pair(
I->valno,
false);
160 void extendSegmentEndTo(iterator
I, SlotIndex NewEnd) {
161 assert(
I != segments().
end() &&
"Not a valid segment!");
162 Segment *S = segmentAt(
I);
163 VNInfo *ValNo =
I->valno;
166 iterator MergeTo = std::next(
I);
167 for (; MergeTo != segments().end() && NewEnd >= MergeTo->end; ++MergeTo)
168 assert(MergeTo->valno == ValNo &&
"Cannot merge with differing values!");
171 S->end = std::max(NewEnd, std::prev(MergeTo)->end);
175 if (MergeTo != segments().
end() && MergeTo->start <=
I->end &&
176 MergeTo->valno == ValNo) {
177 S->end = MergeTo->end;
182 segments().erase(std::next(
I), MergeTo);
188 iterator extendSegmentStartTo(iterator
I, SlotIndex NewStart) {
189 assert(
I != segments().
end() &&
"Not a valid segment!");
190 Segment *S = segmentAt(
I);
191 VNInfo *ValNo =
I->valno;
194 iterator MergeTo =
I;
196 if (MergeTo == segments().
begin()) {
198 segments().erase(MergeTo,
I);
201 assert(MergeTo->valno == ValNo &&
"Cannot merge with differing values!");
203 }
while (NewStart <= MergeTo->start);
207 if (MergeTo->end >= NewStart && MergeTo->valno == ValNo) {
208 segmentAt(MergeTo)->end = S->end;
212 Segment *MergeToSeg = segmentAt(MergeTo);
213 MergeToSeg->start = NewStart;
214 MergeToSeg->end = S->end;
217 segments().erase(std::next(MergeTo), std::next(
I));
221 iterator addSegment(Segment S) {
222 SlotIndex
Start = S.start,
End = S.end;
223 iterator
I =
impl().findInsertPos(S);
227 if (
I != segments().
begin()) {
228 iterator
B = std::prev(
I);
229 if (S.valno ==
B->valno) {
230 if (
B->start <= Start &&
B->end >= Start) {
231 extendSegmentEndTo(
B,
End);
238 "Cannot overlap two segments with differing ValID's"
239 " (did you def the same reg twice in a MachineInstr?)");
245 if (
I != segments().
end()) {
246 if (S.valno ==
I->valno) {
247 if (
I->start <=
End) {
248 I = extendSegmentStartTo(
I, Start);
253 extendSegmentEndTo(
I,
End);
260 "Cannot overlap two segments with differing ValID's");
267 return segments().insert(
I, S);
271 ImplT &
impl() {
return *
static_cast<ImplT *
>(
this); }
273 CollectionT &segments() {
return impl().segmentsColl(); }
275 Segment *segmentAt(iterator
I) {
return const_cast<Segment *
>(&(*I)); }
283class CalcLiveRangeUtilVector;
284using CalcLiveRangeUtilVectorBase =
288class CalcLiveRangeUtilVector :
public CalcLiveRangeUtilVectorBase {
290 CalcLiveRangeUtilVector(
LiveRange *LR) : CalcLiveRangeUtilVectorBase(LR) {}
293 friend CalcLiveRangeUtilVectorBase;
295 LiveRange::Segments &segmentsColl() {
return LR->
segments; }
312 [&](
const Segment &
X) {
return X.end <= Pos; });
316 return CalcLiveRangeUtilVector(
this).createDeadDef(Def, &VNIAlloc,
nullptr);
320 return CalcLiveRangeUtilVector(
this).createDeadDef(VNI->
def,
nullptr, VNI);
349 assert((StartPos->start <= i->start || StartPos == other.
begin()) &&
350 StartPos != other.
end() &&
"Bogus start position hint!");
352 if (i->start < j->start) {
353 i = std::upper_bound(i, ie, j->start);
354 if (i !=
begin()) --i;
355 }
else if (j->start < i->start) {
357 if (StartPos != other.
end() && StartPos->start <= i->start) {
359 j = std::upper_bound(j, je, i->start);
360 if (j != other.
begin()) --j;
366 if (j == je)
return false;
369 if (i->start > j->start) {
374 if (i->end > j->start)
402 if (J->start <
I->end) {
411 if (J->end >
I->end) {
419 while (J->end <=
I->start);
433 return Other.empty();
438 if (
I ==
end() ||
I->start > O.start)
442 while (
I->end < O.end) {
456void LiveRange::markValNoForDeletion(
VNInfo *ValNo) {
473 if (!Seen.
insert(VNI).second)
482 return CalcLiveRangeUtilVector(
this).addSegment(S);
492 for (
size_t N = NewSegs.
size();
N != 0;) {
493 if (Mid != Begin && NewSegs[
N - 1].start < Mid[-1].start)
496 *--Out = NewSegs[--
N];
513 if (Out->valno ==
I->valno && Out->end >=
I->start) {
514 Out->end = std::max(Out->end,
I->end);
519 "Overlapping segments with different values");
526 assert(
I !=
end() &&
"Cannot merge end iterator");
530 if (Prev->valno ==
I->valno && Prev->end ==
I->start) {
554 return CalcLiveRangeUtilVector(
this).extendInBlock(Undefs, StartIdx,
Kill);
558 return CalcLiveRangeUtilVector(
this).extendInBlock(StartIdx,
Kill);
562 bool RemoveDeadValNo) {
571 &&
"Segment is not entirely in range!");
575 if (
I->start == Start) {
611 markValNoForDeletion(ValNo);
619 [ValNo](
const Segment &S) {
return S.
valno == ValNo; });
621 markValNoForDeletion(ValNo);
625 const int *LHSValNoAssignments,
626 const int *RHSValNoAssignments,
633 bool MustMapCurValNos =
false;
635 unsigned NumNewVals = NewVNInfo.
size();
636 for (
unsigned i = 0; i != NumVals; ++i) {
637 unsigned LHSValID = LHSValNoAssignments[i];
639 (NewVNInfo[LHSValID] && NewVNInfo[LHSValID] !=
getValNumInfo(i))) {
640 MustMapCurValNos =
true;
646 if (MustMapCurValNos && !
empty()) {
650 OutIt->valno = NewVNInfo[LHSValNoAssignments[OutIt->valno->id]];
652 VNInfo* nextValNo = NewVNInfo[LHSValNoAssignments[
I->valno->id]];
653 assert(nextValNo &&
"Huh?");
658 if (OutIt->valno == nextValNo && OutIt->end ==
I->start) {
663 OutIt->valno = nextValNo;
665 OutIt->start =
I->start;
684 unsigned NumValNos = 0;
685 for (
unsigned i = 0; i < NumNewVals; ++i) {
686 VNInfo *VNI = NewVNInfo[i];
688 if (NumValNos >= NumVals)
692 VNI->
id = NumValNos++;
695 if (NumNewVals < NumVals)
696 valnos.resize(NumNewVals);
711 for (
const Segment &S : RHS.segments)
724 for (
const Segment &S : RHS.segments)
725 if (S.
valno == RHSValNo)
734 assert(
V1 != V2 &&
"Identical value#'s are always equivalent!");
742 if (
V1->id < V2->
id) {
750 if (S->valno !=
V1)
continue;
759 markValNoForDeletion(
V1);
777 if (SegmentI == SegmentE)
781 for ( ; SlotI != SlotE; ++SlotI) {
785 if (SegmentI == SegmentE)
789 if (SegmentI->contains(*SlotI))
798void LiveInterval::freeSubRange(SubRange *S) {
806 while (
I !=
nullptr) {
817 }
while (
I !=
nullptr &&
I->empty());
837 unsigned ComposeSubRegIdx) {
840 if (!
Reg || !
Reg.isVirtual())
852 assert(
MI &&
"Cannot find the definition of a value");
855 if (!MOI->isReg() || !MOI->isDef())
857 if (MOI->getReg() !=
Reg)
859 LaneBitmask OrigMask =
TRI.getSubRegIndexLaneMask(MOI->getSubReg());
862 ?
TRI.composeSubRegIndexLaneMask(ComposeSubRegIdx, OrigMask)
864 if ((ExpectedDefMask & LaneMask).
none())
873 for (
VNInfo *VNI : ToBeRemoved)
884 unsigned ComposeSubRegIdx) {
893 if (SRMask == Matching) {
899 SR.LaneMask = SRMask & ~Matching;
909 Apply(*MatchingRange);
910 ToApply &= ~Matching;
922 Sum += S.start.distance(S.end);
932 assert((VRegMask & LaneMask).any());
937 unsigned SubReg = MO.getSubReg();
938 assert(SubReg != 0 &&
"Undef should only be set on subreg defs");
941 if ((UndefMask & LaneMask).any()) {
951 return OS <<
'[' << S.
start <<
',' << S.
end <<
':' << S.
valno->
id <<
')';
954#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
956 dbgs() << *
this <<
'\n';
991 assert(vnum == vni->
id &&
"Bad VNInfo");
998 <<
static_cast<const LiveRange &
>(*this);
1007 OS <<
" weight:" << Weight;
1010#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1016 dbgs() << *
this <<
'\n';
1020 dbgs() << *
this <<
'\n';
1027 if (!
I->start.isValid())
1029 if (!
I->end.isValid())
1031 if (
I->start >=
I->end)
1033 if (
I->valno ==
nullptr)
1035 if (
I->valno->id >=
valnos.size())
1037 if (
I->valno !=
valnos[
I->valno->id])
1039 if (std::next(
I) != E) {
1040 if (
I->end > std::next(
I)->start)
1042 if (
I->end == std::next(
I)->start) {
1043 if (
I->valno == std::next(
I)->valno)
1062 if ((Mask & SR.LaneMask).any())
1065 Mask |= SR.LaneMask;
1068 if ((Mask & ~MaxMask).any())
1116#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1120 OS <<
"Clean updater: " << *LR <<
'\n';
1122 OS <<
"Null updater.\n";
1125 assert(LR &&
"Can't have null LR in dirty updater.");
1126 OS <<
" updater with gap = " << (ReadI - WriteI)
1127 <<
", last start = " << LastStart
1129 for (
const auto &S :
make_range(LR->begin(), WriteI))
1135 for (
const auto &S :
make_range(ReadI, LR->end()))
1148 assert(
A.start <=
B.start &&
"Unordered live segments.");
1149 if (
A.end ==
B.start)
1150 return A.valno ==
B.valno;
1151 if (
A.end <
B.start)
1153 assert(
A.valno ==
B.valno &&
"Cannot overlap different values");
1158 assert(LR &&
"Cannot add to a null destination");
1161 if (!LastStart.isValid() || LastStart > Seg.
start) {
1165 assert(Spills.empty() &&
"Leftover spilled segments");
1166 WriteI = ReadI = LR->begin();
1170 LastStart = Seg.
start;
1174 if (ReadI != E && ReadI->end <= Seg.
start) {
1176 if (ReadI != WriteI)
1179 if (ReadI == WriteI)
1180 ReadI = WriteI = LR->find(Seg.
start);
1182 while (ReadI != E && ReadI->end <= Seg.
start)
1183 *WriteI++ = *ReadI++;
1189 if (ReadI != E && ReadI->start <= Seg.
start) {
1190 assert(ReadI->valno == Seg.
valno &&
"Cannot overlap different values");
1192 if (ReadI->end >= Seg.
end)
1195 Seg.
start = ReadI->start;
1201 Seg.
end = std::max(Seg.
end, ReadI->end);
1206 if (!Spills.empty() &&
coalescable(Spills.back(), Seg)) {
1207 Seg.
start = Spills.back().start;
1208 Seg.
end = std::max(Spills.back().end, Seg.
end);
1213 if (WriteI != LR->begin() &&
coalescable(WriteI[-1], Seg)) {
1214 WriteI[-1].end = std::max(WriteI[-1].
end, Seg.
end);
1219 if (WriteI != ReadI) {
1226 LR->segments.push_back(Seg);
1227 WriteI = ReadI = LR->end();
1229 Spills.push_back(Seg);
1234void LiveRangeUpdater::mergeSpills() {
1235 size_t NumMoved = std::min(Spills.size(),
size_t(ReadI - WriteI));
1238 Spills.truncate(Spills.size() - NumMoved);
1247 assert(LR &&
"Cannot add to a null destination");
1250 if (Spills.empty()) {
1251 LR->segments.erase(WriteI, ReadI);
1257 size_t GapSize = ReadI - WriteI;
1258 if (GapSize < Spills.size()) {
1260 size_t WritePos = WriteI - LR->begin();
1263 WriteI = LR->begin() + WritePos;
1266 LR->segments.erase(WriteI + Spills.size(), ReadI);
1268 ReadI = WriteI + Spills.size();
1279 const VNInfo *used =
nullptr, *unused =
nullptr;
1280 bool HasUnreachablePHIDef =
false;
1287 EqClass.join(unused->id, VNI->
id);
1294 assert(
MBB &&
"Phi-def has no defining MBB");
1299 EqClass.join(VNI->
id, PVNI->id);
1306 EqClass.join(VNI->
id, UVNI->id);
1312 EqClass.join(used->id, unused->id);
1314 if (HasUnreachablePHIDef) {
1315 const VNInfo *Defined =
nullptr;
1323 unsigned Leader = EqClass.findLeader(VNI->
id);
1324 Leaders[VNI->
id] = Leader;
1326 KeepSeparate.
set(Leader);
1329 KeepSeparate.
set(Leader);
1338 unsigned Leader = Leaders[VNI->
id];
1339 if (KeepSeparate.
test(Leader))
1342 EqClass.join(Defined->
id, VNI->
id);
1343 KeepSeparate.
set(Leader);
1349 return EqClass.getNumClasses();
1359 if (
MI->isDebugValue()) {
1362 SlotIndex Idx = LIS.getSlotIndexes()->getIndexBefore(*
MI);
1374 MO.setReg(LIV[EqClass - 1]->reg());
1379 unsigned NumComponents = EqClass.getNumClasses();
1386 unsigned NumValNos = SR.valnos.size();
1388 VNIMapping.
reserve(NumValNos);
1390 SubRanges.
resize(NumComponents-1,
nullptr);
1391 for (
unsigned I = 0;
I < NumValNos; ++
I) {
1392 const VNInfo &VNI = *SR.valnos[
I];
1393 unsigned ComponentNum;
1398 assert(MainRangeVNI !=
nullptr
1399 &&
"SubRange def must have corresponding main range def");
1401 if (ComponentNum > 0 && SubRanges[ComponentNum-1] ==
nullptr) {
1402 SubRanges[ComponentNum-1]
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file implements the BitVector class.
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static BasicBlock::iterator findInsertPos(Value *Addr, Instruction *MemoryInst, Value *SunkAddr)
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
A common definition of LaneBitmask for use in TableGen and CodeGen.
static void createDeadDef(SlotIndexes &Indexes, VNInfo::Allocator &Alloc, LiveRange &LR, const MachineOperand &MO)
static LiveRange::iterator mergeBackward(LiveRange::iterator Begin, LiveRange::iterator Mid, ArrayRef< LiveRange::Segment > NewSegs)
Merge NewSegs into the segments [Begin, Mid), filling [Begin, Mid + NewSegs.size()) from the back.
static bool coalescable(const LiveRange::Segment &A, const LiveRange::Segment &B)
static void stripValuesNotDefiningMask(Register Reg, LiveInterval::SubRange &SR, LaneBitmask LaneMask, const SlotIndexes &Indexes, const TargetRegisterInfo &TRI, unsigned ComposeSubRegIdx)
For each VNI in SR, check whether or not that value defines part of the mask describe by LaneMask and...
This file contains helper functions to modify live ranges.
Register const TargetRegisterInfo * TRI
place backedge safepoints impl
MachineRegisterInfo & MRI
SI Optimize VGPR LiveRange
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
Get the array size.
bool empty() const
Check if the array is empty.
bool test(unsigned Idx) const
Returns true if bit Idx is set.
BitVector & set()
Set all bits in the bitvector.
A helper class for register coalescers.
bool isCoalescable(const MachineInstr *) const
Return true if MI is a copy instruction that will become an identity copy after coalescing.
LLVM_ABI void Distribute(LiveInterval &LI, LiveInterval *LIV[], MachineRegisterInfo &MRI)
Distribute values in LI into a separate LiveIntervals for each connected component.
LLVM_ABI unsigned Classify(const LiveRange &LR)
Classify the values in LR into connected components.
unsigned getEqClass(const VNInfo *VNI) const
getEqClass - Classify creates equivalence classes numbered 0..N.
ConstMIBundleOperands - Iterate over all operands in a const bundle of machine instructions.
bool isReachableFromEntry(const NodeT *A) const
isReachableFromEntry - Return true if A is dominated by the entry block of the function containing it...
A live range for subregisters.
LLVM_ABI void print(raw_ostream &OS) const
LLVM_ABI void dump() const
LiveInterval - This class represents the liveness of a register, or stack slot.
LLVM_ABI void removeEmptySubRanges()
Removes all subranges without any segments (subranges without segments are not considered valid and s...
bool hasSubRanges() const
Returns true if subregister liveness information is available.
LLVM_ABI void dump() const
LLVM_ABI unsigned getSize() const
getSize - Returns the sum of sizes of all the LiveRange's.
SubRange * createSubRangeFrom(BumpPtrAllocator &Allocator, LaneBitmask LaneMask, const LiveRange &CopyFrom)
Like createSubRange() but the new range is filled with a copy of the liveness information in CopyFrom...
iterator_range< subrange_iterator > subranges()
LLVM_ABI void refineSubRanges(BumpPtrAllocator &Allocator, LaneBitmask LaneMask, std::function< void(LiveInterval::SubRange &)> Apply, const SlotIndexes &Indexes, const TargetRegisterInfo &TRI, unsigned ComposeSubRegIdx=0)
Refines the subranges to support LaneMask.
LLVM_ABI void print(raw_ostream &OS) const
LLVM_ABI void computeSubRangeUndefs(SmallVectorImpl< SlotIndex > &Undefs, LaneBitmask LaneMask, const MachineRegisterInfo &MRI, const SlotIndexes &Indexes) const
For a given lane mask LaneMask, compute indexes at which the lane is marked undefined by subregister ...
SubRange * createSubRange(BumpPtrAllocator &Allocator, LaneBitmask LaneMask)
Creates a new empty subregister live range.
LLVM_ABI void clearSubRanges()
Removes all subregister liveness information.
Result of a LiveRange query.
VNInfo * valueIn() const
Return the value that is live-in to the instruction.
VNInfo * valueOut() const
Return the value leaving the instruction, if any.
VNInfo * valueDefined() const
Return the value defined by this instruction, if any.
LLVM_ABI void print(raw_ostream &) const
LLVM_ABI void flush()
Flush the updater state to LR so it is valid and contains all added segments.
LLVM_ABI void dump() const
bool isDirty() const
Return true if the LR is currently in an invalid state, and flush() needs to be called.
LLVM_ABI void add(LiveRange::Segment)
Add a segment to LR and coalesce when possible, just like LR.addSegment().
This class represents the liveness of a register, stack slot, etc.
VNInfo * getValNumInfo(unsigned ValNo)
getValNumInfo - Returns pointer to the specified val#.
LLVM_ABI iterator addSegment(Segment S)
Add the specified Segment to this range, merging segments as appropriate.
Segments::iterator iterator
LLVM_ABI void join(LiveRange &Other, const int *ValNoAssignments, const int *RHSValNoAssignments, SmallVectorImpl< VNInfo * > &NewVNInfo)
join - Join two live ranges (this, and other) together.
LLVM_ABI void MergeValueInAsValue(const LiveRange &RHS, const VNInfo *RHSValNo, VNInfo *LHSValNo)
MergeValueInAsValue - Merge all of the segments of a specific val# in RHS into this live range as the...
Segments::const_iterator const_iterator
LLVM_ABI VNInfo * createDeadDef(SlotIndex Def, VNInfo::Allocator &VNIAlloc)
createDeadDef - Make sure the range has a value defined at Def.
LLVM_ABI iterator mergeAdjacentSegments(iterator I)
Merge the segment pointed to by I with its immediate neighbors when they use the same value number an...
LLVM_ABI bool isLiveAtIndexes(ArrayRef< SlotIndex > Slots) const
LLVM_ABI bool covers(const LiveRange &Other) const
Returns true if all segments of the Other live range are completely covered by this live range.
LiveRange()=default
Constructs a new LiveRange object.
iterator advanceTo(iterator I, SlotIndex Pos)
advanceTo - Advance the specified iterator to point to the Segment containing the specified position,...
LLVM_ABI void removeValNo(VNInfo *ValNo)
removeValNo - Remove all the segments defined by the specified value#.
LLVM_ABI void RenumberValues()
RenumberValues - Renumber all values in order of appearance and remove unused values.
bool overlaps(const LiveRange &other) const
overlaps - Return true if the intersection of the two live ranges is not empty.
LLVM_ABI bool overlapsFrom(const LiveRange &Other, const_iterator StartPos) const
overlapsFrom - Return true if the intersection of the two live ranges is not empty.
LiveQueryResult Query(SlotIndex Idx) const
Query Liveness at Idx.
VNInfo * getVNInfoBefore(SlotIndex Idx) const
getVNInfoBefore - Return the VNInfo that is live up to but not necessarily including Idx,...
LLVM_ABI std::pair< VNInfo *, bool > extendInBlock(ArrayRef< SlotIndex > Undefs, SlotIndex StartIdx, SlotIndex Kill)
Attempt to extend a value defined after StartIdx to include Use.
LLVM_ABI void addSegments(ArrayRef< Segment > NewSegs)
Add NewSegs, sorted by start, in one pass.
bool verify() const
Walk the range and assert if any invariants fail to hold.
LLVM_ABI void append(const LiveRange::Segment S)
Append a segment to the list of segments.
friend class LiveRangeUpdater
LLVM_ABI VNInfo * MergeValueNumberInto(VNInfo *V1, VNInfo *V2)
MergeValueNumberInto - This method is called when two value numbers are found to be equivalent.
unsigned getNumValNums() const
LLVM_ABI void MergeSegmentsInAsValue(const LiveRange &RHS, VNInfo *LHSValNo)
Merge all of the live segments of a specific val# in RHS into this live range as the specified value ...
SmallVector< Segment, 2 > Segments
VNInfoList::const_iterator const_vni_iterator
LLVM_ABI void removeSegment(SlotIndex Start, SlotIndex End, bool RemoveDeadValNo=false)
Remove the specified interval from this live range.
LLVM_ABI void removeValNoIfDead(VNInfo *ValNo)
Mark ValNo for deletion if no segments in this range use it.
LLVM_ABI void dump() const
LLVM_ABI void print(raw_ostream &OS) const
VNInfo * getVNInfoAt(SlotIndex Idx) const
getVNInfoAt - Return the VNInfo that is live at Idx, or NULL.
LLVM_ABI iterator find(SlotIndex Pos)
find - Return an iterator pointing to the first segment that ends after Pos, or end().
bool isValid() const
isValid - Returns true until all the operands have been visited.
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
Representation of each machine instruction.
MachineOperand class - Representation of each machine instruction operand.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Wrapper class representing virtual and physical registers.
SlotIndex - An opaque wrapper around machine indexes.
static bool isSameInstr(SlotIndex A, SlotIndex B)
isSameInstr - Return true if A and B refer to the same instruction.
static bool isEarlierInstr(SlotIndex A, SlotIndex B)
isEarlierInstr - Return true if A refers to an instruction earlier than B.
SlotIndex getRegSlot(bool EC=false) const
Returns the register use/def slot in the current instruction for a normal or early-clobber def.
SlotIndex getInstructionIndex(const MachineInstr &MI, bool IgnoreBundle=false) const
Returns the base index for the given instruction.
MachineInstr * getInstructionFromIndex(SlotIndex index) const
Returns the instruction for the given index, or null if the given index has no instruction associated...
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void push_back(const T &Elt)
pointer data()
Return a pointer to the vector's buffer, even if empty().
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
VNInfo - Value Number Information.
LLVM_ABI void dump() const
LLVM_ABI void print(raw_ostream &OS) const
void markUnused()
Mark this value as unused.
BumpPtrAllocator Allocator
bool isUnused() const
Returns true if this value is unused.
unsigned id
The ID number of this value.
SlotIndex def
The index of the defining instruction.
bool isPHIDef() const
Returns true if this value is defined by a PHI instruction (or was, PHI instructions may have been el...
This class implements an extremely fast bulk output stream that can only output to a stream.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
NodeAddr< DefNode * > Def
NodeAddr< UseNode * > Use
LLVM_ABI iterator begin() const
This is an optimization pass for GlobalISel generic memory operations.
auto find(R &&Range, const T &Val)
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly.
@ Kill
The last use of a register.
@ EarlyClobber
Register definition happens before uses.
auto partition_point(R &&Range, Predicate P)
Binary search for the first iterator in a range where a predicate is false.
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
Printable PrintLaneMask(LaneBitmask LaneMask)
Create Printable object to print LaneBitmasks on a raw_ostream.
auto upper_bound(R &&Range, T &&Value)
Provide wrappers to std::upper_bound which take ranges instead of having to pass begin/end explicitly...
static void DistributeRange(LiveRangeT &LR, LiveRangeT *SplitLRs[], EqClassesT VNIClasses)
Helper function that distributes live range value numbers and the corresponding segments of a primary...
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
auto lower_bound(R &&Range, T &&Value)
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
ArrayRef(const T &OneElt) -> ArrayRef< T >
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Next
BumpPtrAllocatorImpl<> BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.
@ End
Run the machine verifier once, at the end of the pipeline.
LLVM_ABI Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)
Prints virtual and physical registers with or without a TRI instance.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
ListT< IteratorSpecifierT< T, I, E > > IteratorT
static constexpr LaneBitmask getAll()
constexpr bool none() const
constexpr bool any() const
This represents a simple continuous liveness interval for a value.
LLVM_ABI void dump() const