|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
include/llvm/CodeGen/LiveInterval.h 679 class LiveInterval : public LiveRange {
686 class SubRange : public LiveRange {
References
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/ADT/STLExtras.h 154 auto adl_begin(ContainerTy &&container)
162 auto adl_end(ContainerTy &&container)
178 auto adl_begin(ContainerTy &&container)
184 auto adl_end(ContainerTy &&container)
1205 auto remove_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
1276 auto upper_bound(R &&Range, T &&Value) -> decltype(adl_begin(Range)) {
include/llvm/CodeGen/LiveInterval.h 236 LiveRange(const LiveRange &Other, BumpPtrAllocator &Allocator) {
243 void assign(const LiveRange &Other, BumpPtrAllocator &Allocator) {
363 void MergeSegmentsInAsValue(const LiveRange &RHS, VNInfo *LHSValNo);
370 void MergeValueInAsValue(const LiveRange &RHS,
439 bool overlaps(const LiveRange &other) const {
450 bool overlaps(const LiveRange &Other, const CoalescerPair &CP,
460 bool overlapsFrom(const LiveRange &Other, const_iterator StartPos) const;
466 bool covers(const LiveRange &Other) const;
500 void join(LiveRange &Other,
590 bool operator<(const LiveRange& other) const {
664 void append(const LiveRange::Segment S);
672 inline raw_ostream &operator<<(raw_ostream &OS, const LiveRange &LR) {
679 class LiveInterval : public LiveRange {
681 using super = LiveRange;
686 class SubRange : public LiveRange {
695 SubRange(LaneBitmask LaneMask, const LiveRange &Other,
785 const LiveRange &CopyFrom) {
884 raw_ostream &operator<<(raw_ostream &OS, const LiveRange::Segment &S);
886 inline bool operator<(SlotIndex V, const LiveRange::Segment &S) {
890 inline bool operator<(const LiveRange::Segment &S, SlotIndex V) {
903 LiveRange *LR;
905 LiveRange::iterator WriteI;
906 LiveRange::iterator ReadI;
907 SmallVector<LiveRange::Segment, 16> Spills;
913 LiveRangeUpdater(LiveRange *lr = nullptr) : LR(lr) {}
920 void add(LiveRange::Segment);
935 void setDest(LiveRange *lr) {
942 LiveRange *getDest() const { return LR; }
975 unsigned Classify(const LiveRange &LR);
include/llvm/CodeGen/LiveIntervalUnion.h 91 void unify(LiveInterval &VirtReg, const LiveRange &Range);
94 void extract(LiveInterval &VirtReg, const LiveRange &Range);
111 const LiveRange *LR = nullptr;
112 LiveRange::const_iterator LRI; ///< current position in LR
120 void reset(unsigned NewUserTag, const LiveRange &NewLR,
133 Query(const LiveRange &LR, const LiveIntervalUnion &LIU):
138 void init(unsigned NewUserTag, const LiveRange &NewLR,
include/llvm/CodeGen/LiveIntervals.h 96 SmallVector<LiveRange*, 0> RegUnitRanges;
184 void extendToIndices(LiveRange &LR, ArrayRef<SlotIndex> Indices,
187 void extendToIndices(LiveRange &LR, ArrayRef<SlotIndex> Indices) {
198 void pruneValue(LiveRange &LR, SlotIndex Kill,
245 bool isLiveInToMBB(const LiveRange &LR,
250 bool isLiveOutOfMBB(const LiveRange &LR,
393 LiveRange &getRegUnit(unsigned Unit) {
394 LiveRange *LR = RegUnitRanges[Unit];
398 RegUnitRanges[Unit] = LR = new LiveRange(UseSegmentSetForPhysRegs);
406 LiveRange *getCachedRegUnit(unsigned Unit) {
410 const LiveRange *getCachedRegUnit(unsigned Unit) const {
471 void computeRegUnitRange(LiveRange&, unsigned Unit);
475 void extendSegmentsToUses(LiveRange &Segments,
include/llvm/CodeGen/LiveRangeCalc.h 75 using EntryInfoMap = DenseMap<LiveRange *, std::pair<BitVector, BitVector>>;
102 LiveRange &LR;
116 LiveInBlock(LiveRange &LR, MachineDomTreeNode *node, SlotIndex kill)
128 bool isDefOnEntry(LiveRange &LR, ArrayRef<SlotIndex> Undefs,
148 bool findReachingDefs(LiveRange &LR, MachineBasicBlock &UseMBB, SlotIndex Use,
172 void extendToUses(LiveRange &LR, unsigned Reg, LaneBitmask LaneMask,
210 void extend(LiveRange &LR, SlotIndex Use, unsigned PhysReg,
216 void createDeadDefs(LiveRange &LR, unsigned Reg);
222 void extendToUses(LiveRange &LR, unsigned PhysReg) {
269 void addLiveInBlock(LiveRange &LR, MachineDomTreeNode *DomNode,
include/llvm/CodeGen/LiveRegMatrix.h 150 LiveIntervalUnion::Query &query(const LiveRange &LR, unsigned RegUnit);
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
lib/CodeGen/InterferenceCache.cpp 237 LiveRange *LR = RegUnits[i].Fixed;
lib/CodeGen/InterferenceCache.h 80 LiveRange *Fixed = nullptr;
lib/CodeGen/LiveDebugVariables.cpp 283 LiveRange *LR, const VNInfo *VNI,
716 void UserValue::extendDef(SlotIndex Idx, DbgValueLocation Loc, LiveRange *LR,
lib/CodeGen/LiveInterval.cpp 67 LiveRange *LR;
70 CalcLiveRangeUtilBase(LiveRange *LR) : LR(LR) {}
73 using Segment = LiveRange::Segment;
283 CalcLiveRangeUtilBase<CalcLiveRangeUtilVector, LiveRange::iterator,
284 LiveRange::Segments>;
288 CalcLiveRangeUtilVector(LiveRange *LR) : CalcLiveRangeUtilVectorBase(LR) {}
293 LiveRange::Segments &segmentsColl() { return LR->segments; }
309 CalcLiveRangeUtilBase<CalcLiveRangeUtilSet, LiveRange::SegmentSet::iterator,
310 LiveRange::SegmentSet>;
314 CalcLiveRangeUtilSet(LiveRange *LR) : CalcLiveRangeUtilSetBase(LR) {}
319 LiveRange::SegmentSet &segmentsColl() { return *LR->segmentSet; }
350 LiveRange::iterator LiveRange::find(SlotIndex Pos) {
404 bool LiveRange::overlapsFrom(const LiveRange& other,
445 bool LiveRange::overlaps(const LiveRange &Other, const CoalescerPair &CP,
494 bool LiveRange::covers(const LiveRange &Other) const {
548 LiveRange::iterator LiveRange::addSegment(Segment S) {
641 void LiveRange::join(LiveRange &Other,
724 void LiveRange::MergeSegmentsInAsValue(const LiveRange &RHS,
736 void LiveRange::MergeValueInAsValue(const LiveRange &RHS,
991 raw_ostream& llvm::operator<<(raw_ostream& OS, const LiveRange::Segment &S) {
1159 static inline bool coalescable(const LiveRange::Segment &A,
1160 const LiveRange::Segment &B) {
1170 void LiveRangeUpdater::add(LiveRange::Segment Seg) {
1193 LiveRange::iterator E = LR->end();
1258 LiveRange::iterator Src = WriteI;
1259 LiveRange::iterator Dst = Src + NumMoved;
1260 LiveRange::iterator SpillSrc = Spills.end();
1261 LiveRange::iterator B = LR->begin();
1309 unsigned ConnectedVNInfoEqClasses::Classify(const LiveRange &LR) {
lib/CodeGen/LiveIntervalUnion.cpp 29 void LiveIntervalUnion::unify(LiveInterval &VirtReg, const LiveRange &Range) {
35 LiveRange::const_iterator RegPos = Range.begin();
36 LiveRange::const_iterator RegEnd = Range.end();
56 void LiveIntervalUnion::extract(LiveInterval &VirtReg, const LiveRange &Range) {
62 LiveRange::const_iterator RegPos = Range.begin();
63 LiveRange::const_iterator RegEnd = Range.end();
139 LiveRange::const_iterator LREnd = LR->end();
lib/CodeGen/LiveIntervals.cpp 117 for (LiveRange *LR : RegUnitRanges)
159 if (LiveRange *LR = RegUnitRanges[Unit])
263 void LiveIntervals::computeRegUnitRange(LiveRange &LR, unsigned Unit) {
330 LiveRange *LR = RegUnitRanges[Unit];
333 LR = RegUnitRanges[Unit] = new LiveRange(UseSegmentSetForPhysRegs);
350 static void createSegmentsForValues(LiveRange &LR,
360 void LiveIntervals::extendSegmentsToUses(LiveRange &Segments,
382 const LiveRange &OldRange = getSubRange(LI, LaneMask);
487 LiveRange NewLR;
507 LiveRange::iterator I = LI.FindSegmentContaining(Def);
585 LiveRange NewLR;
596 const LiveRange::Segment *Segment = SR.getSegmentContaining(VNI->def);
612 void LiveIntervals::extendToIndices(LiveRange &LR,
621 void LiveIntervals::pruneValue(LiveRange &LR, SlotIndex Kill,
685 SmallVector<std::pair<const LiveRange*, LiveRange::const_iterator>, 8> RU;
685 SmallVector<std::pair<const LiveRange*, LiveRange::const_iterator>, 8> RU;
688 LiveRange::const_iterator>, 4> SRs;
703 const LiveRange &RURange = getRegUnit(*Unit);
736 const LiveRange &RURange = *RUP.first;
737 LiveRange::const_iterator &I = RUP.second;
765 LiveRange::const_iterator &I = SRP.second;
799 LiveRange::const_iterator N = std::next(RI);
867 LiveRange::Segment
873 LiveRange::Segment S(SlotIndex(getInstructionIndex(startInst).getRegSlot()),
950 SmallPtrSet<LiveRange*, 8> Updated;
964 LiveRange *getRegUnitLI(unsigned Unit) {
1011 if (LiveRange *LR = getRegUnitLI(*Units))
1021 void updateRange(LiveRange &LR, unsigned Reg, LaneBitmask LaneMask) {
1045 void handleMoveDown(LiveRange &LR) {
1046 LiveRange::iterator E = LR.end();
1048 LiveRange::iterator OldIdxIn = LR.find(OldIdx.getBaseIndex());
1054 LiveRange::iterator OldIdxOut;
1069 LiveRange::iterator Next = std::next(OldIdxIn);
1074 LiveRange::iterator NewIdxIn =
1079 LiveRange::iterator Prev = std::prev(NewIdxIn);
1123 LiveRange::iterator AfterNewIdx
1135 LiveRange::iterator IPrev = std::prev(OldIdxOut);
1140 LiveRange::iterator INext = std::next(OldIdxOut);
1158 LiveRange::iterator NewSegment = std::prev(E);
1163 LiveRange::iterator Prev = std::prev(NewSegment);
1171 LiveRange::iterator Prev = std::prev(AfterNewIdx);
1176 LiveRange::iterator NewSegment = AfterNewIdx;
1208 LiveRange::iterator NewSegment = std::prev(AfterNewIdx);
1218 void handleMoveUp(LiveRange &LR, unsigned Reg, LaneBitmask LaneMask) {
1219 LiveRange::iterator E = LR.end();
1221 LiveRange::iterator OldIdxIn = LR.find(OldIdx.getBaseIndex());
1227 LiveRange::iterator OldIdxOut;
1263 LiveRange::iterator NewIdxOut = LR.find(NewIdx.getRegSlot());
1286 LiveRange::iterator NewIdxIn = NewIdxOut;
1292 LiveRange::iterator Prev = std::prev(OldIdxIn);
1316 LiveRange::iterator NewSegment = NewIdxIn;
1317 LiveRange::iterator Next = std::next(NewSegment);
1376 LiveRange::iterator NewSegment = NewIdxOut;
1549 LiveRange::Segment S(instrIdx.getRegSlot(),
1554 LiveRange::Segment S(instrIdx.getRegSlot(), lastUseIdx, VNI);
1628 if (LiveRange *LR = getCachedRegUnit(*Unit))
lib/CodeGen/LiveRangeCalc.cpp 65 LiveRange &LR, const MachineOperand &MO) {
133 LiveRange &MainRange = LI;
147 void LiveRangeCalc::createDeadDefs(LiveRange &LR, unsigned Reg) {
156 void LiveRangeCalc::extendToUses(LiveRange &LR, unsigned Reg, LaneBitmask Mask,
241 void LiveRangeCalc::extend(LiveRange &LR, SlotIndex Use, unsigned PhysReg,
276 bool LiveRangeCalc::isDefOnEntry(LiveRange &LR, ArrayRef<SlotIndex> Undefs,
313 LiveRange::iterator UB = std::upper_bound(LR.begin(), LR.end(),
316 LiveRange::Segment &Seg = *std::prev(UB);
346 bool LiveRangeCalc::findReachingDefs(LiveRange &LR, MachineBasicBlock &UseMBB,
553 LiveRange &LR = I.LR;
lib/CodeGen/LiveRegMatrix.cpp 171 const LiveRange &UnitRange = LIS->getRegUnit(Unit);
177 LiveIntervalUnion::Query &LiveRegMatrix::query(const LiveRange &LR,
212 LiveRange::Segment Seg(Start, End, &valno);
213 LiveRange LR;
lib/CodeGen/MachineVerifier.cpp 250 void report_context(const LiveRange &LR, unsigned VRegUnit,
252 void report_context(const LiveRange::Segment &S) const;
256 void report_context_liverange(const LiveRange &LR) const;
265 SlotIndex UseIdx, const LiveRange &LR, unsigned VRegOrUnit,
268 SlotIndex DefIdx, const LiveRange &LR, unsigned VRegOrUnit,
280 void verifyLiveRangeValue(const LiveRange&, const VNInfo*, unsigned,
282 void verifyLiveRangeSegment(const LiveRange&,
283 const LiveRange::const_iterator I, unsigned,
285 void verifyLiveRange(const LiveRange&, unsigned,
526 void MachineVerifier::report_context(const LiveRange &LR, unsigned VRegUnit,
534 void MachineVerifier::report_context(const LiveRange::Segment &S) const {
542 void MachineVerifier::report_context_liverange(const LiveRange &LR) const {
1874 unsigned MONum, SlotIndex UseIdx, const LiveRange &LR, unsigned VRegOrUnit,
1896 unsigned MONum, SlotIndex DefIdx, const LiveRange &LR, unsigned VRegOrUnit,
1963 if (const LiveRange *LR = LiveInts->getCachedRegUnit(*Units))
2360 if (const LiveRange *LR = LiveInts->getCachedRegUnit(i))
2364 void MachineVerifier::verifyLiveRangeValue(const LiveRange &LR,
2456 void MachineVerifier::verifyLiveRangeSegment(const LiveRange &LR,
2457 const LiveRange::const_iterator I,
2460 const LiveRange::Segment &S = *I;
2671 void MachineVerifier::verifyLiveRange(const LiveRange &LR, unsigned Reg,
2676 for (LiveRange::const_iterator I = LR.begin(), E = LR.end(); I != E; ++I)
lib/CodeGen/RegAllocGreedy.cpp 2203 const LiveRange &LR = LIS->getRegUnit(*Units);
2204 LiveRange::const_iterator I = LR.find(StartIdx);
2205 LiveRange::const_iterator E = LR.end();
lib/CodeGen/RegisterCoalescer.cpp 227 void mergeSubRangeInto(LiveInterval &LI, const LiveRange &ToMerge,
232 void joinSubRegRanges(LiveRange &LRange, LiveRange &RRange,
232 void joinSubRegRanges(LiveRange &LRange, LiveRange &RRange,
695 for (LiveRange::Segment &ASeg : IntA.segments) {
715 addSegmentsWithValNo(LiveRange &Dst, VNInfo *DstValNo, const LiveRange &Src,
715 addSegmentsWithValNo(LiveRange &Dst, VNInfo *DstValNo, const LiveRange &Src,
719 for (const LiveRange::Segment &S : Src.segments) {
728 LiveRange::Segment Added = LiveRange::Segment(S.start, S.end, DstValNo);
729 LiveRange::Segment &Merged = *Dst.addSegment(Added);
960 if (LiveRange::Segment *S = SB.getSegmentContaining(CopyIdx))
1455 if (LiveRange *LR = LIS->getCachedRegUnit(*Units))
1470 if (LiveRange *LR = LIS->getCachedRegUnit(*Units))
1548 LiveRange::Segment *Seg = DstLI.getSegmentContaining(RegIndex);
2080 LiveRange &LR = LIS->getRegUnit(*UI);
2165 LiveRange &LR;
2336 JoinVals(LiveRange &LR, unsigned Reg, unsigned SubIdx, LaneBitmask LaneMask,
3139 LiveRange::iterator I = LR.FindSegmentContaining(Def);
3159 LiveRange::iterator I = SR.find(Def);
3175 LiveRange::iterator S = LR.find(Def);
3209 void RegisterCoalescer::joinSubRegRanges(LiveRange &LRange, LiveRange &RRange,
3209 void RegisterCoalescer::joinSubRegRanges(LiveRange &LRange, LiveRange &RRange,
3273 const LiveRange &ToMerge,
3284 LiveRange RangeCopy(ToMerge, Allocator);
lib/CodeGen/RegisterPressure.cpp 237 static const LiveRange *getLiveRange(const LiveIntervals &LIS, unsigned Reg) {
424 bool(*Property)(const LiveRange &LR, SlotIndex Pos)) {
440 const LiveRange *LR = LIS.getCachedRegUnit(RegUnit);
584 const LiveRange *LR = getLiveRange(LIS, Reg);
1259 const LiveRange::Segment *S = LR.getSegmentContaining(Pos);
1270 const LiveRange::Segment *S = LR.getSegmentContaining(Pos);
lib/CodeGen/SplitKit.cpp 1125 for (const LiveRange::Segment &S : Edit->getParent()) {
1230 static bool removeDeadSegment(SlotIndex Def, LiveRange &LR) {
1231 const LiveRange::Segment *Seg = LR.getSegmentContaining(Def);
1242 LiveRange &LR, LaneBitmask LM,
1252 LiveRange &PSR = !LM.all() ? getSubRangeForMask(LM, PLI)
1411 for (const LiveRange::Segment &S : LI->segments) {
lib/CodeGen/SplitKit.h 418 LiveRange &LR, LaneBitmask LM,
lib/CodeGen/VirtRegMap.cpp 476 const LiveRange &UnitRange = LIS->getRegUnit(*Unit);
lib/Target/AMDGPU/SIRegisterInfo.cpp 1895 LiveRange &LR = LIS->getRegUnit(*Units);
lib/Target/AMDGPU/SIWholeQuadMode.cpp 286 LiveRange &LR = LIS->getRegUnit(*RegUnit);
584 LiveRange &LR = LIS->getRegUnit(*MCRegUnitIterator(AMDGPU::SCC, TRI));
591 const LiveRange::Segment *S;
lib/Target/Hexagon/HexagonExpandCondsets.cpp 203 void updateDeadsInRange(unsigned Reg, LaneBitmask LM, LiveRange &Range);
348 LiveRange::iterator F = S.find(I->end);
366 LiveRange &Range) {
1110 LiveRange::Segment &LR = *I;
lib/Target/PowerPC/PPCVSXFMAMutate.cpp 322 LiveRange &AddendSrcRange = LIS->getRegUnit(Unit);
lib/Target/SystemZ/SystemZInstrInfo.cpp 1013 LiveRange &CCLiveRange = LIS->getRegUnit(*CCUnit);
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
83 constexpr _Tp&&
usr/include/c++/7.4.0/bits/range_access.h 48 begin(_Container& __cont) -> decltype(__cont.begin())
58 begin(const _Container& __cont) -> decltype(__cont.begin())
68 end(_Container& __cont) -> decltype(__cont.end())
78 end(const _Container& __cont) -> decltype(__cont.end())
usr/include/c++/7.4.0/type_traits 1633 { typedef _Tp type; };
1983 { typedef _Up type; };