reference, declarationdefinition
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