|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/IR/Metadata.def 93 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICompositeType)
References
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/IR/DIBuilder.h 374 DICompositeType *createClassType(
392 DICompositeType *createStructType(
409 DICompositeType *createUnionType(DIScope *Scope, StringRef Name,
430 DICompositeType *createVariantPart(DIScope *Scope, StringRef Name,
482 DICompositeType *createArrayType(uint64_t Size, uint32_t AlignInBits,
490 DICompositeType *createVectorType(uint64_t Size, uint32_t AlignInBits,
505 DICompositeType *createEnumerationType(
532 DICompositeType *createForwardDecl(unsigned Tag, StringRef Name,
540 DICompositeType *createReplaceableCompositeType(
856 void replaceVTableHolder(DICompositeType *&T,
864 void replaceArrays(DICompositeType *&T, DINodeArray Elements,
include/llvm/IR/DebugInfoMetadata.h 915 static DICompositeType *
929 static DICompositeType *
981 static DICompositeType *
988 static DICompositeType *getODRTypeIfExists(LLVMContext &Context,
1000 static DICompositeType *
include/llvm/IR/Metadata.h 970 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
970 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
971 replaceWithPermanent(std::unique_ptr<T, TempMDNodeDeleter> N) {
972 return cast<T>(N.release()->replaceWithPermanentImpl());
982 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
982 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
983 replaceWithUniqued(std::unique_ptr<T, TempMDNodeDeleter> N) {
984 return cast<T>(N.release()->replaceWithUniquedImpl());
992 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
992 static typename std::enable_if<std::is_base_of<MDNode, T>::value, T *>::type
993 replaceWithDistinct(std::unique_ptr<T, TempMDNodeDeleter> N) {
994 return cast<T>(N.release()->replaceWithDistinctImpl());
1042 static void dispatchRecalculateHash(NodeTy *N, std::true_type) {
1046 static void dispatchRecalculateHash(NodeTy *, std::false_type) {}
1048 static void dispatchResetHash(NodeTy *N, std::true_type) {
1052 static void dispatchResetHash(NodeTy *, std::false_type) {}
1192 : public std::iterator<std::input_iterator_tag, T *, std::ptrdiff_t, void,
1193 T *> {
1200 T *operator*() const { return cast_or_null<T>(*I); }
1200 T *operator*() const { return cast_or_null<T>(*I); }
1230 const MDTupleTypedArrayWrapper<U> &Other,
1231 typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
1231 typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
1252 T *operator[](unsigned I) const { return cast_or_null<T>(N->getOperand(I)); }
1255 using iterator = TypedMDOperandIterator<T>;
include/llvm/IR/TrackingMDRef.h 111 explicit TypedTrackingMDRef(T *MD) : Ref(static_cast<Metadata *>(MD)) {}
126 T *get() const { return (T *)Ref.get(); }
127 operator T *() const { return get(); }
128 T *operator->() const { return get(); }
129 T &operator*() const { return *get(); }
135 void reset(T *MD) { Ref.reset(static_cast<Metadata *>(MD)); }
include/llvm/Support/Casting.h 58 return To::classof(&Val);
66 static inline bool doit(const From &) { return true; }
77 return isa_impl<To, From>::doit(Val);
92 return isa_impl<To, From>::doit(*Val);
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
106 return isa_impl<To, From>::doit(*Val);
122 return isa_impl_wrap<To, SimpleFrom,
132 return isa_impl_cl<To,FromTy>::doit(Val);
142 return isa_impl_wrap<X, const Y,
168 using ret_type = const To &; // Normal case, return Ty&
172 using ret_type = To *; // Pointer arg case, return Ty*
176 using ret_type = const To *; // Constant pointer arg case, return const Ty*
198 using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
218 static typename cast_retty<To, From>::ret_type doit(From &Val) {
219 return cast_convert_val<To, SimpleFrom,
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
228 typename cast_retty<To, FromTy>::ret_type Res2
248 typename cast_retty<X, const Y>::ret_type>::type
252 X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
258 return cast_convert_val<X, Y,
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
285 typename cast_retty<X, const Y>::ret_type>::type
290 return cast<X>(Val);
296 typename cast_retty<X, Y>::ret_type>::type
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
309 return cast<X>(Val);
337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
360 typename cast_retty<X, Y>::ret_type>::type
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
lib/Analysis/ModuleDebugInfoPrinter.cpp 121 if (auto *CT = dyn_cast<DICompositeType>(T)) {
lib/AsmParser/LLParser.cpp 4561 if (auto *CT = DICompositeType::buildODRType(
4561 if (auto *CT = DICompositeType::buildODRType(
lib/Bitcode/Reader/MetadataLoader.cpp 126 SmallDenseMap<MDString *, DICompositeType *, 1> Final;
127 SmallDenseMap<MDString *, DICompositeType *, 1> FwdDecls;
190 void addTypeRef(MDString &UUID, DICompositeType &CT);
280 if (DICompositeType *CT = OldTypeRefs.Final.lookup(Ref.first))
307 DICompositeType &CT) {
320 if (auto *CT = OldTypeRefs.Final.lookup(UUID))
1380 DICompositeType *CT = nullptr;
1382 CT = DICompositeType::buildODRType(
1395 MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT));
lib/Bitcode/Writer/BitcodeWriter.cpp 305 void writeDICompositeType(const DICompositeType *N,
1578 const DICompositeType *N, SmallVectorImpl<uint64_t> &Record,
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp 388 if (const auto *Class = dyn_cast_or_null<DICompositeType>(Scope)) {
388 if (const auto *Class = dyn_cast_or_null<DICompositeType>(Scope)) {
406 static bool isNonTrivial(const DICompositeType *DCTy) {
412 const DICompositeType *ClassTy = nullptr,
421 if (auto *ReturnDCTy = dyn_cast_or_null<DICompositeType>(ReturnTy)) {
437 const DICompositeType *Class) {
1496 return lowerTypeArray(cast<DICompositeType>(Ty));
1525 return lowerTypeEnum(cast<DICompositeType>(Ty));
1528 return lowerTypeClass(cast<DICompositeType>(Ty));
1530 return lowerTypeUnion(cast<DICompositeType>(Ty));
1557 TypeIndex CodeViewDebug::lowerTypeArray(const DICompositeType *Ty) {
1985 static TypeRecordKind getRecordKind(const DICompositeType *Ty) {
1995 static ClassOptions getCommonClassOptions(const DICompositeType *Ty) {
2008 if (ImmediateScope && isa<DICompositeType>(ImmediateScope))
2051 TypeIndex CodeViewDebug::lowerTypeEnum(const DICompositeType *Ty) {
2156 const DICompositeType *DCTy = dyn_cast<DICompositeType>(Ty);
2156 const DICompositeType *DCTy = dyn_cast<DICompositeType>(Ty);
2166 ClassInfo CodeViewDebug::collectClassInfo(const DICompositeType *Ty) {
2191 } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
2191 } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
2199 static bool shouldAlwaysEmitCompleteClassType(const DICompositeType *Ty) {
2206 TypeIndex CodeViewDebug::lowerTypeClass(const DICompositeType *Ty) {
2235 TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) {
2272 TypeIndex CodeViewDebug::lowerTypeUnion(const DICompositeType *Ty) {
2287 TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) {
2313 CodeViewDebug::lowerRecordFieldList(const DICompositeType *Ty) {
2534 const auto *CTy = cast<DICompositeType>(Ty);
2534 const auto *CTy = cast<DICompositeType>(Ty);
2585 SmallVector<const DICompositeType *, 4> TypesToEmit;
2588 for (const DICompositeType *RecordTy : TypesToEmit)
lib/CodeGen/AsmPrinter/CodeViewDebug.h 256 DenseMap<const DICompositeType *, codeview::TypeIndex> CompleteTypeIndices;
260 SmallVector<const DICompositeType *, 4> DeferredCompleteTypes;
387 const DICompositeType *Class);
399 codeview::TypeIndex lowerTypeArray(const DICompositeType *Ty);
414 codeview::TypeIndex lowerTypeEnum(const DICompositeType *Ty);
415 codeview::TypeIndex lowerTypeClass(const DICompositeType *Ty);
416 codeview::TypeIndex lowerTypeUnion(const DICompositeType *Ty);
425 codeview::TypeIndex lowerCompleteTypeClass(const DICompositeType *Ty);
426 codeview::TypeIndex lowerCompleteTypeUnion(const DICompositeType *Ty);
433 ClassInfo collectClassInfo(const DICompositeType *Ty);
439 lowerRecordFieldList(const DICompositeType *Ty);
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp 702 auto *Array = dyn_cast<DICompositeType>(Var->getType());
1278 void DwarfCompileUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) {
lib/CodeGen/AsmPrinter/DwarfCompileUnit.h 103 void finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) override;
lib/CodeGen/AsmPrinter/DwarfDebug.cpp 1011 for (auto *Ty : CUNode->getEnumTypes()) {
2878 const DICompositeType *CTy) {
2948 CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
lib/CodeGen/AsmPrinter/DwarfDebug.h 344 std::pair<std::unique_ptr<DwarfTypeUnit>, const DICompositeType *>, 1>
621 DIE &Die, const DICompositeType *CTy);
lib/CodeGen/AsmPrinter/DwarfUnit.cpp 463 if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
633 DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) {
643 constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
660 else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
711 if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
873 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
949 } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
1354 static bool hasVectorBeenPadded(const DICompositeType *CTy) {
1378 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1404 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1717 void DwarfTypeUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) {
lib/CodeGen/AsmPrinter/DwarfUnit.h 277 void constructTypeDIE(DIE &Buffer, const DICompositeType *CTy);
293 DIE *createTypeDIE(const DICompositeType *Ty);
313 void constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy);
314 void constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy);
332 virtual void finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) = 0;
351 void finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) override;
lib/IR/AsmWriter.cpp 1866 static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N,
lib/IR/DIBuilder.cpp 443 DICompositeType *DIBuilder::createClassType(
451 auto *R = DICompositeType::get(
451 auto *R = DICompositeType::get(
460 DICompositeType *DIBuilder::createStructType(
465 auto *R = DICompositeType::get(
465 auto *R = DICompositeType::get(
473 DICompositeType *DIBuilder::createUnionType(
477 auto *R = DICompositeType::get(
477 auto *R = DICompositeType::get(
485 DICompositeType *DIBuilder::createVariantPart(
489 auto *R = DICompositeType::get(
489 auto *R = DICompositeType::get(
503 DICompositeType *DIBuilder::createEnumerationType(
507 auto *CTy = DICompositeType::get(
507 auto *CTy = DICompositeType::get(
517 DICompositeType *DIBuilder::createArrayType(uint64_t Size,
520 auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
520 auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
527 DICompositeType *DIBuilder::createVectorType(uint64_t Size,
530 auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
530 auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
573 DICompositeType *
580 auto *RetTy = DICompositeType::get(
580 auto *RetTy = DICompositeType::get(
588 DICompositeType *DIBuilder::createReplaceableCompositeType(
592 auto *RetTy =
593 DICompositeType::getTemporary(
632 if (auto *CT =
633 dyn_cast_or_null<DICompositeType>(getNonCompileUnitScope(Context)))
980 void DIBuilder::replaceVTableHolder(DICompositeType *&T,
983 TypedTrackingMDRef<DICompositeType> N(T);
1000 void DIBuilder::replaceArrays(DICompositeType *&T, DINodeArray Elements,
1003 TypedTrackingMDRef<DICompositeType> N(T);
lib/IR/DebugInfo.cpp 86 for (auto *ET : CU->getEnumTypes())
133 if (auto *DCT = dyn_cast<DICompositeType>(DT)) {
133 if (auto *DCT = dyn_cast<DICompositeType>(DT)) {
lib/IR/DebugInfoMetadata.cpp 384 DICompositeType *DICompositeType::getImpl(
406 DICompositeType *DICompositeType::buildODRType(
415 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
417 return CT = DICompositeType::getDistinct(
441 DICompositeType *DICompositeType::getODRType(
450 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
452 CT = DICompositeType::getDistinct(
459 DICompositeType *DICompositeType::getODRTypeIfExists(LLVMContext &Context,
lib/IR/LLVMContextImpl.h 249 using KeyTy = MDNodeKeyImpl<NodeTy>;
251 static bool isSubsetEqual(const KeyTy &LHS, const NodeTy *RHS) {
255 static bool isSubsetEqual(const NodeTy *LHS, const NodeTy *RHS) {
255 static bool isSubsetEqual(const NodeTy *LHS, const NodeTy *RHS) {
453 if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
453 if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
485 auto *CT = dyn_cast_or_null<DICompositeType>(Scope);
525 MDNodeKeyImpl(const DICompositeType *N)
536 bool isKeyOf(const DICompositeType *RHS) const {
676 if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
676 if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
712 auto *CT = dyn_cast_or_null<DICompositeType>(Scope);
1139 using KeyTy = MDNodeKeyImpl<NodeTy>;
1140 using SubsetEqualTy = MDNodeSubsetEqualImpl<NodeTy>;
1142 static inline NodeTy *getEmptyKey() {
1143 return DenseMapInfo<NodeTy *>::getEmptyKey();
1146 static inline NodeTy *getTombstoneKey() {
1147 return DenseMapInfo<NodeTy *>::getTombstoneKey();
1152 static unsigned getHashValue(const NodeTy *N) {
1156 static bool isEqual(const KeyTy &LHS, const NodeTy *RHS) {
1162 static bool isEqual(const NodeTy *LHS, const NodeTy *RHS) {
1162 static bool isEqual(const NodeTy *LHS, const NodeTy *RHS) {
1283 Optional<DenseMap<const MDString *, DICompositeType *>> DITypeMap;
lib/IR/Metadata.cpp 761 static T *uniquifyImpl(T *N, DenseSet<T *, InfoT> &Store) {
761 static T *uniquifyImpl(T *N, DenseSet<T *, InfoT> &Store) {
761 static T *uniquifyImpl(T *N, DenseSet<T *, InfoT> &Store) {
762 if (T *U = getUniqued(Store, N))
778 static const bool value = sizeof(check<NodeTy>(nullptr)) == sizeof(Yes);
lib/IR/MetadataImpl.h 22 static T *getUniqued(DenseSet<T *, InfoT> &Store,
22 static T *getUniqued(DenseSet<T *, InfoT> &Store,
42 T *MDNode::storeImpl(T *N, StorageType Storage, StoreT &Store) {
42 T *MDNode::storeImpl(T *N, StorageType Storage, StoreT &Store) {
lib/IR/Verifier.cpp 164 template <class T> void Write(const MDTupleTypedArrayWrapper<T> &MD) {
964 void Verifier::visitDICompositeType(const DICompositeType &N) {
1064 auto *Enum = dyn_cast_or_null<DICompositeType>(Op);
1064 auto *Enum = dyn_cast_or_null<DICompositeType>(Op);
lib/Target/BPF/BPFAbstractMemberAccess.cpp 157 void GetStorageBitRange(DICompositeType *CTy, DIDerivedType *MemberTy,
160 uint32_t GetFieldInfo(uint32_t InfoKind, DICompositeType *CTy,
215 static uint32_t calcArraySize(const DICompositeType *CTy, uint32_t StartDim) {
370 const auto *PTy = dyn_cast<DICompositeType>(PType);
370 const auto *PTy = dyn_cast<DICompositeType>(PType);
371 const auto *CTy = dyn_cast<DICompositeType>(CType);
371 const auto *CTy = dyn_cast<DICompositeType>(CType);
394 return dyn_cast<DICompositeType>(stripQualifiers(Ty)) == CTy;
515 void BPFAbstractMemberAccess::GetStorageBitRange(DICompositeType *CTy,
543 DICompositeType *CTy,
602 const auto *CompTy = dyn_cast<DICompositeType>(BaseTy);
602 const auto *CompTy = dyn_cast<DICompositeType>(BaseTy);
750 if (const auto *CTy = dyn_cast<DICompositeType>(Ty)) {
750 if (const auto *CTy = dyn_cast<DICompositeType>(Ty)) {
764 CTy = dyn_cast<DICompositeType>(BaseTy);
776 auto *CTy = dyn_cast<DICompositeType>(BaseTy);
776 auto *CTy = dyn_cast<DICompositeType>(BaseTy);
826 auto *CTy = cast<DICompositeType>(stripQualifiers(cast<DIType>(MDN)));
826 auto *CTy = cast<DICompositeType>(stripQualifiers(cast<DIType>(MDN)));
lib/Target/BPF/BTFDebug.cpp 154 BTFTypeEnum::BTFTypeEnum(const DICompositeType *ETy, uint32_t VLen) : ETy(ETy) {
218 BTFTypeStruct::BTFTypeStruct(const DICompositeType *STy, bool IsStruct,
447 void BTFDebug::visitStructType(const DICompositeType *CTy, bool IsStruct,
474 void BTFDebug::visitArrayType(const DICompositeType *CTy, uint32_t &TypeId) {
513 void BTFDebug::visitEnumType(const DICompositeType *CTy, uint32_t &TypeId) {
525 void BTFDebug::visitFwdDeclType(const DICompositeType *CTy, bool IsUnion,
532 void BTFDebug::visitCompositeType(const DICompositeType *CTy,
561 if (const auto *CTy = dyn_cast<DICompositeType>(Base)) {
561 if (const auto *CTy = dyn_cast<DICompositeType>(Base)) {
610 else if (const auto *CTy = dyn_cast<DICompositeType>(Ty))
610 else if (const auto *CTy = dyn_cast<DICompositeType>(Ty))
630 const auto *CTy = dyn_cast<DICompositeType>(Ty);
630 const auto *CTy = dyn_cast<DICompositeType>(Ty);
lib/Target/BPF/BTFDebug.h 93 const DICompositeType *ETy;
97 BTFTypeEnum(const DICompositeType *ETy, uint32_t NumValues);
118 const DICompositeType *STy;
123 BTFTypeStruct(const DICompositeType *STy, bool IsStruct, bool HasBitField,
273 void visitFwdDeclType(const DICompositeType *CTy, bool IsUnion,
275 void visitCompositeType(const DICompositeType *CTy, uint32_t &TypeId);
276 void visitStructType(const DICompositeType *STy, bool IsStruct,
278 void visitArrayType(const DICompositeType *ATy, uint32_t &TypeId);
279 void visitEnumType(const DICompositeType *ETy, uint32_t &TypeId);
lib/Transforms/Utils/ValueMapper.cpp 540 auto *CT = dyn_cast<DICompositeType>(&N);
tools/clang/lib/CodeGen/Address.h 108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGDebugInfo.cpp 972 llvm::DICompositeType *
977 return cast<llvm::DICompositeType>(T);
987 llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
1086 auto *EltTy =
1410 llvm::DICompositeType *RecordTy) {
1973 llvm::DICompositeType *RecordTy) {
2243 llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty, DefUnit);
2460 llvm::DICompositeType *RealDecl = DBuilder.createStructType(
3083 llvm::DICompositeType *CGDebugInfo::getOrCreateLimitedType(const RecordType *Ty,
3087 auto *T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));
3087 auto *T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));
3096 llvm::DICompositeType *Res = CreateLimitedType(Ty);
3109 llvm::DICompositeType *CGDebugInfo::CreateLimitedType(const RecordType *Ty) {
3121 auto *T = cast_or_null<llvm::DICompositeType>(
3121 auto *T = cast_or_null<llvm::DICompositeType>(
3155 llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
3194 llvm::DICompositeType *RealDecl) {
3196 llvm::DICompositeType *ContainingType = nullptr;
3208 ContainingType = cast<llvm::DICompositeType>(
3443 cast<llvm::DICompositeType>(S));
3639 llvm::DICompositeType *InterfaceDecl =
3640 cast<llvm::DICompositeType>(It->second);
4352 auto *Ctxt = cast<llvm::DICompositeType>(getDeclContextDescriptor(D));
4352 auto *Ctxt = cast<llvm::DICompositeType>(getDeclContextDescriptor(D));
4684 llvm::DICompositeType *InterfaceDecl =
4685 cast<llvm::DICompositeType>(It->second);
tools/clang/lib/CodeGen/CGDebugInfo.h 68 llvm::DICompositeType *ObjTy = nullptr;
167 llvm::DICompositeType *CreateLimitedType(const RecordType *Ty);
169 llvm::DICompositeType *CT);
305 llvm::DICompositeType *RecordTy);
311 llvm::DICompositeType *RecordTy);
546 llvm::DICompositeType *getOrCreateRecordFwdDecl(const RecordType *,
586 llvm::DICompositeType *getOrCreateLimitedType(const RecordType *Ty,
unittests/IR/DebugTypeODRUniquingTest.cpp 39 auto &CT = *DICompositeType::getODRType(
39 auto &CT = *DICompositeType::getODRType(
71 auto &CT = *DICompositeType::buildODRType(
71 auto &CT = *DICompositeType::buildODRType(
108 auto &CT = *DICompositeType::buildODRType(
108 auto &CT = *DICompositeType::buildODRType(
unittests/IR/MetadataTest.cpp 115 return DICompositeType::getDistinct(
1397 auto *N = DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1397 auto *N = DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1517 auto *N = DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1517 auto *N = DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1540 auto *N = DICompositeType::get(
1540 auto *N = DICompositeType::get(
1589 auto *N = DICompositeType::get(
1589 auto *N = DICompositeType::get(
1595 auto *Same = DICompositeType::get(
1595 auto *Same = DICompositeType::get(
1599 auto *Other = DICompositeType::get(
1599 auto *Other = DICompositeType::get(
1603 auto *NoDisc = DICompositeType::get(
1603 auto *NoDisc = DICompositeType::get(
unittests/Transforms/Utils/CloningTest.cpp 507 auto *StructType = DICompositeType::getDistinct(
507 auto *StructType = DICompositeType::getDistinct(
usr/include/c++/7.4.0/bits/unique_ptr.h 122 using type = _Up*;
137 using pointer = typename _Ptr<_Tp, _Dp>::type;
161 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
163 __uniq_ptr_impl<_Tp, _Dp> _M_t;
166 using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
167 using element_type = _Tp;
252 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1645 { typedef _Tp& type; };
1650 : public __add_lvalue_reference_helper<_Tp>
1983 { typedef _Up type; };
utils/unittest/googletest/include/gtest/gtest-printers.h 407 T* p, ::std::ostream* os) {
416 if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {