|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
include/llvm/IR/DebugInfoMetadata.h 689 class DIBasicType : public DIType {
756 class DIDerivedType : public DIType {
890 class DICompositeType : public DIType {
1061 class DISubroutineType : public DIType {
Declarations
include/llvm/IR/Metadata.def 90 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIType)
lib/Target/BPF/BTFDebug.h 26 class DIType;
References
examples/Kaleidoscope/Chapter9/toy.cpp 94 DIType *DblTy;
98 DIType *getDoubleTy();
822 DIType *DebugInfo::getDoubleTy() {
844 DIType *DblTy = KSDbgInfo.getDoubleTy();
include/llvm/CodeGen/DebugHandlerBase.h 132 static uint64_t getBaseTypeSize(const DIType *Ty);
include/llvm/IR/DIBuilder.h 202 DIDerivedType *createQualifiedType(unsigned Tag, DIType *FromTy);
210 DIDerivedType *createPointerType(DIType *PointeeTy, uint64_t SizeInBits,
222 createMemberPointerType(DIType *PointeeTy, DIType *Class,
222 createMemberPointerType(DIType *PointeeTy, DIType *Class,
228 DIDerivedType *createReferenceType(unsigned Tag, DIType *RTy,
240 DIDerivedType *createTypedef(DIType *Ty, StringRef Name, DIFile *File,
244 DIDerivedType *createFriend(DIType *Ty, DIType *FriendTy);
244 DIDerivedType *createFriend(DIType *Ty, DIType *FriendTy);
254 DIDerivedType *createInheritance(DIType *Ty, DIType *BaseTy,
254 DIDerivedType *createInheritance(DIType *Ty, DIType *BaseTy,
273 DINode::DIFlags Flags, DIType *Ty);
294 DINode::DIFlags Flags, DIType *Ty);
309 uint64_t StorageOffsetInBits, DINode::DIFlags Flags, DIType *Ty);
323 DIType *Ty, DINode::DIFlags Flags,
341 DIType *Ty, MDNode *PropertyNode);
356 unsigned PropertyAttributes, DIType *Ty);
377 DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements,
378 DIType *VTableHolder = nullptr, MDNode *TemplateParms = nullptr,
395 DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang = 0,
396 DIType *VTableHolder = nullptr, StringRef UniqueIdentifier = "");
444 createTemplateTypeParameter(DIScope *Scope, StringRef Name, DIType *Ty);
454 DIType *Ty,
464 DIType *Ty,
474 DIType *Ty,
483 DIType *Ty, DINodeArray Subscripts);
491 DIType *Ty, DINodeArray Subscripts);
508 DIType *UnderlyingType, StringRef UniqueIdentifier = "", bool IsScoped = false);
525 static DIType *createArtificialType(DIType *Ty);
525 static DIType *createArtificialType(DIType *Ty);
529 static DIType *createObjectPointerType(DIType *Ty);
529 static DIType *createObjectPointerType(DIType *Ty);
584 unsigned LineNo, DIType *Ty, bool isLocalToUnit,
592 unsigned LineNo, DIType *Ty, bool isLocalToUnit, MDNode *Decl = nullptr,
605 unsigned LineNo, DIType *Ty, bool AlwaysPreserve = false,
630 DIFile *File, unsigned LineNo, DIType *Ty,
703 DIType *VTableHolder = nullptr,
857 DIType *VTableHolder);
876 NodeTy *replaceTemporary(TempMDNode &&N, NodeTy *Replacement) {
876 NodeTy *replaceTemporary(TempMDNode &&N, NodeTy *Replacement) {
878 return cast<NodeTy>(MDNode::replaceWithUniqued(std::move(N)));
include/llvm/IR/DebugInfo.h 87 void processType(DIType *DT);
92 bool addType(DIType *DT);
100 using type_iterator = SmallVectorImpl<DIType *>::const_iterator;
133 SmallVector<DIType *, 8> TYs;
include/llvm/IR/DebugInfoMetadata.h 79 DIType *operator[](unsigned I) const {
80 return cast_or_null<DIType>(N->getOperand(I));
83 class iterator : std::iterator<std::input_iterator_tag, DIType *,
84 std::ptrdiff_t, void, DIType *> {
91 DIType *operator*() const { return cast_or_null<DIType>(*I); }
91 DIType *operator*() const { return cast_or_null<DIType>(*I); }
618 return TempDIType(cast<DIType>(MDNode::clone().release()));
689 class DIBasicType : public DIType {
756 class DIDerivedType : public DIType {
775 unsigned Line, DIScope *Scope, DIType *BaseType, uint64_t SizeInBits,
823 DIType *getBaseType() const { return cast_or_null<DIType>(getRawBaseType()); }
823 DIType *getBaseType() const { return cast_or_null<DIType>(getRawBaseType()); }
843 DIType *getClassType() const {
845 return cast_or_null<DIType>(getExtraData());
890 class DICompositeType : public DIType {
917 unsigned Line, DIScope *Scope, DIType *BaseType, uint64_t SizeInBits,
919 DINodeArray Elements, unsigned RuntimeLang, DIType *VTableHolder,
1008 DIType *getBaseType() const { return cast_or_null<DIType>(getRawBaseType()); }
1008 DIType *getBaseType() const { return cast_or_null<DIType>(getRawBaseType()); }
1012 DIType *getVTableHolder() const {
1013 return cast_or_null<DIType>(getRawVTableHolder());
1044 void replaceVTableHolder(DIType *VTableHolder) {
1061 class DISubroutineType : public DIType {
1663 DISubroutineType *Type, unsigned ScopeLine, DIType *ContainingType,
1792 DIType *getContainingType() const {
1793 return cast_or_null<DIType>(getRawContainingType());
2138 DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
2138 DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
2160 DIType *Type, StorageType Storage,
2197 StringRef Name, DIType *Type,
2248 DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
2248 DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
2622 StringRef LinkageName, DIFile *File, unsigned Line, DIType *Type,
2766 DIType *Type, unsigned Arg, DIFlags Flags,
2918 DIType *Type, StorageType Storage, bool ShouldCreate = true) {
2958 DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
2958 DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
include/llvm/IR/Metadata.h 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());
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/Support/Casting.h 57 static inline bool doit(const From &Val) {
58 return To::classof(&Val);
66 static inline bool doit(const From &) { return true; }
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,
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
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
306 cast_or_null(Y *Val) {
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) {
342 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;
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
367 dyn_cast_or_null(Y *Val) {
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 101 for (const DIType *T : Finder.types()) {
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp 415 const DIType *ReturnTy = nullptr;
464 const DIType *ClassTy) {
1105 const DIType *DITy = std::get<2>(HeapAllocSite);
1436 static bool shouldEmitUdt(const DIType *T) {
1464 void CodeViewDebug::addToUDTs(const DIType *Ty) {
1492 TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
1492 TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
1558 const DIType *ElementType = Ty->getBaseType();
1804 const DIType *BaseTy = Ty;
1859 for (const DIType *ArgType : Ty->getTypeArray())
1887 const DIType *ClassTy,
2031 void CodeViewDebug::addUDTSrcLine(const DIType *Ty, TypeIndex TI) {
2112 std::vector<const DIType *> NestedTypes;
2140 const DIType *Ty = DDTy->getBaseType();
2430 for (const DIType *Nested : Info.NestedTypes) {
2458 TypeIndex CodeViewDebug::getTypeIndex(const DIType *Ty, const DIType *ClassTy) {
2458 TypeIndex CodeViewDebug::getTypeIndex(const DIType *Ty, const DIType *ClassTy) {
2501 TypeIndex CodeViewDebug::getTypeIndexForReferenceTo(const DIType *Ty) {
2510 TypeIndex CodeViewDebug::getCompleteTypeIndex(const DIType *Ty) {
2863 dyn_cast<DIType>(MD)));
2967 ArrayRef<std::pair<std::string, const DIType *>> UDTs) {
2969 const DIType *T = UDT.second;
3060 if (DIType *RT = dyn_cast<DIType>(Ty)) {
3060 if (DIType *RT = dyn_cast<DIType>(Ty)) {
lib/CodeGen/AsmPrinter/CodeViewDebug.h 151 std::vector<std::tuple<const MCSymbol *, const MCSymbol *, const DIType *>>
251 DenseMap<std::pair<const DINode *, const DIType *>, codeview::TypeIndex>
271 std::vector<std::pair<std::string, const DIType *>> LocalUDTs;
272 std::vector<std::pair<std::string, const DIType *>> GlobalUDTs;
314 emitDebugInfoForUDTs(ArrayRef<std::pair<std::string, const DIType *>> UDTs);
377 codeview::TypeIndex getTypeIndex(const DIType *Ty,
378 const DIType *ClassTy = nullptr);
384 codeview::TypeIndex getTypeIndexForReferenceTo(const DIType *Ty);
393 void addToUDTs(const DIType *Ty);
395 void addUDTSrcLine(const DIType *Ty, codeview::TypeIndex TI);
397 codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy);
397 codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy);
411 const DISubroutineType *Ty, const DIType *ClassTy, int ThisAdjustment,
423 codeview::TypeIndex getCompleteTypeIndex(const DIType *Ty);
444 const DIType *ClassTy = nullptr);
lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp 143 uint64_t DebugHandlerBase::getBaseTypeSize(const DIType *Ty) {
156 DIType *BaseType = DDTy->getBaseType();
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp 122 const DIType *GTy = GV->getType();
1013 else if (auto *T = dyn_cast<DIType>(Entity))
1013 else if (auto *T = dyn_cast<DIType>(Entity))
1144 void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die,
1152 void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty,
lib/CodeGen/AsmPrinter/DwarfCompileUnit.h 308 void addGlobalType(const DIType *Ty, const DIE &Die,
312 void addGlobalTypeUnitType(const DIType *Ty, const DIScope *Context);
lib/CodeGen/AsmPrinter/DwarfDebug.cpp 227 const DIType *DbgVariable::getType() const {
1014 CU.getOrCreateTypeDIE(cast<DIType>(Ty));
1019 if (DIType *RT = dyn_cast<DIType>(Ty))
1019 if (DIType *RT = dyn_cast<DIType>(Ty))
lib/CodeGen/AsmPrinter/DwarfDebug.h 219 const DIType *getType() const;
lib/CodeGen/AsmPrinter/DwarfUnit.cpp 200 return (isa<DIType>(D) ||
449 void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
462 static bool isUnsignedDIType(DwarfDebug *DD, const DIType *Ty) {
538 const DIType *Ty) {
543 const DIType *Ty) {
549 void DwarfUnit::addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty) {
560 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
615 addType(TT, cast<DIType>(Ty));
622 if (auto *T = dyn_cast<DIType>(Context))
650 const DIType *Ty) {
684 auto *Ty = cast<DIType>(TyNode);
708 const DIType *Ty, const DIE &TyDIE) {
725 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
795 const DIType *FromTy = DTy->getBaseType();
827 const DIType *Ty = Args[i];
967 if (auto *ContainingType = CTy->getVTableHolder())
1359 DIType *BaseTy = CTy->getBaseType();
1405 const DIType *DTy = CTy->getBaseType();
1454 if (DIType *Resolved = DT->getBaseType())
1572 const DIType *Ty = DT->getBaseType();
1688 void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
lib/CodeGen/AsmPrinter/DwarfUnit.h 110 virtual void addGlobalType(const DIType *Ty, const DIE &Die,
195 void addSourceLine(DIE &Die, const DIType *Ty);
199 void addConstantValue(DIE &Die, const MachineOperand &MO, const DIType *Ty);
200 void addConstantValue(DIE &Die, const ConstantInt *CI, const DIType *Ty);
201 void addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty);
203 void addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty);
223 void addType(DIE &Entity, const DIType *Ty,
234 DIE *createTypeDIE(const DIScope *Context, DIE &ContextDIE, const DIType *Ty);
336 void updateAcceleratorTables(const DIScope *Context, const DIType *Ty,
369 void addGlobalType(const DIType *Ty, const DIE &Die,
lib/IR/DIBuilder.cpp 267 DIDerivedType *DIBuilder::createQualifiedType(unsigned Tag, DIType *FromTy) {
273 DIType *PointeeTy,
285 DIDerivedType *DIBuilder::createMemberPointerType(DIType *PointeeTy,
286 DIType *Base,
296 unsigned Tag, DIType *RTy,
306 DIDerivedType *DIBuilder::createTypedef(DIType *Ty, StringRef Name,
314 DIDerivedType *DIBuilder::createFriend(DIType *Ty, DIType *FriendTy) {
314 DIDerivedType *DIBuilder::createFriend(DIType *Ty, DIType *FriendTy) {
321 DIDerivedType *DIBuilder::createInheritance(DIType *Ty, DIType *BaseTy,
321 DIDerivedType *DIBuilder::createInheritance(DIType *Ty, DIType *BaseTy,
338 DINode::DIFlags Flags, DIType *Ty) {
353 Constant *Discriminant, DINode::DIFlags Flags, DIType *Ty) {
363 DINode::DIFlags Flags, DIType *Ty) {
375 unsigned LineNumber, DIType *Ty,
389 DIType *Ty, MDNode *PropertyNode) {
399 unsigned PropertyAttributes, DIType *Ty) {
406 DIType *Ty) {
413 DIScope *Context, StringRef Name, DIType *Ty,
421 DIType *Ty, Constant *Val) {
429 DIType *Ty, StringRef Val) {
437 DIType *Ty, DINodeArray Val) {
446 DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements,
447 DIType *VTableHolder, MDNode *TemplateParams, StringRef UniqueIdentifier) {
463 DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang,
464 DIType *VTableHolder, StringRef UniqueIdentifier) {
506 DIType *UnderlyingType, StringRef UniqueIdentifier, bool IsScoped) {
518 uint32_t AlignInBits, DIType *Ty,
528 uint32_t AlignInBits, DIType *Ty,
542 static DIType *createTypeWithFlags(const DIType *Ty,
542 static DIType *createTypeWithFlags(const DIType *Ty,
548 DIType *DIBuilder::createArtificialType(DIType *Ty) {
548 DIType *DIBuilder::createArtificialType(DIType *Ty) {
555 DIType *DIBuilder::createObjectPointerType(DIType *Ty) {
555 DIType *DIBuilder::createObjectPointerType(DIType *Ty) {
615 Elts.push_back(cast<DIType>(Elements[i]));
641 unsigned LineNumber, DIType *Ty, bool isLocalToUnit, DIExpression *Expr,
658 unsigned LineNumber, DIType *Ty, bool isLocalToUnit, MDNode *Decl,
697 DIType *Ty, bool AlwaysPreserve,
707 unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags) {
788 DIType *VTableHolder, DINode::DIFlags Flags,
981 DIType *VTableHolder) {
lib/IR/DebugInfo.cpp 89 if (auto *T = dyn_cast<DIType>(RT))
89 if (auto *T = dyn_cast<DIType>(RT))
95 if (auto *T = dyn_cast<DIType>(Entity))
95 if (auto *T = dyn_cast<DIType>(Entity))
124 void DebugInfoFinder::processType(DIType *DT) {
129 for (DIType *Ref : ST->getTypeArray())
136 if (auto *T = dyn_cast<DIType>(D))
136 if (auto *T = dyn_cast<DIType>(D))
151 if (auto *Ty = dyn_cast<DIType>(Scope)) {
151 if (auto *Ty = dyn_cast<DIType>(Scope)) {
228 bool DebugInfoFinder::addType(DIType *DT) {
431 DIType *ContainingType =
432 cast_or_null<DIType>(map(MDS->getContainingType()));
709 template <typename DIT> DIT *unwrapDI(LLVMMetadataRef Ref) {
969 LineNumber, SizeInBits, AlignInBits, Elts, unwrapDI<DIType>(ClassTy)));
995 unwrapDI<DIType>(Ty), Subs));
1006 unwrapDI<DIType>(Ty), Subs));
1023 return wrap(unwrap(Builder)->createPointerType(unwrapDI<DIType>(PointeeTy),
1040 unwrapDI<DIType>(DerivedFrom), Elts, RunTimeLang,
1041 unwrapDI<DIType>(VTableHolder), {UniqueId, UniqueIdLen}));
1051 OffsetInBits, map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty)));
1068 unwrapDI<DIFile>(File), LineNumber, unwrapDI<DIType>(Type),
1083 map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Ty),
1098 PropertyAttributes, unwrapDI<DIType>(Ty)));
1104 return wrap(unwrap(Builder)->createObjectPointerType(unwrapDI<DIType>(Type)));
1113 unwrapDI<DIType>(Type), {Name, NameLen},
1124 unwrapDI<DIType>(Ty), unwrapDI<DIType>(BaseTy),
1124 unwrapDI<DIType>(Ty), unwrapDI<DIType>(BaseTy),
1158 unwrapDI<DIType>(Type)));
1165 unwrapDI<DIType>(Type)));
1181 unwrapDI<DIType>(PointeeType),
1182 unwrapDI<DIType>(ClassType), AlignInBits, SizeInBits,
1199 map_from_llvmDIFlags(Flags), unwrapDI<DIType>(Type)));
1216 map_from_llvmDIFlags(Flags), unwrapDI<DIType>(DerivedFrom),
1217 Elts, unwrapDI<DIType>(VTableHolder),
1225 return wrap(unwrap(Builder)->createArtificialType(unwrapDI<DIType>(Type)));
1229 StringRef Str = unwrap<DIType>(DType)->getName();
1235 return unwrapDI<DIType>(DType)->getSizeInBits();
1239 return unwrapDI<DIType>(DType)->getOffsetInBits();
1243 return unwrapDI<DIType>(DType)->getAlignInBits();
1247 return unwrapDI<DIType>(DType)->getLine();
1251 return map_to_llvmDIFlags(unwrapDI<DIType>(DType)->getFlags());
1292 unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1342 unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), LocalToUnit,
1395 LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
1405 LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
lib/IR/DebugInfoMetadata.cpp 213 if (auto *T = dyn_cast<DIType>(this))
237 if (auto *T = dyn_cast<DIType>(this))
793 if (auto *T = dyn_cast<DIType>(RawType))
lib/IR/Verifier.cpp 868 static bool isType(const Metadata *MD) { return !MD || isa<DIType>(MD); }
lib/Target/BPF/BPFAbstractMemberAccess.cpp 197 static DIType * stripQualifiers(DIType *Ty) {
197 static DIType * stripQualifiers(DIType *Ty) {
206 static const DIType * stripQualifiers(const DIType *Ty) {
206 static const DIType * stripQualifiers(const DIType *Ty) {
354 const DIType *PType = stripQualifiers(cast<DIType>(ParentType));
354 const DIType *PType = stripQualifiers(cast<DIType>(ParentType));
355 const DIType *CType = stripQualifiers(cast<DIType>(ChildType));
355 const DIType *CType = stripQualifiers(cast<DIType>(ChildType));
388 DIType *Ty;
392 Ty = dyn_cast<DIType>(PTy->getElements()[ParentAI]);
552 auto *EltTy = stripQualifiers(CTy->getBaseType());
570 auto *EltTy = stripQualifiers(CTy->getBaseType());
588 const DIType *BaseTy;
624 auto *EltTy = stripQualifiers(CTy->getBaseType());
655 auto *EltTy = stripQualifiers(CTy->getBaseType());
730 DIType *Ty = stripQualifiers(cast<DIType>(CInfo.Metadata));
730 DIType *Ty = stripQualifiers(cast<DIType>(CInfo.Metadata));
748 DIType *BaseTy = nullptr;
826 auto *CTy = cast<DICompositeType>(stripQualifiers(cast<DIType>(MDN)));
lib/Target/BPF/BTFDebug.cpp 79 const DIType *ResolvedType = DTy->getBaseType();
246 const auto *BaseTy = DDTy->getBaseType();
389 const DIType *Ty) {
477 const DIType *ElemType = CTy->getBaseType();
559 const DIType *Base = DTy->getBaseType();
598 void BTFDebug::visitTypeEntry(const DIType *Ty, uint32_t &TypeId,
618 void BTFDebug::visitTypeEntry(const DIType *Ty) {
623 void BTFDebug::visitMapDefType(const DIType *Ty, uint32_t &TypeId) {
931 unsigned BTFDebug::populateStructType(const DIType *Ty) {
941 const MCSymbol *ORSym, DIType *RootTy,
997 DIType *Ty = dyn_cast<DIType>(MDN);
997 DIType *Ty = dyn_cast<DIType>(MDN);
lib/Target/BPF/BTFDebug.h 244 std::unordered_map<const DIType *, uint32_t> DIToIdMap;
258 uint32_t addType(std::unique_ptr<BTFTypeBase> TypeEntry, const DIType *Ty);
265 void visitTypeEntry(const DIType *Ty);
266 void visitTypeEntry(const DIType *Ty, uint32_t &TypeId, bool CheckPointer,
282 void visitMapDefType(const DIType *Ty, uint32_t &TypeId);
298 DIType *RootTy, StringRef AccessPattern);
301 unsigned populateStructType(const DIType *Ty);
338 uint32_t getTypeId(const DIType *Ty) {
lib/Transforms/Utils/CloneFunction.cpp 199 for (DIType *Type : DIFinder.types())
tools/clang/lib/CodeGen/Address.h 108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGDebugInfo.cpp 632 llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
820 llvm::DIType *CGDebugInfo::CreateType(const ComplexType *Ty) {
830 llvm::DIType *CGDebugInfo::CreateQualifiedType(QualType Ty,
857 auto *FromTy = getOrCreateType(Qc.apply(CGM.getContext(), T), Unit);
864 llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty,
877 llvm::DIType *CGDebugInfo::CreateType(const PointerType *Ty,
976 if (llvm::DIType *T = getTypeOrNull(CGM.getContext().getRecordType(RD)))
1000 llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
1022 llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
1023 llvm::DIType *&Cache) {
1069 llvm::DIType *CGDebugInfo::CreateType(const BlockPointerType *Ty,
1110 llvm::DIType *CGDebugInfo::CreateType(const TemplateSpecializationType *Ty,
1113 llvm::DIType *Src = getOrCreateType(Ty->getAliasedType(), Unit);
1133 llvm::DIType *CGDebugInfo::CreateType(const TypedefType *Ty,
1135 llvm::DIType *Underlying =
1194 llvm::DIType *CGDebugInfo::CreateType(const FunctionType *Ty,
1244 llvm::DIType *CGDebugInfo::createBitFieldType(const FieldDecl *BitFieldDecl,
1251 llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);
1276 llvm::DIType *
1281 llvm::DIType *debugType = getOrCreateType(type, tunit);
1303 llvm::DIType *RecordTy) {
1321 llvm::DIType *FieldType = createFieldType(
1333 llvm::DIType *fieldType = createFieldType(
1343 CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy,
1349 llvm::DIType *VTy = getOrCreateType(Var->getType(), VUnit);
1374 SmallVectorImpl<llvm::Metadata *> &elements, llvm::DIType *RecordTy,
1383 llvm::DIType *FieldType;
1403 llvm::DIType *nestedType = getOrCreateType(Ty, getOrCreateFile(Loc));
1496 llvm::DIType *PointeeType = getOrCreateType(PointeeTy, Unit);
1497 llvm::DIType *ThisPtrType =
1506 llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);
1539 const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {
1566 llvm::DIType *ContainingType = nullptr;
1646 SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy) {
1684 llvm::DIType *RecordTy) {
1699 SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy,
1709 auto *BaseTy = getOrCreateType(BI.getType(), Unit);
1738 llvm::DIType *DTy = DBuilder.createInheritance(RecordTy, BaseTy, BaseOffset,
1756 llvm::DIType *TTy = getOrCreateType(TA.getAsType(), Unit);
1761 llvm::DIType *TTy = getOrCreateType(TA.getIntegralType(), Unit);
1769 llvm::DIType *TTy = getOrCreateType(T, Unit);
1806 llvm::DIType *TTy = getOrCreateType(T, Unit);
1840 llvm::DIType *TTy = getOrCreateType(T, Unit);
1893 llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
1902 llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements);
1908 llvm::DIType *vtbl_ptr_type = DBuilder.createPointerType(
1989 llvm::DIType *VPtrTy = nullptr;
2005 llvm::DIType *VTableType = DBuilder.createPointerType(
2021 llvm::DIType *VPtrMember =
2027 llvm::DIType *CGDebugInfo::getOrCreateRecordType(QualType RTy,
2030 llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
2034 llvm::DIType *CGDebugInfo::getOrCreateInterfaceType(QualType D,
2039 llvm::DIType *CGDebugInfo::getOrCreateStandaloneType(QualType D,
2043 llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc));
2070 if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())
2072 llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<EnumType>());
2145 if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
2147 llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<RecordType>());
2213 llvm::DIType *T = getTypeOrNull(Ty);
2218 llvm::DIType *CGDebugInfo::CreateType(const RecordType *Ty) {
2220 llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(QualType(Ty, 0)));
2220 llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(QualType(Ty, 0)));
2231 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) {
2289 llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectType *Ty,
2295 llvm::DIType *CGDebugInfo::CreateType(const ObjCTypeParamType *Ty,
2331 llvm::DIType *CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
2357 llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(
2444 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty,
2476 llvm::DIType *SClassTy =
2481 llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0, 0,
2522 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
2608 llvm::DIType *CGDebugInfo::CreateType(const VectorType *Ty,
2610 llvm::DIType *ElementTy = getOrCreateType(Ty->getElementType(), Unit);
2628 llvm::DIType *CGDebugInfo::CreateType(const ArrayType *Ty, llvm::DIFile *Unit) {
2691 llvm::DIType *CGDebugInfo::CreateType(const LValueReferenceType *Ty,
2697 llvm::DIType *CGDebugInfo::CreateType(const RValueReferenceType *Ty,
2703 llvm::DIType *CGDebugInfo::CreateType(const MemberPointerType *Ty,
2731 llvm::DIType *ClassType = getOrCreateType(QualType(Ty->getClass(), 0), U);
2746 llvm::DIType *CGDebugInfo::CreateType(const AtomicType *Ty, llvm::DIFile *U) {
2747 auto *FromTy = getOrCreateType(Ty->getValueType(), U);
2751 llvm::DIType *CGDebugInfo::CreateType(const PipeType *Ty, llvm::DIFile *U) {
2755 llvm::DIType *CGDebugInfo::CreateEnumType(const EnumType *Ty) {
2786 llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType(
2799 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) {
2827 llvm::DIType *ClassTy = getOrCreateType(ED->getIntegerType(), DefUnit);
2913 llvm::DIType *CGDebugInfo::getTypeOrNull(QualType Ty) {
2922 return cast<llvm::DIType>(V);
2945 llvm::DIType *CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile *Unit) {
2952 if (auto *T = getTypeOrNull(Ty))
2955 llvm::DIType *Res = CreateTypeNode(Ty, Unit);
2999 llvm::DIType *CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile *Unit) {
3217 llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit, QualType FType,
3219 llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
3222 llvm::DIType *Ty =
3887 llvm::DIType *WrappedTy = getOrCreateType(FType, Unit);
3892 llvm::DIType *FieldTy = DBuilder.createMemberType(
3920 llvm::DIType *Ty;
3991 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
4078 llvm::DIType *CGDebugInfo::CreateSelfType(const QualType &QualTy,
4079 llvm::DIType *Ty) {
4080 llvm::DIType *CachedTy = getTypeOrNull(QualTy);
4101 llvm::DIType *Ty;
4292 llvm::DIType *fieldType;
4318 llvm::DIType *type =
4362 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
4451 llvm::DIType *Ty = getOrCreateType(VD->getType(), Unit);
4468 llvm::DIType *EDTy =
4668 llvm::DIType *Ty = E.Type->getDecl()->getDefinition()
4699 auto *Ty = cast<llvm::DIType>(P.second);
4699 auto *Ty = cast<llvm::DIType>(P.second);
4707 cast<llvm::DIType>(It->second));
4733 DBuilder.retainType(cast<llvm::DIType>(MD));
4746 if (auto *DieTy = getOrCreateType(Ty, TheCU->getFile()))
tools/clang/lib/CodeGen/CGDebugInfo.h 66 llvm::DIType *VTablePtrType = nullptr;
67 llvm::DIType *ClassTy = nullptr;
69 llvm::DIType *SelTy = nullptr;
73 llvm::DIType *OCLSamplerDITy = nullptr;
74 llvm::DIType *OCLEventDITy = nullptr;
75 llvm::DIType *OCLClkEventDITy = nullptr;
76 llvm::DIType *OCLQueueDITy = nullptr;
77 llvm::DIType *OCLNDRangeDITy = nullptr;
78 llvm::DIType *OCLReserveIDDITy = nullptr;
94 llvm::DIType *Decl;
96 ObjCInterfaceCacheEntry(const ObjCInterfaceType *Type, llvm::DIType *Decl,
154 llvm::DIType *CreateType(const BuiltinType *Ty);
155 llvm::DIType *CreateType(const ComplexType *Ty);
156 llvm::DIType *CreateQualifiedType(QualType Ty, llvm::DIFile *Fg);
157 llvm::DIType *CreateType(const TypedefType *Ty, llvm::DIFile *Fg);
158 llvm::DIType *CreateType(const TemplateSpecializationType *Ty,
160 llvm::DIType *CreateType(const ObjCObjectPointerType *Ty, llvm::DIFile *F);
161 llvm::DIType *CreateType(const PointerType *Ty, llvm::DIFile *F);
162 llvm::DIType *CreateType(const BlockPointerType *Ty, llvm::DIFile *F);
163 llvm::DIType *CreateType(const FunctionType *Ty, llvm::DIFile *F);
165 llvm::DIType *CreateType(const RecordType *Tyg);
166 llvm::DIType *CreateTypeDefinition(const RecordType *Ty);
171 llvm::DIType *CreateType(const ObjCInterfaceType *Ty, llvm::DIFile *F);
172 llvm::DIType *CreateTypeDefinition(const ObjCInterfaceType *Ty,
175 llvm::DIType *CreateType(const ObjCObjectType *Ty, llvm::DIFile *F);
176 llvm::DIType *CreateType(const ObjCTypeParamType *Ty, llvm::DIFile *Unit);
178 llvm::DIType *CreateType(const VectorType *Ty, llvm::DIFile *F);
179 llvm::DIType *CreateType(const ArrayType *Ty, llvm::DIFile *F);
180 llvm::DIType *CreateType(const LValueReferenceType *Ty, llvm::DIFile *F);
181 llvm::DIType *CreateType(const RValueReferenceType *Ty, llvm::DIFile *Unit);
182 llvm::DIType *CreateType(const MemberPointerType *Ty, llvm::DIFile *F);
183 llvm::DIType *CreateType(const AtomicType *Ty, llvm::DIFile *F);
184 llvm::DIType *CreateType(const PipeType *Ty, llvm::DIFile *F);
186 llvm::DIType *CreateEnumType(const EnumType *Ty);
187 llvm::DIType *CreateTypeDefinition(const EnumType *Ty);
194 llvm::DIType *CreateSelfType(const QualType &QualTy, llvm::DIType *Ty);
194 llvm::DIType *CreateSelfType(const QualType &QualTy, llvm::DIType *Ty);
199 llvm::DIType *getTypeOrNull(const QualType);
212 llvm::DIType *getOrCreateVTablePtrType(llvm::DIFile *F);
216 llvm::DIType *CreatePointerLikeType(llvm::dwarf::Tag Tag, const Type *Ty,
218 llvm::DIType *getOrCreateStructPtrType(StringRef Name, llvm::DIType *&Cache);
218 llvm::DIType *getOrCreateStructPtrType(StringRef Name, llvm::DIType *&Cache);
224 llvm::DIType *RecordTy);
231 llvm::DIType *T);
238 llvm::DIType *RecordTy);
244 SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy,
269 llvm::DIType *createFieldType(StringRef name, QualType type,
275 llvm::DIType *createFieldType(StringRef name, QualType type,
285 llvm::DIType *createBitFieldType(const FieldDecl *BitFieldDecl,
293 llvm::DIType *RecordTy);
295 llvm::DIType *RecordTy,
300 llvm::DIType *RecordTy, const RecordDecl *RD);
485 llvm::DIType *getOrCreateRecordType(QualType Ty, SourceLocation L);
488 llvm::DIType *getOrCreateInterfaceType(QualType Ty, SourceLocation Loc);
491 llvm::DIType *getOrCreateStandaloneType(QualType Ty, SourceLocation Loc);
528 llvm::DIType *BlockByRefWrapper;
530 llvm::DIType *WrappedType;
573 llvm::DIType *getOrCreateType(QualType Ty, llvm::DIFile *Fg);
590 llvm::DIType *CreateTypeNode(QualType Ty, llvm::DIFile *Fg);
593 llvm::DIType *CreateMemberType(llvm::DIFile *Unit, QualType FType,
tools/clang/lib/CodeGen/CGExpr.cpp 3438 llvm::DIType *DbgInfo = nullptr;
3956 llvm::DIType *DbgInfo = CGF.getDebugInfo()->getOrCreateRecordType(
4001 llvm::DIType *DbgInfo = getDebugInfo()->getOrCreateRecordType(
4085 llvm::DIType *DbgInfo = getDebugInfo()->getOrCreateRecordType(
tools/opt/BreakpointPrinter.cpp 36 } else if (auto *TY = dyn_cast<DIType>(Context)) {
tools/opt/Debugify.cpp 75 DenseMap<uint64_t, DIType *> TypeCache;
78 DIType *&DTy = TypeCache[Size];
unittests/IR/MetadataTest.cpp 100 DIType *getBasicType(StringRef Name) {
103 DIType *getDerivedType() {
114 DIType *getCompositeType() {
1167 DIType *Type = getDerivedType();
1260 DIType *N = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "int", 32, 32,
1272 DIType *D =
1292 DIType *BaseType = getBasicType("basic");
1364 DIType *BaseType = getBasicType("basic");
1386 DIType *BaseType = getCompositeType();
1393 DIType *VTableHolder = getCompositeType();
1506 DIType *BaseType = getCompositeType();
1513 DIType *VTableHolder = getCompositeType();
1532 DIType *BaseType = getCompositeType();
1551 DIType *VTableHolder = getCompositeType();
1557 DIType *BasicType = getBasicType("basic");
1577 DIType *BaseType = getCompositeType();
1802 DIType *ContainingType = getCompositeType();
2083 DIType *Type = getBasicType("basic");
2105 DIType *Type = getBasicType("basic");
2137 DIType *Type = getDerivedType();
2224 DIType *Type = getDerivedType();
2259 DIType *Type = getDerivedType();
2406 DIType *Type = getBasicType("basic");
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)) {
utils/unittest/googletest/include/gtest/gtest.h 1475 T* rhs) {