|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/DebugInfo/CodeView/TypeStreamMerger.h 20 class TypeIndex;
tools/lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.h 18 class TypeIndex;
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 {
290 class LLVM_NODISCARD MutableArrayRef : public ArrayRef<T> {
292 using iterator = T *;
302 /*implicit*/ MutableArrayRef(T &OneElt) : ArrayRef<T>(OneElt) {}
305 /*implicit*/ MutableArrayRef(T *data, size_t length)
309 MutableArrayRef(T *begin, T *end) : ArrayRef<T>(begin, end) {}
309 MutableArrayRef(T *begin, T *end) : ArrayRef<T>(begin, end) {}
312 /*implicit*/ MutableArrayRef(SmallVectorImpl<T> &Vec)
316 /*implicit*/ MutableArrayRef(std::vector<T> &Vec)
321 /*implicit*/ constexpr MutableArrayRef(std::array<T, N> &Arr)
326 /*implicit*/ constexpr MutableArrayRef(T (&Arr)[N]) : ArrayRef<T>(Arr) {}
328 T *data() const { return const_cast<T*>(ArrayRef<T>::data()); }
337 T &front() const {
343 T &back() const {
350 MutableArrayRef<T> slice(size_t N, size_t M) const {
356 MutableArrayRef<T> slice(size_t N) const {
361 MutableArrayRef<T> drop_front(size_t N = 1) const {
366 MutableArrayRef<T> drop_back(size_t N = 1) const {
374 MutableArrayRef<T> drop_while(PredicateT Pred) const {
381 MutableArrayRef<T> drop_until(PredicateT Pred) const {
386 MutableArrayRef<T> take_front(size_t N = 1) const {
393 MutableArrayRef<T> take_back(size_t N = 1) const {
402 MutableArrayRef<T> take_while(PredicateT Pred) const {
409 MutableArrayRef<T> take_until(PredicateT Pred) const {
416 T &operator[](size_t Index) const {
468 ArrayRef<T> makeArrayRef(const SmallVectorImpl<T> &Vec) {
468 ArrayRef<T> makeArrayRef(const SmallVectorImpl<T> &Vec) {
474 ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) {
474 ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) {
480 ArrayRef<T> makeArrayRef(const std::vector<T> &Vec) {
480 ArrayRef<T> makeArrayRef(const std::vector<T> &Vec) {
include/llvm/ADT/DenseMap.h 40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
43 KeyT &getFirst() { return std::pair<KeyT, ValueT>::first; }
44 const KeyT &getFirst() const { return std::pair<KeyT, ValueT>::first; }
45 ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
46 const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
65 using key_type = KeyT;
66 using mapped_type = ValueT;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
78 if (shouldReverseIterate<KeyT>())
123 is_trivially_copyable<ValueT>::value) {
145 size_type count(const_arg_type_t<KeyT> Val) const {
150 iterator find(const_arg_type_t<KeyT> Val) {
156 const_iterator find(const_arg_type_t<KeyT> Val) const {
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
195 std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
195 std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
202 std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
202 std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
210 std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
219 InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
229 std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
237 TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
249 std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
249 std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
272 bool erase(const KeyT &Val) {
291 value_type& FindAndConstruct(const KeyT &Key) {
299 ValueT &operator[](const KeyT &Key) {
299 ValueT &operator[](const KeyT &Key) {
303 value_type& FindAndConstruct(KeyT &&Key) {
311 ValueT &operator[](KeyT &&Key) {
311 ValueT &operator[](KeyT &&Key) {
334 const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
349 const KeyT EmptyKey = getEmptyKey();
351 ::new (&B->getFirst()) KeyT(EmptyKey);
369 const KeyT EmptyKey = getEmptyKey();
370 const KeyT TombstoneKey = getTombstoneKey();
380 ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
414 static unsigned getHashValue(const KeyT &Val) {
419 static unsigned getHashValue(const LookupKeyT &Val) {
423 static const KeyT getEmptyKey() {
429 static const KeyT getTombstoneKey() {
437 if (shouldReverseIterate<KeyT>()) {
515 BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
516 ValueArgs &&... Values) {
520 ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
520 ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
525 BucketT *InsertIntoBucketWithLookup(BucketT *TheBucket, KeyT &&Key,
526 ValueT &&Value, LookupKeyT &Lookup) {
535 BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
535 BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
566 const KeyT EmptyKey = getEmptyKey();
578 bool LookupBucketFor(const LookupKeyT &Val,
590 const KeyT EmptyKey = getEmptyKey();
591 const KeyT TombstoneKey = getTombstoneKey();
629 bool LookupBucketFor(const LookupKeyT &Val, BucketT *&FoundBucket) {
684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
685 KeyT, ValueT, KeyInfoT, BucketT> {
685 KeyT, ValueT, KeyInfoT, BucketT> {
690 using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
690 using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
1163 using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
1163 using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
1186 if (shouldReverseIterate<KeyT>()) {
1199 const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
1199 const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
1204 if (shouldReverseIterate<KeyT>())
1210 if (shouldReverseIterate<KeyT>())
1232 if (shouldReverseIterate<KeyT>()) {
1249 const KeyT Empty = KeyInfoT::getEmptyKey();
1250 const KeyT Tombstone = KeyInfoT::getTombstoneKey();
1259 const KeyT Empty = KeyInfoT::getEmptyKey();
1260 const KeyT Tombstone = KeyInfoT::getTombstoneKey();
include/llvm/ADT/DenseMapInfo.h 186 using Pair = std::pair<T, U>;
187 using FirstInfo = DenseMapInfo<T>;
include/llvm/ADT/Optional.h 144 T value;
160 explicit OptionalStorage(in_place_t, Args &&... args)
161 : value(std::forward<Args>(args)...), hasVal(true) {}
172 T &getValue() LLVM_LVALUE_FUNCTION noexcept {
176 T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
181 T &&getValue() && noexcept {
197 ::new ((void *)std::addressof(value)) T(y);
206 ::new ((void *)std::addressof(value)) T(std::move(y));
216 optional_detail::OptionalStorage<T> Storage;
219 using value_type = T;
224 Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
227 Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
230 Optional &operator=(T &&y) {
241 static inline Optional create(const T *y) {
245 Optional &operator=(const T &y) {
253 const T *getPointer() const { return &Storage.getValue(); }
254 T *getPointer() { return &Storage.getValue(); }
255 const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
256 T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
260 const T *operator->() const { return getPointer(); }
261 T *operator->() { return getPointer(); }
262 const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
263 T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
266 constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
271 T &&getValue() && { return std::move(Storage.getValue()); }
272 T &&operator*() && { return std::move(Storage.getValue()); }
275 T getValueOr(U &&value) && {
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/DebugInfo/CodeView/AppendingTypeTableBuilder.h 42 Optional<TypeIndex> getFirst() override;
43 Optional<TypeIndex> getNext(TypeIndex Prev) override;
43 Optional<TypeIndex> getNext(TypeIndex Prev) override;
44 CVType getType(TypeIndex Index) override;
45 StringRef getTypeName(TypeIndex Index) override;
46 bool contains(TypeIndex Index) override;
52 TypeIndex nextTypeIndex() const;
57 TypeIndex insertRecordBytes(ArrayRef<uint8_t> &Record);
58 TypeIndex insertRecord(ContinuationRecordBuilder &Builder);
60 template <typename T> TypeIndex writeLeafType(T &Record) {
include/llvm/DebugInfo/CodeView/CVRecord.h 68 SmallVector<std::pair<uint32_t, TypeIndex>, 8> Mappings;
include/llvm/DebugInfo/CodeView/CVTypeVisitor.h 30 Error visitTypeRecord(CVType &Record, TypeIndex Index,
include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h 38 virtual std::string getTypeName(TypeIndex TI) = 0;
66 Error mapInteger(TypeIndex &TypeInd, const Twine &Comment = "");
99 template <typename T> Error mapInteger(T &Value, const Twine &Comment = "") {
151 for (auto &X : Items) {
160 for (auto &X : Items) {
include/llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h 46 Optional<TypeIndex> RefersTo);
59 std::vector<CVType> end(TypeIndex Index);
include/llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h 37 TypeIndex Inlinee; // ID of the function that was inlined.
105 void addInlineSite(TypeIndex FuncId, StringRef FileName, uint32_t SourceLine);
include/llvm/DebugInfo/CodeView/Formatters.h 51 static void format(const codeview::TypeIndex &V, raw_ostream &Stream,
58 Stream << " (" << codeview::TypeIndex::simpleTypeName(V) << ")";
include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h 41 DenseMap<GloballyHashedType, TypeIndex> HashedRecords;
54 Optional<TypeIndex> getFirst() override;
55 Optional<TypeIndex> getNext(TypeIndex Prev) override;
55 Optional<TypeIndex> getNext(TypeIndex Prev) override;
56 CVType getType(TypeIndex Index) override;
57 StringRef getTypeName(TypeIndex Index) override;
58 bool contains(TypeIndex Index) override;
64 TypeIndex nextTypeIndex() const;
72 TypeIndex insertRecordAs(GloballyHashedType Hash, size_t RecordSize,
103 TypeIndex insertRecordBytes(ArrayRef<uint8_t> Data);
104 TypeIndex insertRecord(ContinuationRecordBuilder &Builder);
106 template <typename T> TypeIndex writeLeafType(T &Record) {
include/llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h 71 uint32_t getOffsetOfType(TypeIndex Index);
73 Optional<CVType> tryGetType(TypeIndex Index);
75 CVType getType(TypeIndex Index) override;
76 StringRef getTypeName(TypeIndex Index) override;
77 bool contains(TypeIndex Index) override;
80 Optional<TypeIndex> getFirst() override;
81 Optional<TypeIndex> getNext(TypeIndex Prev) override;
81 Optional<TypeIndex> getNext(TypeIndex Prev) override;
84 Error ensureTypeExists(TypeIndex Index);
85 void ensureCapacityFor(TypeIndex Index);
87 Error visitRangeForType(TypeIndex TI);
88 Error fullScanForType(TypeIndex TI);
89 void visitRange(TypeIndex Begin, uint32_t BeginOffset, TypeIndex End);
89 void visitRange(TypeIndex Begin, uint32_t BeginOffset, TypeIndex End);
95 TypeIndex LargestTypeIndex = TypeIndex::None();
95 TypeIndex LargestTypeIndex = TypeIndex::None();
include/llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h 41 DenseMap<LocallyHashedType, TypeIndex> HashedRecords;
51 Optional<TypeIndex> getFirst() override;
52 Optional<TypeIndex> getNext(TypeIndex Prev) override;
52 Optional<TypeIndex> getNext(TypeIndex Prev) override;
53 CVType getType(TypeIndex Index) override;
54 StringRef getTypeName(TypeIndex Index) override;
55 bool contains(TypeIndex Index) override;
61 TypeIndex nextTypeIndex() const;
67 TypeIndex insertRecordAs(hash_code Hash, ArrayRef<uint8_t> &Record);
68 TypeIndex insertRecordBytes(ArrayRef<uint8_t> &Record);
69 TypeIndex insertRecord(ContinuationRecordBuilder &Builder);
71 template <typename T> TypeIndex writeLeafType(T &Record) {
include/llvm/DebugInfo/CodeView/RecordName.h 18 std::string computeTypeName(TypeCollection &Types, TypeIndex Index);
include/llvm/DebugInfo/CodeView/SymbolRecord.h 60 TypeIndex FunctionType;
154 std::vector<TypeIndex> Indices;
347 TypeIndex Inlinee;
378 TypeIndex Index;
409 TypeIndex Type;
687 TypeIndex Index;
808 TypeIndex Type;
830 TypeIndex Type;
863 TypeIndex Type;
877 TypeIndex BuildId;
891 TypeIndex Type;
906 TypeIndex Type;
921 TypeIndex Type;
941 TypeIndex Type;
963 TypeIndex Type;
include/llvm/DebugInfo/CodeView/TypeCollection.h 25 virtual Optional<TypeIndex> getFirst() = 0;
26 virtual Optional<TypeIndex> getNext(TypeIndex Prev) = 0;
26 virtual Optional<TypeIndex> getNext(TypeIndex Prev) = 0;
28 virtual CVType getType(TypeIndex Index) = 0;
29 virtual StringRef getTypeName(TypeIndex Index) = 0;
30 virtual bool contains(TypeIndex Index) = 0;
35 Optional<TypeIndex> Next = getFirst();
38 TypeIndex N = *Next;
include/llvm/DebugInfo/CodeView/TypeDeserializer.h 73 Error visitTypeBegin(CVType &Record, TypeIndex Index) override {
include/llvm/DebugInfo/CodeView/TypeDumpVisitor.h 38 void printTypeIndex(StringRef FieldName, TypeIndex TI) const;
40 void printItemIndex(StringRef FieldName, TypeIndex TI) const;
49 Error visitTypeBegin(CVType &Record, TypeIndex Index) override;
include/llvm/DebugInfo/CodeView/TypeIndex.h 122 static TypeIndex fromArrayIndex(uint32_t Index) {
136 TypeIndex makeDirect() const { return TypeIndex{getSimpleKind()}; }
138 static TypeIndex None() { return TypeIndex(SimpleTypeKind::None); }
139 static TypeIndex Void() { return TypeIndex(SimpleTypeKind::Void); }
140 static TypeIndex VoidPointer32() {
143 static TypeIndex VoidPointer64() {
147 static TypeIndex NullptrT() {
154 static TypeIndex SignedCharacter() {
157 static TypeIndex UnsignedCharacter() {
160 static TypeIndex NarrowCharacter() {
163 static TypeIndex WideCharacter() {
166 static TypeIndex Int16Short() {
169 static TypeIndex UInt16Short() {
172 static TypeIndex Int32() { return TypeIndex(SimpleTypeKind::Int32); }
173 static TypeIndex UInt32() { return TypeIndex(SimpleTypeKind::UInt32); }
174 static TypeIndex Int32Long() { return TypeIndex(SimpleTypeKind::Int32Long); }
175 static TypeIndex UInt32Long() {
178 static TypeIndex Int64() { return TypeIndex(SimpleTypeKind::Int64); }
179 static TypeIndex UInt64() { return TypeIndex(SimpleTypeKind::UInt64); }
180 static TypeIndex Int64Quad() { return TypeIndex(SimpleTypeKind::Int64Quad); }
181 static TypeIndex UInt64Quad() {
185 static TypeIndex Float32() { return TypeIndex(SimpleTypeKind::Float32); }
186 static TypeIndex Float64() { return TypeIndex(SimpleTypeKind::Float64); }
188 TypeIndex &operator+=(unsigned N) {
193 TypeIndex &operator++() {
198 TypeIndex operator++(int) {
199 TypeIndex Copy = *this;
204 TypeIndex &operator-=(unsigned N) {
210 TypeIndex &operator--() {
215 TypeIndex operator--(int) {
216 TypeIndex Copy = *this;
221 friend inline bool operator==(const TypeIndex &A, const TypeIndex &B) {
221 friend inline bool operator==(const TypeIndex &A, const TypeIndex &B) {
225 friend inline bool operator!=(const TypeIndex &A, const TypeIndex &B) {
225 friend inline bool operator!=(const TypeIndex &A, const TypeIndex &B) {
229 friend inline bool operator<(const TypeIndex &A, const TypeIndex &B) {
229 friend inline bool operator<(const TypeIndex &A, const TypeIndex &B) {
233 friend inline bool operator<=(const TypeIndex &A, const TypeIndex &B) {
233 friend inline bool operator<=(const TypeIndex &A, const TypeIndex &B) {
237 friend inline bool operator>(const TypeIndex &A, const TypeIndex &B) {
237 friend inline bool operator>(const TypeIndex &A, const TypeIndex &B) {
241 friend inline bool operator>=(const TypeIndex &A, const TypeIndex &B) {
241 friend inline bool operator>=(const TypeIndex &A, const TypeIndex &B) {
245 friend inline TypeIndex operator+(const TypeIndex &A, uint32_t N) {
245 friend inline TypeIndex operator+(const TypeIndex &A, uint32_t N) {
246 TypeIndex Result(A);
251 friend inline TypeIndex operator-(const TypeIndex &A, uint32_t N) {
251 friend inline TypeIndex operator-(const TypeIndex &A, uint32_t N) {
253 TypeIndex Result(A);
258 friend inline uint32_t operator-(const TypeIndex &A, const TypeIndex &B) {
258 friend inline uint32_t operator-(const TypeIndex &A, const TypeIndex &B) {
263 static StringRef simpleTypeName(TypeIndex TI);
273 TypeIndex Type;
277 void printTypeIndex(ScopedPrinter &Printer, StringRef FieldName, TypeIndex TI,
282 static inline codeview::TypeIndex getEmptyKey() {
285 static inline codeview::TypeIndex getTombstoneKey() {
288 static unsigned getHashValue(const codeview::TypeIndex &TI) {
291 static bool isEqual(const codeview::TypeIndex &LHS,
292 const codeview::TypeIndex &RHS) {
include/llvm/DebugInfo/CodeView/TypeIndexDiscovery.h 31 SmallVectorImpl<TypeIndex> &Indices);
33 SmallVectorImpl<TypeIndex> &Indices);
42 SmallVectorImpl<TypeIndex> &Indices);
include/llvm/DebugInfo/CodeView/TypeRecord.h 110 MemberPointerInfo(TypeIndex ContainingType,
114 TypeIndex getContainingType() const { return ContainingType; }
119 TypeIndex ContainingType;
139 ModifierRecord(TypeIndex ModifiedType, ModifierOptions Modifiers)
143 TypeIndex getModifiedType() const { return ModifiedType; }
146 TypeIndex ModifiedType;
155 ProcedureRecord(TypeIndex ReturnType, CallingConvention CallConv,
157 TypeIndex ArgumentList)
162 TypeIndex getReturnType() const { return ReturnType; }
166 TypeIndex getArgumentList() const { return ArgumentList; }
168 TypeIndex ReturnType;
172 TypeIndex ArgumentList;
181 MemberFunctionRecord(TypeIndex ReturnType, TypeIndex ClassType,
181 MemberFunctionRecord(TypeIndex ReturnType, TypeIndex ClassType,
182 TypeIndex ThisType, CallingConvention CallConv,
184 TypeIndex ArgumentList, int32_t ThisPointerAdjustment)
191 TypeIndex getReturnType() const { return ReturnType; }
192 TypeIndex getClassType() const { return ClassType; }
193 TypeIndex getThisType() const { return ThisType; }
197 TypeIndex getArgumentList() const { return ArgumentList; }
200 TypeIndex ReturnType;
201 TypeIndex ClassType;
202 TypeIndex ThisType;
206 TypeIndex ArgumentList;
226 MemberFuncIdRecord(TypeIndex ClassType, TypeIndex FunctionType,
226 MemberFuncIdRecord(TypeIndex ClassType, TypeIndex FunctionType,
231 TypeIndex getClassType() const { return ClassType; }
232 TypeIndex getFunctionType() const { return FunctionType; }
235 TypeIndex ClassType;
236 TypeIndex FunctionType;
246 ArgListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)
249 ArrayRef<TypeIndex> getIndices() const { return ArgIndices; }
251 std::vector<TypeIndex> ArgIndices;
260 StringListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)
263 ArrayRef<TypeIndex> getIndices() const { return StringIndices; }
265 std::vector<TypeIndex> StringIndices;
289 PointerRecord(TypeIndex ReferentType, uint32_t Attrs)
293 PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,
298 PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,
303 TypeIndex getReferentType() const { return ReferentType; }
353 TypeIndex ReferentType;
379 NestedTypeRecord(TypeIndex Type, StringRef Name)
382 TypeIndex getNestedType() const { return Type; }
385 TypeIndex Type;
405 ArrayRecord(TypeIndex ElementType, TypeIndex IndexType, uint64_t Size,
405 ArrayRecord(TypeIndex ElementType, TypeIndex IndexType, uint64_t Size,
410 TypeIndex getElementType() const { return ElementType; }
411 TypeIndex getIndexType() const { return IndexType; }
415 TypeIndex ElementType;
416 TypeIndex IndexType;
426 TypeIndex FieldList, StringRef Name, StringRef UniqueName)
458 TypeIndex getFieldList() const { return FieldList; }
464 TypeIndex FieldList;
475 TypeIndex FieldList, TypeIndex DerivationList,
475 TypeIndex FieldList, TypeIndex DerivationList,
476 TypeIndex VTableShape, uint64_t Size, StringRef Name,
493 TypeIndex getDerivationList() const { return DerivationList; }
494 TypeIndex getVTableShape() const { return VTableShape; }
497 TypeIndex DerivationList;
498 TypeIndex VTableShape;
506 UnionRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,
528 EnumRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,
529 StringRef Name, StringRef UniqueName, TypeIndex UnderlyingType)
534 TypeIndex getUnderlyingType() const { return UnderlyingType; }
536 TypeIndex UnderlyingType;
544 BitFieldRecord(TypeIndex Type, uint8_t BitSize, uint8_t BitOffset)
548 TypeIndex getType() const { return Type; }
552 TypeIndex Type;
604 StringIdRecord(TypeIndex Id, StringRef String)
607 TypeIndex getId() const { return Id; }
610 TypeIndex Id;
619 FuncIdRecord(TypeIndex ParentScope, TypeIndex FunctionType, StringRef Name)
619 FuncIdRecord(TypeIndex ParentScope, TypeIndex FunctionType, StringRef Name)
623 TypeIndex getParentScope() const { return ParentScope; }
624 TypeIndex getFunctionType() const { return FunctionType; }
627 TypeIndex ParentScope;
628 TypeIndex FunctionType;
637 UdtSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile, uint32_t LineNumber)
637 UdtSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile, uint32_t LineNumber)
641 TypeIndex getUDT() const { return UDT; }
642 TypeIndex getSourceFile() const { return SourceFile; }
645 TypeIndex UDT;
646 TypeIndex SourceFile;
655 UdtModSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile,
655 UdtModSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile,
660 TypeIndex getUDT() const { return UDT; }
661 TypeIndex getSourceFile() const { return SourceFile; }
665 TypeIndex UDT;
666 TypeIndex SourceFile;
676 BuildInfoRecord(ArrayRef<TypeIndex> ArgIndices)
680 ArrayRef<TypeIndex> getArgs() const { return ArgIndices; }
692 SmallVector<TypeIndex, MaxArgs> ArgIndices;
700 VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
700 VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
709 TypeIndex getCompleteClass() const { return CompleteClass; }
710 TypeIndex getOverriddenVTable() const { return OverriddenVFTable; }
718 TypeIndex CompleteClass;
719 TypeIndex OverriddenVFTable;
729 OneMethodRecord(TypeIndex Type, MemberAttributes Attrs, int32_t VFTableOffset,
733 OneMethodRecord(TypeIndex Type, MemberAccess Access, MethodKind MK,
738 TypeIndex getType() const { return Type; }
750 TypeIndex Type;
774 OverloadedMethodRecord(uint16_t NumOverloads, TypeIndex MethodList,
780 TypeIndex getMethodList() const { return MethodList; }
784 TypeIndex MethodList;
793 DataMemberRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset,
797 DataMemberRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset,
803 TypeIndex getType() const { return Type; }
808 TypeIndex Type;
818 StaticDataMemberRecord(MemberAttributes Attrs, TypeIndex Type, StringRef Name)
821 StaticDataMemberRecord(MemberAccess Access, TypeIndex Type, StringRef Name)
826 TypeIndex getType() const { return Type; }
830 TypeIndex Type;
860 VFPtrRecord(TypeIndex Type)
863 TypeIndex getType() const { return Type; }
865 TypeIndex Type;
873 BaseClassRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset)
876 BaseClassRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset)
881 TypeIndex getBaseType() const { return Type; }
885 TypeIndex Type;
895 TypeIndex BaseType, TypeIndex VBPtrType,
895 TypeIndex BaseType, TypeIndex VBPtrType,
900 TypeIndex BaseType, TypeIndex VBPtrType,
900 TypeIndex BaseType, TypeIndex VBPtrType,
906 TypeIndex getBaseType() const { return BaseType; }
907 TypeIndex getVBPtrType() const { return VBPtrType; }
912 TypeIndex BaseType;
913 TypeIndex VBPtrType;
924 ListContinuationRecord(TypeIndex ContinuationIndex)
928 TypeIndex getContinuationIndex() const { return ContinuationIndex; }
930 TypeIndex ContinuationIndex;
include/llvm/DebugInfo/CodeView/TypeRecordHelpers.h 23 TypeIndex getModifiedType(const CVType &CVT);
include/llvm/DebugInfo/CodeView/TypeRecordMapping.h 31 Error visitTypeBegin(CVType &Record, TypeIndex Index) override;
include/llvm/DebugInfo/CodeView/TypeStreamMerger.h 39 SmallVectorImpl<TypeIndex> &SourceToDest,
63 Error mergeIdRecords(MergingTypeTableBuilder &Dest, ArrayRef<TypeIndex> Types,
64 SmallVectorImpl<TypeIndex> &SourceToDest,
84 SmallVectorImpl<TypeIndex> &SourceToDest,
90 SmallVectorImpl<TypeIndex> &SourceToDest,
96 SmallVectorImpl<TypeIndex> &SourceToDest,
101 Error mergeIdRecords(GlobalTypeTableBuilder &Dest, ArrayRef<TypeIndex> Types,
102 SmallVectorImpl<TypeIndex> &SourceToDest,
include/llvm/DebugInfo/CodeView/TypeTableCollection.h 24 Optional<TypeIndex> getFirst() override;
25 Optional<TypeIndex> getNext(TypeIndex Prev) override;
25 Optional<TypeIndex> getNext(TypeIndex Prev) override;
27 CVType getType(TypeIndex Index) override;
28 StringRef getTypeName(TypeIndex Index) override;
29 bool contains(TypeIndex Index) override;
include/llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h 49 Error visitTypeBegin(CVType &Record, TypeIndex Index) override {
include/llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h 32 virtual Error visitTypeBegin(CVType &Record, TypeIndex Index) {
include/llvm/DebugInfo/PDB/Native/NativeEnumTypes.h 31 std::vector<codeview::TypeIndex> Indices);
39 std::vector<codeview::TypeIndex> Matches;
include/llvm/DebugInfo/PDB/Native/NativeTypeArray.h 24 NativeTypeArray(NativeSession &Session, SymIndexId Id, codeview::TypeIndex TI,
43 codeview::TypeIndex Index;
include/llvm/DebugInfo/PDB/Native/NativeTypeEnum.h 25 NativeTypeEnum(NativeSession &Session, SymIndexId Id, codeview::TypeIndex TI,
65 codeview::TypeIndex Index;
include/llvm/DebugInfo/PDB/Native/NativeTypeFunctionSig.h 30 codeview::TypeIndex TI, codeview::ProcedureRecord Proc);
33 codeview::TypeIndex TI,
57 void initializeArgList(codeview::TypeIndex ArgListTI);
65 codeview::TypeIndex Index;
include/llvm/DebugInfo/PDB/Native/NativeTypePointer.h 25 codeview::TypeIndex TI);
29 codeview::TypeIndex TI, codeview::PointerRecord PR);
53 codeview::TypeIndex TI;
include/llvm/DebugInfo/PDB/Native/NativeTypeUDT.h 23 NativeTypeUDT(NativeSession &Session, SymIndexId Id, codeview::TypeIndex TI,
26 NativeTypeUDT(NativeSession &Session, SymIndexId Id, codeview::TypeIndex TI,
61 codeview::TypeIndex Index;
include/llvm/DebugInfo/PDB/Native/NativeTypeVTShape.h 25 codeview::TypeIndex TI, codeview::VFTableShapeRecord SR);
38 codeview::TypeIndex TI;
include/llvm/DebugInfo/PDB/Native/SymbolCache.h 40 DenseMap<codeview::TypeIndex, SymIndexId> TypeIndexToSymbolId;
45 DenseMap<std::pair<codeview::TypeIndex, uint32_t>, SymIndexId>
62 SymIndexId createSymbolForType(codeview::TypeIndex TI, codeview::CVType CVT,
75 SymIndexId createSymbolForModifiedType(codeview::TypeIndex ModifierTI,
78 SymIndexId createSimpleType(codeview::TypeIndex TI,
85 SymIndexId createSymbol(Args &&... ConstructorArgs) {
112 SymIndexId findSymbolByTypeIndex(codeview::TypeIndex TI);
115 SymIndexId getOrCreateFieldListMember(codeview::TypeIndex FieldListTI,
119 std::pair<codeview::TypeIndex, uint32_t> Key{FieldListTI, Index};
include/llvm/DebugInfo/PDB/Native/TpiStream.h 60 Expected<codeview::TypeIndex>
61 findFullDeclForForwardRef(codeview::TypeIndex ForwardRefTI) const;
63 std::vector<codeview::TypeIndex> findRecordsByName(StringRef Name) const;
65 codeview::CVType getType(codeview::TypeIndex Index);
90 std::vector<std::vector<codeview::TypeIndex>> HashMap;
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/Alignment.h 103 return Constant<std::alignment_of<T>::value>();
include/llvm/Support/BinaryStreamArray.h 262 typedef FixedStreamArrayIterator<T> Iterator;
269 bool operator==(const FixedStreamArray<T> &Other) const {
273 bool operator!=(const FixedStreamArray<T> &Other) const {
279 const T &operator[](uint32_t Index) const {
281 uint32_t Off = Index * sizeof(T);
283 if (auto EC = Stream.readBytes(Off, sizeof(T), Data)) {
293 uint32_t size() const { return Stream.getLength() / sizeof(T); }
297 FixedStreamArrayIterator<T> begin() const {
301 FixedStreamArrayIterator<T> end() const {
305 const T &front() const { return *begin(); }
306 const T &back() const {
319 : public iterator_facade_base<FixedStreamArrayIterator<T>,
320 std::random_access_iterator_tag, const T> {
323 FixedStreamArrayIterator(const FixedStreamArray<T> &Array, uint32_t Index)
326 FixedStreamArrayIterator<T> &
327 operator=(const FixedStreamArrayIterator<T> &Other) {
333 const T &operator*() const { return Array[Index]; }
334 const T &operator*() { return Array[Index]; }
336 bool operator==(const FixedStreamArrayIterator<T> &R) const {
341 FixedStreamArrayIterator<T> &operator+=(std::ptrdiff_t N) {
346 FixedStreamArrayIterator<T> &operator-=(std::ptrdiff_t N) {
352 std::ptrdiff_t operator-(const FixedStreamArrayIterator<T> &R) const {
358 bool operator<(const FixedStreamArrayIterator<T> &RHS) const {
364 FixedStreamArray<T> Array;
include/llvm/Support/BinaryStreamReader.h 235 Error readArray(FixedStreamArray<T> &Array, uint32_t NumItems) {
241 if (NumItems > UINT32_MAX / sizeof(T))
246 if (auto EC = readStreamRef(View, NumItems * sizeof(T)))
include/llvm/Support/Error.h 437 static const bool isRef = std::is_reference<T>::value;
439 using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
444 using storage_type = typename std::conditional<isRef, wrap, T>::type;
445 using value_type = T;
448 using reference = typename std::remove_reference<T>::type &;
449 using const_reference = const typename std::remove_reference<T>::type &;
450 using pointer = typename std::remove_reference<T>::type *;
451 using const_pointer = const typename std::remove_reference<T>::type *;
474 Expected(OtherT &&Val,
475 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
475 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
483 new (getStorage()) storage_type(std::forward<OtherT>(Val));
492 Expected(Expected<OtherT> &&Other,
493 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
493 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
594 template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
731 T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
731 T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
include/llvm/Support/FormatAdapters.h 22 explicit FormatAdapter(T &&Item) : Item(std::forward<T>(Item)) {}
34 AlignAdapter(T &&Item, AlignStyle Where, size_t Amount, char Fill)
85 detail::AlignAdapter<T> fmt_align(T &&Item, AlignStyle Where, size_t Amount,
include/llvm/Support/FormatVariadic.h 253 inline auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object<decltype(
254 std::make_tuple(detail::build_format_adapter(std::forward<Ts>(Vals))...))> {
256 std::make_tuple(detail::build_format_adapter(std::forward<Ts>(Vals))...));
259 std::make_tuple(detail::build_format_adapter(std::forward<Ts>(Vals))...));
include/llvm/Support/FormatVariadicDetails.h 33 T Item;
36 explicit provider_format_adapter(T &&Item) : Item(std::forward<T>(Item)) {}
36 explicit provider_format_adapter(T &&Item) : Item(std::forward<T>(Item)) {}
39 format_provider<typename std::decay<T>::type>::format(Item, S, Options);
62 using Decayed = typename std::decay<T>::type;
78 using ConstRefT = const typename std::decay<T>::type &;
136 typename std::enable_if<uses_format_provider<T>::value,
137 provider_format_adapter<T>>::type
138 build_format_adapter(T &&Item) {
139 return provider_format_adapter<T>(std::forward<T>(Item));
include/llvm/Support/YAMLTraits.h 313 using Signature_enumeration = void (*)(class IO&, T&);
322 (sizeof(test<ScalarEnumerationTraits<T>>(nullptr)) == 1);
329 using Signature_bitset = void (*)(class IO&, T&);
337 static bool const value = (sizeof(test<ScalarBitSetTraits<T>>(nullptr)) == 1);
344 using Signature_input = StringRef (*)(StringRef, void*, T&);
345 using Signature_output = void (*)(const T&, void*, raw_ostream&);
357 (sizeof(test<ScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
364 using Signature_input = StringRef (*)(StringRef, void *, T &);
365 using Signature_output = void (*)(const T &, void *, raw_ostream &);
375 (sizeof(test<BlockScalarTraits<T>>(nullptr, nullptr)) == 1);
380 using Signature_input = StringRef (*)(StringRef, StringRef, void *, T &);
381 using Signature_output = void (*)(const T &, void *, raw_ostream &,
383 using Signature_mustQuote = QuotingType (*)(const T &, StringRef);
393 (sizeof(test<TaggedScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
412 using Signature_mapping = void (*)(class IO &, T &);
419 static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
438 using Signature_validate = StringRef (*)(class IO &, T &);
445 static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
452 using Signature_size = size_t (*)(class IO&, T&);
460 static bool const value = (sizeof(test<SequenceTraits<T>>(nullptr)) == 1);
467 using Signature_input = void (*)(IO &io, StringRef key, T &v);
476 (sizeof(test<CustomMappingTraits<T>>(nullptr)) == 1);
516 using Signature_size = size_t (*)(class IO &, T &);
524 static bool const value = (sizeof(test<DocumentListTraits<T>>(nullptr))==1);
528 using Signature_getKind = NodeKind (*)(const T &);
535 static bool const value = (sizeof(test<PolymorphicTraits<T>>(nullptr)) == 1);
849 template <typename T> void mapRequired(const char *Key, T &Val) {
941 void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
988 typename std::enable_if<has_ScalarTraits<T>::value, void>::type
989 yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
993 ScalarTraits<T>::output(Val, io.getContext(), Buffer);
995 io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999 io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
1000 StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1904 : SequenceTraitsImpl<std::vector<T>, SequenceElementTraits<T>::flow> {};
1909 : SequenceTraitsImpl<SmallVector<T, N>, SequenceElementTraits<T>::flow> {};
include/llvm/Support/type_traits.h 65 using type = const T &;
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/AsmPrinter/CodeViewDebug.cpp 118 std::string getTypeName(TypeIndex TI) {
122 TypeName = TypeIndex::simpleTypeName(TI);
355 TypeIndex CodeViewDebug::getScopeIndex(const DIScope *Scope) {
370 auto TI = TypeTable.writeLeafType(SID);
374 TypeIndex CodeViewDebug::getFuncIdForSubprogram(const DISubprogram *SP) {
387 TypeIndex TI;
392 TypeIndex ClassType = getTypeIndex(Class);
398 TypeIndex ParentScope = getScopeIndex(Scope);
436 TypeIndex CodeViewDebug::getMemberFunctionType(const DISubprogram *SP,
457 TypeIndex TI = lowerTypeMemberFunction(
462 TypeIndex CodeViewDebug::recordTypeIndexForDINode(const DINode *Node,
463 TypeIndex TI,
653 Optional<TypeIndex> B = Table.getFirst();
685 TypeIndex TI(TypeIndex::FirstNonSimpleIndex);
685 TypeIndex TI(TypeIndex::FirstNonSimpleIndex);
808 static TypeIndex getStringIdTypeIdx(GlobalTypeTableBuilder &TypeTable,
825 TypeIndex BuildInfoArgs[BuildInfoRecord::MaxArgs] = {};
837 TypeIndex BuildInfoIndex = TypeTable.writeLeafType(BIR);
865 TypeIndex InlineeIdx = TypeIndices[{SP, nullptr}];
887 TypeIndex InlineeIdx = TypeIndices[{Site.Inlinee, nullptr}];
1492 TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
1533 return TypeIndex::NullptrT();
1534 return TypeIndex::None();
1541 TypeIndex CodeViewDebug::lowerTypeAlias(const DIDerivedType *Ty) {
1542 TypeIndex UnderlyingTypeIndex = getTypeIndex(Ty->getBaseType());
1557 TypeIndex CodeViewDebug::lowerTypeArray(const DICompositeType *Ty) {
1559 TypeIndex ElementTypeIndex = getTypeIndex(ElementType);
1561 TypeIndex IndexType = getPointerSizeInBytes() == 8
1603 TypeIndex CodeViewDebug::lowerTypeBasic(const DIBasicType *Ty) {
1604 TypeIndex Index;
1696 TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty,
1698 TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType());
1767 TypeIndex CodeViewDebug::lowerTypeMemberPointer(const DIDerivedType *Ty,
1770 TypeIndex ClassTI = getTypeIndex(Ty->getClassType());
1771 TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType(), Ty->getClassType());
1800 TypeIndex CodeViewDebug::lowerTypeModifier(const DIDerivedType *Ty) {
1846 TypeIndex ModifiedTI = getTypeIndex(BaseTy);
1857 TypeIndex CodeViewDebug::lowerTypeFunction(const DISubroutineType *Ty) {
1858 SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
1864 ReturnAndArgTypeIndices.back() == TypeIndex::Void()) {
1865 ReturnAndArgTypeIndices.back() = TypeIndex::None();
1867 TypeIndex ReturnTypeIndex = TypeIndex::Void();
1867 TypeIndex ReturnTypeIndex = TypeIndex::Void();
1868 ArrayRef<TypeIndex> ArgTypeIndices = None;
1876 TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec);
1886 TypeIndex CodeViewDebug::lowerTypeMemberFunction(const DISubroutineType *Ty,
1892 TypeIndex ClassType = getTypeIndex(ClassTy);
1897 SmallVector<TypeIndex, 8> ArgTypeIndices;
1898 TypeIndex ReturnTypeIndex = TypeIndex::Void();
1898 TypeIndex ReturnTypeIndex = TypeIndex::Void();
1906 TypeIndex ThisTypeIndex;
1921 if (!ArgTypeIndices.empty() && ArgTypeIndices.back() == TypeIndex::Void())
1922 ArgTypeIndices.back() = TypeIndex::None();
1925 TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec);
1934 TypeIndex CodeViewDebug::lowerTypeVFTableShape(const DIDerivedType *Ty) {
2031 void CodeViewDebug::addUDTSrcLine(const DIType *Ty, TypeIndex TI) {
2044 TypeIndex SIDI = TypeTable.writeLeafType(SIDR);
2051 TypeIndex CodeViewDebug::lowerTypeEnum(const DICompositeType *Ty) {
2053 TypeIndex FTI;
2079 TypeIndex EnumTI = TypeTable.writeLeafType(ER);
2110 TypeIndex VShapeTI;
2206 TypeIndex CodeViewDebug::lowerTypeClass(const DICompositeType *Ty) {
2229 TypeIndex FwdDeclTI = TypeTable.writeLeafType(CR);
2235 TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) {
2239 TypeIndex FieldTI;
2240 TypeIndex VShapeTI;
2263 TypeIndex ClassTI = TypeTable.writeLeafType(CR);
2272 TypeIndex CodeViewDebug::lowerTypeUnion(const DICompositeType *Ty) {
2281 TypeIndex FwdDeclTI = TypeTable.writeLeafType(UR);
2287 TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) {
2289 TypeIndex FieldTI;
2303 TypeIndex UnionTI = TypeTable.writeLeafType(UR);
2312 std::tuple<TypeIndex, TypeIndex, unsigned, bool>
2312 std::tuple<TypeIndex, TypeIndex, unsigned, bool>
2354 TypeIndex MemberBaseType = getTypeIndex(Member->getBaseType());
2402 TypeIndex MethodType = getMemberFunctionType(SP, Ty);
2422 TypeIndex MethodList = TypeTable.writeLeafType(MOLR);
2436 TypeIndex FieldTI = TypeTable.insertRecord(ContinuationBuilder);
2441 TypeIndex CodeViewDebug::getVBPTypeIndex() {
2444 ModifierRecord MR(TypeIndex::Int32(), ModifierOptions::Const);
2445 TypeIndex ModifiedTI = TypeTable.writeLeafType(MR);
2458 TypeIndex CodeViewDebug::getTypeIndex(const DIType *Ty, const DIType *ClassTy) {
2461 return TypeIndex::Void();
2471 TypeIndex TI = lowerType(Ty, ClassTy);
2475 codeview::TypeIndex
2497 TypeIndex TI = lowerTypePointer(PtrTy, Options);
2501 TypeIndex CodeViewDebug::getTypeIndexForReferenceTo(const DIType *Ty) {
2510 TypeIndex CodeViewDebug::getCompleteTypeIndex(const DIType *Ty) {
2513 return TypeIndex::Void();
2543 TypeIndex FwdDeclTI = getTypeIndex(CTy);
2559 TypeIndex TI;
2625 TypeIndex TI = Var.UseReferenceType
lib/CodeGen/AsmPrinter/CodeViewDebug.h 225 codeview::TypeIndex getFuncIdForSubprogram(const DISubprogram *SP);
251 DenseMap<std::pair<const DINode *, const DIType *>, codeview::TypeIndex>
256 DenseMap<const DICompositeType *, codeview::TypeIndex> CompleteTypeIndices;
265 codeview::TypeIndex VBPType;
377 codeview::TypeIndex getTypeIndex(const DIType *Ty,
380 codeview::TypeIndex
384 codeview::TypeIndex getTypeIndexForReferenceTo(const DIType *Ty);
386 codeview::TypeIndex getMemberFunctionType(const DISubprogram *SP,
389 codeview::TypeIndex getScopeIndex(const DIScope *Scope);
391 codeview::TypeIndex getVBPTypeIndex();
395 void addUDTSrcLine(const DIType *Ty, codeview::TypeIndex TI);
397 codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy);
398 codeview::TypeIndex lowerTypeAlias(const DIDerivedType *Ty);
399 codeview::TypeIndex lowerTypeArray(const DICompositeType *Ty);
400 codeview::TypeIndex lowerTypeBasic(const DIBasicType *Ty);
401 codeview::TypeIndex lowerTypePointer(
404 codeview::TypeIndex lowerTypeMemberPointer(
407 codeview::TypeIndex lowerTypeModifier(const DIDerivedType *Ty);
408 codeview::TypeIndex lowerTypeFunction(const DISubroutineType *Ty);
409 codeview::TypeIndex lowerTypeVFTableShape(const DIDerivedType *Ty);
410 codeview::TypeIndex lowerTypeMemberFunction(
414 codeview::TypeIndex lowerTypeEnum(const DICompositeType *Ty);
415 codeview::TypeIndex lowerTypeClass(const DICompositeType *Ty);
416 codeview::TypeIndex lowerTypeUnion(const DICompositeType *Ty);
423 codeview::TypeIndex getCompleteTypeIndex(const DIType *Ty);
425 codeview::TypeIndex lowerCompleteTypeClass(const DICompositeType *Ty);
426 codeview::TypeIndex lowerCompleteTypeUnion(const DICompositeType *Ty);
438 std::tuple<codeview::TypeIndex, codeview::TypeIndex, unsigned, bool>
438 std::tuple<codeview::TypeIndex, codeview::TypeIndex, unsigned, bool>
442 codeview::TypeIndex recordTypeIndexForDINode(const DINode *Node,
443 codeview::TypeIndex TI,
lib/DebugInfo/CodeView/AppendingTypeTableBuilder.cpp 30 TypeIndex AppendingTypeTableBuilder::nextTypeIndex() const {
31 return TypeIndex::fromArrayIndex(SeenRecords.size());
39 Optional<TypeIndex> AppendingTypeTableBuilder::getFirst() {
43 return TypeIndex(TypeIndex::FirstNonSimpleIndex);
46 Optional<TypeIndex> AppendingTypeTableBuilder::getNext(TypeIndex Prev) {
46 Optional<TypeIndex> AppendingTypeTableBuilder::getNext(TypeIndex Prev) {
52 CVType AppendingTypeTableBuilder::getType(TypeIndex Index){
56 StringRef AppendingTypeTableBuilder::getTypeName(TypeIndex Index) {
60 bool AppendingTypeTableBuilder::contains(TypeIndex Index) {
77 TypeIndex
79 TypeIndex NewTI = nextTypeIndex();
87 TypeIndex
89 TypeIndex TI;
lib/DebugInfo/CodeView/CVTypeVisitor.cpp 77 Error visitTypeRecord(CVType &Record, TypeIndex Index);
123 Error CVTypeVisitor::visitTypeRecord(CVType &Record, TypeIndex Index) {
159 Optional<TypeIndex> I = Types.getFirst();
218 Error llvm::codeview::visitTypeRecord(CVType &Record, TypeIndex Index,
lib/DebugInfo/CodeView/CodeViewRecordIO.cpp 127 Error CodeViewRecordIO::mapInteger(TypeIndex &TypeInd, const Twine &Comment) {
lib/DebugInfo/CodeView/ContinuationRecordBuilder.cpp 150 uint32_t OffBegin, uint32_t OffEnd, Optional<TypeIndex> RefersTo) {
173 std::vector<CVType> ContinuationRecordBuilder::end(TypeIndex Index) {
231 Optional<TypeIndex> RefersTo;
lib/DebugInfo/CodeView/DebugInlineeLinesSubsection.cpp 115 void DebugInlineeLinesSubsection::addInlineSite(TypeIndex FuncId,
lib/DebugInfo/CodeView/GlobalTypeTableBuilder.cpp 30 TypeIndex GlobalTypeTableBuilder::nextTypeIndex() const {
31 return TypeIndex::fromArrayIndex(SeenRecords.size());
41 Optional<TypeIndex> GlobalTypeTableBuilder::getFirst() {
45 return TypeIndex(TypeIndex::FirstNonSimpleIndex);
48 Optional<TypeIndex> GlobalTypeTableBuilder::getNext(TypeIndex Prev) {
48 Optional<TypeIndex> GlobalTypeTableBuilder::getNext(TypeIndex Prev) {
54 CVType GlobalTypeTableBuilder::getType(TypeIndex Index) {
59 StringRef GlobalTypeTableBuilder::getTypeName(TypeIndex Index) {
63 bool GlobalTypeTableBuilder::contains(TypeIndex Index) {
87 TypeIndex GlobalTypeTableBuilder::insertRecordBytes(ArrayRef<uint8_t> Record) {
98 TypeIndex
100 TypeIndex TI;
lib/DebugInfo/CodeView/LazyRandomTypeCollection.cpp 83 uint32_t LazyRandomTypeCollection::getOffsetOfType(TypeIndex Index) {
90 CVType LazyRandomTypeCollection::getType(TypeIndex Index) {
100 Optional<CVType> LazyRandomTypeCollection::tryGetType(TypeIndex Index) {
113 StringRef LazyRandomTypeCollection::getTypeName(TypeIndex Index) {
115 return TypeIndex::simpleTypeName(Index);
135 bool LazyRandomTypeCollection::contains(TypeIndex Index) {
150 Error LazyRandomTypeCollection::ensureTypeExists(TypeIndex TI) {
157 void LazyRandomTypeCollection::ensureCapacityFor(TypeIndex Index) {
170 Error LazyRandomTypeCollection::visitRangeForType(TypeIndex TI) {
183 TypeIndex TIB = Prev->Type;
193 TypeIndex TIE;
195 TIE = TypeIndex::fromArrayIndex(capacity());
204 Optional<TypeIndex> LazyRandomTypeCollection::getFirst() {
205 TypeIndex TI = TypeIndex::fromArrayIndex(0);
205 TypeIndex TI = TypeIndex::fromArrayIndex(0);
213 Optional<TypeIndex> LazyRandomTypeCollection::getNext(TypeIndex Prev) {
213 Optional<TypeIndex> LazyRandomTypeCollection::getNext(TypeIndex Prev) {
225 Error LazyRandomTypeCollection::fullScanForType(TypeIndex TI) {
229 TypeIndex CurrentTI = TypeIndex::fromArrayIndex(0);
229 TypeIndex CurrentTI = TypeIndex::fromArrayIndex(0);
264 void LazyRandomTypeCollection::visitRange(TypeIndex Begin, uint32_t BeginOffset,
265 TypeIndex End) {
lib/DebugInfo/CodeView/MergingTypeTableBuilder.cpp 30 TypeIndex MergingTypeTableBuilder::nextTypeIndex() const {
31 return TypeIndex::fromArrayIndex(SeenRecords.size());
41 Optional<TypeIndex> MergingTypeTableBuilder::getFirst() {
45 return TypeIndex(TypeIndex::FirstNonSimpleIndex);
48 Optional<TypeIndex> MergingTypeTableBuilder::getNext(TypeIndex Prev) {
48 Optional<TypeIndex> MergingTypeTableBuilder::getNext(TypeIndex Prev) {
54 CVType MergingTypeTableBuilder::getType(TypeIndex Index) {
59 StringRef MergingTypeTableBuilder::getTypeName(TypeIndex Index) {
63 bool MergingTypeTableBuilder::contains(TypeIndex Index) {
90 TypeIndex MergingTypeTableBuilder::insertRecordAs(hash_code Hash,
105 TypeIndex ActualTI = Result.first->second;
110 TypeIndex
115 TypeIndex
117 TypeIndex TI;
lib/DebugInfo/CodeView/RecordName.cpp 25 TypeIndex CurrentTypeIndex = TypeIndex::None();
25 TypeIndex CurrentTypeIndex = TypeIndex::None();
38 Error visitTypeBegin(CVType &Record, TypeIndex Index) override;
54 Error TypeNameComputer::visitTypeBegin(CVType &Record, TypeIndex Index) {
249 TypeIndex Index) {
lib/DebugInfo/CodeView/SymbolDumper.cpp 54 void printTypeIndex(StringRef FieldName, TypeIndex TI);
99 void CVSymbolDumperImpl::printTypeIndex(StringRef FieldName, TypeIndex TI) {
595 for (auto FuncID : Caller.Indices)
lib/DebugInfo/CodeView/TypeDumpVisitor.cpp 161 void TypeDumpVisitor::printTypeIndex(StringRef FieldName, TypeIndex TI) const {
165 void TypeDumpVisitor::printItemIndex(StringRef FieldName, TypeIndex TI) const {
170 return visitTypeBegin(Record, TypeIndex::fromArrayIndex(TpiTypes.size()));
173 Error TypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {
429 for (auto Arg : Args.getArgs()) {
lib/DebugInfo/CodeView/TypeHashing.cpp 50 auto RefData = RecordData.slice(Ref.Offset, Ref.Count * sizeof(TypeIndex));
53 ArrayRef<TypeIndex> Indices(
55 for (TypeIndex TI : Indices) {
59 BytesToHash = makeArrayRef(IndexBytes, sizeof(TypeIndex));
72 Off = Ref.Offset + Ref.Count * sizeof(TypeIndex);
lib/DebugInfo/CodeView/TypeIndex.cpp 70 StringRef TypeIndex::simpleTypeName(TypeIndex TI) {
76 if (TI == TypeIndex::NullptrT())
93 TypeIndex TI, TypeCollection &Types) {
97 TypeName = TypeIndex::simpleTypeName(TI);
lib/DebugInfo/CodeView/TypeIndexDiscovery.cpp 463 SmallVectorImpl<TypeIndex> &Indices) {
474 FixedStreamArray<TypeIndex> Run;
481 SmallVectorImpl<TypeIndex> &Indices) {
486 SmallVectorImpl<TypeIndex> &Indices) {
516 ArrayRef<uint8_t> RecordData, SmallVectorImpl<TypeIndex> &Indices) {
lib/DebugInfo/CodeView/TypeRecordHelpers.cpp 47 TypeIndex llvm::codeview::getModifiedType(const CVType &CVT) {
49 SmallVector<TypeIndex, 1> Refs;
lib/DebugInfo/CodeView/TypeRecordMapping.cpp 212 Error TypeRecordMapping::visitTypeBegin(CVType &CVR, TypeIndex Index) {
lib/DebugInfo/CodeView/TypeStreamMerger.cpp 23 static inline size_t slotForIndex(TypeIndex Idx) {
25 return Idx.getIndex() - TypeIndex::FirstNonSimpleIndex;
64 explicit TypeStreamMerger(SmallVectorImpl<TypeIndex> &SourceToDest)
74 static const TypeIndex Untranslated;
81 ArrayRef<TypeIndex> TypeSourceToDest,
93 ArrayRef<TypeIndex> TypeSourceToDest,
107 void addMapping(TypeIndex Idx);
109 inline bool remapTypeIndex(TypeIndex &Idx) {
121 inline bool remapItemIndex(TypeIndex &Idx) {
137 inline bool remapIndex(TypeIndex &Idx, ArrayRef<TypeIndex> Map) {
137 inline bool remapIndex(TypeIndex &Idx, ArrayRef<TypeIndex> Map) {
144 inline bool remapIndexSimple(TypeIndex &Idx, ArrayRef<TypeIndex> Map) const {
144 inline bool remapIndexSimple(TypeIndex &Idx, ArrayRef<TypeIndex> Map) const {
160 bool remapIndexFallback(TypeIndex &Idx, ArrayRef<TypeIndex> Map);
160 bool remapIndexFallback(TypeIndex &Idx, ArrayRef<TypeIndex> Map);
176 TypeIndex CurIndex{TypeIndex::FirstNonSimpleIndex};
176 TypeIndex CurIndex{TypeIndex::FirstNonSimpleIndex};
188 ArrayRef<TypeIndex> TypeLookup;
192 SmallVectorImpl<TypeIndex> &IndexMap;
203 const TypeIndex TypeStreamMerger::Untranslated(SimpleTypeKind::NotTranslated);
220 void TypeStreamMerger::addMapping(TypeIndex Idx) {
231 bool TypeStreamMerger::remapIndexFallback(TypeIndex &Idx,
232 ArrayRef<TypeIndex> Map) {
264 ArrayRef<TypeIndex> TypeSourceToDest,
299 ArrayRef<TypeIndex> TypeSourceToDest,
339 CurIndex = TypeIndex(TypeIndex::FirstNonSimpleIndex);
371 TypeIndex DestIdx = Untranslated;
414 TypeIndex *DestTIs =
418 TypeIndex &TI = DestTIs[I];
429 SmallVectorImpl<TypeIndex> &SourceToDest,
436 ArrayRef<TypeIndex> TypeSourceToDest,
437 SmallVectorImpl<TypeIndex> &SourceToDest,
445 SmallVectorImpl<TypeIndex> &SourceToDest, const CVTypeArray &IdsAndTypes,
453 SmallVectorImpl<TypeIndex> &SourceToDest, const CVTypeArray &IdsAndTypes,
461 SmallVectorImpl<TypeIndex> &SourceToDest,
470 ArrayRef<TypeIndex> Types,
471 SmallVectorImpl<TypeIndex> &SourceToDest,
lib/DebugInfo/CodeView/TypeTableCollection.cpp 23 Optional<TypeIndex> TypeTableCollection::getFirst() {
26 return TypeIndex::fromArrayIndex(0);
29 Optional<TypeIndex> TypeTableCollection::getNext(TypeIndex Prev) {
29 Optional<TypeIndex> TypeTableCollection::getNext(TypeIndex Prev) {
37 CVType TypeTableCollection::getType(TypeIndex Index) {
42 StringRef TypeTableCollection::getTypeName(TypeIndex Index) {
44 return TypeIndex::simpleTypeName(Index);
54 bool TypeTableCollection::contains(TypeIndex Index) {
lib/DebugInfo/PDB/Native/NativeEnumTypes.cpp 27 Optional<TypeIndex> TI = Types.getFirst();
36 TypeIndex ModifiedTI = getModifiedType(CVT);
51 std::vector<codeview::TypeIndex> Indices)
lib/DebugInfo/PDB/Native/NativeTypeArray.cpp 20 codeview::TypeIndex TI,
lib/DebugInfo/PDB/Native/NativeTypeEnum.cpp 58 Optional<TypeIndex> ContinuationIndex;
116 TypeIndex Index, EnumRecord Record)
184 codeview::TypeIndex Underlying = Record->getUnderlyingType();
lib/DebugInfo/PDB/Native/NativeTypeFunctionSig.cpp 78 codeview::TypeIndex Index,
84 NativeSession &Session, SymIndexId Id, codeview::TypeIndex Index,
101 void NativeTypeFunctionSig::initializeArgList(codeview::TypeIndex ArgListTI) {
161 TypeIndex ReturnTI =
lib/DebugInfo/PDB/Native/NativeTypePointer.cpp 20 codeview::TypeIndex TI)
27 codeview::TypeIndex TI,
102 TypeIndex Referent = Record ? Record->ReferentType : TI.makeDirect();
lib/DebugInfo/PDB/Native/NativeTypeUDT.cpp 20 codeview::TypeIndex TI, codeview::ClassRecord CR)
25 codeview::TypeIndex TI, codeview::UnionRecord UR)
lib/DebugInfo/PDB/Native/NativeTypeVTShape.cpp 8 codeview::TypeIndex TI,
lib/DebugInfo/PDB/Native/SymbolCache.cpp 96 SymIndexId SymbolCache::createSimpleType(TypeIndex Index,
111 SymbolCache::createSymbolForModifiedType(codeview::TypeIndex ModifierTI,
142 SymIndexId SymbolCache::findSymbolByTypeIndex(codeview::TypeIndex Index) {
166 Expected<TypeIndex> EFD = Tpi->findFullDeclForForwardRef(Index);
lib/DebugInfo/PDB/Native/TpiStream.cpp 152 TypeIndex TIB{Header->TypeIndexBegin};
153 TypeIndex TIE{Header->TypeIndexEnd};
160 std::vector<TypeIndex> TpiStream::findRecordsByName(StringRef Name) const {
168 std::vector<TypeIndex> Result;
169 for (TypeIndex TI : HashMap[Bucket]) {
179 Expected<TypeIndex>
180 TpiStream::findFullDeclForForwardRef(TypeIndex ForwardRefTI) const {
194 for (TypeIndex TI : HashMap[BucketIdx]) {
221 codeview::CVType TpiStream::getType(codeview::TypeIndex Index) {
lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp 51 {codeview::TypeIndex(codeview::TypeIndex::FirstNonSimpleIndex +
72 H->TypeIndexBegin = codeview::TypeIndex::FirstNonSimpleIndex;
lib/ObjectYAML/CodeViewYAMLTypes.cpp 171 void ScalarTraits<TypeIndex>::output(const TypeIndex &S, void *,
177 TypeIndex &S) {
tools/lld/COFF/PDB.cpp 574 static bool remapTypeIndex(TypeIndex &ti, ArrayRef<TypeIndex> typeIndexMap) {
574 static bool remapTypeIndex(TypeIndex &ti, ArrayRef<TypeIndex> typeIndexMap) {
590 unsigned byteSize = ref.Count * sizeof(TypeIndex);
595 ArrayRef<TypeIndex> typeOrItemMap = indexMap.tpiMap;
600 MutableArrayRef<TypeIndex> tIs(
602 for (TypeIndex &ti : tIs) {
677 TypeIndex *ti =
685 SmallVector<TypeIndex, 2> indices;
1079 TypeIndex inlinee = line.Header->Inlinee;
1083 ArrayRef<TypeIndex> typeOrItemMap =
tools/lld/COFF/TypeMerger.h 56 llvm::SmallVector<llvm::codeview::TypeIndex, 0> tpiMap;
57 llvm::SmallVector<llvm::codeview::TypeIndex, 0> ipiMap;
tools/lldb/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.h 71 llvm::SmallVector<llvm::codeview::TypeIndex, 5> m_build_info;
tools/lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp 76 static std::pair<size_t, bool> GetIntegralTypeInfo(TypeIndex ti,
222 TypeIndex underlying_ti, TpiStream &tpi, const llvm::APSInt &constant,
tools/lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.h 39 llvm::codeview::TypeIndex underlying_ti, llvm::pdb::TpiStream &tpi,
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp 108 static bool IsCVarArgsFunction(llvm::ArrayRef<TypeIndex> args) {
111 return args.back() == TypeIndex::None();
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h 91 using TypeIndex = llvm::codeview::TypeIndex;
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbSymUid.h 72 PdbTypeSymId(llvm::codeview::TypeIndex index, bool is_ipi = false)
76 llvm::codeview::TypeIndex index;
85 llvm::codeview::TypeIndex index;
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.cpp 421 TypeIndex lldb_private::npdb::GetFieldListIndex(CVType cvt) {
445 TypeIndex lldb_private::npdb::LookThroughModifierRecord(CVType modifier) {
850 TypeIndex index = id.index;
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.h 105 llvm::codeview::TypeIndex type;
137 llvm::codeview::TypeIndex GetFieldListIndex(llvm::codeview::CVType cvt);
138 llvm::codeview::TypeIndex
tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp 406 if (proc.FunctionType == TypeIndex::None())
486 lldb::TypeSP SymbolFileNativePDB::CreateSimpleType(TypeIndex ti,
489 if (ti == TypeIndex::NullptrT()) {
749 TypeIndex ti;
855 lldb::TypeSP SymbolFileNativePDB::GetOrCreateType(TypeIndex ti) {
1269 std::vector<TypeIndex> matches = m_index->tpi().findRecordsByName(name);
1273 for (TypeIndex ti : matches) {
tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h 166 lldb::TypeSP CreateSimpleType(llvm::codeview::TypeIndex ti, CompilerType ct);
193 lldb::TypeSP GetOrCreateType(llvm::codeview::TypeIndex ti);
tools/lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.cpp 53 llvm::codeview::TypeIndex ti, llvm::codeview::MemberAccess access,
72 void UdtRecordCompleter::AddMethod(llvm::StringRef name, TypeIndex type_idx,
150 TypeIndex ti(data_member.Type);
188 TypeIndex method_list_idx = overloaded.MethodList;
tools/lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.h 71 llvm::codeview::TypeIndex ti, llvm::codeview::MemberAccess access,
73 void AddMethod(llvm::StringRef name, llvm::codeview::TypeIndex type_idx,
tools/llvm-pdbutil/BytesOutputStyle.cpp 309 TypeIndex TI(Id);
tools/llvm-pdbutil/DumpOutputStyle.cpp 705 for (Optional<TypeIndex> TI = Types.getFirst(); TI; TI = Types.getNext(*TI)) {
1294 ArrayRef<TypeIndex> Indices,
1295 std::map<TypeIndex, CVType> &DepSet) {
1296 SmallVector<TypeIndex, 4> DepList;
1297 for (const auto &I : Indices) {
1298 TypeIndex TI(I);
1317 uint32_t Width = NumDigits(TypeIndex::FirstNonSimpleIndex + NumTypeRecords);
1331 TpiStream &Stream, ArrayRef<TypeIndex> TiList,
1334 NumDigits(TypeIndex::FirstNonSimpleIndex + Stream.getNumTypeRecords());
1343 std::map<TypeIndex, CVType> DepSet;
1358 for (const auto &I : TiList) {
1359 TypeIndex TI(I);
1409 TypeIndex TI(TypeIndex::FirstNonSimpleIndex);
1409 TypeIndex TI(TypeIndex::FirstNonSimpleIndex);
1484 std::vector<TypeIndex> TiList(Indices.begin(), Indices.end());
1516 TypeIndex TI(A.second);
1622 for (Optional<TypeIndex> TI = Types.getFirst(); TI; TI = Types.getNext(*TI)) {
tools/llvm-pdbutil/LinePrinter.h 44 template <typename... Ts> void formatLine(const char *Fmt, Ts &&... Items) {
45 printLine(formatv(Fmt, std::forward<Ts>(Items)...));
47 template <typename... Ts> void format(const char *Fmt, Ts &&... Items) {
48 print(formatv(Fmt, std::forward<Ts>(Items)...));
tools/llvm-pdbutil/MinimalSymbolDumper.cpp 366 std::string MinimalSymbolDumper::typeOrIdIndex(codeview::TypeIndex TI,
379 std::string MinimalSymbolDumper::idIndex(codeview::TypeIndex TI) const {
383 std::string MinimalSymbolDumper::typeIndex(TypeIndex TI) const {
843 for (const auto &I : Caller.Indices) {
tools/llvm-pdbutil/MinimalSymbolDumper.h 49 std::string typeOrIdIndex(codeview::TypeIndex TI, bool IsType) const;
51 std::string typeIndex(codeview::TypeIndex TI) const;
52 std::string idIndex(codeview::TypeIndex TI) const;
tools/llvm-pdbutil/MinimalTypeDumper.cpp 33 TypeIndex CurrentTypeIndex) {
40 Expected<TypeIndex> ETI =
220 Error MinimalTypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {
279 StringRef MinimalTypeDumpVisitor::getTypeName(TypeIndex TI) const {
308 for (auto I : Indices)
323 for (auto I : Indices)
493 for (auto I : Indices)
tools/llvm-pdbutil/MinimalTypeDumper.h 38 codeview::TypeIndex Index) override;
54 StringRef getTypeName(codeview::TypeIndex TI) const;
63 codeview::TypeIndex CurrentTypeIndex;
tools/llvm-pdbutil/TypeReferenceTracker.cpp 25 for (Optional<TypeIndex> TI = Types.getFirst(); TI; TI = Types.getNext(*TI))
88 void TypeReferenceTracker::addOneTypeRef(TiRefKind RefKind, TypeIndex RefTI) {
114 ArrayRef<TypeIndex> TIs(
120 for (TypeIndex RefTI : TIs)
128 TypeIndex RefTI;
tools/llvm-pdbutil/TypeReferenceTracker.h 37 bool isTypeReferenced(codeview::TypeIndex TI) {
52 void addOneTypeRef(codeview::TiRefKind RefKind, codeview::TypeIndex RefTI);
60 SmallVector<std::pair<codeview::TiRefKind, codeview::TypeIndex>, 10>
tools/llvm-pdbutil/llvm-pdbutil.cpp 1302 SmallVector<TypeIndex, 128> TypeMap;
1303 SmallVector<TypeIndex, 128> IdMap;
tools/llvm-readobj/COFFDumper.cpp 127 StringRef getTypeName(TypeIndex Ty);
130 void printTypeIndex(StringRef FieldName, TypeIndex TI) {
1272 SmallVector<TypeIndex, 128> SourceToDest;
unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp 66 virtual Error visitTypeBegin(CVType &CVR, TypeIndex Index) {
81 std::vector<TypeIndex> Indices;
98 AR.ElementType = TypeIndex::Int32();
99 AR.IndexType = TypeIndex::UInt32();
130 TypeIndex TI = TypeIndex::fromArrayIndex(Index);
130 TypeIndex TI = TypeIndex::fromArrayIndex(Index);
140 TypeIndex TI = TypeIndex::fromArrayIndex(GlobalArrayIndex);
140 TypeIndex TI = TypeIndex::fromArrayIndex(GlobalArrayIndex);
162 std::vector<TypeIndex> Indices;
213 TypeIndex TI = TypeIndex::fromArrayIndex(I);
213 TypeIndex TI = TypeIndex::fromArrayIndex(I);
242 TypeIndex TI = TypeIndex::fromArrayIndex(I);
242 TypeIndex TI = TypeIndex::fromArrayIndex(I);
271 TypeIndex TI = TypeIndex::fromArrayIndex(I);
271 TypeIndex TI = TypeIndex::fromArrayIndex(I);
302 TypeIndex TI = TypeIndex::fromArrayIndex(I);
302 TypeIndex TI = TypeIndex::fromArrayIndex(I);
332 TypeIndex TI = TypeIndex::fromArrayIndex(I);
332 TypeIndex TI = TypeIndex::fromArrayIndex(I);
358 Class.DerivationList = TypeIndex::fromArrayIndex(0);
359 Class.FieldList = TypeIndex::fromArrayIndex(0);
360 Class.VTableShape = TypeIndex::fromArrayIndex(0);
361 TypeIndex IndexZero = Builder.writeLeafType(Class);
365 Modifier.ModifiedType = TypeIndex::fromArrayIndex(0);
367 TypeIndex IndexOne = Builder.writeLeafType(Modifier);
unittests/DebugInfo/CodeView/TypeHashingTest.cpp 17 static TypeIndex createPointerRecord(AppendingTypeTableBuilder &Builder,
18 TypeIndex TI) {
26 static TypeIndex createArgListRecord(AppendingTypeTableBuilder &Builder,
27 TypeIndex Q, TypeIndex R) {
27 TypeIndex Q, TypeIndex R) {
34 static TypeIndex createProcedureRecord(AppendingTypeTableBuilder &Builder,
35 uint32_t ParamCount, TypeIndex Return,
36 TypeIndex ArgList) {
47 TypeIndex TI) {
64 TypeIndex CharStar(SimpleTypeKind::SignedCharacter,
71 TypeIndex CharP(SimpleTypeKind::SignedCharacter, SimpleTypeMode::NearPointer);
72 TypeIndex IntP(SimpleTypeKind::Int32, SimpleTypeMode::NearPointer);
73 TypeIndex DoubleP(SimpleTypeKind::Float64, SimpleTypeMode::NearPointer);
78 TypeIndex CharPP[2];
79 TypeIndex IntPP[2];
80 TypeIndex IntPPP[2];
81 TypeIndex DoublePP[2];
82 TypeIndex Args[2];
83 TypeIndex Proc[2];
unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp 40 bool checkTypeReferences(uint32_t RecordIndex, Indices &&... TIs) const {
54 std::forward<Indices>(TIs)...);
91 TypeIndex TI) const {
97 ArrayRef<TypeIndex> Indices(
115 TypeIndex TI, Indices &&... Rest) const {
115 TypeIndex TI, Indices &&... Rest) const {
120 std::forward<Indices>(Rest)...);
177 std::vector<TypeIndex> Ids = {TypeIndex(6), TypeIndex(7), TypeIndex(8)};
181 std::vector<TypeIndex> Ids = {TypeIndex(9), TypeIndex(10), TypeIndex(11)};
196 std::vector<TypeIndex> Ids = {TypeIndex(23), TypeIndex(24), TypeIndex(25)};
214 const TypeIndex T1{40};
215 const TypeIndex T2{41};
216 const TypeIndex T3{42};
217 const TypeIndex T4{43};
247 const TypeIndex T1{50};
248 const TypeIndex T2{51};
249 const TypeIndex T3{52};
250 const TypeIndex T4{53};
539 GS.FunctionType = TypeIndex::Float32();
541 LS.FunctionType = TypeIndex::Float64();
549 DS.Type = TypeIndex::Float32();
556 Reg.Index = TypeIndex::UInt32();
584 P.StartTypeIndex = TypeIndex::FirstNonSimpleIndex;
usr/include/c++/7.4.0/bits/algorithmfwd.h 369 const _Tp&
370 max(const _Tp&, const _Tp&);
370 max(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 { };
136 inline _GLIBCXX17_CONSTEXPR _Tp*
137 addressof(_Tp& __r) noexcept
143 const _Tp* addressof(const _Tp&&) = delete;
143 const _Tp* addressof(const _Tp&&) = delete;
usr/include/c++/7.4.0/bits/ptr_traits.h 126 typedef _Tp* pointer;
128 typedef _Tp element_type;
141 pointer_to(__make_not_void<element_type>& __r) noexcept
141 pointer_to(__make_not_void<element_type>& __r) noexcept
usr/include/c++/7.4.0/bits/stl_algo.h 2040 const _Tp& __val, _Compare __comp)
2108 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_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_map.h 102 typedef _Key key_type;
104 typedef std::pair<const _Key, _Tp> value_type;
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>;
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)) { }
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
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)
522 constexpr pair<typename __decay_and_strip<_T1>::__type,
524 make_pair(_T1&& __x, _T2&& __y)
526 typedef typename __decay_and_strip<_T1>::__type __ds_type1;
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
usr/include/c++/7.4.0/bits/stl_tree.h 563 typedef _Key key_type;
758 static const _Key&
782 static const _Key&
894 const _Key& __k);
898 const _Key& __k) const;
902 const _Key& __k);
906 const _Key& __k) const;
usr/include/c++/7.4.0/bits/stl_uninitialized.h 288 _ForwardIterator __result, allocator<_Tp>&)
644 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);
1561 _Up*
1562 _M_data_ptr(_Up* __ptr) const _GLIBCXX_NOEXCEPT
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;
84 new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }
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 56 struct __is_empty_non_tuple : is_empty<_Tp> { };
125 constexpr _Head_base(const _Head& __h)
132 constexpr _Head_base(_UHead&& __h)
133 : _M_head_impl(std::forward<_UHead>(__h)) { }
159 static constexpr _Head&
162 static constexpr const _Head&
165 _Head _M_head_impl;
186 : public _Tuple_impl<_Idx + 1, _Tail...>,
187 private _Head_base<_Idx, _Head>
191 typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
192 typedef _Head_base<_Idx, _Head> _Base;
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)
227 _Base(std::forward<_Head>(_M_head(__in))) { }
230 constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
235 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
235 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
242 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
248 const _Head& __head, const _Tail&... __tail)
248 const _Head& __head, const _Tail&... __tail)
322 _M_head(*this) = std::forward<_UHead>
323 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
323 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
325 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
325 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
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;
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
508 return __not_<is_same<tuple<_Elements...>,
556 class tuple : public _Tuple_impl<0, _Elements...>
558 typedef _Tuple_impl<0, _Elements...> _Inherited;
598 _Elements...>;
608 constexpr tuple(const _Elements&... __elements)
619 explicit constexpr tuple(const _Elements&... __elements)
628 _Elements...>;
636 _Elements...>;
646 constexpr tuple(_UElements&&... __elements)
668 _Elements...>;
730 const _Elements&... __elements)
741 const _Elements&... __elements)
853 operator=(const tuple<_UElements...>& __in)
863 operator=(tuple<_UElements...>&& __in)
947 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)
1066 tuple(allocator_arg_t __tag, const _Alloc& __a)
1078 const _T1& __a1, const _T2& __a2)
1090 const _T1& __a1, const _T2& __a2)
1241 operator=(const pair<_U1, _U2>& __in)
1250 operator=(pair<_U1, _U2>&& __in)
1253 this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
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...>>&&
1448 make_tuple(_Elements&&... __args)
1588 constexpr tuple<_Elements&...>
1589 tie(_Elements&... __args) noexcept
1620 operator=(const _Tp&) const
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
594 : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
594 : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
595 is_null_pointer<_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;
1538 typedef decltype(__test<_From, _To>(0)) type;
1545 : public __is_convertible_helper<_From, _To>::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;
2171 { typedef _Iffalse type; };