|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
include/llvm/ADT/ArrayRef.h 43 using iterator = const T *;
44 using const_iterator = const T *;
50 const T *Data = nullptr;
66 /*implicit*/ ArrayRef(const T &OneElt)
70 /*implicit*/ ArrayRef(const T *data, size_t length)
74 ArrayRef(const T *begin, const T *end)
74 ArrayRef(const T *begin, const T *end)
81 /*implicit*/ ArrayRef(const SmallVectorTemplateCommon<T, U> &Vec)
87 /*implicit*/ ArrayRef(const std::vector<T, A> &Vec)
92 /*implicit*/ constexpr ArrayRef(const std::array<T, N> &Arr)
97 /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
100 /*implicit*/ ArrayRef(const std::initializer_list<T> &Vec)
145 const T *data() const { return Data; }
151 const T &front() const {
157 const T &back() const {
163 template <typename Allocator> ArrayRef<T> copy(Allocator &A) {
178 ArrayRef<T> slice(size_t N, size_t M) const {
184 ArrayRef<T> slice(size_t N) const { return slice(N, size() - N); }
187 ArrayRef<T> drop_front(size_t N = 1) const {
193 ArrayRef<T> drop_back(size_t N = 1) const {
200 template <class PredicateT> ArrayRef<T> drop_while(PredicateT Pred) const {
206 template <class PredicateT> ArrayRef<T> drop_until(PredicateT Pred) const {
211 ArrayRef<T> take_front(size_t N = 1) const {
218 ArrayRef<T> take_back(size_t N = 1) const {
226 template <class PredicateT> ArrayRef<T> take_while(PredicateT Pred) const {
232 template <class PredicateT> ArrayRef<T> take_until(PredicateT Pred) const {
239 const T &operator[](size_t Index) const {
249 typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
257 typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
263 std::vector<T> vec() const {
270 operator std::vector<T>() const {
include/llvm/ADT/DenseMap.h 40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
45 ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
46 const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
66 using mapped_type = ValueT;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
123 is_trivially_copyable<ValueT>::value) {
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
219 InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
299 ValueT &operator[](const KeyT &Key) {
311 ValueT &operator[](KeyT &&Key) {
380 ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
516 ValueArgs &&... Values) {
520 ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
520 ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
526 ValueT &&Value, LookupKeyT &Lookup) {
684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
685 KeyT, ValueT, KeyInfoT, BucketT> {
690 using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
1163 using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
1199 const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
include/llvm/ADT/IntervalMap.h 166 static inline bool startLess(const T &x, const T &a) {
166 static inline bool startLess(const T &x, const T &a) {
171 static inline bool stopLess(const T &b, const T &x) {
171 static inline bool stopLess(const T &b, const T &x) {
176 static inline bool adjacent(const T &a, const T &b) {
176 static inline bool adjacent(const T &a, const T &b) {
181 static inline bool nonEmpty(const T &a, const T &b) {
181 static inline bool nonEmpty(const T &a, const T &b) {
225 T2 second[N];
233 void copy(const NodeBase<T1, T2, M> &Other, unsigned i,
444 static_cast<unsigned>(2*sizeof(KeyT)+sizeof(ValT)),
449 using LeafBase = NodeBase<std::pair<KeyT, KeyT>, ValT, LeafSize>;
449 using LeafBase = NodeBase<std::pair<KeyT, KeyT>, ValT, LeafSize>;
458 static_cast<unsigned>(sizeof(KeyT) + sizeof(void*))
563 class LeafNode : public NodeBase<std::pair<KeyT, KeyT>, ValT, N> {
563 class LeafNode : public NodeBase<std::pair<KeyT, KeyT>, ValT, N> {
565 const KeyT &start(unsigned i) const { return this->first[i].first; }
566 const KeyT &stop(unsigned i) const { return this->first[i].second; }
569 KeyT &start(unsigned i) { return this->first[i].first; }
570 KeyT &stop(unsigned i) { return this->first[i].second; }
579 unsigned findFrom(unsigned i, unsigned Size, KeyT x) const {
594 unsigned safeFind(unsigned i, KeyT x) const {
608 ValT safeLookup(KeyT x, ValT NotFound) const {
613 unsigned insertFrom(unsigned &Pos, unsigned Size, KeyT a, KeyT b, ValT y);
613 unsigned insertFrom(unsigned &Pos, unsigned Size, KeyT a, KeyT b, ValT y);
700 class BranchNode : public NodeBase<NodeRef, KeyT, N> {
702 const KeyT &stop(unsigned i) const { return this->second[i]; }
705 KeyT &stop(unsigned i) { return this->second[i]; }
714 unsigned findFrom(unsigned i, unsigned Size, KeyT x) const {
728 unsigned safeFind(unsigned i, KeyT x) const {
740 NodeRef safeLookup(KeyT x) const {
749 void insert(unsigned i, unsigned Size, NodeRef Node, KeyT Stop) {
934 using Sizer = IntervalMapImpl::NodeSizer<KeyT, ValT>;
935 using Leaf = IntervalMapImpl::LeafNode<KeyT, ValT, Sizer::LeafSize, Traits>;
937 IntervalMapImpl::BranchNode<KeyT, ValT, Sizer::BranchSize, Traits>;
938 using RootLeaf = IntervalMapImpl::LeafNode<KeyT, ValT, N, Traits>;
944 DesiredRootBranchCap = (sizeof(RootLeaf) - sizeof(KeyT)) /
945 (sizeof(KeyT) + sizeof(IntervalMapImpl::NodeRef)),
950 IntervalMapImpl::BranchNode<KeyT, ValT, RootBranchCap, Traits>;
954 KeyT start;
960 using KeyType = KeyT;
1007 KeyT rootBranchStart() const { return rootBranchData().start; }
1008 KeyT &rootBranchStart() { return rootBranchData().start; }
1036 ValT treeSafeLookup(KeyT x, ValT NotFound) const;
1059 KeyT start() const {
1065 KeyT stop() const {
1072 ValT lookup(KeyT x, ValT NotFound = ValT()) const {
1082 void insert(KeyT a, KeyT b, ValT y) {
1082 void insert(KeyT a, KeyT b, ValT y) {
1125 const_iterator find(KeyT x) const {
1131 iterator find(KeyT x) {
1139 bool overlaps(KeyT a, KeyT b) {
1139 bool overlaps(KeyT a, KeyT b) {
1324 void pathFillFind(KeyT x);
1325 void treeFind(KeyT x);
1326 void treeAdvanceTo(KeyT x);
1329 KeyT &unsafeStart() const {
1336 KeyT &unsafeStop() const {
1364 const KeyT &start() const { return unsafeStart(); }
1367 const KeyT &stop() const { return unsafeStop(); }
1432 void find(KeyT x) {
1442 void advanceTo(KeyT x) {
1527 void setNodeStop(unsigned Level, KeyT Stop);
1528 bool insertNode(unsigned Level, IntervalMapImpl::NodeRef Node, KeyT Stop);
1530 void treeInsert(KeyT a, KeyT b, ValT y);
1530 void treeInsert(KeyT a, KeyT b, ValT y);
1533 bool canCoalesceLeft(KeyT Start, ValT x);
1534 bool canCoalesceRight(KeyT Stop, ValT x);
1543 void setStart(KeyT a);
1548 void setStop(KeyT b);
1559 void setStartUnchecked(KeyT a) { this->unsafeStart() = a; }
1565 void setStopUnchecked(KeyT b) {
1578 void insert(KeyT a, KeyT b, ValT y);
1578 void insert(KeyT a, KeyT b, ValT y);
1684 KeyT &CurStart = this->unsafeStart();
1706 KeyT a = this->start();
1716 KeyT a = this->start();
1722 KeyT a = this->start();
2018 KeyT Stop = Node[Pos]->stop(NewSize[Pos]-1);
include/llvm/ADT/STLExtras.h 1042 inline int (*get_array_pod_sort_comparator(const T &))
1044 return array_pod_sort_comparator<T>;
1261 auto lower_bound(R &&Range, T &&Value) -> decltype(adl_begin(Range)) {
1263 std::forward<T>(Value));
1276 auto upper_bound(R &&Range, T &&Value) -> decltype(adl_begin(Range)) {
include/llvm/ADT/SmallVector.h 75 AlignedCharArrayUnion<T> FirstEl;
114 using value_type = T;
115 using iterator = T *;
116 using const_iterator = const T *;
121 using reference = T &;
122 using const_reference = const T &;
123 using pointer = T *;
124 using const_pointer = const T *;
259 class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
264 static void destroy_range(T *, T *) {}
264 static void destroy_range(T *, T *) {}
286 T1 *I, T1 *E, T2 *Dest,
286 T1 *I, T1 *E, T2 *Dest,
286 T1 *I, T1 *E, T2 *Dest,
287 typename std::enable_if<std::is_same<typename std::remove_const<T1>::type,
288 T2>::value>::type * = nullptr) {
294 memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
299 void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
302 void push_back(const T &Elt) {
305 memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
315 class SmallVectorImpl : public SmallVectorTemplateBase<T> {
316 using SuperClass = SmallVectorTemplateBase<T>;
352 new (&*I) T();
357 void resize(size_type N, const T &NV) {
374 LLVM_NODISCARD T pop_back_val() {
397 void append(size_type NumInputs, const T &Elt) {
405 void append(std::initializer_list<T> IL) {
412 void assign(size_type NumElts, const T &Elt) {
429 void assign(std::initializer_list<T> IL) {
467 iterator insert(iterator I, T &&Elt) {
497 iterator insert(iterator I, const T &Elt) {
526 iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
637 void insert(iterator I, std::initializer_list<T> IL) {
820 AlignedCharArrayUnion<T> InlineElts[N];
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
846 explicit SmallVector(size_t Size, const T &Value = T())
865 SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
884 SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
include/llvm/CodeGen/CalcSpillWeights.h 41 return UseDefFreq / (Size + 25*SlotIndex::InstrDist);
78 float futureWeight(LiveInterval &li, SlotIndex start, SlotIndex end);
78 float futureWeight(LiveInterval &li, SlotIndex start, SlotIndex end);
92 float weightCalcHelper(LiveInterval &li, SlotIndex *start = nullptr,
93 SlotIndex *end = nullptr);
include/llvm/CodeGen/LiveInterval.h 60 SlotIndex def;
63 VNInfo(unsigned i, SlotIndex d) : id(i), def(d) {}
92 const SlotIndex EndPoint;
96 LiveQueryResult(VNInfo *EarlyVal, VNInfo *LateVal, SlotIndex EndPoint,
146 SlotIndex endPoint() const {
162 SlotIndex start; // Start point of the interval (inclusive)
163 SlotIndex end; // End point of the interval (exclusive)
169 Segment(SlotIndex S, SlotIndex E, VNInfo *V)
169 Segment(SlotIndex S, SlotIndex E, VNInfo *V)
175 bool contains(SlotIndex I) const {
180 bool containsInterval(SlotIndex S, SlotIndex E) const {
180 bool containsInterval(SlotIndex S, SlotIndex E) const {
262 iterator advanceTo(iterator I, SlotIndex Pos) {
270 const_iterator advanceTo(const_iterator I, SlotIndex Pos) const {
285 iterator find(SlotIndex Pos);
287 const_iterator find(SlotIndex Pos) const {
322 VNInfo *getNextValue(SlotIndex def, VNInfo::Allocator &VNInfoAllocator) {
332 VNInfo *createDeadDef(SlotIndex Def, VNInfo::Allocator &VNIAlloc);
376 SlotIndex beginIndex() const {
383 SlotIndex endIndex() const {
388 bool expiredAt(SlotIndex index) const {
392 bool liveAt(SlotIndex index) const {
399 const Segment *getSegmentContaining(SlotIndex Idx) const {
406 Segment *getSegmentContaining(SlotIndex Idx) {
412 VNInfo *getVNInfoAt(SlotIndex Idx) const {
420 VNInfo *getVNInfoBefore(SlotIndex Idx) const {
427 iterator FindSegmentContaining(SlotIndex Idx) {
432 const_iterator FindSegmentContaining(SlotIndex Idx) const {
455 bool overlaps(SlotIndex Start, SlotIndex End) const;
455 bool overlaps(SlotIndex Start, SlotIndex End) const;
487 std::pair<VNInfo*,bool> extendInBlock(ArrayRef<SlotIndex> Undefs,
488 SlotIndex StartIdx, SlotIndex Kill);
488 SlotIndex StartIdx, SlotIndex Kill);
495 VNInfo *extendInBlock(SlotIndex StartIdx, SlotIndex Kill);
495 VNInfo *extendInBlock(SlotIndex StartIdx, SlotIndex Kill);
509 bool isLocal(SlotIndex Start, SlotIndex End) const {
509 bool isLocal(SlotIndex Start, SlotIndex End) const {
516 void removeSegment(SlotIndex Start, SlotIndex End,
516 void removeSegment(SlotIndex Start, SlotIndex End,
532 LiveQueryResult Query(SlotIndex Idx) const {
544 SlotIndex EndPoint;
550 if (SlotIndex::isSameInstr(Idx, I->end)) {
564 if (!SlotIndex::isEarlierInstr(Idx, I->start)) {
588 bool isLiveAtIndexes(ArrayRef<SlotIndex> Slots) const;
591 const SlotIndex &thisIndex = beginIndex();
592 const SlotIndex &otherIndex = other.beginIndex();
598 bool isUndefIn(ArrayRef<SlotIndex> Undefs, SlotIndex Begin,
598 bool isUndefIn(ArrayRef<SlotIndex> Undefs, SlotIndex Begin,
599 SlotIndex End) const {
819 void computeSubRangeUndefs(SmallVectorImpl<SlotIndex> &Undefs,
845 const SlotIndex &thisIndex = beginIndex();
846 const SlotIndex &otherIndex = other.beginIndex();
886 inline bool operator<(SlotIndex V, const LiveRange::Segment &S) {
890 inline bool operator<(const LiveRange::Segment &S, SlotIndex V) {
904 SlotIndex LastStart;
922 void add(SlotIndex Start, SlotIndex End, VNInfo *VNI) {
922 void add(SlotIndex Start, SlotIndex End, VNInfo *VNI) {
include/llvm/CodeGen/LiveIntervalUnion.h 46 using LiveSegments = IntervalMap<SlotIndex, LiveInterval*>;
71 SegmentIter find(SlotIndex x) { return Segments.find(x); }
74 ConstSegmentIter find(SlotIndex x) const { return Segments.find(x); }
77 SlotIndex startIndex() const { return Segments.start(); }
78 SlotIndex endIndex() const { return Segments.stop(); }
include/llvm/CodeGen/LiveIntervals.h 72 SmallVector<SlotIndex, 8> RegMaskSlots;
184 void extendToIndices(LiveRange &LR, ArrayRef<SlotIndex> Indices,
185 ArrayRef<SlotIndex> Undefs);
187 void extendToIndices(LiveRange &LR, ArrayRef<SlotIndex> Indices) {
198 void pruneValue(LiveRange &LR, SlotIndex Kill,
199 SmallVectorImpl<SlotIndex> *EndPoints);
205 LLVM_ATTRIBUTE_UNUSED void pruneValue(LiveInterval &, SlotIndex,
206 SmallVectorImpl<SlotIndex> *) {
226 SlotIndex getInstructionIndex(const MachineInstr &Instr) const {
231 MachineInstr* getInstructionFromIndex(SlotIndex index) const {
236 SlotIndex getMBBStartIdx(const MachineBasicBlock *mbb) const {
241 SlotIndex getMBBEndIdx(const MachineBasicBlock *mbb) const {
255 MachineBasicBlock* getMBBFromIndex(SlotIndex index) const {
266 SlotIndex InsertMachineInstrInMaps(MachineInstr &MI) {
280 SlotIndex ReplaceMachineInstrInMaps(MachineInstr &MI, MachineInstr &NewMI) {
351 ArrayRef<SlotIndex> getRegMaskSlots() const { return RegMaskSlots; }
355 ArrayRef<SlotIndex> getRegMaskSlotsInBlock(unsigned MBBNum) const {
433 void removePhysRegDefAt(unsigned Reg, SlotIndex Pos);
437 void removeVRegDefAt(LiveInterval &LI, SlotIndex Pos);
474 using ShrinkToUsesWorkList = SmallVector<std::pair<SlotIndex, VNInfo*>, 16>;
include/llvm/CodeGen/LiveRangeCalc.h 111 SlotIndex Kill;
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,
149 unsigned PhysReg, ArrayRef<SlotIndex> Undefs);
210 void extend(LiveRange &LR, SlotIndex Use, unsigned PhysReg,
211 ArrayRef<SlotIndex> Undefs);
270 SlotIndex Kill = SlotIndex()) {
289 ArrayRef<SlotIndex> Defs,
include/llvm/CodeGen/LiveRangeEdit.h 101 bool allUsesAvailableAt(const MachineInstr *OrigMI, SlotIndex OrigIdx,
102 SlotIndex UseIdx) const;
212 bool canRematerializeAt(Remat &RM, VNInfo *OrigVNI, SlotIndex UseIdx,
219 SlotIndex rematerializeAt(MachineBasicBlock &MBB,
include/llvm/CodeGen/LiveRegMatrix.h 114 bool checkInterference(SlotIndex Start, SlotIndex End, unsigned PhysReg);
114 bool checkInterference(SlotIndex Start, SlotIndex End, unsigned PhysReg);
include/llvm/CodeGen/RegisterPressure.h 70 SlotIndex TopIdx;
71 SlotIndex BottomIdx;
75 void openTop(SlotIndex NextTop);
77 void openBottom(SlotIndex PrevBottom);
193 const MachineRegisterInfo &MRI, SlotIndex Pos,
549 SlotIndex getCurrSlot() const;
564 LaneBitmask getLastUsedLanes(unsigned RegUnit, SlotIndex Pos) const;
565 LaneBitmask getLiveLanesAt(unsigned RegUnit, SlotIndex Pos) const;
566 LaneBitmask getLiveThroughAt(unsigned RegUnit, SlotIndex Pos) const;
include/llvm/CodeGen/SlotIndexes.h 144 SlotIndex(const SlotIndex &li, Slot s) : lie(li.listEntry(), unsigned(s)) {
165 bool operator==(SlotIndex other) const {
169 bool operator!=(SlotIndex other) const {
175 bool operator<(SlotIndex other) const {
180 bool operator<=(SlotIndex other) const {
186 bool operator>(SlotIndex other) const {
192 bool operator>=(SlotIndex other) const {
197 static bool isSameInstr(SlotIndex A, SlotIndex B) {
197 static bool isSameInstr(SlotIndex A, SlotIndex B) {
203 static bool isEarlierInstr(SlotIndex A, SlotIndex B) {
203 static bool isEarlierInstr(SlotIndex A, SlotIndex B) {
209 static bool isEarlierEqualInstr(SlotIndex A, SlotIndex B) {
209 static bool isEarlierEqualInstr(SlotIndex A, SlotIndex B) {
214 int distance(SlotIndex other) const {
220 int getInstrDistance(SlotIndex other) const {
241 SlotIndex getBaseIndex() const {
248 SlotIndex getBoundaryIndex() const {
254 SlotIndex getRegSlot(bool EC = false) const {
259 SlotIndex getDeadSlot() const {
269 SlotIndex getNextSlot() const {
279 SlotIndex getNextIndex() const {
289 SlotIndex getPrevSlot() const {
299 SlotIndex getPrevIndex() const {
304 inline raw_ostream& operator<<(raw_ostream &os, SlotIndex li) {
309 using IdxMBBPair = std::pair<SlotIndex, MachineBasicBlock *>;
324 using Mi2IndexMap = DenseMap<const MachineInstr *, SlotIndex>;
328 SmallVector<std::pair<SlotIndex, SlotIndex>, 8> MBBRanges;
328 SmallVector<std::pair<SlotIndex, SlotIndex>, 8> MBBRanges;
373 SlotIndex getZeroIndex() {
379 SlotIndex getLastIndex() {
390 SlotIndex getInstructionIndex(const MachineInstr &MI) const {
406 MachineInstr* getInstructionFromIndex(SlotIndex index) const {
412 SlotIndex getNextNonNullIndex(SlotIndex Index) {
412 SlotIndex getNextNonNullIndex(SlotIndex Index) {
425 SlotIndex getIndexBefore(const MachineInstr &MI) const {
442 SlotIndex getIndexAfter(const MachineInstr &MI) const {
457 const std::pair<SlotIndex, SlotIndex> &
457 const std::pair<SlotIndex, SlotIndex> &
463 const std::pair<SlotIndex, SlotIndex> &
463 const std::pair<SlotIndex, SlotIndex> &
469 SlotIndex getMBBStartIdx(unsigned Num) const {
474 SlotIndex getMBBStartIdx(const MachineBasicBlock *mbb) const {
479 SlotIndex getMBBEndIdx(unsigned Num) const {
484 SlotIndex getMBBEndIdx(const MachineBasicBlock *mbb) const {
494 MBBIndexIterator advanceMBBIndex(MBBIndexIterator I, SlotIndex To) const {
502 MBBIndexIterator findMBBIndex(SlotIndex Idx) const {
517 MachineBasicBlock* getMBBFromIndex(SlotIndex index) const {
538 SlotIndex insertMachineInstrInMaps(MachineInstr &MI, bool Late = false) {
573 SlotIndex newIndex(&*newItr, SlotIndex::Slot_Block);
573 SlotIndex newIndex(&*newItr, SlotIndex::Slot_Block);
591 SlotIndex replaceMachineInstrInMaps(MachineInstr &MI, MachineInstr &NewMI) {
595 SlotIndex replaceBaseIndex = mi2iItr->second;
623 SlotIndex startIdx(startEntry, SlotIndex::Slot_Block);
623 SlotIndex startIdx(startEntry, SlotIndex::Slot_Block);
624 SlotIndex endIdx(endEntry, SlotIndex::Slot_Block);
624 SlotIndex endIdx(endEntry, SlotIndex::Slot_Block);
644 struct IntervalMapInfo<SlotIndex> : IntervalMapHalfOpenInfo<SlotIndex> {
include/llvm/Support/AlignOf.h 30 T t;
39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
50 llvm::detail::SizerImpl<T, Ts...>)];
include/llvm/Support/type_traits.h 91 T t;
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
145 std::is_copy_constructible<detail::trivial_helper<T>>::value;
147 !std::is_copy_constructible<T>::value;
151 std::is_move_constructible<detail::trivial_helper<T>>::value;
153 !std::is_move_constructible<T>::value;
157 is_copy_assignable<detail::trivial_helper<T>>::value;
159 !is_copy_assignable<T>::value;
163 is_move_assignable<detail::trivial_helper<T>>::value;
165 !is_move_assignable<T>::value;
169 std::is_destructible<detail::trivial_helper<T>>::value;
lib/CodeGen/CalcSpillWeights.cpp 146 float VirtRegAuxInfo::futureWeight(LiveInterval &li, SlotIndex start,
147 SlotIndex end) {
151 float VirtRegAuxInfo::weightCalcHelper(LiveInterval &li, SlotIndex *start,
152 SlotIndex *end) {
213 SlotIndex si = LIS.getInstructionIndex(*mi);
lib/CodeGen/InlineSpiller.cpp 228 void insertReload(unsigned VReg, SlotIndex, MachineBasicBlock::iterator MI);
373 SlotIndex Idx = LIS.getInstructionIndex(CopyMI);
453 SlotIndex Idx = LIS.getInstructionIndex(MI);
552 SlotIndex UseIdx = LIS.getInstructionIndex(MI).getRegSlot(true);
609 SlotIndex DefIdx =
766 SlotIndex Idx = LIS.getInstructionIndex(*I).getRegSlot();
860 SlotIndex Idx = LIS.getInstructionIndex(*MI).getRegSlot();
904 SlotIndex Idx,
1000 SlotIndex Idx = LIS.getInstructionIndex(*MI).getRegSlot();
1002 if (SlotIndex::isSameInstr(Idx, VNI->def))
1152 SlotIndex Idx = LIS.getInstructionIndex(Spill);
1165 SlotIndex Idx = LIS.getInstructionIndex(Spill);
1175 SlotIndex Idx;
1210 SlotIndex PIdx = LIS.getInstructionIndex(*PrevSpill);
1211 SlotIndex CIdx = LIS.getInstructionIndex(*CurrentSpill);
lib/CodeGen/InterferenceCache.cpp 136 SlotIndex Start, Stop;
161 ArrayRef<SlotIndex> RegMaskSlots;
172 SlotIndex StartI = I.start();
185 SlotIndex StartI = I->start;
195 SlotIndex Limit = BI->First.isValid() ? BI->First : Stop;
227 SlotIndex StopI = I.stop();
244 SlotIndex StopI = I->end;
252 SlotIndex Limit = BI->Last.isValid() ? BI->Last : Start;
lib/CodeGen/InterferenceCache.h 37 SlotIndex First;
38 SlotIndex Last;
66 SlotIndex PrevPos;
232 SlotIndex first() {
238 SlotIndex last() {
lib/CodeGen/LiveDebugVariables.cpp 135 using LocMap = IntervalMap<SlotIndex, DbgValueLocation, 4>;
198 void insertDebugValue(MachineBasicBlock *MBB, SlotIndex StartIdx,
199 SlotIndex StopIdx, DbgValueLocation Loc, bool Spilled,
257 void addDef(SlotIndex Idx, const MachineOperand &LocMO) {
282 void extendDef(SlotIndex Idx, DbgValueLocation Loc,
284 SmallVectorImpl<SlotIndex> *Kills,
297 const SmallVectorImpl<SlotIndex> &Kills,
298 SmallVectorImpl<std::pair<SlotIndex, DbgValueLocation>> &NewDefs,
358 SlotIndex loc; ///< Slot used by the debug label.
361 void insertDebugLabel(MachineBasicBlock *MBB, SlotIndex Idx,
366 UserLabel(const DILabel *label, DebugLoc L, SlotIndex Idx)
371 const SlotIndex Index) const {
425 bool handleDebugValue(MachineInstr &MI, SlotIndex Idx);
433 bool handleDebugLabel(MachineInstr &MI, SlotIndex Idx);
599 bool LDVImpl::handleDebugValue(MachineInstr &MI, SlotIndex Idx) {
658 bool LDVImpl::handleDebugLabel(MachineInstr &MI, SlotIndex Idx) {
696 SlotIndex Idx =
716 void UserValue::extendDef(SlotIndex Idx, DbgValueLocation Loc, LiveRange *LR,
717 const VNInfo *VNI, SmallVectorImpl<SlotIndex> *Kills,
719 SlotIndex Start = Idx;
721 SlotIndex Stop = LIS.getMBBEndIdx(MBB);
762 const SmallVectorImpl<SlotIndex> &Kills,
763 SmallVectorImpl<std::pair<SlotIndex, DbgValueLocation>> &NewDefs,
789 SlotIndex Idx = LIS.getInstructionIndex(*MI);
810 SlotIndex Idx = Kills[i];
836 SmallVector<std::pair<SlotIndex, DbgValueLocation>, 16> Defs;
845 SlotIndex Idx = Defs[i].first;
862 SmallVector<SlotIndex, 16> Kills;
895 SlotIndex PrevEnd;
903 SlotIndex RStart = LIS.getInstructionIndex(*Range.first);
904 SlotIndex REnd = LIS.getInstructionIndex(*Range.second);
909 SlotIndex IStop = I.stop();
1049 SlotIndex LStart = LocMapI.start();
1050 SlotIndex LStop = LocMapI.stop();
1240 SlotIndex Start = LIS.getMBBStartIdx(MBB);
1274 SlotIndex::isEarlierEqualInstr(StopIdx, LIS.getInstructionIndex(*I)))
1284 void UserValue::insertDebugValue(MachineBasicBlock *MBB, SlotIndex StartIdx,
1285 SlotIndex StopIdx, DbgValueLocation Loc,
1289 SlotIndex MBBEndIdx = LIS.getMBBEndIdx(&*MBB);
1328 void UserLabel::insertDebugLabel(MachineBasicBlock *MBB, SlotIndex Idx,
1344 SlotIndex Start = I.start();
1345 SlotIndex Stop = I.stop();
1354 SlotIndex MBBEnd = LIS.getMBBEndIdx(&*MBB);
lib/CodeGen/LiveInterval.cpp 87 VNInfo *createDeadDef(SlotIndex Def, VNInfo::Allocator *VNInfoAllocator,
100 if (SlotIndex::isSameInstr(Def, S->start)) {
120 VNInfo *extendInBlock(SlotIndex StartIdx, SlotIndex Use) {
120 VNInfo *extendInBlock(SlotIndex StartIdx, SlotIndex Use) {
135 std::pair<VNInfo*,bool> extendInBlock(ArrayRef<SlotIndex> Undefs,
136 SlotIndex StartIdx, SlotIndex Use) {
136 SlotIndex StartIdx, SlotIndex Use) {
139 SlotIndex BeforeUse = Use.getPrevSlot();
158 void extendSegmentEndTo(iterator I, SlotIndex NewEnd) {
186 iterator extendSegmentStartTo(iterator I, SlotIndex NewStart) {
220 SlotIndex Start = S.start, End = S.end;
297 iterator find(SlotIndex Pos) { return LR->find(Pos); }
325 iterator find(SlotIndex Pos) {
350 LiveRange::iterator LiveRange::find(SlotIndex Pos) {
370 VNInfo *LiveRange::createDeadDef(SlotIndex Def, VNInfo::Allocator &VNIAlloc) {
467 SlotIndex Def = std::max(I->start, J->start);
488 bool LiveRange::overlaps(SlotIndex Start, SlotIndex End) const {
488 bool LiveRange::overlaps(SlotIndex Start, SlotIndex End) const {
564 std::pair<VNInfo*,bool> LiveRange::extendInBlock(ArrayRef<SlotIndex> Undefs,
565 SlotIndex StartIdx, SlotIndex Kill) {
565 SlotIndex StartIdx, SlotIndex Kill) {
573 VNInfo *LiveRange::extendInBlock(SlotIndex StartIdx, SlotIndex Kill) {
573 VNInfo *LiveRange::extendInBlock(SlotIndex StartIdx, SlotIndex Kill) {
583 void LiveRange::removeSegment(SlotIndex Start, SlotIndex End,
583 void LiveRange::removeSegment(SlotIndex Start, SlotIndex End,
623 SlotIndex OldEnd = I->end;
814 bool LiveRange::isLiveAtIndexes(ArrayRef<SlotIndex> Slots) const {
815 ArrayRef<SlotIndex>::iterator SlotI = Slots.begin();
816 ArrayRef<SlotIndex>::iterator SlotE = Slots.end();
967 void LiveInterval::computeSubRangeUndefs(SmallVectorImpl<SlotIndex> &Undefs,
985 SlotIndex Pos = Indexes.getInstructionIndex(MI).getRegSlot(EarlyClobber);
1364 SlotIndex Idx = LIS.getSlotIndexes()->getIndexBefore(*MI);
1367 SlotIndex Idx = LIS.getInstructionIndex(*MI);
lib/CodeGen/LiveIntervals.cpp 170 for (SlotIndex Idx : RegMaskSlots)
325 SlotIndex Begin = Indexes->getMBBStartIdx(&MBB);
355 SlotIndex Def = VNI->def;
386 SlotIndex Idx = WorkList.back().first;
390 SlotIndex BlockStart = Indexes->getMBBStartIdx(MBB);
404 SlotIndex Stop = Indexes->getMBBEndIdx(Pred);
420 SlotIndex Stop = Indexes->getMBBEndIdx(Pred);
431 SmallVector<SlotIndex,8> Undefs;
465 SlotIndex Idx = getInstructionIndex(UseMI).getRegSlot();
506 SlotIndex Def = VNI->def;
550 SlotIndex LastIdx;
564 SlotIndex Idx = getInstructionIndex(*UseMI).getRegSlot();
613 ArrayRef<SlotIndex> Indices,
614 ArrayRef<SlotIndex> Undefs) {
617 for (SlotIndex Idx : Indices)
621 void LiveIntervals::pruneValue(LiveRange &LR, SlotIndex Kill,
622 SmallVectorImpl<SlotIndex> *EndPoints) {
629 SlotIndex MBBEnd = Indexes->getMBBEndIdx(KillMBB);
654 SlotIndex MBBStart, MBBEnd;
822 SlotIndex Start = LI.beginIndex();
826 SlotIndex Stop = LI.endIndex();
891 ArrayRef<SlotIndex> Slots;
903 ArrayRef<SlotIndex>::iterator SlotI = llvm::lower_bound(Slots, LiveI->start);
904 ArrayRef<SlotIndex>::iterator SlotE = Slots.end();
948 SlotIndex OldIdx;
949 SlotIndex NewIdx;
956 SlotIndex OldIdx, SlotIndex NewIdx, bool UpdateFlags)
956 SlotIndex OldIdx, SlotIndex NewIdx, bool UpdateFlags)
1035 if (SlotIndex::isEarlierInstr(OldIdx, NewIdx))
1051 if (OldIdxIn == E || SlotIndex::isEarlierInstr(OldIdx, OldIdxIn->start))
1056 if (SlotIndex::isEarlierInstr(OldIdxIn->start, OldIdx)) {
1058 if (SlotIndex::isEarlierEqualInstr(NewIdx, OldIdxIn->end))
1070 if (Next != E && !SlotIndex::isSameInstr(OldIdx, Next->start) &&
1071 SlotIndex::isEarlierInstr(Next->start, NewIdx)) {
1078 !SlotIndex::isEarlierInstr(NewIdxIn->start, NewIdx)) {
1089 bool isKill = SlotIndex::isSameInstr(OldIdx, OldIdxIn->end);
1097 if (OldIdxOut == E || !SlotIndex::isSameInstr(OldIdx, OldIdxOut->start))
1112 SlotIndex NewIdxDef = NewIdx.getRegSlot(OldIdxOut->start.isEarlyClobber());
1113 if (SlotIndex::isEarlierInstr(NewIdxDef, OldIdxOut->end)) {
1127 SlotIndex::isEarlierInstr(OldIdxOut->end, NewIdxDef)) {
1131 !SlotIndex::isEarlierInstr(std::prev(OldIdxOut)->end,
1173 if (SlotIndex::isEarlierInstr(Prev->start, NewIdxDef)) {
1194 SlotIndex::isSameInstr(AfterNewIdx->start, NewIdxDef)) {
1224 if (OldIdxIn == E || SlotIndex::isEarlierInstr(OldIdx, OldIdxIn->start))
1229 if (SlotIndex::isEarlierInstr(OldIdxIn->start, OldIdx)) {
1233 bool isKill = SlotIndex::isSameInstr(OldIdx, OldIdxIn->end);
1239 SlotIndex DefBeforeOldIdx
1246 if (OldIdxOut == E || !SlotIndex::isSameInstr(OldIdx, OldIdxOut->start))
1262 SlotIndex NewIdxDef = NewIdx.getRegSlot(OldIdxOut->start.isEarlyClobber());
1264 if (SlotIndex::isSameInstr(NewIdxOut->start, NewIdx)) {
1284 SlotIndex::isEarlierInstr(NewIdxDef, OldIdxIn->start)) {
1288 const SlotIndex SplitPos = NewIdxDef;
1291 SlotIndex NewDefEndPoint = std::next(NewIdxIn)->end;
1294 SlotIndex::isEarlierInstr(NewIdx, Prev->end)) {
1318 if (SlotIndex::isEarlierInstr(Next->start, NewIdx)) {
1335 if (OldIdxIn != E && SlotIndex::isEarlierInstr(NewIdx, OldIdxIn->end))
1339 && SlotIndex::isEarlierInstr(NewIdxOut->start, NewIdx)
1340 && SlotIndex::isEarlierInstr(NewIdx, NewIdxOut->end)) {
1386 SmallVectorImpl<SlotIndex>::iterator RI =
1400 SlotIndex findLastUseBefore(SlotIndex Before, unsigned Reg,
1400 SlotIndex findLastUseBefore(SlotIndex Before, unsigned Reg,
1403 SlotIndex LastUse = Before;
1413 SlotIndex InstSlot = LIS.getSlotIndexes()->getInstructionIndex(MI);
1438 SlotIndex Idx = Indexes->getInstructionIndex(*MII);
1441 if (!SlotIndex::isEarlierInstr(Before, Idx))
1461 SlotIndex OldIndex = Indexes->getInstructionIndex(MI);
1463 SlotIndex NewIndex = Indexes->insertMachineInstrInMaps(MI);
1475 SlotIndex OldIndex = Indexes->getInstructionIndex(MI);
1476 SlotIndex NewIndex = Indexes->getInstructionIndex(BundleStart);
1487 SlotIndex lastUseIdx;
1504 SlotIndex instrIdx = getInstructionIndex(MI);
1525 SlotIndex prevStart;
1587 SlotIndex endIdx;
1626 void LiveIntervals::removePhysRegDefAt(unsigned Reg, SlotIndex Pos) {
1634 void LiveIntervals::removeVRegDefAt(LiveInterval &LI, SlotIndex Pos) {
lib/CodeGen/LiveRangeCalc.cpp 67 SlotIndex DefIdx =
158 SmallVector<SlotIndex, 4> Undefs;
190 SlotIndex UseIdx;
223 SlotIndex Start, End;
241 void LiveRangeCalc::extend(LiveRange &LR, SlotIndex Use, unsigned PhysReg,
242 ArrayRef<SlotIndex> Undefs) {
276 bool LiveRangeCalc::isDefOnEntry(LiveRange &LR, ArrayRef<SlotIndex> Undefs,
307 SlotIndex Begin, End;
347 SlotIndex Use, unsigned PhysReg,
348 ArrayRef<SlotIndex> Undefs) {
397 SlotIndex Start, End;
438 SlotIndex Start, End;
551 SlotIndex Start, End;
588 ArrayRef<SlotIndex> Defs,
592 for (SlotIndex I : Defs)
lib/CodeGen/LiveRangeEdit.cpp 107 SlotIndex OrigIdx,
108 SlotIndex UseIdx) const {
131 if (SlotIndex::isSameInstr(OrigIdx, UseIdx))
141 SlotIndex UseIdx, bool cheapAsAMove) {
149 SlotIndex DefIdx;
164 SlotIndex LiveRangeEdit::rematerializeAt(MachineBasicBlock &MBB,
246 SlotIndex Idx = LIS.getInstructionIndex(MI).getRegSlot();
263 SlotIndex Idx = LIS.getInstructionIndex(*MI).getRegSlot();
303 isOrigDef = SlotIndex::isSameInstr(OrigVNI->def, Idx);
lib/CodeGen/LiveRegMatrix.cpp 208 bool LiveRegMatrix::checkInterference(SlotIndex Start, SlotIndex End,
208 bool LiveRegMatrix::checkInterference(SlotIndex Start, SlotIndex End,
lib/CodeGen/MachineBasicBlock.cpp 1020 SlotIndex StartIndex = Indexes->getMBBEndIdx(this);
1021 SlotIndex PrevIndex = StartIndex.getPrevSlot();
1022 SlotIndex EndIndex = Indexes->getMBBEndIdx(NMBB);
lib/CodeGen/MachineScheduler.cpp 1405 SlotIndex SlotIdx = LIS->getInstructionIndex(*MI).getRegSlot();
1439 SlotIndex SlotIdx = LIS->getInstructionIndex(*MI).getRegSlot();
1640 SlotIndex RegionBeginIdx;
1644 SlotIndex RegionEndIdx;
1741 if (SlotIndex::isSameInstr(std::prev(GlobalSegment)->end,
1747 if (SlotIndex::isSameInstr(std::prev(GlobalSegment)->start,
lib/CodeGen/MachineVerifier.cpp 120 SlotIndex lastIndex;
254 void report_context(SlotIndex Pos) const;
265 SlotIndex UseIdx, const LiveRange &LR, unsigned VRegOrUnit,
268 SlotIndex DefIdx, const LiveRange &LR, unsigned VRegOrUnit,
342 SlotIndex Last;
518 void MachineVerifier::report_context(SlotIndex Pos) const {
829 SlotIndex idx = Indexes->getInstructionIndex(*MI);
1832 SlotIndex Idx = LiveInts->getInstructionIndex(*MI);
1874 unsigned MONum, SlotIndex UseIdx, const LiveRange &LR, unsigned VRegOrUnit,
1896 unsigned MONum, SlotIndex DefIdx, const LiveRange &LR, unsigned VRegOrUnit,
1957 SlotIndex UseIdx = LiveInts->getInstructionIndex(*MI);
2069 SlotIndex DefIdx = LiveInts->getInstructionIndex(*MI);
2124 SlotIndex stop = Indexes->getMBBEndIdx(MBB);
2484 SlotIndex MBBStartIdx = LiveInts->getMBBStartIdx(MBB);
2529 if (!SlotIndex::isSameInstr(S.start, S.end)) {
2613 SmallVector<SlotIndex, 4> Undefs;
2636 SlotIndex PEnd = LiveInts->getMBBEndIdx(*PI);
lib/CodeGen/PHIElimination.cpp 328 SlotIndex DestCopyIndex = LIS->InsertMachineInstrInMaps(*PHICopy);
330 SlotIndex MBBStartIndex = LIS->getMBBStartIdx(&MBB);
491 SlotIndex startIdx = LIS->getMBBStartIdx(*SI);
531 SlotIndex LastUseIndex = LIS->getInstructionIndex(*KillInst);
lib/CodeGen/RegAllocGreedy.cpp 470 SlotIndex Start, SlotIndex End,
470 SlotIndex Start, SlotIndex End,
473 LiveInterval &VirtReg, SlotIndex Start,
474 SlotIndex End, float *BestEvictWeight);
713 (Size / SlotIndex::InstrDist) > (2 * RC.getNumRegs());
970 unsigned PhysReg, SlotIndex Start,
971 SlotIndex End,
1024 SlotIndex Start, SlotIndex End,
1024 SlotIndex Start, SlotIndex End,
1227 SlotIndex::isEarlierInstr(BI.FirstInstr,
1286 SlotIndex::isEarlierInstr(LIS->getInstructionIndex(MBB->instr_front()),
1698 SlotIndex IntfIn, IntfOut;
1747 SlotIndex IntfIn, IntfOut;
2098 ArrayRef<SlotIndex> Uses = SA->getUseSlots();
2122 SlotIndex SegStart = SE->enterIntvBefore(Uses[i]);
2123 SlotIndex SegStop = SE->leaveIntvAfter(Uses[i]);
2155 ArrayRef<SlotIndex> Uses = SA->getUseSlots();
2159 SlotIndex StartIdx =
2161 SlotIndex StopIdx =
2245 ArrayRef<SlotIndex> Uses = SA->getUseSlots();
2262 ArrayRef<SlotIndex> RMS = LIS->getRegMaskSlotsInBlock(BI.MBB->getNumber());
2271 if (SlotIndex::isEarlierInstr(Uses[i+1], RMS[ri]))
2275 if (SlotIndex::isSameInstr(Uses[i+1], RMS[ri]) && i+1 == NumGaps)
2282 while (ri != re && SlotIndex::isEarlierInstr(RMS[ri], Uses[i+1]))
2370 (LiveBefore + LiveAfter) * SlotIndex::InstrDist,
2425 SlotIndex SegStart = SE->enterIntvBefore(Uses[BestBefore]);
2426 SlotIndex SegStop = SE->leaveIntvAfter(Uses[BestAfter]);
lib/CodeGen/RegAllocPBQP.cpp 260 static SlotIndex getStartPoint(const IntervalInfo &I) {
264 static SlotIndex getEndPoint(const IntervalInfo &I) {
281 SlotIndex E1 = getEndPoint(I1);
282 SlotIndex E2 = getEndPoint(I2);
lib/CodeGen/RegisterCoalescer.cpp 281 void addUndefFlag(const LiveInterval &Int, SlotIndex UseIdx,
564 SlotIndex CopyIdx = LIS->getInstructionIndex(*CopyMI).getRegSlot();
592 SlotIndex CopyUseIdx = CopyIdx.getRegSlot(true);
625 SlotIndex FillerStart = ValS->end, FillerEnd = BS->start;
645 if (SS != S.end() && SlotIndex::isSameInstr(SS->start, SS->end)) {
769 SlotIndex CopyIdx = LIS->getInstructionIndex(*CopyMI).getRegSlot();
819 SlotIndex UseIdx = LIS->getInstructionIndex(*UseMI);
873 SlotIndex UseIdx = LIS->getInstructionIndex(*UseMI).getRegSlot(true);
894 SlotIndex DefIdx = UseIdx.getRegSlot();
925 SlotIndex AIdx = CopyIdx.getRegSlot(true);
1044 SlotIndex CopyIdx = LIS->getInstructionIndex(CopyMI).getRegSlot(true);
1114 SlotIndex InsPosIdx = LIS->getInstructionIndex(*InsPos).getRegSlot(true);
1126 SlotIndex NewCopyIdx =
1149 SmallVector<SlotIndex, 8> EndPoints;
1171 if (SlotIndex::isSameInstr(EndPoints[I], CopyIdx)) {
1216 SlotIndex CopyIdx = LIS->getInstructionIndex(*CopyMI);
1384 SlotIndex CurrIdx = LIS->getInstructionIndex(NewMI);
1385 SlotIndex DefIndex =
1410 SlotIndex CurrIdx = LIS->getInstructionIndex(NewMI);
1452 SlotIndex NewMIIdx = LIS->getInstructionIndex(NewMI);
1466 SlotIndex NewMIIdx = LIS->getInstructionIndex(NewMI);
1530 SlotIndex Idx = LIS->getInstructionIndex(*CopyMI);
1547 SlotIndex RegIndex = Idx.getRegSlot();
1591 SlotIndex UseIdx = LIS->getInstructionIndex(MI);
1625 void RegisterCoalescer::addUndefFlag(const LiveInterval &Int, SlotIndex UseIdx,
1665 SlotIndex UseIdx = LIS->getInstructionIndex(MI).getRegSlot(true);
1711 SlotIndex MIIdx = UseMI->isDebugValue()
1714 SlotIndex UseIdx = MIIdx.getRegSlot(true);
1804 const SlotIndex CopyIdx = LIS->getInstructionIndex(*CopyMI);
2054 SlotIndex CopyRegIdx = LIS->getInstructionIndex(*CopyMI).getRegSlot();
2055 SlotIndex DestRegIdx = LIS->getInstructionIndex(DestMI).getRegSlot();
2062 for (SlotIndex SI = Indexes->getNextNonNullIndex(DestRegIdx);
2321 SmallVectorImpl<std::pair<SlotIndex, LaneBitmask>> &TaintExtent);
2356 void pruneValues(JoinVals &Other, SmallVectorImpl<SlotIndex> &EndPoints,
2409 SlotIndex Def = VNI->def;
2785 SmallVectorImpl<std::pair<SlotIndex, LaneBitmask>> &TaintExtent) {
2788 SlotIndex MBBEnd = Indexes->getMBBEndIdx(MBB);
2796 SlotIndex End = OtherI->end;
2859 SmallVector<std::pair<SlotIndex, LaneBitmask>, 8> TaintExtent;
2920 SmallVectorImpl<SlotIndex> &EndPoints,
2923 SlotIndex Def = LR.getValNumInfo(i)->def;
3030 SlotIndex Def = LR.getValNumInfo(i)->def;
3031 SlotIndex OtherDef;
3049 SmallVector<SlotIndex,8> EndPoints;
3078 static bool isDefInSubRange(LiveInterval &LI, SlotIndex Def) {
3118 SlotIndex Def = LR.getValNumInfo(i)->def;
3135 SlotIndex Def = VNI->def;
3137 SlotIndex NewEnd;
3157 SlotIndex ED, LE;
3239 SmallVector<SlotIndex, 8> EndPoints;
3376 SmallVector<SlotIndex, 8> EndPoints;
lib/CodeGen/RegisterPressure.cpp 194 void IntervalPressure::openTop(SlotIndex NextTop) {
210 void IntervalPressure::openBottom(SlotIndex PrevBottom) {
310 SlotIndex RegPressureTracker::getCurrSlot() const {
423 SlotIndex Pos, LaneBitmask SafeDefault,
424 bool(*Property)(const LiveRange &LR, SlotIndex Pos)) {
452 SlotIndex Pos) {
581 SlotIndex SlotIdx = LIS.getInstructionIndex(MI);
601 SlotIndex Pos,
797 SlotIndex SlotIdx;
863 SlotIndex SlotIdx;
885 SlotIndex SlotIdx = LIS->getInstructionIndex(*CurrPos).getRegSlot();
901 SlotIndex SlotIdx;
951 SlotIndex SlotIdx = getCurrSlot();
1044 SlotIndex SlotIdx;
1223 SlotIndex PriorUseIdx, SlotIndex NextUseIdx,
1223 SlotIndex PriorUseIdx, SlotIndex NextUseIdx,
1231 SlotIndex InstSlot = LIS->getInstructionIndex(*MI).getRegSlot();
1244 SlotIndex Pos) const {
1254 SlotIndex Pos) const {
1265 SlotIndex Pos) const {
1285 SlotIndex SlotIdx;
1306 SlotIndex CurrIdx = getCurrSlot();
lib/CodeGen/RenameIndependentSubregs.cpp 188 SlotIndex Pos = LIS->getInstructionIndex(*MO.getParent());
222 SlotIndex Pos = LIS->getInstructionIndex(*MI);
290 static bool subRangeLiveAt(const LiveInterval &LI, SlotIndex Pos) {
322 SlotIndex Def = VNI.def;
325 SlotIndex PredEnd = Indexes.getMBBEndIdx(PredMBB);
334 SlotIndex DefIdx = LIS->InsertMachineInstrInMaps(*ImpDef);
335 SlotIndex RegDefIdx = DefIdx.getRegSlot();
354 SlotIndex Pos = LIS->getInstructionIndex(*MO.getParent());
359 SlotIndex Pos = LIS->getInstructionIndex(*MO.getParent()).getDeadSlot();
lib/CodeGen/ScheduleDAGInstrs.cpp 815 SlotIndex SlotIdx = LIS->getInstructionIndex(MI);
lib/CodeGen/SlotIndexes.cpp 72 SlotIndex blockStartIndex(&indexList.back(), SlotIndex::Slot_Block);
72 SlotIndex blockStartIndex(&indexList.back(), SlotIndex::Slot_Block);
79 indexList.push_back(createEntry(&MI, index += SlotIndex::InstrDist));
83 &MI, SlotIndex(&indexList.back(), SlotIndex::Slot_Block)));
87 indexList.push_back(createEntry(nullptr, index += SlotIndex::InstrDist));
91 SlotIndex::Slot_Block);
111 SlotIndex MIIndex = mi2iItr->second;
124 SlotIndex MIIndex = mi2iItr->second;
150 const unsigned Space = SlotIndex::InstrDist/2;
180 SlotIndex startIdx;
186 SlotIndex endIdx;
lib/CodeGen/SplitKit.cpp 75 SlotIndex
79 std::pair<SlotIndex, SlotIndex> &LIP = LastInsertPoint[Num];
79 std::pair<SlotIndex, SlotIndex> &LIP = LastInsertPoint[Num];
80 SlotIndex MBBEnd = LIS.getMBBEndIdx(&MBB);
130 if (!SlotIndex::isEarlierInstr(VNI->def, LIP.second) && VNI->def < MBBEnd)
141 SlotIndex LIP = getLastInsertPoint(CurLI, MBB);
185 SlotIndex::isSameInstr),
220 SmallVectorImpl<SlotIndex>::const_iterator UseI, UseE;
230 SlotIndex Start, Stop;
265 SlotIndex LastStop = LVI->end;
327 SlotIndex Stop = LIS.getMBBEndIdx(&*MFI);
340 bool SplitAnalysis::isOriginalEndpoint(SlotIndex Idx) const {
421 SlotIndex Def = VNI->def;
458 SlotIndex Idx,
512 SlotIndex SplitEditor::buildSingleSubRegCopy(unsigned FromReg, unsigned ToReg,
538 SlotIndex SplitEditor::buildCopy(unsigned FromReg, unsigned ToReg,
589 SlotIndex Def = buildSingleSubRegCopy(FromReg, ToReg, MBB, InsertBefore,
629 SlotIndex UseIdx,
632 SlotIndex Def;
692 SlotIndex SplitEditor::enterIntvBefore(SlotIndex Idx) {
692 SlotIndex SplitEditor::enterIntvBefore(SlotIndex Idx) {
709 SlotIndex SplitEditor::enterIntvAfter(SlotIndex Idx) {
709 SlotIndex SplitEditor::enterIntvAfter(SlotIndex Idx) {
727 SlotIndex SplitEditor::enterIntvAtEnd(MachineBasicBlock &MBB) {
729 SlotIndex End = LIS.getMBBEndIdx(&MBB);
730 SlotIndex Last = End.getPrevSlot();
751 void SplitEditor::useIntv(SlotIndex Start, SlotIndex End) {
751 void SplitEditor::useIntv(SlotIndex Start, SlotIndex End) {
758 SlotIndex SplitEditor::leaveIntvAfter(SlotIndex Idx) {
758 SlotIndex SplitEditor::leaveIntvAfter(SlotIndex Idx) {
763 SlotIndex Boundary = Idx.getBoundaryIndex();
777 if (SpillMode && !SlotIndex::isSameInstr(ParentVNI->def, Idx) &&
789 SlotIndex SplitEditor::leaveIntvBefore(SlotIndex Idx) {
789 SlotIndex SplitEditor::leaveIntvBefore(SlotIndex Idx) {
808 SlotIndex SplitEditor::leaveIntvAtTop(MachineBasicBlock &MBB) {
810 SlotIndex Start = LIS.getMBBStartIdx(&MBB);
827 void SplitEditor::overlapIntv(SlotIndex Start, SlotIndex End) {
827 void SplitEditor::overlapIntv(SlotIndex Start, SlotIndex End) {
854 SlotIndex Def = Copies[i]->def;
883 SlotIndex Kill = LIS.getInstructionIndex(*MBBI).getRegSlot();
1009 using DomPair = std::pair<MachineBasicBlock *, SlotIndex>;
1091 SlotIndex Last = LIS.getMBBEndIdx(Dom.first).getPrevSlot();
1129 SlotIndex Start = S.start;
1133 SlotIndex End = S.end;
1175 SlotIndex BlockStart, BlockEnd;
1230 static bool removeDeadSegment(SlotIndex Def, LiveRange &LR) {
1243 ArrayRef<SlotIndex> Undefs) {
1245 SlotIndex End = LIS.getMBBEndIdx(P);
1246 SlotIndex LastUse = End.getPrevSlot();
1279 SmallVector<SlotIndex, 4> Undefs;
1305 ExtPoint(const MachineOperand &O, unsigned R, SlotIndex N)
1310 SlotIndex Next;
1330 SlotIndex Idx = LIS.getInstructionIndex(*MI);
1357 SlotIndex Next = Idx.getNextSlot();
1391 SmallVector<SlotIndex, 4> Undefs;
1461 SlotIndex PredEnd = Indexes.getMBBEndIdx(Pred);
1576 SlotIndex LastSplitPoint = SA.getLastSplitPoint(BI.MBB->getNumber());
1577 SlotIndex SegStart = enterIntvBefore(std::min(BI.FirstInstr,
1583 SlotIndex SegStop = leaveIntvBefore(LastSplitPoint);
1601 unsigned IntvIn, SlotIndex LeaveBefore,
1602 unsigned IntvOut, SlotIndex EnterAfter){
1603 SlotIndex Start, Stop;
1626 SlotIndex Idx = leaveIntvAtTop(*MBB);
1640 SlotIndex Idx = enterIntvAtEnd(*MBB);
1658 SlotIndex LSP = SA.getLastSplitPoint(MBBNum);
1670 SlotIndex Idx;
1693 SlotIndex Idx = enterIntvAfter(EnterAfter);
1704 unsigned IntvIn, SlotIndex LeaveBefore) {
1705 SlotIndex Start, Stop;
1730 SlotIndex LSP = SA.getLastSplitPoint(BI.MBB->getNumber());
1746 SlotIndex Idx = leaveIntvAfter(BI.LastInstr);
1752 SlotIndex Idx = leaveIntvBefore(LSP);
1773 SlotIndex To = leaveIntvAfter(BI.LastInstr);
1774 SlotIndex From = enterIntvBefore(LeaveBefore);
1787 SlotIndex To = leaveIntvBefore(LSP);
1789 SlotIndex From = enterIntvBefore(std::min(To, LeaveBefore));
1797 unsigned IntvOut, SlotIndex EnterAfter) {
1798 SlotIndex Start, Stop;
1807 SlotIndex LSP = SA.getLastSplitPoint(BI.MBB->getNumber());
1833 SlotIndex Idx = enterIntvBefore(std::min(LSP, BI.FirstInstr));
1849 SlotIndex Idx = enterIntvAfter(EnterAfter);
1854 SlotIndex From = enterIntvBefore(std::min(Idx, BI.FirstInstr));
lib/CodeGen/SplitKit.h 57 SmallVector<std::pair<SlotIndex, SlotIndex>, 8> LastInsertPoint;
57 SmallVector<std::pair<SlotIndex, SlotIndex>, 8> LastInsertPoint;
59 SlotIndex computeLastInsertPoint(const LiveInterval &CurLI,
66 SlotIndex getLastInsertPoint(const LiveInterval &CurLI,
81 SlotIndex getFirstInsertPoint(MachineBasicBlock &MBB) {
82 SlotIndex Res = LIS.getMBBStartIdx(&MBB);
122 SlotIndex FirstInstr; ///< First instr accessing current reg.
123 SlotIndex LastInstr; ///< Last instr accessing current reg.
124 SlotIndex FirstDef; ///< First non-phi valno->def, or SlotIndex().
131 return SlotIndex::isSameInstr(FirstInstr, LastInstr);
143 SmallVector<SlotIndex, 8> UseSlots;
192 bool isOriginalEndpoint(SlotIndex Idx) const;
196 ArrayRef<SlotIndex> getUseSlots() const { return UseSlots; }
233 SlotIndex getLastSplitPoint(unsigned Num) {
241 SlotIndex getFirstSplitPoint(unsigned Num) {
307 using RegAssignMap = IntervalMap<SlotIndex, unsigned>;
369 VNInfo *defValue(unsigned RegIdx, const VNInfo *ParentVNI, SlotIndex Idx,
386 SlotIndex UseIdx,
419 ArrayRef<SlotIndex> Undefs);
434 SlotIndex buildCopy(unsigned FromReg, unsigned ToReg, LaneBitmask LaneMask,
438 SlotIndex buildSingleSubRegCopy(unsigned FromReg, unsigned ToReg,
466 SlotIndex enterIntvBefore(SlotIndex Idx);
466 SlotIndex enterIntvBefore(SlotIndex Idx);
470 SlotIndex enterIntvAfter(SlotIndex Idx);
470 SlotIndex enterIntvAfter(SlotIndex Idx);
475 SlotIndex enterIntvAtEnd(MachineBasicBlock &MBB);
481 void useIntv(SlotIndex Start, SlotIndex End);
481 void useIntv(SlotIndex Start, SlotIndex End);
485 SlotIndex leaveIntvAfter(SlotIndex Idx);
485 SlotIndex leaveIntvAfter(SlotIndex Idx);
489 SlotIndex leaveIntvBefore(SlotIndex Idx);
489 SlotIndex leaveIntvBefore(SlotIndex Idx);
494 SlotIndex leaveIntvAtTop(MachineBasicBlock &MBB);
506 void overlapIntv(SlotIndex Start, SlotIndex End);
506 void overlapIntv(SlotIndex Start, SlotIndex End);
535 unsigned IntvIn, SlotIndex LeaveBefore,
536 unsigned IntvOut, SlotIndex EnterAfter);
547 unsigned IntvIn, SlotIndex LeaveBefore);
559 unsigned IntvOut, SlotIndex EnterAfter);
lib/CodeGen/StackColoring.cpp 416 SmallVector<SmallVector<SlotIndex, 4>, 16> LiveStarts;
814 SmallVector<SlotIndex, 16> Starts;
838 SlotIndex ThisIndex = Indexes->getInstructionIndex(MI);
867 SlotIndex EndIdx = Indexes->getMBBEndIdx(&MBB);
1010 SlotIndex Index = Indexes->getInstructionIndex(I);
1109 SlotIndex Index = Indexes->getInstructionIndex(I);
lib/CodeGen/TwoAddressInstructionPass.cpp 256 SlotIndex MBBEndIdx = LIS->getMBBEndIdx(MBB).getPrevSlot();
443 SlotIndex useIdx = LIS->getInstructionIndex(*MI);
446 return !I->end.isBlock() && SlotIndex::isSameInstr(I->end, useIdx);
876 SlotIndex MBBEndIdx = LIS->getMBBEndIdx(MBB).getPrevSlot();
1066 SlotIndex MBBEndIdx = LIS->getMBBEndIdx(MBB).getPrevSlot();
1514 SlotIndex LastCopyIdx;
1583 SlotIndex endIdx =
1643 SlotIndex MIIdx = LIS->getInstructionIndex(*MI);
1647 SlotIndex UseIdx = MIIdx.getRegSlot(IsEarlyClobber);
lib/CodeGen/VirtRegMap.cpp 275 SlotIndex First;
276 SlotIndex Last;
289 SlotIndex MBBBegin = MBBI->first;
358 SlotIndex BaseIndex = LIS->getInstructionIndex(MI);
472 SlotIndex MIIndex = LIS->getInstructionIndex(MI);
473 SlotIndex BeforeMIUses = MIIndex.getBaseIndex();
474 SlotIndex AfterMIDefs = MIIndex.getBoundaryIndex();
lib/Target/AArch64/AArch64PBQPRegAlloc.cpp 322 SlotIndex SI = LIs.getInstructionIndex(MI);
lib/Target/AMDGPU/GCNIterativeScheduler.cpp 399 auto SlotIdx = LIS->getInstructionIndex(*MI).getRegSlot();
lib/Target/AMDGPU/GCNNSAReassign.cpp 276 SlotIndex MinInd, MaxInd;
lib/Target/AMDGPU/GCNRegPressure.cpp 36 void llvm::printLivesAt(SlotIndex SI,
225 auto SI = LIS.getInstructionIndex(*MO.getParent()).getBaseIndex();
257 SlotIndex SI,
275 GCNRPTracker::LiveRegSet llvm::getLiveRegs(SlotIndex SI,
374 SlotIndex SI = LIS.getInstructionIndex(*NextMI).getBaseIndex();
474 const auto &SI = LIS.getInstructionIndex(*LastTrackedMI).getBaseIndex();
lib/Target/AMDGPU/GCNRegPressure.h 188 SlotIndex SI,
192 GCNRPTracker::LiveRegSet getLiveRegs(SlotIndex SI,
204 std::vector<SlotIndex> Indexes;
208 auto SI = SII.getInstructionIndex(*I);
215 SmallVector<SlotIndex, 32> LiveIdxs, SRLiveIdxs;
225 for (auto SI : LiveIdxs)
233 for (auto SI : SRLiveIdxs)
264 void printLivesAt(SlotIndex SI,
lib/Target/AMDGPU/GCNSchedStrategy.cpp 417 SlotIndex SlotIdx = LIS->getInstructionIndex(*MI).getRegSlot();
lib/Target/AMDGPU/SIMachineScheduler.cpp 309 SlotIndex First, SlotIndex Last,
309 SlotIndex First, SlotIndex Last,
318 SlotIndex InstSlot = LIS->getInstructionIndex(*MI).getRegSlot();
lib/Target/AMDGPU/SIRegisterInfo.cpp 1869 SlotIndex UseIdx = LIS->getInstructionIndex(Use);
1870 SlotIndex DefIdx;
lib/Target/AMDGPU/SIWholeQuadMode.cpp 586 SlotIndex FirstIdx = First != MBBE ? LIS->getInstructionIndex(*First)
588 SlotIndex LastIdx =
590 SlotIndex Idx = PreferLast ? LastIdx : FirstIdx;
599 SlotIndex Next = S->start.getBaseIndex();
604 SlotIndex Next = S->end.getNextIndex().getBaseIndex();
lib/Target/Hexagon/HexagonExpandCondsets.cpp 414 SmallVector<SlotIndex,4> PredDefs;
424 SmallVector<SlotIndex,8> Undefs;
428 for (auto &SI : PredDefs) {
437 SmallVector<SlotIndex,4> ExtTo;
438 for (auto &SI : PredDefs) {
lib/Target/Hexagon/HexagonRegisterInfo.cpp 256 for (SlotIndex I = S.start.getBaseIndex(), E = S.end.getBaseIndex();
lib/Target/PowerPC/PPCVSXFMAMutate.cpp 108 SlotIndex FMAIdx = LIS->getInstructionIndex(MI);
lib/Target/SystemZ/SystemZInstrInfo.cpp 1016 SlotIndex MISlot =
lib/Target/WebAssembly/WebAssemblyMemIntrinsicResults.cpp 94 SlotIndex FromIdx = LIS.getInstructionIndex(MI).getRegSlot();
97 SmallVector<SlotIndex, 4> Indices;
109 SlotIndex WhereIdx = LIS.getInstructionIndex(*Where);
lib/Target/WebAssembly/WebAssemblyRegStackify.cpp 561 SlotIndex Idx = LIS.getInstructionIndex(Def).getRegSlot();
619 SlotIndex TeeIdx = LIS.InsertMachineInstrInMaps(*Tee).getRegSlot();
620 SlotIndex DefIdx = LIS.getInstructionIndex(*Def).getRegSlot();
unittests/CodeGen/TypeTraitsTest.cpp 22 static_assert(is_trivially_copyable<SlotIndex>::value, "trivially copyable");
usr/include/c++/7.4.0/bits/algorithmfwd.h 353 lower_bound(_FIter, _FIter, const _Tp&);
369 const _Tp&
370 max(const _Tp&, const _Tp&);
370 max(const _Tp&, const _Tp&);
382 const _Tp&
383 min(const _Tp&, const _Tp&);
383 min(const _Tp&, const _Tp&);
usr/include/c++/7.4.0/bits/alloc_traits.h 387 using allocator_type = allocator<_Tp>;
389 using value_type = _Tp;
392 using pointer = _Tp*;
395 using const_pointer = const _Tp*;
474 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
474 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
475 { __a.construct(__p, std::forward<_Args>(__args)...); }
486 destroy(allocator_type& __a, _Up* __p)
usr/include/c++/7.4.0/bits/allocator.h 108 class allocator: public __allocator_base<_Tp>
113 typedef _Tp* pointer;
114 typedef const _Tp* const_pointer;
115 typedef _Tp& reference;
116 typedef const _Tp& const_reference;
117 typedef _Tp value_type;
137 allocator(const allocator<_Tp1>&) throw() { }
usr/include/c++/7.4.0/bits/move.h 46 inline _GLIBCXX_CONSTEXPR _Tp*
47 __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
72 constexpr _Tp&&
73 forward(typename std::remove_reference<_Tp>::type& __t) noexcept
83 constexpr _Tp&&
84 forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
98 move(_Tp&& __t) noexcept
104 : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
105 is_copy_constructible<_Tp>>::type { };
198 _Tp __tmp = _GLIBCXX_MOVE(__a);
usr/include/c++/7.4.0/bits/predefined_ops.h 64 operator()(_Iterator __it, _Value& __val) const
89 operator()(_Value& __val, _Iterator __it) const
usr/include/c++/7.4.0/bits/stl_algo.h 2024 const _Tp& __val, _Compare __comp)
2040 const _Tp& __val, _Compare __comp)
2078 const _Tp& __val)
2108 const _Tp& __val, _Compare __comp)
usr/include/c++/7.4.0/bits/stl_algobase.h 947 const _Tp& __val, _Compare __comp)
usr/include/c++/7.4.0/bits/stl_construct.h 74 _Construct(_T1* __p, _Args&&... __args)
74 _Construct(_T1* __p, _Args&&... __args)
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
204 allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_function.h 121 typedef _Arg1 first_argument_type;
124 typedef _Arg2 second_argument_type;
381 struct less : public binary_function<_Tp, _Tp, bool>
381 struct less : public binary_function<_Tp, _Tp, bool>
385 operator()(const _Tp& __x, const _Tp& __y) const
385 operator()(const _Tp& __x, const _Tp& __y) const
usr/include/c++/7.4.0/bits/stl_heap.h 129 _Distance __holeIndex, _Distance __topIndex, _Tp __value,
215 _Distance __len, _Tp __value, _Compare __comp)
usr/include/c++/7.4.0/bits/stl_iterator.h 1224 __make_move_if_noexcept_iterator(_Tp* __i)
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h 181 typedef _Tp value_type;
183 typedef _Tp* pointer;
184 typedef _Tp& reference;
192 typedef _Tp value_type;
194 typedef const _Tp* pointer;
195 typedef const _Tp& reference;
usr/include/c++/7.4.0/bits/stl_pair.h 100 return __and_<is_constructible<_T1, const _U1&>,
100 return __and_<is_constructible<_T1, const _U1&>,
101 is_constructible<_T2, const _U2&>>::value;
101 is_constructible<_T2, const _U2&>>::value;
107 return __and_<is_convertible<const _U1&, _T1>,
107 return __and_<is_convertible<const _U1&, _T1>,
108 is_convertible<const _U2&, _T2>>::value;
108 is_convertible<const _U2&, _T2>>::value;
114 return __and_<is_constructible<_T1, _U1&&>,
114 return __and_<is_constructible<_T1, _U1&&>,
115 is_constructible<_T2, _U2&&>>::value;
115 is_constructible<_T2, _U2&&>>::value;
121 return __and_<is_convertible<_U1&&, _T1>,
121 return __and_<is_convertible<_U1&&, _T1>,
122 is_convertible<_U2&&, _T2>>::value;
122 is_convertible<_U2&&, _T2>>::value;
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
129 is_convertible<_U2&&, _T2>>;
129 is_convertible<_U2&&, _T2>>;
133 return __and_<is_constructible<_T1, const _U1&>,
133 return __and_<is_constructible<_T1, const _U1&>,
134 is_constructible<_T2, _U2&&>,
134 is_constructible<_T2, _U2&&>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
143 is_convertible<const _U2&, _T2>>;
143 is_convertible<const _U2&, _T2>>;
147 return __and_<is_constructible<_T1, _U1&&>,
147 return __and_<is_constructible<_T1, _U1&&>,
148 is_constructible<_T2, const _U2&&>,
148 is_constructible<_T2, const _U2&&>,
209 : private __pair_base<_T1, _T2>
209 : private __pair_base<_T1, _T2>
211 typedef _T1 first_type; /// @c first_type is the first bound type
212 typedef _T2 second_type; /// @c second_type is the second bound type
214 _T1 first; /// @c first is a copy of the first object
215 _T2 second; /// @c second is a copy of the second object
252 using _PCCP = _PCC<true, _T1, _T2>;
252 using _PCCP = _PCC<true, _T1, _T2>;
260 constexpr pair(const _T1& __a, const _T2& __b)
260 constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
283 _T1, _T2>;
283 _T1, _T2>;
291 constexpr pair(const pair<_U1, _U2>& __p)
311 constexpr pair(_U1&& __x, const _T2& __y)
311 constexpr pair(_U1&& __x, const _T2& __y)
318 explicit constexpr pair(_U1&& __x, const _T2& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
332 explicit pair(const _T1& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
360 constexpr pair(pair<_U1, _U2>&& __p)
362 second(std::forward<_U2>(__p.second)) { }
379 __and_<is_copy_assignable<_T1>,
380 is_copy_assignable<_T2>>::value,
390 __and_<is_move_assignable<_T1>,
391 is_move_assignable<_T2>>::value,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
403 is_assignable<_T2&, const _U2&>>::value,
403 is_assignable<_T2&, const _U2&>>::value,
405 operator=(const pair<_U1, _U2>& __p)
405 operator=(const pair<_U1, _U2>& __p)
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
414 is_assignable<_T2&, _U2&&>>::value,
414 is_assignable<_T2&, _U2&&>>::value,
416 operator=(pair<_U1, _U2>&& __p)
416 operator=(pair<_U1, _U2>&& __p)
495 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
495 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
523 typename __decay_and_strip<_T2>::__type>
524 make_pair(_T1&& __x, _T2&& __y)
524 make_pair(_T1&& __x, _T2&& __y)
527 typedef typename __decay_and_strip<_T2>::__type __ds_type2;
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
usr/include/c++/7.4.0/bits/stl_tempbuf.h 84 pair<_Tp*, ptrdiff_t>
88 __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
94 _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
94 _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
112 return_temporary_buffer(_Tp* __p)
128 typedef _Tp value_type;
usr/include/c++/7.4.0/bits/stl_uninitialized.h 288 _ForwardIterator __result, allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_vector.h 77 rebind<_Tp>::other _Tp_alloc_type;
216 class vector : protected _Vector_base<_Tp, _Alloc>
227 typedef _Vector_base<_Tp, _Alloc> _Base;
232 typedef _Tp value_type;
919 _Tp*
923 const _Tp*
962 emplace_back(_Args&&... __args);
1483 _M_realloc_insert(iterator __position, _Args&&... __args);
usr/include/c++/7.4.0/bits/unique_ptr.h 824 make_unique(_Args&&... __args)
usr/include/c++/7.4.0/bits/vector.tcc 101 std::forward<_Args>(__args)...);
105 _M_realloc_insert(end(), std::forward<_Args>(__args)...);
418 std::forward<_Args>(__args)...);
usr/include/c++/7.4.0/ext/alloc_traits.h 117 { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
usr/include/c++/7.4.0/ext/new_allocator.h 63 typedef _Tp* pointer;
64 typedef const _Tp* const_pointer;
65 typedef _Tp& reference;
66 typedef const _Tp& const_reference;
67 typedef _Tp value_type;
111 return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
130 { return size_t(-1) / sizeof(_Tp); }
135 construct(_Up* __p, _Args&&... __args)
135 construct(_Up* __p, _Args&&... __args)
136 { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
136 { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
140 destroy(_Up* __p) { __p->~_Up(); }
usr/include/c++/7.4.0/initializer_list 50 typedef _E value_type;
51 typedef const _E& reference;
52 typedef const _E& const_reference;
54 typedef const _E* iterator;
55 typedef const _E* const_iterator;
usr/include/c++/7.4.0/tuple 125 constexpr _Head_base(const _Head& __h)
132 constexpr _Head_base(_UHead&& __h)
159 static constexpr _Head&
162 static constexpr const _Head&
194 static constexpr _Head&
197 static constexpr const _Head&
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
242 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
248 const _Head& __head, const _Tail&... __tail)
248 const _Head& __head, const _Tail&... __tail)
350 static constexpr _Head&
353 static constexpr const _Head&
360 constexpr _Tuple_impl(const _Head& __head)
365 constexpr _Tuple_impl(_UHead&& __head)
390 const _Head& __head)
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
947 constexpr tuple(const _T1& __a1, const _T2& __a2)
947 constexpr tuple(const _T1& __a1, const _T2& __a2)
956 explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
956 explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
971 constexpr tuple(_U1&& __a1, _U2&& __a2)
971 constexpr tuple(_U1&& __a1, _U2&& __a2)
1066 tuple(allocator_arg_t __tag, const _Alloc& __a)
1078 const _T1& __a1, const _T2& __a2)
1078 const _T1& __a1, const _T2& __a2)
1090 const _T1& __a1, const _T2& __a2)
1090 const _T1& __a1, const _T2& __a2)
1241 operator=(const pair<_U1, _U2>& __in)
1241 operator=(const pair<_U1, _U2>& __in)
1250 operator=(pair<_U1, _U2>&& __in)
1250 operator=(pair<_U1, _U2>&& __in)
1302 constexpr _Head&
1307 constexpr const _Head&
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1588 constexpr tuple<_Elements&...>
1589 tie(_Elements&... __args) noexcept
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
326 : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
354 : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
567 : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_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
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
631 : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
762 typename add_rvalue_reference<_Tp>::type declval() noexcept;
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
798 typedef decltype(__test<_Tp>(0)) type;
811 remove_all_extents<_Tp>::type>::type
825 : public __is_destructible_safe<_Tp>::type
889 typedef decltype(__test<_Tp>(0)) type;
894 : public __and_<__not_<is_void<_Tp>>,
895 __is_default_constructible_impl<_Tp>>
915 : public __is_default_constructible_atom<_Tp>::type
921 : public __is_default_constructible_safe<_Tp>::type
984 typedef decltype(__test<_Tp, _Arg>(0)) type;
989 : public __and_<is_destructible<_Tp>,
990 __is_direct_constructible_impl<_Tp, _Arg>>
1072 __is_direct_constructible_ref_cast<_Tp, _Arg>,
1073 __is_direct_constructible_new_safe<_Tp, _Arg>
1079 : public __is_direct_constructible_new<_Tp, _Arg>::type
1119 : public __is_direct_constructible<_Tp, _Arg>
1130 : public __is_constructible_impl<_Tp, _Args...>::type
1142 : public is_constructible<_Tp, const _Tp&>
1142 : public is_constructible<_Tp, const _Tp&>
1148 : public __is_copy_constructible_impl<_Tp>
1160 : public is_constructible<_Tp, _Tp&&>
1160 : public is_constructible<_Tp, _Tp&&>
1166 : public __is_move_constructible_impl<_Tp>
1215 : public __and_<is_constructible<_Tp, _Args...>,
1216 __is_nt_constructible_impl<_Tp, _Args...>>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1252 : public __is_nothrow_move_constructible_impl<_Tp>
1286 : public is_assignable<_Tp&, const _Tp&>
1286 : public is_assignable<_Tp&, const _Tp&>
1292 : public __is_copy_assignable_impl<_Tp>
1304 : public is_assignable<_Tp&, _Tp&&>
1304 : public is_assignable<_Tp&, _Tp&&>
1310 : public __is_move_assignable_impl<_Tp>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1358 : public __is_nt_move_assignable_impl<_Tp>
1377 static void __helper(const _Tp&);
1380 static true_type __test(const _Tp&,
1381 decltype(__helper<const _Tp&>({}))* = 0);
1390 typedef decltype(__test(declval<_Tp>())) type;
1395 : public __is_implicitly_default_constructible_impl<_Tp>::type
1400 : public __and_<is_default_constructible<_Tp>,
1401 __is_implicitly_default_constructible_safe<_Tp>>
1526 static void __test_aux(_To1);
1538 typedef decltype(__test<_From, _To>(0)) type;
1545 : public __is_convertible_helper<_From, _To>::type
1554 { typedef _Tp type; };
1558 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1629 { typedef _Tp type; };
1633 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1664 : public __add_rvalue_reference_helper<_Tp>
1955 { typedef _Tp type; };
2104 { typedef typename remove_cv<_Up>::type __type; };
2118 typedef typename remove_reference<_Tp>::type __remove_type;
2131 typedef _Tp __type;
2144 typename decay<_Tp>::type>::__type __type;
2574 typename remove_reference<_Tp>::type>::type>::type
2579 typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
2580 is_move_constructible<_Tp>,
2581 is_move_assignable<_Tp>>::value>::type
2582 swap(_Tp&, _Tp&)
2582 swap(_Tp&, _Tp&)
2609 noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
2609 noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
2629 typedef decltype(__test<_Tp>(0)) type;
2639 : public __is_nothrow_swappable_impl<_Tp>::type