|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/CodeGen/CalcSpillWeights.h 17 class LiveInterval;
include/llvm/CodeGen/LiveRegMatrix.h 34 class LiveInterval;
lib/CodeGen/RegAllocBase.h 44 class LiveInterval;
References
include/llvm/ADT/ArrayRef.h 108 const ArrayRef<U *> &A,
110 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
118 const SmallVectorTemplateCommon<U *, DummyT> &Vec,
120 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
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)
1172 bool any_of(R &&Range, UnaryPredicate P) {
1276 auto upper_bound(R &&Range, T &&Value) -> decltype(adl_begin(Range)) {
include/llvm/CodeGen/CalcSpillWeights.h 67 void calculateSpillWeightAndHint(LiveInterval &li);
78 float futureWeight(LiveInterval &li, SlotIndex start, SlotIndex end);
92 float weightCalcHelper(LiveInterval &li, SlotIndex *start = nullptr,
include/llvm/CodeGen/LiveInterval.h 840 std::function<void(LiveInterval::SubRange &)> Apply,
844 bool operator<(const LiveInterval& other) const {
874 const LiveInterval::SubRange &SR) {
879 inline raw_ostream &operator<<(raw_ostream &OS, const LiveInterval &LI) {
985 void Distribute(LiveInterval &LI, LiveInterval *LIV[],
985 void Distribute(LiveInterval &LI, LiveInterval *LIV[],
include/llvm/CodeGen/LiveIntervalUnion.h 46 using LiveSegments = IntervalMap<SlotIndex, LiveInterval*>;
91 void unify(LiveInterval &VirtReg, const LiveRange &Range);
94 void extract(LiveInterval &VirtReg, const LiveRange &Range);
114 SmallVector<LiveInterval*,4> InterferingVRegs;
157 bool isSeenInterference(LiveInterval *VirtReg) const;
163 const SmallVectorImpl<LiveInterval*> &interferingVRegs() const {
include/llvm/CodeGen/LiveIntervals.h 68 IndexedMap<LiveInterval*, VirtReg2IndexFunctor> VirtRegIntervals;
114 LiveInterval &getInterval(Register Reg) {
121 const LiveInterval &getInterval(Register Reg) const {
131 LiveInterval &createEmptyInterval(Register Reg) {
138 LiveInterval &createAndComputeVirtRegInterval(Register Reg) {
139 LiveInterval &LI = createEmptyInterval(Reg);
152 LiveInterval::Segment addSegmentToEndOfBlock(unsigned reg,
161 bool shrinkToUses(LiveInterval *li,
170 void shrinkToUses(LiveInterval::SubRange &SR, unsigned Reg);
205 LLVM_ATTRIBUTE_UNUSED void pruneValue(LiveInterval &, SlotIndex,
297 MachineBasicBlock *intervalIsInOneMBB(const LiveInterval &LI) const;
301 bool hasPHIKill(const LiveInterval &LI, const VNInfo *VNI) const;
377 bool checkRegMaskInterference(LiveInterval &LI,
437 void removeVRegDefAt(LiveInterval &LI, SlotIndex Pos);
440 void splitSeparateComponents(LiveInterval &LI,
441 SmallVectorImpl<LiveInterval*> &SplitLIs);
446 void constructMainRangeFromSubranges(LiveInterval &LI);
462 bool computeDeadValues(LiveInterval &LI,
465 static LiveInterval* createInterval(unsigned Reg);
472 void computeVirtRegInterval(LiveInterval&);
include/llvm/CodeGen/LiveRangeCalc.h 173 LiveInterval *LI = nullptr);
229 void calculate(LiveInterval &LI, bool TrackSubRegs);
234 void constructMainRangeFromSubranges(LiveInterval &LI);
include/llvm/CodeGen/LiveRangeEdit.h 70 LiveInterval *Parent;
106 bool foldAsLoad(LiveInterval *LI, SmallVectorImpl<MachineInstr *> &Dead);
108 using ToShrinkSet = SetVector<LiveInterval *, SmallVector<LiveInterval *, 8>,
108 using ToShrinkSet = SetVector<LiveInterval *, SmallVector<LiveInterval *, 8>,
109 SmallPtrSet<LiveInterval *, 8>>;
121 bool useIsKill(const LiveInterval &LI, const MachineOperand &MO) const;
124 LiveInterval &createEmptyIntervalFrom(unsigned OldReg, bool createSubRanges);
138 LiveRangeEdit(LiveInterval *parent, SmallVectorImpl<unsigned> &newRegs,
150 LiveInterval &getParent() const {
184 LiveInterval &createEmptyInterval() {
include/llvm/CodeGen/LiveRegMatrix.h 107 InterferenceKind checkInterference(LiveInterval &VirtReg, unsigned PhysReg);
119 void assign(LiveInterval &VirtReg, unsigned PhysReg);
124 void unassign(LiveInterval &VirtReg);
139 bool checkRegMaskInterference(LiveInterval &VirtReg, unsigned PhysReg = 0);
144 bool checkRegUnitInterference(LiveInterval &VirtReg, unsigned PhysReg);
include/llvm/CodeGen/LiveStacks.h 38 using SS2IntervalMap = std::unordered_map<int, LiveInterval>;
61 LiveInterval &getOrCreateInterval(int Slot, const TargetRegisterClass *RC);
63 LiveInterval &getInterval(int Slot) {
70 const LiveInterval &getInterval(int Slot) const {
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 };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
lib/CodeGen/CalcSpillWeights.cpp 85 static bool isRematerializable(const LiveInterval &LI,
91 for (LiveInterval::const_vni_iterator I = LI.vni_begin(), E = LI.vni_end();
121 const LiveInterval &SrcLI = LIS.getInterval(Reg);
138 void VirtRegAuxInfo::calculateSpillWeightAndHint(LiveInterval &li) {
146 float VirtRegAuxInfo::futureWeight(LiveInterval &li, SlotIndex start,
151 float VirtRegAuxInfo::weightCalcHelper(LiveInterval &li, SlotIndex *start,
lib/CodeGen/InlineSpiller.cpp 104 DenseMap<int, std::unique_ptr<LiveInterval>> StackSlotToOrigLI;
118 bool isSpillCandBB(LiveInterval &OrigLI, VNInfo &OrigVNI,
133 void runHoistSpills(LiveInterval &OrigLI, VNInfo &OrigVNI,
173 LiveInterval *StackInt;
211 bool isSnippet(const LiveInterval &SnipLI);
217 bool hoistSpillInsideBB(LiveInterval &SpillLI, MachineInstr &CopyMI);
218 void eliminateRedundantSpills(LiveInterval &LI, VNInfo *VNI);
220 void markValueUsed(LiveInterval*, VNInfo*);
222 bool reMaterializeFor(LiveInterval &, MachineInstr &MI);
274 bool InlineSpiller::isSnippet(const LiveInterval &SnipLI) {
336 LiveInterval &SnipLI = LIS.getInterval(SnipReg);
371 bool InlineSpiller::hoistSpillInsideBB(LiveInterval &SpillLI,
380 LiveInterval &SrcLI = LIS.getInterval(SrcReg);
391 LiveInterval &OrigLI = LIS.getInterval(Original);
425 void InlineSpiller::eliminateRedundantSpills(LiveInterval &SLI, VNInfo *VNI) {
427 SmallVector<std::pair<LiveInterval*, VNInfo*>, 8> WorkList;
432 LiveInterval *LI;
460 LiveInterval &DstLI = LIS.getInterval(DstReg);
490 void InlineSpiller::markValueUsed(LiveInterval *LI, VNInfo *VNI) {
491 SmallVector<std::pair<LiveInterval*, VNInfo*>, 8> WorkList;
512 LiveInterval &SnipLI = LIS.getInterval(MI->getOperand(1).getReg());
543 bool InlineSpiller::reMaterializeFor(LiveInterval &VirtReg, MachineInstr &MI) {
569 LiveInterval &OrigLI = LIS.getInterval(Original);
646 LiveInterval &LI = LIS.getInterval(Reg);
667 LiveInterval &LI = LIS.getInterval(Reg);
668 for (LiveInterval::vni_iterator I = LI.vni_begin(), E = LI.vni_end();
964 LiveInterval &OldLI = LIS.getInterval(Reg);
1023 LiveInterval &SibLI = LIS.getInterval(SibReg);
1144 LiveInterval &OrigLI = LIS.getInterval(Original);
1148 auto LI = std::make_unique<LiveInterval>(OrigLI.reg, OrigLI.weight);
1173 bool HoistSpillHelper::isSpillCandBB(LiveInterval &OrigLI, VNInfo &OrigVNI,
1186 LiveInterval &LI = LIS.getInterval(SibReg);
1318 LiveInterval &OrigLI, VNInfo &OrigVNI,
1469 LiveInterval &OrigLI = *StackSlotToOrigLI[Slot];
1501 LiveInterval &StackIntvl = LSS.getInterval(Slot);
lib/CodeGen/InterferenceCache.cpp 181 LiveInterval::const_iterator I = RegUnits[i].FixedI;
182 LiveInterval::const_iterator E = RegUnits[i].Fixed->end();
236 LiveInterval::iterator &I = RegUnits[i].FixedI;
lib/CodeGen/InterferenceCache.h 83 LiveInterval::iterator FixedI;
lib/CodeGen/LiveDebugVariables.cpp 296 LiveInterval *LI, unsigned LocNo,
629 const LiveInterval &LI = LIS->getInterval(Reg);
727 LiveInterval::Segment *Segment = LR->getSegmentContaining(Start);
761 LiveInterval *LI, unsigned LocNo,
772 SmallVector<std::pair<LiveInterval*, const VNInfo*>, 8> CopyValues;
796 LiveInterval *DstLI = &LIS.getInterval(DstReg);
812 LiveInterval *DstLI = CopyValues[j].first;
856 LiveInterval *LI = nullptr;
1020 LiveInterval *LI = &LIS.getInterval(NewRegs[i]);
1031 LiveInterval::iterator LII = LI->advanceTo(LI->begin(), LocMapI.start());
1032 LiveInterval::iterator LIE = LI->end();
lib/CodeGen/LiveInterval.cpp 883 static void stripValuesNotDefiningMask(unsigned Reg, LiveInterval::SubRange &SR,
926 std::function<void(LiveInterval::SubRange &)> Apply,
1352 void ConnectedVNInfoEqClasses::Distribute(LiveInterval &LI, LiveInterval *LIV[],
1352 void ConnectedVNInfoEqClasses::Distribute(LiveInterval &LI, LiveInterval *LIV[],
1383 SmallVector<LiveInterval::SubRange*, 8> SubRanges;
1385 for (LiveInterval::SubRange &SR : LI.subranges()) {
lib/CodeGen/LiveIntervalUnion.cpp 29 void LiveIntervalUnion::unify(LiveInterval &VirtReg, const LiveRange &Range) {
56 void LiveIntervalUnion::extract(LiveInterval &VirtReg, const LiveRange &Range) {
104 bool LiveIntervalUnion::Query::isSeenInterference(LiveInterval *VirtReg) const {
140 LiveInterval *RecentReg = nullptr;
147 LiveInterval *VReg = LiveUnionI.value();
lib/CodeGen/LiveIntervals.cpp 188 LiveInterval* LiveIntervals::createInterval(unsigned reg) {
190 return new LiveInterval(reg, Weight);
194 void LiveIntervals::computeVirtRegInterval(LiveInterval &LI) {
351 iterator_range<LiveInterval::vni_iterator> VNIs) {
372 for (const LiveInterval::SubRange &SR : I.subranges()) {
381 const LiveInterval &LI = getInterval(Reg);
441 bool LiveIntervals::shrinkToUses(LiveInterval *li,
449 for (LiveInterval::SubRange &S : li->subranges()) {
500 bool LiveIntervals::computeDeadValues(LiveInterval &LI,
542 void LiveIntervals::shrinkToUses(LiveInterval::SubRange &SR, unsigned Reg) {
687 SmallVector<std::pair<const LiveInterval::SubRange*,
694 const LiveInterval &LI = getInterval(Reg);
711 for (const LiveInterval::SubRange &SR : LI.subranges()) {
718 for (LiveInterval::const_iterator RI = LI.begin(), RE = LI.end(); RI != RE;
764 const LiveInterval::SubRange &SR = *SRP.first;
814 LiveIntervals::intervalIsInOneMBB(const LiveInterval &LI) const {
838 LiveIntervals::hasPHIKill(const LiveInterval &LI, const VNInfo *VNI) const {
869 LiveInterval& Interval = createEmptyInterval(reg);
884 bool LiveIntervals::checkRegMaskInterference(LiveInterval &LI,
888 LiveInterval::iterator LiveI = LI.begin(), LiveE = LI.end();
993 LiveInterval &LI = LIS.getInterval(Reg);
998 for (LiveInterval::SubRange &S : LI.subranges()) {
1486 LiveInterval::iterator LII = LR.find(endIdx);
1614 LiveInterval &LI = getInterval(Reg);
1619 for (LiveInterval::SubRange &S : LI.subranges())
1634 void LiveIntervals::removeVRegDefAt(LiveInterval &LI, SlotIndex Pos) {
1644 for (LiveInterval::SubRange &S : LI.subranges()) {
1652 void LiveIntervals::splitSeparateComponents(LiveInterval &LI,
1653 SmallVectorImpl<LiveInterval*> &SplitLIs) {
1663 LiveInterval &NewLI = createEmptyInterval(NewVReg);
1669 void LiveIntervals::constructMainRangeFromSubranges(LiveInterval &LI) {
lib/CodeGen/LiveRangeCalc.cpp 74 void LiveRangeCalc::calculate(LiveInterval &LI, bool TrackSubRegs) {
118 for (LiveInterval::SubRange &S : LI.subranges()) {
131 void LiveRangeCalc::constructMainRangeFromSubranges(LiveInterval &LI) {
137 for (const LiveInterval::SubRange &SR : LI.subranges()) {
157 LiveInterval *LI) {
lib/CodeGen/LiveRangeEdit.cpp 33 LiveInterval &LiveRangeEdit::createEmptyIntervalFrom(unsigned OldReg,
39 LiveInterval &LI = LIS.createEmptyInterval(VReg);
46 LiveInterval &OldLI = LIS.getInterval(OldReg);
48 for (LiveInterval::SubRange &S : OldLI.subranges())
86 LiveInterval &OrigLI = LIS.getInterval(Original);
123 LiveInterval &li = LIS.getInterval(MO.getReg());
185 bool LiveRangeEdit::foldAsLoad(LiveInterval *LI,
243 bool LiveRangeEdit::useIsKill(const LiveInterval &LI,
252 for (const LiveInterval::SubRange &S : LI.subranges()) {
296 LiveInterval &OrigLI = LIS.getInterval(Original);
320 LiveInterval &LI = LIS.getInterval(Reg);
364 LiveInterval &NewLI = createEmptyIntervalFrom(Dest, false);
406 LiveInterval *LI = ToShrink.back();
432 SmallVector<LiveInterval*, 8> SplitLIs;
438 for (const LiveInterval *SplitLI : SplitLIs) {
467 LiveInterval &LI = LIS.getInterval(get(I));
lib/CodeGen/LiveRangeUtils.h 26 static void DistributeRange(LiveRangeT &LR, LiveRangeT *SplitLRs[],
26 static void DistributeRange(LiveRangeT &LR, LiveRangeT *SplitLRs[],
29 typename LiveRangeT::iterator J = LR.begin(), E = LR.end();
32 for (typename LiveRangeT::iterator I = J; I != E; ++I) {
lib/CodeGen/LiveRegMatrix.cpp 80 LiveInterval &VRegInterval, unsigned PhysReg,
86 for (LiveInterval::SubRange &S : VRegInterval.subranges()) {
103 void LiveRegMatrix::assign(LiveInterval &VirtReg, unsigned PhysReg) {
120 void LiveRegMatrix::unassign(LiveInterval &VirtReg) {
145 bool LiveRegMatrix::checkRegMaskInterference(LiveInterval &VirtReg,
163 bool LiveRegMatrix::checkRegUnitInterference(LiveInterval &VirtReg,
185 LiveRegMatrix::checkInterference(LiveInterval &VirtReg, unsigned PhysReg) {
lib/CodeGen/LiveStacks.cpp 56 LiveInterval &
lib/CodeGen/MachineBasicBlock.cpp 1037 LiveInterval &LI = LIS->getInterval(Reg);
1052 LiveInterval &LI = LIS->getInterval(Reg);
lib/CodeGen/MachineScheduler.cpp 1130 const LiveInterval &LI = LIS->getInterval(Reg);
1326 const LiveInterval &LI = LIS->getInterval(Reg);
1709 LiveInterval *LocalLI = &LIS->getInterval(LocalReg);
1717 LiveInterval *GlobalLI = &LIS->getInterval(GlobalReg);
1720 LiveInterval::iterator GlobalSegment = GlobalLI->find(LocalLI->beginIndex());
lib/CodeGen/MachineVerifier.cpp 249 void report_context(const LiveInterval &LI) const;
279 void verifyLiveInterval(const LiveInterval&);
522 void MachineVerifier::report_context(const LiveInterval &LI) const {
1831 LiveInterval &LI = LiveStks->getInterval(FI);
1971 const LiveInterval &LI = LiveInts->getInterval(Reg);
1980 for (const LiveInterval::SubRange &SR : LI.subranges()) {
2074 const LiveInterval &LI = LiveInts->getInterval(Reg);
2082 for (const LiveInterval::SubRange &SR : LI.subranges()) {
2353 const LiveInterval &LI = LiveInts->getInterval(Reg);
2615 LiveInterval &OwnerLI = LiveInts->getInterval(Reg);
2680 void MachineVerifier::verifyLiveInterval(const LiveInterval &LI) {
2687 for (const LiveInterval::SubRange &SR : LI.subranges()) {
2716 for (LiveInterval::const_vni_iterator I = LI.vni_begin(),
lib/CodeGen/PHIElimination.cpp 334 LiveInterval &IncomingLI = LIS->createEmptyInterval(IncomingReg);
344 LiveInterval &DestLI = LIS->getInterval(DestReg);
486 LiveInterval &SrcLI = LIS->getInterval(SrcReg);
661 const LiveInterval &LI = LIS->getInterval(Reg);
lib/CodeGen/RegAllocBase.cpp 89 while (LiveInterval *VirtReg = dequeue()) {
147 LiveInterval *SplitVirtReg = &LIS->getInterval(Reg);
lib/CodeGen/RegAllocBase.h 95 virtual void enqueue(LiveInterval *LI) = 0;
98 virtual LiveInterval *dequeue() = 0;
104 virtual unsigned selectOrSplit(LiveInterval &VirtReg,
112 virtual void aboutToRemoveInterval(LiveInterval &LI) {}
lib/CodeGen/RegAllocBasic.cpp 48 bool operator()(LiveInterval *A, LiveInterval *B) const {
48 bool operator()(LiveInterval *A, LiveInterval *B) const {
68 std::priority_queue<LiveInterval*, std::vector<LiveInterval*>,
68 std::priority_queue<LiveInterval*, std::vector<LiveInterval*>,
91 void enqueue(LiveInterval *LI) override {
95 LiveInterval *dequeue() override {
98 LiveInterval *LI = Queue.top();
103 unsigned selectOrSplit(LiveInterval &VirtReg,
117 bool spillInterferences(LiveInterval &VirtReg, unsigned PhysReg,
145 LiveInterval &LI = LIS->getInterval(VirtReg);
164 LiveInterval &LI = LIS->getInterval(VirtReg);
204 bool RABasic::spillInterferences(LiveInterval &VirtReg, unsigned PhysReg,
208 SmallVector<LiveInterval*, 8> Intfs;
215 LiveInterval *Intf = Q.interferingVRegs()[i - 1];
227 LiveInterval &Spill = *Intfs[i];
256 unsigned RABasic::selectOrSplit(LiveInterval &VirtReg,
lib/CodeGen/RegAllocGreedy.cpp 155 using SmallLISet = SmallPtrSet<LiveInterval *, 4>;
255 LiveRangeStage getStage(const LiveInterval &VirtReg) const {
259 void setStage(const LiveInterval &VirtReg, LiveRangeStage Stage) {
412 SmallSetVector<LiveInterval *, 8> SetOfBrokenHints;
424 void enqueue(LiveInterval *LI) override;
425 LiveInterval *dequeue() override;
426 unsigned selectOrSplit(LiveInterval&, SmallVectorImpl<unsigned>&) override;
427 void aboutToRemoveInterval(LiveInterval &) override;
440 unsigned selectOrSplitImpl(LiveInterval &, SmallVectorImpl<unsigned> &,
446 void enqueue(PQueue &CurQueue, LiveInterval *LI);
447 LiveInterval *dequeue(PQueue &CurQueue);
465 unsigned canReassign(LiveInterval &VirtReg, unsigned PrevReg);
466 bool shouldEvict(LiveInterval &A, bool, LiveInterval &B, bool);
466 bool shouldEvict(LiveInterval &A, bool, LiveInterval &B, bool);
467 bool canEvictInterference(LiveInterval&, unsigned, bool, EvictionCost&,
469 bool canEvictInterferenceInRange(LiveInterval &VirtReg, unsigned PhysReg,
473 LiveInterval &VirtReg, SlotIndex Start,
475 void evictInterference(LiveInterval&, unsigned,
477 bool mayRecolorAllInterferences(unsigned PhysReg, LiveInterval &VirtReg,
481 unsigned tryAssign(LiveInterval&, AllocationOrder&,
484 unsigned tryEvict(LiveInterval&, AllocationOrder&,
487 unsigned tryRegionSplit(LiveInterval&, AllocationOrder&,
489 unsigned isSplitBenefitWorthCost(LiveInterval &VirtReg);
491 unsigned calculateRegionSplitCost(LiveInterval &VirtReg,
497 unsigned doRegionSplit(LiveInterval &VirtReg, unsigned BestCand,
502 unsigned tryAssignCSRFirstTime(LiveInterval &VirtReg, AllocationOrder &Order,
506 unsigned tryBlockSplit(LiveInterval&, AllocationOrder&,
508 unsigned tryInstructionSplit(LiveInterval&, AllocationOrder&,
510 unsigned tryLocalSplit(LiveInterval&, AllocationOrder&,
512 unsigned trySplit(LiveInterval&, AllocationOrder&,
515 unsigned tryLastChanceRecoloring(LiveInterval &, AllocationOrder &,
520 void tryHintRecoloring(LiveInterval &);
637 LiveInterval &LI = LIS->getInterval(VirtReg);
656 LiveInterval &LI = LIS->getInterval(VirtReg);
681 void RAGreedy::enqueue(LiveInterval *LI) { enqueue(Queue, LI); }
683 void RAGreedy::enqueue(PQueue &CurQueue, LiveInterval *LI) {
747 LiveInterval *RAGreedy::dequeue() { return dequeue(Queue); }
749 LiveInterval *RAGreedy::dequeue(PQueue &CurQueue) {
752 LiveInterval *LI = &LIS->getInterval(~CurQueue.top().second);
762 unsigned RAGreedy::tryAssign(LiveInterval &VirtReg,
809 unsigned RAGreedy::canReassign(LiveInterval &VirtReg, unsigned PrevReg) {
847 bool RAGreedy::shouldEvict(LiveInterval &A, bool IsHint,
848 LiveInterval &B, bool BreaksHint) {
872 bool RAGreedy::canEvictInterference(LiveInterval &VirtReg, unsigned PhysReg,
901 LiveInterval *Intf = Q.interferingVRegs()[i - 1];
969 bool RAGreedy::canEvictInterferenceInRange(LiveInterval &VirtReg,
980 LiveInterval *Intf = Q.interferingVRegs()[i - 1];
1023 LiveInterval &VirtReg,
1048 void RAGreedy::evictInterference(LiveInterval &VirtReg, unsigned PhysReg,
1061 SmallVector<LiveInterval*, 8> Intfs;
1069 ArrayRef<LiveInterval*> IVR = Q.interferingVRegs();
1075 LiveInterval *Intf = Intfs[i];
1106 unsigned RAGreedy::tryEvict(LiveInterval &VirtReg,
1514 LiveInterval &EvictorLI = LIS->getInterval(Evictor);
1785 LiveInterval &Reg = LIS->getInterval(LREdit.get(i));
1821 unsigned RAGreedy::isSplitBenefitWorthCost(LiveInterval &VirtReg) {
1829 unsigned RAGreedy::tryRegionSplit(LiveInterval &VirtReg, AllocationOrder &Order,
1872 unsigned RAGreedy::calculateRegionSplitCost(LiveInterval &VirtReg,
1972 unsigned RAGreedy::doRegionSplit(LiveInterval &VirtReg, unsigned BestCand,
2019 unsigned RAGreedy::tryBlockSplit(LiveInterval &VirtReg, AllocationOrder &Order,
2048 LiveInterval &LI = LIS->getInterval(LREdit.get(i));
2086 RAGreedy::tryInstructionSplit(LiveInterval &VirtReg, AllocationOrder &Order,
2229 unsigned RAGreedy::tryLocalSplit(LiveInterval &VirtReg, AllocationOrder &Order,
2460 unsigned RAGreedy::trySplit(LiveInterval &VirtReg, AllocationOrder &Order,
2529 RAGreedy::mayRecolorAllInterferences(unsigned PhysReg, LiveInterval &VirtReg,
2545 LiveInterval *Intf = Q.interferingVRegs()[i - 1];
2603 unsigned RAGreedy::tryLastChanceRecoloring(LiveInterval &VirtReg,
2743 LiveInterval *LI = dequeue(RecoloringQueue);
2773 unsigned RAGreedy::selectOrSplit(LiveInterval &VirtReg,
2803 unsigned RAGreedy::tryAssignCSRFirstTime(LiveInterval &VirtReg,
2839 void RAGreedy::aboutToRemoveInterval(LiveInterval &LI) {
2914 void RAGreedy::tryHintRecoloring(LiveInterval &VirtReg) {
2942 LiveInterval &LI = LIS->getInterval(Reg);
3023 for (LiveInterval *LI : SetOfBrokenHints) {
3034 unsigned RAGreedy::selectOrSplitImpl(LiveInterval &VirtReg,
lib/CodeGen/RegAllocPBQP.cpp 144 using LI2NodeMap = std::map<const LiveInterval *, unsigned>;
145 using Node2LIMap = std::vector<const LiveInterval *>;
258 std::tuple<LiveInterval*, size_t, PBQP::GraphBase::NodeId>;
335 LiveInterval &LI = LIS.getInterval(VReg);
594 LiveInterval &VRegLI = LIS.getInterval(VReg);
694 const LiveInterval &LI = LIS.getInterval(*I);
751 LiveInterval &LI = LIS.getInterval(*I);
lib/CodeGen/RegisterCoalescer.cpp 217 bool isHighCostLiveInterval(LiveInterval &LI);
227 void mergeSubRangeInto(LiveInterval &LI, const LiveRange &ToMerge,
243 bool hasOtherReachingDefs(LiveInterval &IntA, LiveInterval &IntB,
243 bool hasOtherReachingDefs(LiveInterval &IntA, LiveInterval &IntB,
281 void addUndefFlag(const LiveInterval &Int, SlotIndex UseIdx,
307 void shrinkToUses(LiveInterval *LI,
313 SmallVector<LiveInterval*, 8> SplitLIs;
560 LiveInterval &IntA =
562 LiveInterval &IntB =
582 LiveInterval::iterator BS = IntB.FindSegmentContaining(CopyIdx);
593 LiveInterval::iterator AS = IntA.FindSegmentContaining(CopyUseIdx);
606 LiveInterval::iterator ValS =
641 for (LiveInterval::SubRange &S : IntB.subranges()) {
644 LiveInterval::iterator SS = S.FindSegmentContaining(CopyIdx);
671 for (LiveInterval::SubRange &S : IntA.subranges()) {
672 LiveInterval::iterator SS = S.FindSegmentContaining(CopyUseIdx);
686 bool RegisterCoalescer::hasOtherReachingDefs(LiveInterval &IntA,
687 LiveInterval &IntB,
697 LiveInterval::iterator BI = llvm::upper_bound(IntB, ASeg.start);
742 LiveInterval &IntA =
744 LiveInterval &IntB =
820 LiveInterval::iterator US = IntA.FindSegmentContaining(UseIdx);
874 LiveInterval::iterator US = IntA.FindSegmentContaining(UseIdx);
901 for (LiveInterval::SubRange &S : IntB.subranges()) {
928 for (LiveInterval::SubRange &SA : IntA.subranges()) {
957 for (LiveInterval::SubRange &SB : IntB.subranges()) {
1038 LiveInterval &IntA =
1040 LiveInterval &IntB =
1129 for (LiveInterval::SubRange &SR : IntB.subranges())
1158 for (LiveInterval::SubRange &SR : IntB.subranges()) {
1215 LiveInterval &SrcInt = LIS->getInterval(SrcReg);
1355 LiveInterval &DstInt = LIS->getInterval(DstReg);
1356 for (LiveInterval::SubRange &SR : DstInt.subranges()) {
1389 for (LiveInterval::SubRange &SR : DstInt.subranges()) {
1395 LiveInterval::SubRange *SR = DstInt.createSubRange(Alloc, MaxMask);
1413 for (LiveInterval::SubRange &SR : DstInt.subranges()) {
1531 const LiveInterval &SrcLI = LIS->getInterval(SrcReg);
1535 for (const LiveInterval::SubRange &SR : SrcLI.subranges()) {
1546 LiveInterval &DstLI = LIS->getInterval(DstReg);
1574 for (LiveInterval::SubRange &SR : DstLI.subranges()) {
1596 for (const LiveInterval::SubRange &SR : DstLI.subranges()) {
1625 void RegisterCoalescer::addUndefFlag(const LiveInterval &Int, SlotIndex UseIdx,
1631 for (const LiveInterval::SubRange &S : Int.subranges()) {
1655 LiveInterval *DstInt = DstIsPhys ? nullptr : &LIS->getInterval(DstReg);
1742 LiveInterval &JoinVInt = LIS->getInterval(CP.getSrcReg());
1802 LiveInterval &LI = LIS->getInterval(CP.getSrcReg());
1813 for (LiveInterval::SubRange &S : LI.subranges()) {
1888 LiveInterval &DstLI = LIS->getInterval(DstReg);
1934 LiveInterval &LI = LIS->getInterval(CP.getDstReg());
1935 for (LiveInterval::SubRange &S : LI.subranges()) {
1952 LiveInterval &LI = LIS->getInterval(CP.getDstReg());
1983 LiveInterval &RHS = LIS->getInterval(SrcReg);
2362 void pruneSubRegValues(LiveInterval &LI, LaneBitmask &ShrinkMask);
2371 void pruneMainSegments(LiveInterval &LI, bool &ShrinkMainRange);
2379 LiveInterval *LI = nullptr);
2418 const LiveInterval &LI = LIS->getInterval(SrcReg);
2428 for (const LiveInterval::SubRange &S : LI.subranges()) {
2791 LiveInterval::iterator OtherI = Other.LR.find(VNI->def);
3018 void JoinVals::pruneSubRegValues(LiveInterval &LI, LaneBitmask &ShrinkMask) {
3038 for (LiveInterval::SubRange &S : LI.subranges()) {
3078 static bool isDefInSubRange(LiveInterval &LI, SlotIndex Def) {
3079 for (LiveInterval::SubRange &SR : LI.subranges()) {
3087 void JoinVals::pruneMainSegments(LiveInterval &LI, bool &ShrinkMainRange) {
3115 LiveInterval *LI) {
3158 for (LiveInterval::SubRange &SR : LI->subranges()) {
3272 void RegisterCoalescer::mergeSubRangeInto(LiveInterval &LI,
3291 bool RegisterCoalescer::isHighCostLiveInterval(LiveInterval &LI) {
3304 LiveInterval &RHS = LIS->getInterval(CP.getSrcReg());
3305 LiveInterval &LHS = LIS->getInterval(CP.getDstReg());
3341 for (LiveInterval::SubRange &R : LHS.subranges()) {
3357 for (LiveInterval::SubRange &R : RHS.subranges()) {
3480 LiveInterval &LI = LIS->getInterval(reg);
3539 const LiveInterval &DstLI = LIS->getInterval(DstReg);
3724 LiveInterval &LI = LIS->getInterval(Reg);
3735 for (LiveInterval::SubRange &S : LI.subranges()) {
lib/CodeGen/RegisterPressure.cpp 426 const LiveInterval &LI = LIS.getInterval(RegUnit);
429 for (const LiveInterval::SubRange &SR : LI.subranges()) {
lib/CodeGen/RenameIndependentSubregs.cpp 68 LiveInterval::SubRange *SR;
71 SubRangeInfo(LiveIntervals &LIS, LiveInterval::SubRange &SR,
77 bool renameComponents(LiveInterval &LI) const;
84 LiveInterval &LI) const;
90 const SmallVectorImpl<LiveInterval*> &Intervals) const;
95 const SmallVectorImpl<LiveInterval*> &Intervals) const;
100 const SmallVectorImpl<LiveInterval*> &Intervals) const;
121 bool RenameIndependentSubregs::renameComponents(LiveInterval &LI) const {
134 SmallVector<LiveInterval*, 4> Intervals;
142 LiveInterval &NewLI = LIS->createEmptyInterval(NewVReg);
156 LiveInterval &LI) const {
160 for (LiveInterval::SubRange &SR : LI.subranges()) {
185 const LiveInterval::SubRange &SR = *SRInfo.SR;
212 const SmallVectorImpl<LiveInterval*> &Intervals) const {
230 const LiveInterval::SubRange &SR = *SRInfo.SR;
266 const SmallVectorImpl<LiveInterval*> &Intervals) const {
269 SmallVector<LiveInterval::SubRange*, 8> SubRanges;
272 LiveInterval::SubRange &SR = *SRInfo.SR;
290 static bool subRangeLiveAt(const LiveInterval &LI, SlotIndex Pos) {
291 for (const LiveInterval::SubRange &SR : LI.subranges()) {
301 const SmallVectorImpl<LiveInterval*> &Intervals) const {
305 LiveInterval &LI = *Intervals[I];
313 for (const LiveInterval::SubRange &SR : LI.subranges()) {
336 for (LiveInterval::SubRange &SR : LI.subranges()) {
396 LiveInterval &LI = LIS->getInterval(Reg);
lib/CodeGen/SplitKit.cpp 76 InsertPointAnalysis::computeLastInsertPoint(const LiveInterval &CurLI,
217 LiveInterval::const_iterator LVI = CurLI->begin();
218 LiveInterval::const_iterator LVE = CurLI->end();
316 unsigned SplitAnalysis::countLiveBlocks(const LiveInterval *cli) const {
319 LiveInterval *li = const_cast<LiveInterval*>(cli);
320 LiveInterval::iterator LVI = li->begin();
321 LiveInterval::iterator LVE = li->end();
342 const LiveInterval &Orig = LIS.getInterval(OrigReg);
344 LiveInterval::const_iterator I = Orig.find(Idx);
354 void SplitAnalysis::analyze(const LiveInterval *li) {
407 LiveInterval::SubRange &SplitEditor::getSubRangeForMask(LaneBitmask LM,
408 LiveInterval &LI) {
409 for (LiveInterval::SubRange &S : LI.subranges())
415 void SplitEditor::addDeadDef(LiveInterval &LI, VNInfo *VNI, bool Original) {
426 for (LiveInterval::SubRange &S : LI.subranges()) {
450 for (LiveInterval::SubRange &S : LI.subranges())
463 LiveInterval *LI = &LIS.getInterval(Edit->get(RegIdx));
553 LiveInterval &DestLI = LIS.getInterval(Edit->get(RegIdx));
633 LiveInterval *LI = &LIS.getInterval(Edit->get(RegIdx));
641 LiveInterval &OrigLI = LIS.getInterval(Original);
659 for (LiveInterval::SubRange &S : LI->subranges())
848 LiveInterval *LI = &LIS.getInterval(Edit->get(0));
949 LiveInterval *LI = &LIS.getInterval(Edit->get(0));
950 LiveInterval *Parent = &Edit->getParent();
1004 LiveInterval *LI = &LIS.getInterval(Edit->get(0));
1005 LiveInterval *Parent = &Edit->getParent();
1150 LiveInterval &LI = LIS.getInterval(Edit->get(RegIdx));
1249 LiveInterval &PLI = Edit->getParent();
1266 LiveInterval &ParentLI = Edit->getParent();
1272 LiveInterval &LI = LIS.getInterval(Edit->get(RegIdx));
1282 for (LiveInterval::SubRange &PS : ParentLI.subranges()) {
1287 LiveInterval &LI = LIS.getInterval(Edit->get(RegIdx));
1288 LiveInterval::SubRange &S = getSubRangeForMask(PS.LaneMask, LI);
1336 LiveInterval &LI = LIS.getInterval(Edit->get(RegIdx));
1372 LiveInterval &LI = LIS.getInterval(Edit->get(EP.RegIdx));
1379 for (LiveInterval::SubRange &S : LI.subranges()) {
1398 LiveInterval &LI = LIS.getInterval(R);
1410 LiveInterval *LI = &LIS.getInterval(*I);
1449 const LiveInterval &ParentLI = Edit->getParent();
1517 LiveInterval &LI = LIS.getInterval(Reg);
1534 LiveInterval &LI = LIS.getInterval(VReg);
1535 SmallVector<LiveInterval*, 8> SplitLIs;
1538 for (LiveInterval *SplitLI : SplitLIs)
lib/CodeGen/SplitKit.h 59 SlotIndex computeLastInsertPoint(const LiveInterval &CurLI,
66 SlotIndex getLastInsertPoint(const LiveInterval &CurLI,
137 const LiveInterval *CurLI = nullptr;
173 void analyze(const LiveInterval *li);
185 const LiveInterval &getParent() const { return *CurLI; }
219 unsigned countLiveBlocks(const LiveInterval *li) const;
351 LiveInterval::SubRange &getSubRangeForMask(LaneBitmask LM, LiveInterval &LI);
351 LiveInterval::SubRange &getSubRangeForMask(LaneBitmask LM, LiveInterval &LI);
359 void addDeadDef(LiveInterval &LI, VNInfo *VNI, bool Original);
lib/CodeGen/StackColoring.cpp 413 SmallVector<std::unique_ptr<LiveInterval>, 16> Intervals;
1011 const LiveInterval *Interval = &*Intervals[FromSlot];
1108 LiveInterval *Interval = &*Intervals[Slot];
1184 std::unique_ptr<LiveInterval> LI(new LiveInterval(i, 0));
1184 std::unique_ptr<LiveInterval> LI(new LiveInterval(i, 0));
1249 LiveInterval *First = &*Intervals[FirstSlot];
1250 LiveInterval *Second = &*Intervals[SecondSlot];
lib/CodeGen/StackSlotColoring.cpp 67 std::vector<LiveInterval*> SSIntervals;
94 SmallVector<SmallVector<LiveInterval*,4>, 16> Assignments;
119 bool OverlapWithAssignments(LiveInterval *li, int Color) const;
120 int ColorSlot(LiveInterval *li);
146 bool operator()(LiveInterval* LHS, LiveInterval* RHS) const {
146 bool operator()(LiveInterval* LHS, LiveInterval* RHS) const {
174 LiveInterval &li = LS->getInterval(FI);
222 LiveInterval &li = I->second;
257 StackSlotColoring::OverlapWithAssignments(LiveInterval *li, int Color) const {
258 const SmallVectorImpl<LiveInterval *> &OtherLIs = Assignments[Color];
260 LiveInterval *OtherLI = OtherLIs[i];
268 int StackSlotColoring::ColorSlot(LiveInterval *li) {
332 LiveInterval *li = SSIntervals[i];
345 LiveInterval *li = SSIntervals[i];
lib/CodeGen/TwoAddressInstructionPass.cpp 252 LiveInterval &LI = LIS->getInterval(SavedReg);
257 LiveInterval::const_iterator I = LI.find(MBBEndIdx);
437 LiveInterval &LI = LIS->getInterval(Reg);
444 LiveInterval::const_iterator I = LI.find(useIdx);
872 LiveInterval &LI = LIS->getInterval(Reg);
877 LiveInterval::const_iterator I = LI.find(MBBEndIdx);
1062 LiveInterval &LI = LIS->getInterval(Reg);
1067 LiveInterval::const_iterator I = LI.find(MBBEndIdx);
1581 LiveInterval &LI = LIS->getInterval(RegA);
1642 LiveInterval &LI = LIS->getInterval(RegB);
1644 LiveInterval::const_iterator I = LI.find(MIIdx);
lib/CodeGen/VirtRegMap.cpp 187 void addLiveInsForSubRanges(const LiveInterval &LI, Register PhysReg) const;
266 void VirtRegRewriter::addLiveInsForSubRanges(const LiveInterval &LI,
272 std::pair<const LiveInterval::SubRange *, LiveInterval::const_iterator>;
272 std::pair<const LiveInterval::SubRange *, LiveInterval::const_iterator>;
277 for (const LiveInterval::SubRange &SR : LI.subranges()) {
294 const LiveInterval::SubRange *SR = RangeIterPair.first;
295 LiveInterval::const_iterator &SRI = RangeIterPair.second;
317 LiveInterval &LI = LIS->getInterval(VirtReg);
356 const LiveInterval &LI = LIS->getInterval(Reg);
367 for (const LiveInterval::SubRange &SR : LI.subranges()) {
lib/Target/AArch64/AArch64PBQPRegAlloc.cpp 186 const LiveInterval &ld = LIs.getInterval(Rd);
187 const LiveInterval &la = LIs.getInterval(Ra);
262 const LiveInterval &ld = LIs.getInterval(Rd);
268 const LiveInterval &lr = LIs.getInterval(r);
321 const LiveInterval &LI = LIs.getInterval(reg);
lib/Target/AMDGPU/GCNNSAReassign.cpp 87 bool tryAssignRegisters(SmallVectorImpl<LiveInterval *> &Intervals,
92 bool scavengeRegs(SmallVectorImpl<LiveInterval *> &Intervals) const;
111 GCNNSAReassign::tryAssignRegisters(SmallVectorImpl<LiveInterval *> &Intervals,
145 GCNNSAReassign::scavengeRegs(SmallVectorImpl<LiveInterval *> &Intervals) const {
274 SmallVector<LiveInterval *, 16> Intervals;
280 LiveInterval *LI = &LIS->getInterval(Reg);
lib/Target/AMDGPU/GCNRegBankReassign.cpp 220 unsigned scavengeReg(LiveInterval& LI, unsigned Bank) const;
589 unsigned GCNRegBankReassign::scavengeReg(LiveInterval& LI,
623 LiveInterval &LI = LIS->getInterval(C.Reg);
lib/Target/AMDGPU/GCNRegPressure.cpp 46 const auto &LI = LIS.getInterval(Reg);
261 const auto &LI = LIS.getInterval(Reg);
379 const LiveInterval &LI = LIS.getInterval(It.first);
lib/Target/AMDGPU/GCNRegPressure.h 220 auto &LI = LIS.getInterval(Reg);
lib/Target/AMDGPU/SIPreAllocateWWMRegs.cpp 104 LiveInterval &LI = LIS->getInterval(Reg);
lib/Target/AMDGPU/SIRegisterInfo.cpp 1875 LiveInterval &LI = LIS->getInterval(Reg);
lib/Target/Hexagon/HexagonExpandCondsets.cpp 235 bool isIntraBlocks(LiveInterval &LI);
333 LiveInterval &LI = LIS->getInterval(Reg);
353 for (LiveInterval::SubRange &S : LI.subranges()) {
425 LiveInterval &LI = LIS->getInterval(Reg);
527 LiveInterval &LI = LIS->getInterval(Reg);
529 for (LiveInterval::SubRange &S : LI.subranges()) {
1108 bool HexagonExpandCondsets::isIntraBlocks(LiveInterval &LI) {
1109 for (LiveInterval::iterator I = LI.begin(), E = LI.end(); I != E; ++I) {
1135 LiveInterval &L1 = LIS->getInterval(R1.Reg);
1136 LiveInterval &L2 = LIS->getInterval(R2.Reg);
1163 for (LiveInterval::iterator I = L2.begin(), E = L2.end(); I != E; ++I) {
lib/Target/PowerPC/PPCVSXFMAMutate.cpp 280 LiveInterval &FMAInt = LIS->getInterval(OldFMAReg);
298 LiveInterval &NewFMAInt = LIS->getInterval(KilledProdReg);
299 for (LiveInterval::iterator AI = FMAInt.begin(), AE = FMAInt.end();
lib/Target/SystemZ/SystemZRegisterInfo.cpp 357 LiveInterval &IntGR128 = LIS.getInterval(GR128Reg);
358 LiveInterval &IntGRNar = LIS.getInterval(GRNarReg);
lib/Target/WebAssembly/WebAssemblyMemIntrinsicResults.cpp 91 LiveInterval *FromLI = &LIS.getInterval(FromReg);
92 LiveInterval *ToLI = &LIS.getInterval(ToReg);
lib/Target/WebAssembly/WebAssemblyOptimizeLiveIntervals.cpp 82 SmallVector<LiveInterval *, 4> SplitLIs;
99 LiveInterval &LI = LIS.getInterval(MI->getOperand(0).getReg());
lib/Target/WebAssembly/WebAssemblyRegColoring.cpp 96 SmallVector<LiveInterval *, 0> SortedIntervals;
108 LiveInterval *LI = &Liveness->getInterval(VReg);
132 SmallVector<SmallVector<LiveInterval *, 4>, 16> Assignments(
137 LiveInterval *LI = SortedIntervals[I];
147 for (LiveInterval *OtherLI : Assignments[C])
lib/Target/WebAssembly/WebAssemblyRegStackify.cpp 294 const LiveInterval &LI = LIS.getInterval(Reg);
406 const LiveInterval &LI = LIS.getInterval(Reg);
474 static void shrinkToUses(LiveInterval &LI, LiveIntervals &LIS) {
476 SmallVector<LiveInterval *, 4> SplitLIs;
510 LiveInterval &LI = LIS.getInterval(Reg);
552 LiveInterval &LI = LIS.getInterval(Reg);
625 LiveInterval &LI = LIS.getInterval(Reg);
626 LiveInterval::iterator I = LI.FindSegmentContaining(DefIdx);
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/bits/stl_pair.h 209 : private __pair_base<_T1, _T2>
212 typedef _T2 second_type; /// @c second_type is the second bound type
215 _T2 second; /// @c second is a copy of the second object
252 using _PCCP = _PCC<true, _T1, _T2>;
260 constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
283 _T1, _T2>;
311 constexpr pair(_U1&& __x, const _T2& __y)
318 explicit constexpr pair(_U1&& __x, const _T2& __y)
380 is_copy_assignable<_T2>>::value,
391 is_move_assignable<_T2>>::value,
usr/include/c++/7.4.0/bits/unique_ptr.h 68 default_delete(const default_delete<_Up>&) noexcept { }
72 operator()(_Tp* __ptr) const
74 static_assert(!is_void<_Tp>::value,
76 static_assert(sizeof(_Tp)>0,
122 using type = _Up*;
137 using pointer = typename _Ptr<_Tp, _Dp>::type;
161 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
163 __uniq_ptr_impl<_Tp, _Dp> _M_t;
166 using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
167 using element_type = _Tp;
252 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
297 __safe_conversion_up<_Up, _Ep>,
301 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
811 { typedef unique_ptr<_Tp> __single_object; };
823 inline typename _MakeUniq<_Tp>::__single_object
825 { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
usr/include/c++/7.4.0/bits/unordered_map.h 103 typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1633 { typedef _Tp type; };
1645 { typedef _Tp& type; };
1650 : public __add_lvalue_reference_helper<_Tp>
1983 { typedef _Up type; };
usr/include/c++/7.4.0/utility 180 { typedef _Tp2 type; };
190 __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
200 __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
224 constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
225 get(std::pair<_Tp1, _Tp2>& __in) noexcept
229 constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
230 get(std::pair<_Tp1, _Tp2>&& __in) noexcept
234 constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
235 get(const std::pair<_Tp1, _Tp2>& __in) noexcept