36 #include "llvm/ADT/DenseSet.h" 37 #include "llvm/ADT/SmallVector.h" 38 #include "llvm/ADT/StringExtras.h" 39 #include "llvm/IR/Constants.h" 40 #include "llvm/IR/DataLayout.h" 41 #include "llvm/IR/DerivedTypes.h" 42 #include "llvm/IR/Instructions.h" 43 #include "llvm/IR/Intrinsics.h" 44 #include "llvm/IR/Metadata.h" 45 #include "llvm/IR/Module.h" 46 #include "llvm/Support/FileSystem.h" 47 #include "llvm/Support/MD5.h" 48 #include "llvm/Support/Path.h" 49 using namespace clang;
66 : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
67 DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),
68 DBuilder(CGM.getModule()) {
70 DebugPrefixMap[KV.first] = KV.second;
75 assert(LexicalBlockStack.empty() &&
76 "Region stack mismatch, stack not empty!");
82 init(TemporaryLocation);
89 init(TemporaryLocation, DefaultToEmpty);
93 bool DefaultToEmpty) {
100 OriginalLocation = CGF->
Builder.getCurrentDebugLocation();
102 if (OriginalLocation && !DI->CGM.getExpressionLocationsEnabled())
105 if (TemporaryLocation.
isValid()) {
106 DI->EmitLocation(CGF->
Builder, TemporaryLocation);
110 if (DefaultToEmpty) {
111 CGF->
Builder.SetCurrentDebugLocation(llvm::DebugLoc());
116 assert(!DI->LexicalBlockStack.empty());
117 CGF->
Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
118 0, 0, DI->LexicalBlockStack.back(), DI->getInlinedAt()));
132 OriginalLocation = CGF.
Builder.getCurrentDebugLocation();
134 CGF.
Builder.SetCurrentDebugLocation(std::move(Loc));
141 CGF->
Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
152 SavedLocation = DI.getLocation();
153 assert((DI.getInlinedAt() ==
154 CGF.
Builder.getCurrentDebugLocation()->getInlinedAt()) &&
155 "CGDebugInfo and IRBuilder are out of sync");
157 DI.EmitInlineFunctionStart(CGF.
Builder, InlinedFn);
165 DI.EmitLocation(CGF->
Builder, SavedLocation);
173 CurLoc = CGM.getContext().getSourceManager().getExpansionLoc(Loc);
178 if (LexicalBlockStack.empty())
182 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
184 if (PCLoc.isInvalid() ||
Scope->getFile() == getOrCreateFile(CurLoc))
187 if (
auto *LBF = dyn_cast<llvm::DILexicalBlockFile>(
Scope)) {
188 LexicalBlockStack.pop_back();
189 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlockFile(
190 LBF->getScope(), getOrCreateFile(CurLoc)));
191 }
else if (isa<llvm::DILexicalBlock>(
Scope) ||
192 isa<llvm::DISubprogram>(
Scope)) {
193 LexicalBlockStack.pop_back();
194 LexicalBlockStack.emplace_back(
195 DBuilder.createLexicalBlockFile(
Scope, getOrCreateFile(CurLoc)));
199 llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(
const Decl *D) {
200 llvm::DIScope *Mod = getParentModuleOrNull(D);
205 llvm::DIScope *CGDebugInfo::getContextDescriptor(
const Decl *Context,
210 auto I = RegionMap.find(Context);
211 if (I != RegionMap.end()) {
212 llvm::Metadata *
V = I->second;
213 return dyn_cast_or_null<llvm::DIScope>(
V);
217 if (
const auto *NSDecl = dyn_cast<NamespaceDecl>(Context))
218 return getOrCreateNamespace(NSDecl);
220 if (
const auto *RDecl = dyn_cast<RecordDecl>(Context))
221 if (!RDecl->isDependentType())
222 return getOrCreateType(CGM.getContext().getTypeDeclType(RDecl),
234 if (CGM.getCodeGenOpts().EmitCodeView)
239 PP.
remapPath = [
this](StringRef Path) {
return remapDIPath(Path); };
243 StringRef CGDebugInfo::getFunctionName(
const FunctionDecl *FD) {
244 assert(FD &&
"Invalid FunctionDecl!");
256 CGM.getCodeGenOpts().EmitCodeView;
258 if (!Info && FII && !UseQualifiedName)
262 llvm::raw_svector_ostream OS(NS);
263 if (!UseQualifiedName)
275 return internString(OS.str());
278 StringRef CGDebugInfo::getObjCMethodName(
const ObjCMethodDecl *OMD) {
280 llvm::raw_svector_ostream OS(MethodName);
283 if (
const auto *OID = dyn_cast<ObjCImplementationDecl>(DC)) {
284 OS << OID->getName();
285 }
else if (
const auto *OID = dyn_cast<ObjCInterfaceDecl>(DC)) {
286 OS << OID->getName();
287 }
else if (
const auto *OC = dyn_cast<ObjCCategoryDecl>(DC)) {
288 if (OC->IsClassExtension()) {
289 OS << OC->getClassInterface()->getName();
291 OS << OC->getIdentifier()->getNameStart() <<
'(' 292 << OC->getIdentifier()->getNameStart() <<
')';
294 }
else if (
const auto *OCD = dyn_cast<ObjCCategoryImplDecl>(DC)) {
295 OS << OCD->getClassInterface()->getName() <<
'(' << OCD->getName() <<
')';
296 }
else if (isa<ObjCProtocolDecl>(DC)) {
300 cast<ObjCObjectPointerType>(SelfDecl->getType())->getPointeeType();
306 return internString(OS.str());
309 StringRef CGDebugInfo::getSelectorName(
Selector S) {
313 StringRef CGDebugInfo::getClassName(
const RecordDecl *RD) {
314 if (isa<ClassTemplateSpecializationDecl>(RD)) {
316 llvm::raw_svector_ostream OS(Name);
321 return internString(Name);
327 return II->getName();
331 if (CGM.getCodeGenOpts().EmitCodeView) {
334 "Typedef should not be in another decl context!");
335 assert(D->getDeclName().getAsIdentifierInfo() &&
336 "Typedef was not named!");
337 return D->getDeclName().getAsIdentifierInfo()->getName();
340 if (CGM.getLangOpts().CPlusPlus) {
347 Name = DD->getName();
352 Name = TND->getName();
358 return internString(UnnamedType);
370 if (!CGM.getCodeGenOpts().EmitCodeView &&
371 CGM.getCodeGenOpts().DwarfVersion < 5)
376 const llvm::MemoryBuffer *MemBuffer = SM.
getBuffer(FID, &Invalid);
381 llvm::MD5::MD5Result Result;
383 Hash.update(MemBuffer->getBuffer());
386 Hash.stringifyResult(Result, Checksum);
387 return llvm::DIFile::CSK_MD5;
392 if (!CGM.getCodeGenOpts().EmbedSource)
395 bool SourceInvalid =
false;
407 return TheCU->getFile();
413 if (PLoc.
isInvalid() || FileName.empty())
415 return TheCU->getFile();
418 auto It = DIFileCache.find(FileName.data());
419 if (It != DIFileCache.end()) {
421 if (llvm::Metadata *
V = It->second)
422 return cast<llvm::DIFile>(
V);
431 computeChecksum(PLoc.
getFileID(), Checksum);
434 CSInfo.emplace(*CSKind, Checksum);
439 CGDebugInfo::createFile(StringRef FileName,
440 Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo,
444 std::string RemappedFile = remapDIPath(FileName);
445 std::string CurDir = remapDIPath(getCurrentDirname());
448 if (llvm::sys::path::is_absolute(RemappedFile)) {
451 auto FileIt = llvm::sys::path::begin(RemappedFile);
452 auto FileE = llvm::sys::path::end(RemappedFile);
453 auto CurDirIt = llvm::sys::path::begin(CurDir);
454 auto CurDirE = llvm::sys::path::end(CurDir);
455 for (; CurDirIt != CurDirE && *CurDirIt == *FileIt; ++CurDirIt, ++FileIt)
456 llvm::sys::path::append(DirBuf, *CurDirIt);
457 if (
std::distance(llvm::sys::path::begin(CurDir), CurDirIt) == 1) {
463 for (; FileIt != FileE; ++FileIt)
464 llvm::sys::path::append(FileBuf, *FileIt);
472 llvm::DIFile *F = DBuilder.createFile(File, Dir, CSInfo, Source);
473 DIFileCache[FileName.data()].reset(F);
478 for (
const auto &Entry : DebugPrefixMap)
479 if (Path.startswith(Entry.first))
480 return (Twine(Entry.second) + Path.substr(Entry.first.size())).str();
485 if (Loc.
isInvalid() && CurLoc.isInvalid())
492 unsigned CGDebugInfo::getColumnNumber(
SourceLocation Loc,
bool Force) {
494 if (!Force && !CGM.getCodeGenOpts().DebugColumnInfo)
498 if (Loc.
isInvalid() && CurLoc.isInvalid())
505 StringRef CGDebugInfo::getCurrentDirname() {
506 if (!CGM.getCodeGenOpts().DebugCompilationDir.empty())
507 return CGM.getCodeGenOpts().DebugCompilationDir;
509 if (!CWDName.empty())
512 llvm::sys::fs::current_path(CWD);
513 return CWDName = internString(CWD);
516 void CGDebugInfo::CreateCompileUnit() {
530 std::string MainFileName = CGM.getCodeGenOpts().MainFileName;
531 if (MainFileName.empty())
532 MainFileName =
"<stdin>";
538 std::string MainFileDir;
540 MainFileDir = remapDIPath(MainFile->getDir()->getName());
541 if (MainFileDir !=
".") {
543 llvm::sys::path::append(MainFileDirSS, MainFileName);
544 MainFileName = MainFileDirSS.str();
550 if (MainFile->getName() == MainFileName &&
552 MainFile->getName().rsplit(
'.').second)
554 MainFileName = CGM.getModule().getName().str();
559 llvm::dwarf::SourceLanguage LangTag;
563 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
565 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
566 }
else if (LO.ObjC) {
567 LangTag = llvm::dwarf::DW_LANG_ObjC;
568 }
else if (LO.RenderScript) {
569 LangTag = llvm::dwarf::DW_LANG_GOOGLE_RenderScript;
571 LangTag = llvm::dwarf::DW_LANG_C99;
573 LangTag = llvm::dwarf::DW_LANG_C89;
579 unsigned RuntimeVers = 0;
583 llvm::DICompileUnit::DebugEmissionKind EmissionKind;
587 EmissionKind = llvm::DICompileUnit::NoDebug;
590 EmissionKind = llvm::DICompileUnit::LineTablesOnly;
597 EmissionKind = llvm::DICompileUnit::FullDebug;
602 auto &CGOpts = CGM.getCodeGenOpts();
608 CSInfo.emplace(*CSKind, Checksum);
609 llvm::DIFile *CUFile = DBuilder.createFile(
610 remapDIPath(MainFileName), remapDIPath(getCurrentDirname()), CSInfo,
614 TheCU = DBuilder.createCompileUnit(
615 LangTag, CUFile, CGOpts.EmitVersionIdentMetadata ? Producer :
"",
616 LO.Optimize || CGOpts.PrepareForLTO || CGOpts.PrepareForThinLTO,
617 CGOpts.DwarfDebugFlags, RuntimeVers, CGOpts.SplitDwarfFile, EmissionKind,
618 DwoId, CGOpts.SplitDwarfInlining, CGOpts.DebugInfoForProfiling,
619 CGM.getTarget().getTriple().isNVPTX()
621 :
static_cast<llvm::DICompileUnit::DebugNameTableKind
>(
622 CGOpts.DebugNameTable),
623 CGOpts.DebugRangesBaseAddress);
626 llvm::DIType *CGDebugInfo::CreateType(
const BuiltinType *BT) {
630 #define BUILTIN_TYPE(Id, SingletonId) 631 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id: 632 #include "clang/AST/BuiltinTypes.def" 633 case BuiltinType::Dependent:
634 llvm_unreachable(
"Unexpected builtin type");
635 case BuiltinType::NullPtr:
636 return DBuilder.createNullPtrType();
637 case BuiltinType::Void:
639 case BuiltinType::ObjCClass:
642 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
643 "objc_class", TheCU, TheCU->getFile(), 0);
645 case BuiltinType::ObjCId: {
656 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
657 "objc_class", TheCU, TheCU->getFile(), 0);
659 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
661 auto *ISATy = DBuilder.createPointerType(ClassTy, Size);
663 ObjTy = DBuilder.createStructType(TheCU,
"objc_object", TheCU->getFile(), 0,
664 0, 0, llvm::DINode::FlagZero,
nullptr,
665 llvm::DINodeArray());
667 DBuilder.replaceArrays(
668 ObjTy, DBuilder.getOrCreateArray(&*DBuilder.createMemberType(
669 ObjTy,
"isa", TheCU->getFile(), 0, Size, 0, 0,
670 llvm::DINode::FlagZero, ISATy)));
673 case BuiltinType::ObjCSel: {
675 SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
676 "objc_selector", TheCU,
677 TheCU->getFile(), 0);
681 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 682 case BuiltinType::Id: \ 683 return getOrCreateStructPtrType("opencl_" #ImgType "_" #Suffix "_t", \ 685 #include "clang/Basic/OpenCLImageTypes.def" 686 case BuiltinType::OCLSampler:
687 return getOrCreateStructPtrType(
"opencl_sampler_t", OCLSamplerDITy);
688 case BuiltinType::OCLEvent:
689 return getOrCreateStructPtrType(
"opencl_event_t", OCLEventDITy);
690 case BuiltinType::OCLClkEvent:
691 return getOrCreateStructPtrType(
"opencl_clk_event_t", OCLClkEventDITy);
692 case BuiltinType::OCLQueue:
693 return getOrCreateStructPtrType(
"opencl_queue_t", OCLQueueDITy);
694 case BuiltinType::OCLReserveID:
695 return getOrCreateStructPtrType(
"opencl_reserve_id_t", OCLReserveIDDITy);
696 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ 697 case BuiltinType::Id: \ 698 return getOrCreateStructPtrType("opencl_" #ExtType, Id##Ty); 699 #include "clang/Basic/OpenCLExtensionTypes.def" 701 case BuiltinType::UChar:
702 case BuiltinType::Char_U:
703 Encoding = llvm::dwarf::DW_ATE_unsigned_char;
705 case BuiltinType::Char_S:
706 case BuiltinType::SChar:
707 Encoding = llvm::dwarf::DW_ATE_signed_char;
709 case BuiltinType::Char8:
710 case BuiltinType::Char16:
711 case BuiltinType::Char32:
712 Encoding = llvm::dwarf::DW_ATE_UTF;
714 case BuiltinType::UShort:
715 case BuiltinType::UInt:
716 case BuiltinType::UInt128:
717 case BuiltinType::ULong:
718 case BuiltinType::WChar_U:
719 case BuiltinType::ULongLong:
720 Encoding = llvm::dwarf::DW_ATE_unsigned;
722 case BuiltinType::Short:
723 case BuiltinType::Int:
724 case BuiltinType::Int128:
725 case BuiltinType::Long:
726 case BuiltinType::WChar_S:
727 case BuiltinType::LongLong:
728 Encoding = llvm::dwarf::DW_ATE_signed;
730 case BuiltinType::Bool:
731 Encoding = llvm::dwarf::DW_ATE_boolean;
733 case BuiltinType::Half:
734 case BuiltinType::Float:
735 case BuiltinType::LongDouble:
736 case BuiltinType::Float16:
737 case BuiltinType::Float128:
738 case BuiltinType::Double:
744 Encoding = llvm::dwarf::DW_ATE_float;
746 case BuiltinType::ShortAccum:
747 case BuiltinType::Accum:
748 case BuiltinType::LongAccum:
749 case BuiltinType::ShortFract:
750 case BuiltinType::Fract:
751 case BuiltinType::LongFract:
752 case BuiltinType::SatShortFract:
753 case BuiltinType::SatFract:
754 case BuiltinType::SatLongFract:
755 case BuiltinType::SatShortAccum:
756 case BuiltinType::SatAccum:
757 case BuiltinType::SatLongAccum:
758 Encoding = llvm::dwarf::DW_ATE_signed_fixed;
760 case BuiltinType::UShortAccum:
761 case BuiltinType::UAccum:
762 case BuiltinType::ULongAccum:
763 case BuiltinType::UShortFract:
764 case BuiltinType::UFract:
765 case BuiltinType::ULongFract:
766 case BuiltinType::SatUShortAccum:
767 case BuiltinType::SatUAccum:
768 case BuiltinType::SatULongAccum:
769 case BuiltinType::SatUShortFract:
770 case BuiltinType::SatUFract:
771 case BuiltinType::SatULongFract:
772 Encoding = llvm::dwarf::DW_ATE_unsigned_fixed;
777 case BuiltinType::Long:
780 case BuiltinType::LongLong:
781 BTName =
"long long int";
783 case BuiltinType::ULong:
784 BTName =
"long unsigned int";
786 case BuiltinType::ULongLong:
787 BTName =
"long long unsigned int";
790 BTName = BT->
getName(CGM.getLangOpts());
794 uint64_t Size = CGM.getContext().getTypeSize(BT);
795 return DBuilder.createBasicType(BTName, Size, Encoding);
798 llvm::DIType *CGDebugInfo::CreateType(
const ComplexType *Ty) {
800 llvm::dwarf::TypeKind
Encoding = llvm::dwarf::DW_ATE_complex_float;
802 Encoding = llvm::dwarf::DW_ATE_lo_user;
804 uint64_t Size = CGM.getContext().getTypeSize(Ty);
805 return DBuilder.createBasicType(
"complex", Size, Encoding);
808 llvm::DIType *CGDebugInfo::CreateQualifiedType(
QualType Ty,
809 llvm::DIFile *Unit) {
820 llvm::dwarf::Tag Tag;
822 Tag = llvm::dwarf::DW_TAG_const_type;
825 Tag = llvm::dwarf::DW_TAG_volatile_type;
828 Tag = llvm::dwarf::DW_TAG_restrict_type;
831 assert(Qc.
empty() &&
"Unknown type qualifier for debug info");
832 return getOrCreateType(
QualType(T, 0), Unit);
835 auto *FromTy = getOrCreateType(Qc.
apply(CGM.getContext(), T), Unit);
839 return DBuilder.createQualifiedType(Tag, FromTy);
843 llvm::DIFile *Unit) {
849 return getOrCreateType(CGM.getContext().getObjCIdType(), Unit);
851 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
855 llvm::DIType *CGDebugInfo::CreateType(
const PointerType *Ty,
856 llvm::DIFile *Unit) {
857 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
863 switch (TheCU->getSourceLanguage()) {
864 case llvm::dwarf::DW_LANG_C_plus_plus:
866 case llvm::dwarf::DW_LANG_ObjC_plus_plus:
867 return isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD);
895 llvm::DICompileUnit *TheCU) {
913 llvm::DICompileUnit *TheCU) {
919 if (
const auto *RD = dyn_cast<CXXRecordDecl>(TD))
921 if (RD->isDynamicClass() &&
927 llvm::raw_svector_ostream Out(Identifier);
934 llvm::dwarf::Tag Tag;
936 Tag = llvm::dwarf::DW_TAG_structure_type;
938 Tag = llvm::dwarf::DW_TAG_union_type;
943 Tag = llvm::dwarf::DW_TAG_class_type;
948 llvm::DICompositeType *
949 CGDebugInfo::getOrCreateRecordFwdDecl(
const RecordType *Ty,
950 llvm::DIScope *Ctx) {
952 if (llvm::DIType *T = getTypeOrNull(CGM.getContext().getRecordType(RD)))
953 return cast<llvm::DICompositeType>(T);
954 llvm::DIFile *DefUnit = getOrCreateFile(RD->
getLocation());
956 StringRef RDName = getClassName(RD);
963 llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
965 llvm::DINode::FlagFwdDecl, Identifier);
966 if (CGM.getCodeGenOpts().DebugFwdTemplateParams)
967 if (
auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
968 DBuilder.replaceArrays(RetTy, llvm::DINodeArray(),
969 CollectCXXTemplateParams(TSpecial, DefUnit));
970 ReplaceMap.emplace_back(
971 std::piecewise_construct, std::make_tuple(Ty),
972 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
976 llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
979 llvm::DIFile *Unit) {
983 unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(PointeeTy);
984 uint64_t Size = CGM.getTarget().getPointerWidth(AddressSpace);
987 CGM.getTarget().getDWARFAddressSpace(AddressSpace);
989 if (Tag == llvm::dwarf::DW_TAG_reference_type ||
990 Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)
991 return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit),
992 Size, Align, DWARFAddressSpace);
994 return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
995 Align, DWARFAddressSpace);
998 llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
999 llvm::DIType *&
Cache) {
1002 Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
1003 TheCU, TheCU->getFile(), 0);
1004 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
1005 Cache = DBuilder.createPointerType(Cache, Size);
1009 uint64_t CGDebugInfo::collectDefaultElementTypesForBlockPointer(
1010 const BlockPointerType *Ty, llvm::DIFile *Unit, llvm::DIDerivedType *DescTy,
1016 uint64_t FieldOffset = 0;
1021 if (CGM.getLangOpts().OpenCL) {
1022 FType = CGM.getContext().IntTy;
1023 EltTys.push_back(CreateMemberType(Unit, FType,
"__size", &FieldOffset));
1024 EltTys.push_back(CreateMemberType(Unit, FType,
"__align", &FieldOffset));
1026 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
1027 EltTys.push_back(CreateMemberType(Unit, FType,
"__isa", &FieldOffset));
1028 FType = CGM.getContext().IntTy;
1029 EltTys.push_back(CreateMemberType(Unit, FType,
"__flags", &FieldOffset));
1030 EltTys.push_back(CreateMemberType(Unit, FType,
"__reserved", &FieldOffset));
1032 EltTys.push_back(CreateMemberType(Unit, FType,
"__FuncPtr", &FieldOffset));
1033 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
1034 uint64_t FieldSize = CGM.getContext().getTypeSize(Ty);
1035 uint32_t FieldAlign = CGM.getContext().getTypeAlign(Ty);
1036 EltTys.push_back(DBuilder.createMemberType(
1037 Unit,
"__descriptor",
nullptr, LineNo, FieldSize, FieldAlign,
1038 FieldOffset, llvm::DINode::FlagZero, DescTy));
1039 FieldOffset += FieldSize;
1046 llvm::DIFile *Unit) {
1049 uint64_t FieldOffset;
1050 llvm::DINodeArray Elements;
1053 FType = CGM.getContext().UnsignedLongTy;
1054 EltTys.push_back(CreateMemberType(Unit, FType,
"reserved", &FieldOffset));
1055 EltTys.push_back(CreateMemberType(Unit, FType,
"Size", &FieldOffset));
1057 Elements = DBuilder.getOrCreateArray(EltTys);
1060 llvm::DINode::DIFlags Flags = llvm::DINode::FlagAppleBlock;
1063 DBuilder.createStructType(Unit,
"__block_descriptor",
nullptr, 0,
1064 FieldOffset, 0, Flags,
nullptr, Elements);
1067 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1069 auto *DescTy = DBuilder.createPointerType(EltTy, Size);
1071 FieldOffset = collectDefaultElementTypesForBlockPointer(Ty, Unit, DescTy,
1074 Elements = DBuilder.getOrCreateArray(EltTys);
1080 EltTy = DBuilder.createStructType(Unit,
"",
nullptr, 0, FieldOffset, 0,
1081 Flags,
nullptr, Elements);
1083 return DBuilder.createPointerType(EltTy, Size);
1087 llvm::DIFile *Unit) {
1093 ->getTemplatedDecl();
1095 if (AliasDecl->hasAttr<NoDebugAttr>())
1099 llvm::raw_svector_ostream OS(NS);
1104 return DBuilder.createTypedef(Src, OS.str(), getOrCreateFile(Loc),
1106 getDeclContextDescriptor(AliasDecl));
1109 llvm::DIType *CGDebugInfo::CreateType(
const TypedefType *Ty,
1110 llvm::DIFile *Unit) {
1111 llvm::DIType *Underlying =
1122 return DBuilder.createTypedef(Underlying, Ty->
getDecl()->
getName(),
1123 getOrCreateFile(Loc), getLineNumber(Loc),
1124 getDeclContextDescriptor(Ty->
getDecl()));
1134 return llvm::dwarf::DW_CC_BORLAND_stdcall;
1136 return llvm::dwarf::DW_CC_BORLAND_msfastcall;
1138 return llvm::dwarf::DW_CC_BORLAND_thiscall;
1140 return llvm::dwarf::DW_CC_LLVM_vectorcall;
1142 return llvm::dwarf::DW_CC_BORLAND_pascal;
1144 return llvm::dwarf::DW_CC_LLVM_Win64;
1146 return llvm::dwarf::DW_CC_LLVM_X86_64SysV;
1149 return llvm::dwarf::DW_CC_LLVM_AAPCS;
1151 return llvm::dwarf::DW_CC_LLVM_AAPCS_VFP;
1153 return llvm::dwarf::DW_CC_LLVM_IntelOclBicc;
1155 return llvm::dwarf::DW_CC_LLVM_SpirFunction;
1157 return llvm::dwarf::DW_CC_LLVM_OpenCLKernel;
1159 return llvm::dwarf::DW_CC_LLVM_Swift;
1161 return llvm::dwarf::DW_CC_LLVM_PreserveMost;
1163 return llvm::dwarf::DW_CC_LLVM_PreserveAll;
1165 return llvm::dwarf::DW_CC_LLVM_X86RegCall;
1170 llvm::DIType *CGDebugInfo::CreateType(
const FunctionType *Ty,
1171 llvm::DIFile *Unit) {
1175 EltTys.push_back(getOrCreateType(Ty->
getReturnType(), Unit));
1179 if (isa<FunctionNoProtoType>(Ty))
1180 EltTys.push_back(DBuilder.createUnspecifiedParameter());
1181 else if (
const auto *FPT = dyn_cast<FunctionProtoType>(Ty)) {
1182 for (
const QualType &ParamType : FPT->param_types())
1183 EltTys.push_back(getOrCreateType(ParamType, Unit));
1184 if (FPT->isVariadic())
1185 EltTys.push_back(DBuilder.createUnspecifiedParameter());
1188 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
1189 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
1204 if (Access == Default)
1205 return llvm::DINode::FlagZero;
1209 return llvm::DINode::FlagPrivate;
1211 return llvm::DINode::FlagProtected;
1213 return llvm::DINode::FlagPublic;
1215 return llvm::DINode::FlagZero;
1217 llvm_unreachable(
"unexpected access enumerator");
1220 llvm::DIType *CGDebugInfo::createBitFieldType(
const FieldDecl *BitFieldDecl,
1221 llvm::DIScope *RecordTy,
1223 StringRef Name = BitFieldDecl->
getName();
1226 llvm::DIFile *VUnit = getOrCreateFile(Loc);
1227 llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);
1230 llvm::DIFile *File = getOrCreateFile(Loc);
1231 unsigned Line = getLineNumber(Loc);
1234 CGM.getTypes().getCGRecordLayout(RD).getBitFieldInfo(BitFieldDecl);
1235 uint64_t SizeInBits = BitFieldInfo.
Size;
1236 assert(SizeInBits > 0 &&
"found named 0-width bitfield");
1237 uint64_t StorageOffsetInBits =
1243 if (CGM.getDataLayout().isBigEndian())
1245 uint64_t OffsetInBits = StorageOffsetInBits + Offset;
1247 return DBuilder.createBitFieldMemberType(
1248 RecordTy, Name, File, Line, SizeInBits, OffsetInBits, StorageOffsetInBits,
1255 uint32_t AlignInBits, llvm::DIFile *tunit,
1256 llvm::DIScope *scope,
const RecordDecl *RD) {
1257 llvm::DIType *debugType = getOrCreateType(type, tunit);
1260 llvm::DIFile *file = getOrCreateFile(loc);
1261 unsigned line = getLineNumber(loc);
1263 uint64_t SizeInBits = 0;
1264 auto Align = AlignInBits;
1266 TypeInfo TI = CGM.getContext().getTypeInfo(type);
1267 SizeInBits = TI.
Width;
1273 return DBuilder.createMemberType(scope,
name, file, line, SizeInBits, Align,
1274 offsetInBits, flags, debugType);
1277 void CGDebugInfo::CollectRecordLambdaFields(
1279 llvm::DIType *RecordTy) {
1283 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(CXXDecl);
1285 unsigned fieldno = 0;
1288 I != E; ++I, ++Field, ++fieldno) {
1292 assert(!Field->isBitField() &&
"lambdas don't have bitfield members!");
1294 StringRef VName = V->
getName();
1295 llvm::DIFile *VUnit = getOrCreateFile(Loc);
1297 llvm::DIType *FieldType = createFieldType(
1298 VName, Field->getType(), Loc, Field->getAccess(),
1299 layout.
getFieldOffset(fieldno), Align, VUnit, RecordTy, CXXDecl);
1300 elements.push_back(FieldType);
1307 llvm::DIFile *VUnit = getOrCreateFile(f->
getLocation());
1309 llvm::DIType *fieldType = createFieldType(
1313 elements.push_back(fieldType);
1318 llvm::DIDerivedType *
1319 CGDebugInfo::CreateRecordStaticField(
const VarDecl *Var, llvm::DIType *RecordTy,
1324 llvm::DIFile *VUnit = getOrCreateFile(Var->
getLocation());
1325 llvm::DIType *VTy = getOrCreateType(Var->
getType(), VUnit);
1327 unsigned LineNumber = getLineNumber(Var->
getLocation());
1328 StringRef VName = Var->
getName();
1329 llvm::Constant *C =
nullptr;
1334 C = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->
getInt());
1336 C = llvm::ConstantFP::get(CGM.getLLVMContext(), Value->
getFloat());
1342 llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
1343 RecordTy, VName, VUnit, LineNumber, VTy, Flags, C, Align);
1348 void CGDebugInfo::CollectRecordNormalField(
1349 const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit,
1359 llvm::DIType *FieldType;
1361 FieldType = createBitFieldType(field, RecordTy, RD);
1366 OffsetInBits, Align, tunit, RecordTy, RD);
1369 elements.push_back(FieldType);
1372 void CGDebugInfo::CollectRecordNestedType(
1374 QualType Ty = CGM.getContext().getTypeDeclType(TD);
1376 if (isa<InjectedClassNameType>(Ty))
1379 llvm::DIType *nestedType = getOrCreateType(Ty, getOrCreateFile(Loc));
1380 elements.push_back(nestedType);
1383 void CGDebugInfo::CollectRecordFields(
1384 const RecordDecl *record, llvm::DIFile *tunit,
1386 llvm::DICompositeType *RecordTy) {
1389 if (CXXDecl && CXXDecl->
isLambda())
1390 CollectRecordLambdaFields(CXXDecl, elements, RecordTy);
1392 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(record);
1395 unsigned fieldNo = 0;
1399 for (
const auto *I : record->
decls())
1400 if (
const auto *
V = dyn_cast<VarDecl>(I)) {
1401 if (
V->hasAttr<NoDebugAttr>())
1406 if (CGM.getCodeGenOpts().EmitCodeView &&
1407 isa<VarTemplateSpecializationDecl>(
V))
1410 if (isa<VarTemplatePartialSpecializationDecl>(
V))
1414 auto MI = StaticDataMemberCache.find(
V->getCanonicalDecl());
1415 if (MI != StaticDataMemberCache.end()) {
1416 assert(MI->second &&
1417 "Static data member declaration should still exist");
1418 elements.push_back(MI->second);
1420 auto Field = CreateRecordStaticField(
V, RecordTy, record);
1421 elements.push_back(Field);
1423 }
else if (
const auto *field = dyn_cast<FieldDecl>(I)) {
1424 CollectRecordNormalField(field, layout.
getFieldOffset(fieldNo), tunit,
1425 elements, RecordTy, record);
1429 }
else if (CGM.getCodeGenOpts().EmitCodeView) {
1432 if (
const auto *nestedType = dyn_cast<TypeDecl>(I))
1433 if (!nestedType->isImplicit() &&
1434 nestedType->getDeclContext() == record)
1435 CollectRecordNestedType(nestedType, elements);
1440 llvm::DISubroutineType *
1441 CGDebugInfo::getOrCreateMethodType(
const CXXMethodDecl *Method,
1442 llvm::DIFile *Unit) {
1445 return cast_or_null<llvm::DISubroutineType>(
1446 getOrCreateType(
QualType(Func, 0), Unit));
1447 return getOrCreateInstanceMethodType(Method->
getThisType(), Func, Unit);
1450 llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType(
1453 llvm::DITypeRefArray Args(
1454 cast<llvm::DISubroutineType>(getOrCreateType(
QualType(Func, 0), Unit))
1456 assert(Args.size() &&
"Invalid number of arguments!");
1461 Elts.push_back(Args[0]);
1465 if (isa<ClassTemplateSpecializationDecl>(RD)) {
1467 const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr);
1469 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
1470 uint64_t Size = CGM.getTarget().getPointerWidth(AS);
1472 llvm::DIType *PointeeType = getOrCreateType(PointeeTy, Unit);
1473 llvm::DIType *ThisPtrType =
1474 DBuilder.createPointerType(PointeeType, Size, Align);
1479 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1480 Elts.push_back(ThisPtrType);
1482 llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);
1484 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1485 Elts.push_back(ThisPtrType);
1489 for (
unsigned i = 1, e = Args.size();
i != e; ++
i)
1490 Elts.push_back(Args[
i]);
1492 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
1494 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1496 Flags |= llvm::DINode::FlagLValueReference;
1498 Flags |= llvm::DINode::FlagRValueReference;
1500 return DBuilder.createSubroutineType(EltTypeArray, Flags,
1507 if (
const auto *NRD = dyn_cast<CXXRecordDecl>(RD->
getDeclContext()))
1514 llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
1515 const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {
1517 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
1519 StringRef MethodName = getFunctionName(Method);
1520 llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit);
1524 StringRef MethodLinkageName;
1531 MethodLinkageName = CGM.getMangledName(Method);
1534 llvm::DIFile *MethodDefUnit =
nullptr;
1535 unsigned MethodLine = 0;
1537 MethodDefUnit = getOrCreateFile(Method->
getLocation());
1538 MethodLine = getLineNumber(Method->
getLocation());
1542 llvm::DIType *ContainingType =
nullptr;
1543 unsigned VIndex = 0;
1544 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1545 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
1550 SPFlags |= llvm::DISubprogram::SPFlagPureVirtual;
1552 SPFlags |= llvm::DISubprogram::SPFlagVirtual;
1554 if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1557 if (!isa<CXXDestructorDecl>(Method))
1558 VIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(Method);
1565 CGM.getMicrosoftVTableContext().getMethodVFTableLocation(GD);
1574 Flags |= llvm::DINode::FlagIntroducedVirtual;
1579 ThisAdjustment = CGM.getCXXABI()
1580 .getVirtualFunctionPrologueThisAdjustment(GD)
1583 ContainingType = RecordTy;
1587 Flags |= llvm::DINode::FlagStaticMember;
1589 Flags |= llvm::DINode::FlagArtificial;
1591 if (
const auto *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
1592 if (CXXC->isExplicit())
1593 Flags |= llvm::DINode::FlagExplicit;
1594 }
else if (
const auto *CXXC = dyn_cast<CXXConversionDecl>(Method)) {
1595 if (CXXC->isExplicit())
1596 Flags |= llvm::DINode::FlagExplicit;
1599 Flags |= llvm::DINode::FlagPrototyped;
1601 Flags |= llvm::DINode::FlagLValueReference;
1603 Flags |= llvm::DINode::FlagRValueReference;
1604 if (CGM.getLangOpts().Optimize)
1605 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
1607 llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
1608 llvm::DISubprogram *SP = DBuilder.createMethod(
1609 RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
1610 MethodTy, VIndex, ThisAdjustment, ContainingType, Flags, SPFlags,
1611 TParamsArray.get());
1618 void CGDebugInfo::CollectCXXMemberFunctions(
1625 for (
const auto *I : RD->
decls()) {
1650 EltTys.push_back(MI == SPCache.end()
1651 ? CreateCXXMemberFunction(Method, Unit, RecordTy)
1652 :
static_cast<llvm::Metadata *
>(MI->second));
1656 void CGDebugInfo::CollectCXXBases(
const CXXRecordDecl *RD, llvm::DIFile *Unit,
1658 llvm::DIType *RecordTy) {
1660 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->
bases(), SeenTypes,
1661 llvm::DINode::FlagZero);
1665 if (CGM.getCodeGenOpts().EmitCodeView) {
1666 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->
vbases(), SeenTypes,
1667 llvm::DINode::FlagIndirectVirtualBase);
1671 void CGDebugInfo::CollectCXXBasesAux(
1676 llvm::DINode::DIFlags StartingFlags) {
1678 for (
const auto &BI : Bases) {
1680 cast<CXXRecordDecl>(BI.getType()->getAs<
RecordType>()->getDecl());
1681 if (!SeenTypes.insert(
Base).second)
1683 auto *BaseTy = getOrCreateType(BI.getType(), Unit);
1684 llvm::DINode::DIFlags BFlags = StartingFlags;
1685 uint64_t BaseOffset;
1686 uint32_t VBPtrOffset = 0;
1688 if (BI.isVirtual()) {
1689 if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1692 BaseOffset = 0 - CGM.getItaniumVTableContext()
1693 .getVirtualBaseOffsetOffset(RD,
Base)
1699 4 * CGM.getMicrosoftVTableContext().getVBTableIndex(RD,
Base);
1700 VBPtrOffset = CGM.getContext()
1701 .getASTRecordLayout(RD)
1705 BFlags |= llvm::DINode::FlagVirtual;
1712 llvm::DIType *DTy = DBuilder.createInheritance(RecordTy, BaseTy, BaseOffset,
1713 VBPtrOffset, BFlags);
1714 EltTys.push_back(DTy);
1721 llvm::DIFile *Unit) {
1723 for (
unsigned i = 0, e = TAList.size();
i != e; ++
i) {
1730 llvm::DIType *TTy = getOrCreateType(TA.
getAsType(), Unit);
1731 TemplateParams.push_back(
1732 DBuilder.createTemplateTypeParameter(TheCU, Name, TTy));
1736 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1738 llvm::ConstantInt::get(CGM.getLLVMContext(), TA.
getAsIntegral())));
1743 llvm::DIType *TTy = getOrCreateType(T, Unit);
1744 llvm::Constant *
V =
nullptr;
1747 if (!CGM.getLangOpts().CUDA || CGM.getLangOpts().CUDAIsDevice ||
1748 !D->
hasAttr<CUDADeviceAttr>()) {
1752 if (
const auto *VD = dyn_cast<VarDecl>(D))
1753 V = CGM.GetAddrOfGlobalVar(VD);
1756 else if ((MD = dyn_cast<CXXMethodDecl>(D)) && MD->
isInstance())
1757 V = CGM.getCXXABI().EmitMemberFunctionPointer(MD);
1758 else if (
const auto *FD = dyn_cast<FunctionDecl>(D))
1759 V = CGM.GetAddrOfFunction(FD);
1762 else if (
const auto *MPT =
1763 dyn_cast<MemberPointerType>(T.
getTypePtr())) {
1767 uint64_t fieldOffset = CGM.getContext().getFieldOffset(D);
1769 CGM.getContext().toCharUnitsFromBits((int64_t)fieldOffset);
1770 V = CGM.getCXXABI().EmitMemberDataPointer(MPT, chars);
1772 V = V->stripPointerCasts();
1774 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1775 TheCU, Name, TTy, cast_or_null<llvm::Constant>(V)));
1779 llvm::DIType *TTy = getOrCreateType(T, Unit);
1780 llvm::Constant *
V =
nullptr;
1783 if (
const auto *MPT = dyn_cast<MemberPointerType>(T.
getTypePtr()))
1789 if (MPT->isMemberDataPointer())
1790 V = CGM.getCXXABI().EmitNullMemberPointer(MPT);
1792 V = llvm::ConstantInt::get(CGM.Int8Ty, 0);
1793 TemplateParams.push_back(
1794 DBuilder.createTemplateValueParameter(TheCU, Name, TTy, V));
1797 TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(
1798 TheCU, Name,
nullptr,
1802 TemplateParams.push_back(DBuilder.createTemplateParameterPack(
1803 TheCU, Name,
nullptr,
1810 T = CGM.getContext().getLValueReferenceType(T);
1812 assert(V &&
"Expression in template argument isn't constant");
1813 llvm::DIType *TTy = getOrCreateType(T, Unit);
1814 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1815 TheCU, Name, TTy, V->stripPointerCasts()));
1821 "These argument types shouldn't exist in concrete types");
1824 return DBuilder.getOrCreateArray(TemplateParams);
1828 CGDebugInfo::CollectFunctionTemplateParams(
const FunctionDecl *FD,
1829 llvm::DIFile *Unit) {
1835 return CollectTemplateParams(
1838 return llvm::DINodeArray();
1841 llvm::DINodeArray CGDebugInfo::CollectVarTemplateParams(
const VarDecl *VL,
1842 llvm::DIFile *Unit) {
1848 return llvm::DINodeArray();
1851 auto TA = TS->getTemplateArgs().
asArray();
1852 return CollectTemplateParams(TList, TA, Unit);
1855 llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(
1863 return CollectTemplateParams(TPList, TAList.
asArray(), Unit);
1866 llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
1868 return VTablePtrType;
1873 llvm::Metadata *STy = getOrCreateType(Context.
IntTy, Unit);
1874 llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);
1875 llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements);
1877 unsigned VtblPtrAddressSpace = CGM.getTarget().getVtblPtrAddressSpace();
1879 CGM.getTarget().getDWARFAddressSpace(VtblPtrAddressSpace);
1881 llvm::DIType *vtbl_ptr_type = DBuilder.createPointerType(
1882 SubTy, Size, 0, DWARFAddressSpace,
"__vtbl_ptr_type");
1883 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
1884 return VTablePtrType;
1887 StringRef CGDebugInfo::getVTableName(
const CXXRecordDecl *RD) {
1892 StringRef CGDebugInfo::getDynamicInitializerName(
const VarDecl *VD,
1894 llvm::Function *InitFn) {
1897 if (!CGM.getCodeGenOpts().EmitCodeView)
1898 return InitFn->getName();
1908 llvm::raw_svector_ostream OS(QualifiedGV);
1910 std::tie(Quals, GVName) = OS.str().rsplit(
"::");
1912 std::swap(Quals, GVName);
1916 llvm::raw_svector_ostream OS(InitName);
1918 OS << Quals <<
"::";
1922 llvm_unreachable(
"not an initializer");
1924 OS <<
"`dynamic initializer for '";
1927 OS <<
"`dynamic atexit destructor for '";
1934 if (
const auto *VTpl = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
1936 getPrintingPolicy());
1941 return internString(OS.str());
1944 void CGDebugInfo::CollectVTableInfo(
const CXXRecordDecl *RD, llvm::DIFile *Unit,
1946 llvm::DICompositeType *RecordTy) {
1962 llvm::DIType *VPtrTy =
nullptr;
1963 bool NeedVTableShape = CGM.getCodeGenOpts().EmitCodeView &&
1964 CGM.getTarget().getCXXABI().isMicrosoft();
1965 if (NeedVTableShape) {
1967 CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
1969 CGM.getMicrosoftVTableContext().getVFTableLayout(RD,
CharUnits::Zero());
1970 unsigned VSlotCount =
1972 unsigned VTableWidth = PtrWidth * VSlotCount;
1973 unsigned VtblPtrAddressSpace = CGM.getTarget().getVtblPtrAddressSpace();
1975 CGM.getTarget().getDWARFAddressSpace(VtblPtrAddressSpace);
1978 llvm::DIType *VTableType = DBuilder.createPointerType(
1979 nullptr, VTableWidth, 0, DWARFAddressSpace,
"__vtbl_ptr_type");
1980 EltTys.push_back(VTableType);
1983 VPtrTy = DBuilder.createPointerType(VTableType, PtrWidth);
1991 VPtrTy = getOrCreateVTablePtrType(Unit);
1993 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
1994 llvm::DIType *VPtrMember =
1995 DBuilder.createMemberType(Unit, getVTableName(RD), Unit, 0, Size, 0, 0,
1996 llvm::DINode::FlagArtificial, VPtrTy);
1997 EltTys.push_back(VPtrMember);
2003 llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
2009 return getOrCreateStandaloneType(D, Loc);
2015 assert(!D.
isNull() &&
"null type");
2016 llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc));
2017 assert(T &&
"could not create debug info for type");
2028 node = llvm::MDNode::get(CGM.getLLVMContext(), None);
2031 node = getOrCreateType(PointeeTy, getOrCreateFile(Loc));
2034 CI->setMetadata(
"heapallocsite", node);
2040 QualType Ty = CGM.getContext().getEnumType(ED);
2042 auto I = TypeCache.find(TyPtr);
2043 if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())
2045 llvm::DIType *Res = CreateTypeDefinition(Ty->
castAs<
EnumType>());
2046 assert(!Res->isForwardDecl());
2047 TypeCache[TyPtr].reset(Res);
2052 !CGM.getLangOpts().CPlusPlus)
2053 completeRequiredType(RD);
2058 if (RD->
hasAttr<DLLImportAttr>())
2061 if (MD->hasAttr<DLLImportAttr>())
2074 if (
auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) {
2083 bool Explicit =
false;
2084 if (
auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(CXXDecl))
2085 Explicit = TD->isExplicitInstantiationOrSpecialization();
2099 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
2100 if (CXXRD->isDynamicClass() &&
2101 CGM.getVTableLinkage(CXXRD) ==
2102 llvm::GlobalValue::AvailableExternallyLinkage &&
2115 QualType Ty = CGM.getContext().getRecordType(RD);
2117 auto I = TypeCache.find(TyPtr);
2118 if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
2121 assert(!Res->isForwardDecl());
2122 TypeCache[TyPtr].reset(Res);
2129 if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&
2130 !MD->getMemberSpecializationInfo()->isExplicitSpecialization())
2148 if (!LangOpts.CPlusPlus)
2170 if (
const auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
2171 Spec = SD->getSpecializationKind();
2185 QualType Ty = CGM.getContext().getRecordType(RD);
2186 llvm::DIType *T = getTypeOrNull(Ty);
2187 if (T && T->isForwardDecl())
2188 completeClassData(RD);
2191 llvm::DIType *CGDebugInfo::CreateType(
const RecordType *Ty) {
2193 llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(
QualType(Ty, 0)));
2195 CGM.getLangOpts())) {
2197 T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));
2201 return CreateTypeDefinition(Ty);
2204 llvm::DIType *CGDebugInfo::CreateTypeDefinition(
const RecordType *Ty) {
2208 llvm::DIFile *DefUnit = getOrCreateFile(RD->
getLocation());
2216 llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty, DefUnit);
2222 if (
const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
2223 CollectContainingType(CXXDecl, FwdDecl);
2226 LexicalBlockStack.emplace_back(&*FwdDecl);
2227 RegionMap[Ty->
getDecl()].reset(FwdDecl);
2239 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
2240 CollectVTableInfo(CXXDecl, DefUnit, EltTys, FwdDecl);
2244 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
2246 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
2248 LexicalBlockStack.pop_back();
2249 RegionMap.erase(Ty->
getDecl());
2251 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2252 DBuilder.replaceArrays(FwdDecl, Elements);
2254 if (FwdDecl->isTemporary())
2256 llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
2258 RegionMap[Ty->
getDecl()].reset(FwdDecl);
2263 llvm::DIFile *Unit) {
2269 llvm::DIFile *Unit) {
2274 return DBuilder.createTypedef(
2276 Ty->
getDecl()->
getName(), getOrCreateFile(Loc), getLineNumber(Loc),
2277 getDeclContextDescriptor(Ty->
getDecl()));
2305 llvm::DIFile *Unit) {
2315 return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
2317 getDeclContextDescriptor(ID), Unit, 0);
2320 llvm::DIFile *DefUnit = getOrCreateFile(ID->
getLocation());
2323 static_cast<llvm::dwarf::SourceLanguage
>(TheCU->getSourceLanguage());
2329 llvm::DIScope *Mod = getParentModuleOrNull(ID);
2330 llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(
2331 llvm::dwarf::DW_TAG_structure_type, ID->
getName(), Mod ? Mod : TheCU,
2332 DefUnit,
Line, RuntimeLang);
2333 ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit));
2337 return CreateTypeDefinition(Ty, Unit);
2342 bool CreateSkeletonCU) {
2347 auto ModRef = ModuleCache.find(M);
2348 if (ModRef != ModuleCache.end())
2349 return cast<llvm::DIModule>(ModRef->second);
2354 llvm::raw_svector_ostream OS(ConfigMacros);
2355 const auto &PPOpts = CGM.getPreprocessorOpts();
2358 for (
auto &M : PPOpts.Macros) {
2361 const std::string &Macro = M.first;
2362 bool Undef = M.second;
2363 OS <<
"\"-" << (Undef ?
'U' :
'D');
2364 for (
char c : Macro)
2379 bool IsRootModule = M ? !M->
Parent :
true;
2383 if (CreateSkeletonCU && IsRootModule && Mod.
getASTFile().empty() && M)
2384 assert(StringRef(M->
Name).startswith(CGM.getLangOpts().ModuleName) &&
2385 "clang module without ASTFile must be specified by -fmodule-name");
2387 if (CreateSkeletonCU && IsRootModule && !Mod.
getASTFile().empty()) {
2391 uint64_t Signature =
2395 llvm::DIBuilder DIB(CGM.getModule());
2396 DIB.createCompileUnit(TheCU->getSourceLanguage(),
2399 TheCU->getProducer(),
true, StringRef(), 0,
2400 Mod.
getASTFile(), llvm::DICompileUnit::FullDebug,
2406 IsRootModule ? nullptr
2407 : getOrCreateModuleRef(
2410 llvm::DIModule *DIMod =
2411 DBuilder.createModule(Parent, Mod.
getModuleName(), ConfigMacros,
2412 Mod.
getPath(), CGM.getHeaderSearchOpts().Sysroot);
2413 ModuleCache[M].reset(DIMod);
2418 llvm::DIFile *Unit) {
2420 llvm::DIFile *DefUnit = getOrCreateFile(ID->
getLocation());
2422 unsigned RuntimeLang = TheCU->getSourceLanguage();
2425 uint64_t Size = CGM.getContext().getTypeSize(Ty);
2428 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2430 Flags |= llvm::DINode::FlagObjcClassComplete;
2432 llvm::DIScope *Mod = getParentModuleOrNull(ID);
2433 llvm::DICompositeType *RealDecl = DBuilder.createStructType(
2434 Mod ? Mod : Unit, ID->
getName(), DefUnit,
Line, Size, Align, Flags,
2435 nullptr, llvm::DINodeArray(), RuntimeLang);
2441 LexicalBlockStack.emplace_back(RealDecl);
2442 RegionMap[Ty->
getDecl()].reset(RealDecl);
2449 llvm::DIType *SClassTy =
2450 getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit);
2454 llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0, 0,
2455 llvm::DINode::FlagZero);
2456 EltTys.push_back(InhTag);
2462 llvm::DIFile *PUnit = getOrCreateFile(Loc);
2463 unsigned PLine = getLineNumber(Loc);
2466 llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(
2467 PD->getName(), PUnit, PLine,
2469 : getSelectorName(PD->getGetterName()),
2471 : getSelectorName(PD->getSetterName()),
2472 PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit));
2473 EltTys.push_back(PropertyNode);
2476 llvm::SmallPtrSet<const IdentifierInfo *, 16> PropertySet;
2478 for (
auto *PD : ClassExt->properties()) {
2479 PropertySet.insert(PD->getIdentifier());
2485 if (!PropertySet.insert(PD->getIdentifier()).second)
2491 const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(ID);
2492 unsigned FieldNo = 0;
2494 Field = Field->getNextIvar(), ++FieldNo) {
2495 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
2499 StringRef FieldName = Field->getName();
2502 if (FieldName.empty())
2506 llvm::DIFile *FieldDefUnit = getOrCreateFile(Field->getLocation());
2507 unsigned FieldLine = getLineNumber(Field->getLocation());
2509 uint64_t FieldSize = 0;
2510 uint32_t FieldAlign = 0;
2512 if (!FType->isIncompleteArrayType()) {
2515 FieldSize = Field->isBitField()
2516 ? Field->getBitWidthValue(CGM.getContext())
2517 : CGM.getContext().getTypeSize(FType);
2521 uint64_t FieldOffset;
2522 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
2526 if (Field->isBitField()) {
2528 CGM.getObjCRuntime().ComputeBitfieldBitOffset(CGM, ID, Field);
2529 FieldOffset %= CGM.getContext().getCharWidth();
2537 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2539 Flags = llvm::DINode::FlagProtected;
2541 Flags = llvm::DINode::FlagPrivate;
2543 Flags = llvm::DINode::FlagPublic;
2545 llvm::MDNode *PropertyNode =
nullptr;
2548 ImpD->FindPropertyImplIvarDecl(Field->getIdentifier())) {
2551 llvm::DIFile *PUnit = getOrCreateFile(Loc);
2552 unsigned PLine = getLineNumber(Loc);
2555 PropertyNode = DBuilder.createObjCProperty(
2556 PD->getName(), PUnit, PLine,
2559 : getSelectorName(PD->getGetterName()),
2562 : getSelectorName(PD->getSetterName()),
2563 PD->getPropertyAttributes(),
2564 getOrCreateType(PD->getType(), PUnit));
2568 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine,
2569 FieldSize, FieldAlign, FieldOffset, Flags,
2570 FieldTy, PropertyNode);
2571 EltTys.push_back(FieldTy);
2574 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2575 DBuilder.replaceArrays(RealDecl, Elements);
2577 LexicalBlockStack.pop_back();
2581 llvm::DIType *CGDebugInfo::CreateType(
const VectorType *Ty,
2582 llvm::DIFile *Unit) {
2583 llvm::DIType *ElementTy = getOrCreateType(Ty->
getElementType(), Unit);
2586 llvm::Metadata *Subscript;
2588 auto SizeExpr = SizeExprCache.find(QTy);
2589 if (SizeExpr != SizeExprCache.end())
2590 Subscript = DBuilder.getOrCreateSubrange(0, SizeExpr->getSecond());
2592 Subscript = DBuilder.getOrCreateSubrange(0, Count ? Count : -1);
2593 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
2595 uint64_t Size = CGM.getContext().getTypeSize(Ty);
2598 return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
2601 llvm::DIType *CGDebugInfo::CreateType(
const ArrayType *Ty, llvm::DIFile *Unit) {
2606 if (
const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
2621 Size = CGM.getContext().getTypeSize(Ty);
2630 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
2639 if (
const auto *CAT = dyn_cast<ConstantArrayType>(Ty))
2640 Count = CAT->getSize().getZExtValue();
2641 else if (
const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
2642 if (
Expr *Size = VAT->getSizeExpr()) {
2644 if (Size->EvaluateAsInt(Result, CGM.getContext()))
2645 Count = Result.
Val.
getInt().getExtValue();
2649 auto SizeNode = SizeExprCache.find(EltTy);
2650 if (SizeNode != SizeExprCache.end())
2651 Subscripts.push_back(
2652 DBuilder.getOrCreateSubrange(0, SizeNode->getSecond()));
2654 Subscripts.push_back(DBuilder.getOrCreateSubrange(0, Count));
2658 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
2660 return DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
2665 llvm::DIFile *Unit) {
2666 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty,
2671 llvm::DIFile *Unit) {
2672 return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type, Ty,
2678 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2682 Size = CGM.getContext().getTypeSize(Ty);
2685 if (CGM.getTarget().getCXXABI().isMicrosoft()) {
2687 case MSInheritanceAttr::Keyword_single_inheritance:
2688 Flags |= llvm::DINode::FlagSingleInheritance;
2690 case MSInheritanceAttr::Keyword_multiple_inheritance:
2691 Flags |= llvm::DINode::FlagMultipleInheritance;
2693 case MSInheritanceAttr::Keyword_virtual_inheritance:
2694 Flags |= llvm::DINode::FlagVirtualInheritance;
2696 case MSInheritanceAttr::Keyword_unspecified_inheritance:
2704 return DBuilder.createMemberPointerType(
2710 return DBuilder.createMemberPointerType(
2711 getOrCreateInstanceMethodType(
2714 ClassType, Size, 0, Flags);
2717 llvm::DIType *CGDebugInfo::CreateType(
const AtomicType *Ty, llvm::DIFile *U) {
2719 return DBuilder.createQualifiedType(llvm::dwarf::DW_TAG_atomic_type, FromTy);
2722 llvm::DIType *CGDebugInfo::CreateType(
const PipeType *Ty, llvm::DIFile *U) {
2726 llvm::DIType *CGDebugInfo::CreateEnumType(
const EnumType *Ty) {
2738 bool isImportedFromModule =
2750 llvm::DIScope *EDContext = getDeclContextDescriptor(ED);
2751 llvm::DIFile *DefUnit = getOrCreateFile(ED->
getLocation());
2752 llvm::TempDIScope TmpContext(DBuilder.createReplaceableCompositeType(
2753 llvm::dwarf::DW_TAG_enumeration_type,
"", TheCU, DefUnit, 0));
2756 StringRef EDName = ED->
getName();
2757 llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType(
2758 llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit, Line,
2759 0, Size, Align, llvm::DINode::FlagFwdDecl, Identifier);
2761 ReplaceMap.emplace_back(
2762 std::piecewise_construct, std::make_tuple(Ty),
2763 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
2767 return CreateTypeDefinition(Ty);
2770 llvm::DIType *CGDebugInfo::CreateTypeDefinition(
const EnumType *Ty) {
2786 const auto &InitVal = Enum->getInitVal();
2787 auto Value = IsSigned ? InitVal.getSExtValue() : InitVal.getZExtValue();
2788 Enumerators.push_back(
2789 DBuilder.createEnumerator(Enum->getName(),
Value, !IsSigned));
2793 llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
2795 llvm::DIFile *DefUnit = getOrCreateFile(ED->
getLocation());
2797 llvm::DIScope *EnumContext = getDeclContextDescriptor(ED);
2798 llvm::DIType *ClassTy = getOrCreateType(ED->
getIntegerType(), DefUnit);
2799 return DBuilder.createEnumerationType(EnumContext, ED->
getName(), DefUnit,
2800 Line, Size, Align, EltArray, ClassTy,
2806 StringRef Name, StringRef
Value) {
2807 unsigned Line = LineLoc.
isInvalid() ? 0 : getLineNumber(LineLoc);
2808 return DBuilder.createMacro(Parent, Line, MType, Name, Value);
2814 llvm::DIFile *FName = getOrCreateFile(FileLoc);
2815 unsigned Line = LineLoc.
isInvalid() ? 0 : getLineNumber(LineLoc);
2816 return DBuilder.createTempMacroFile(Parent, Line, FName);
2826 Quals += InnerQuals;
2831 case Type::TemplateSpecialization: {
2832 const auto *Spec = cast<TemplateSpecializationType>(T);
2833 if (Spec->isTypeAlias())
2835 T = Spec->desugar();
2838 case Type::TypeOfExpr:
2839 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
2844 case Type::Decltype:
2847 case Type::UnaryTransform:
2850 case Type::Attributed:
2851 T = cast<AttributedType>(T)->getEquivalentType();
2853 case Type::Elaborated:
2854 T = cast<ElaboratedType>(T)->getNamedType();
2857 T = cast<ParenType>(T)->getInnerType();
2859 case Type::MacroQualified:
2862 case Type::SubstTemplateTypeParm:
2863 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
2866 case Type::DeducedTemplateSpecialization: {
2867 QualType DT = cast<DeducedType>(T)->getDeducedType();
2868 assert(!DT.
isNull() &&
"Undeduced types shouldn't reach here.");
2872 case Type::Adjusted:
2875 T = cast<AdjustedType>(T)->getAdjustedType();
2879 assert(T != LastT &&
"Type unwrapping failed to unwrap!");
2884 llvm::DIType *CGDebugInfo::getTypeOrNull(
QualType Ty) {
2890 if (It != TypeCache.end()) {
2892 if (llvm::Metadata *
V = It->second)
2893 return cast<llvm::DIType>(
V);
2903 completeUnusedClass(SD);
2910 completeClassData(&D);
2913 RetainedTypes.push_back(CGM.getContext().getRecordType(&D).getAsOpaquePtr());
2916 llvm::DIType *CGDebugInfo::getOrCreateType(
QualType Ty, llvm::DIFile *Unit) {
2923 if (
auto *T = getTypeOrNull(Ty))
2926 llvm::DIType *Res = CreateTypeNode(Ty, Unit);
2930 TypeCache[TyPtr].reset(Res);
2935 llvm::DIModule *CGDebugInfo::getParentModuleOrNull(
const Decl *D) {
2937 if (isa<RecordDecl>(D) && !cast<RecordDecl>(D)->
getDefinition())
2941 auto *Reader = CGM.getContext().getExternalSource();
2943 auto Info = Reader->getSourceDescriptor(Idx);
2945 return getOrCreateModuleRef(*Info,
true);
2946 }
else if (ClangModuleMap) {
2960 return getOrCreateModuleRef(Info,
false);
2963 return getOrCreateModuleRef(PCHDescriptor,
false);
2970 llvm::DIType *CGDebugInfo::CreateTypeNode(
QualType Ty, llvm::DIFile *Unit) {
2973 return CreateQualifiedType(Ty, Unit);
2977 #define TYPE(Class, Base) 2978 #define ABSTRACT_TYPE(Class, Base) 2979 #define NON_CANONICAL_TYPE(Class, Base) 2980 #define DEPENDENT_TYPE(Class, Base) case Type::Class: 2981 #include "clang/AST/TypeNodes.def" 2982 llvm_unreachable(
"Dependent types cannot show up in debug information");
2984 case Type::ExtVector:
2986 return CreateType(cast<VectorType>(Ty), Unit);
2987 case Type::ObjCObjectPointer:
2988 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
2989 case Type::ObjCObject:
2990 return CreateType(cast<ObjCObjectType>(Ty), Unit);
2991 case Type::ObjCTypeParam:
2992 return CreateType(cast<ObjCTypeParamType>(Ty), Unit);
2993 case Type::ObjCInterface:
2994 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
2996 return CreateType(cast<BuiltinType>(Ty));
2998 return CreateType(cast<ComplexType>(Ty));
3000 return CreateType(cast<PointerType>(Ty), Unit);
3001 case Type::BlockPointer:
3002 return CreateType(cast<BlockPointerType>(Ty), Unit);
3004 return CreateType(cast<TypedefType>(Ty), Unit);
3006 return CreateType(cast<RecordType>(Ty));
3008 return CreateEnumType(cast<EnumType>(Ty));
3009 case Type::FunctionProto:
3010 case Type::FunctionNoProto:
3011 return CreateType(cast<FunctionType>(Ty), Unit);
3012 case Type::ConstantArray:
3013 case Type::VariableArray:
3014 case Type::IncompleteArray:
3015 return CreateType(cast<ArrayType>(Ty), Unit);
3017 case Type::LValueReference:
3018 return CreateType(cast<LValueReferenceType>(Ty), Unit);
3019 case Type::RValueReference:
3020 return CreateType(cast<RValueReferenceType>(Ty), Unit);
3022 case Type::MemberPointer:
3023 return CreateType(cast<MemberPointerType>(Ty), Unit);
3026 return CreateType(cast<AtomicType>(Ty), Unit);
3029 return CreateType(cast<PipeType>(Ty), Unit);
3031 case Type::TemplateSpecialization:
3032 return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
3035 case Type::Attributed:
3036 case Type::Adjusted:
3038 case Type::DeducedTemplateSpecialization:
3039 case Type::Elaborated:
3041 case Type::MacroQualified:
3042 case Type::SubstTemplateTypeParm:
3043 case Type::TypeOfExpr:
3045 case Type::Decltype:
3046 case Type::UnaryTransform:
3047 case Type::PackExpansion:
3051 llvm_unreachable(
"type should have been unwrapped!");
3054 llvm::DICompositeType *CGDebugInfo::getOrCreateLimitedType(
const RecordType *Ty,
3055 llvm::DIFile *Unit) {
3058 auto *T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));
3063 if (T && !T->isForwardDecl())
3067 llvm::DICompositeType *Res = CreateLimitedType(Ty);
3072 DBuilder.replaceArrays(Res, T ? T->getElements() : llvm::DINodeArray());
3080 llvm::DICompositeType *CGDebugInfo::CreateLimitedType(
const RecordType *Ty) {
3084 llvm::DIFile *DefUnit = getOrCreateFile(RD->
getLocation());
3086 StringRef RDName = getClassName(RD);
3088 llvm::DIScope *RDContext = getDeclContextDescriptor(RD);
3092 auto *T = cast_or_null<llvm::DICompositeType>(
3093 getTypeOrNull(CGM.getContext().getRecordType(RD)));
3101 return getOrCreateRecordFwdDecl(Ty, RDContext);
3103 uint64_t Size = CGM.getContext().getTypeSize(Ty);
3109 auto Flags = llvm::DINode::FlagZero;
3110 if (
auto CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3112 Flags |= llvm::DINode::FlagTypePassByReference;
3114 Flags |= llvm::DINode::FlagTypePassByValue;
3117 if (!CXXRD->isTrivial())
3118 Flags |= llvm::DINode::FlagNonTrivial;
3121 llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
3122 getTagForRecord(RD), RDName, RDContext, DefUnit, Line, 0, Size, Align,
3127 switch (RealDecl->getTag()) {
3129 llvm_unreachable(
"invalid composite type tag");
3131 case llvm::dwarf::DW_TAG_array_type:
3132 case llvm::dwarf::DW_TAG_enumeration_type:
3137 if (Identifier.empty())
3141 case llvm::dwarf::DW_TAG_structure_type:
3142 case llvm::dwarf::DW_TAG_union_type:
3143 case llvm::dwarf::DW_TAG_class_type:
3146 llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
3150 RegionMap[Ty->
getDecl()].reset(RealDecl);
3153 if (
const auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
3154 DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),
3155 CollectCXXTemplateParams(TSpecial, DefUnit));
3159 void CGDebugInfo::CollectContainingType(
const CXXRecordDecl *RD,
3160 llvm::DICompositeType *RealDecl) {
3162 llvm::DICompositeType *ContainingType =
nullptr;
3167 const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase);
3174 ContainingType = cast<llvm::DICompositeType>(
3175 getOrCreateType(
QualType(PBase->getTypeForDecl(), 0),
3178 ContainingType = RealDecl;
3180 DBuilder.replaceVTableHolder(RealDecl, ContainingType);
3183 llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit,
QualType FType,
3184 StringRef Name, uint64_t *
Offset) {
3185 llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
3186 uint64_t FieldSize = CGM.getContext().getTypeSize(FType);
3189 DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize, FieldAlign,
3190 *Offset, llvm::DINode::FlagZero, FieldTy);
3191 *Offset += FieldSize;
3195 void CGDebugInfo::collectFunctionDeclProps(
GlobalDecl GD, llvm::DIFile *Unit,
3197 StringRef &LinkageName,
3198 llvm::DIScope *&FDContext,
3199 llvm::DINodeArray &TParamsArray,
3200 llvm::DINode::DIFlags &Flags) {
3201 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
3202 Name = getFunctionName(FD);
3205 LinkageName = CGM.getMangledName(GD);
3206 Flags |= llvm::DINode::FlagPrototyped;
3211 if (LinkageName == Name || (!CGM.getCodeGenOpts().EmitGcovArcs &&
3212 !CGM.getCodeGenOpts().EmitGcovNotes &&
3213 !CGM.getCodeGenOpts().DebugInfoForProfiling &&
3215 LinkageName = StringRef();
3220 FDContext = getOrCreateNamespace(NSDecl);
3223 llvm::DIScope *Mod = getParentModuleOrNull(RDecl);
3224 FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU);
3228 Flags |= llvm::DINode::FlagNoReturn;
3230 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
3234 void CGDebugInfo::collectVarDeclProps(
const VarDecl *VD, llvm::DIFile *&Unit,
3236 StringRef &Name, StringRef &LinkageName,
3237 llvm::MDTuple *&TemplateParameters,
3238 llvm::DIScope *&VDContext) {
3245 if (T->isIncompleteArrayType()) {
3247 llvm::APInt ConstVal(32, 1);
3248 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
3257 LinkageName = CGM.getMangledName(VD);
3258 if (LinkageName == Name)
3259 LinkageName = StringRef();
3261 if (isa<VarTemplateSpecializationDecl>(VD)) {
3262 llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VD, &*Unit);
3263 TemplateParameters = parameterNodes.get();
3265 TemplateParameters =
nullptr;
3283 DC = CGM.getContext().getTranslationUnitDecl();
3285 llvm::DIScope *Mod = getParentModuleOrNull(VD);
3286 VDContext = getContextDescriptor(cast<Decl>(DC), Mod ? Mod : TheCU);
3289 llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(
GlobalDecl GD,
3291 llvm::DINodeArray TParamsArray;
3292 StringRef Name, LinkageName;
3293 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3294 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
3296 llvm::DIFile *Unit = getOrCreateFile(Loc);
3297 llvm::DIScope *DContext = Unit;
3298 unsigned Line = getLineNumber(Loc);
3299 collectFunctionDeclProps(GD, Unit, Name, LinkageName, DContext, TParamsArray,
3307 ArgTypes.push_back(Parm->getType());
3309 QualType FnType = CGM.getContext().getFunctionType(
3312 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
3313 if (CGM.getLangOpts().Optimize)
3314 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
3317 Flags |= getCallSiteRelatedAttrs();
3318 SPFlags |= llvm::DISubprogram::SPFlagDefinition;
3319 return DBuilder.createFunction(
3320 DContext, Name, LinkageName, Unit, Line,
3321 getOrCreateFunctionType(GD.
getDecl(), FnType, Unit), 0, Flags, SPFlags,
3322 TParamsArray.get(), getFunctionDeclaration(FD));
3325 llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
3326 DContext, Name, LinkageName, Unit, Line,
3327 getOrCreateFunctionType(GD.
getDecl(), FnType, Unit), 0, Flags, SPFlags,
3328 TParamsArray.get(), getFunctionDeclaration(FD));
3330 FwdDeclReplaceMap.emplace_back(std::piecewise_construct,
3331 std::make_tuple(CanonDecl),
3332 std::make_tuple(SP));
3336 llvm::DISubprogram *CGDebugInfo::getFunctionForwardDeclaration(
GlobalDecl GD) {
3337 return getFunctionFwdDeclOrStub(GD,
false);
3340 llvm::DISubprogram *CGDebugInfo::getFunctionStub(
GlobalDecl GD) {
3341 return getFunctionFwdDeclOrStub(GD,
true);
3344 llvm::DIGlobalVariable *
3345 CGDebugInfo::getGlobalVariableForwardDeclaration(
const VarDecl *VD) {
3347 StringRef Name, LinkageName;
3349 llvm::DIFile *Unit = getOrCreateFile(Loc);
3350 llvm::DIScope *DContext = Unit;
3351 unsigned Line = getLineNumber(Loc);
3352 llvm::MDTuple *TemplateParameters =
nullptr;
3354 collectVarDeclProps(VD, Unit, Line, T, Name, LinkageName, TemplateParameters,
3357 auto *GV = DBuilder.createTempGlobalVariableFwdDecl(
3358 DContext, Name, LinkageName, Unit, Line, getOrCreateType(T, Unit),
3360 FwdDeclReplaceMap.emplace_back(
3361 std::piecewise_construct,
3363 std::make_tuple(static_cast<llvm::Metadata *>(GV)));
3367 llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(
const Decl *D) {
3372 if (
const auto *TD = dyn_cast<TypeDecl>(D))
3373 return getOrCreateType(CGM.getContext().getTypeDeclType(TD),
3377 if (I != DeclCache.end()) {
3379 if (
auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(N))
3380 return GVE->getVariable();
3381 return dyn_cast_or_null<llvm::DINode>(N);
3386 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
3387 return getFunctionForwardDeclaration(FD);
3388 else if (
const auto *VD = dyn_cast<VarDecl>(D))
3389 return getGlobalVariableForwardDeclaration(VD);
3394 llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(
const Decl *D) {
3403 auto *S = getDeclContextDescriptor(D);
3406 if (MI == SPCache.end()) {
3408 return CreateCXXMemberFunction(MD, getOrCreateFile(MD->getLocation()),
3409 cast<llvm::DICompositeType>(S));
3412 if (MI != SPCache.end()) {
3413 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3414 if (SP && !SP->isDefinition())
3418 for (
auto NextFD : FD->
redecls()) {
3419 auto MI = SPCache.find(NextFD->getCanonicalDecl());
3420 if (MI != SPCache.end()) {
3421 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3422 if (SP && !SP->isDefinition())
3431 llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(
const Decl *D,
3437 return DBuilder.createSubroutineType(DBuilder.getOrCreateTypeArray(None));
3439 if (
const auto *Method = dyn_cast<CXXMethodDecl>(D))
3440 return getOrCreateMethodType(Method, F);
3445 if (
const auto *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
3450 QualType ResultTy = OMethod->getReturnType();
3453 if (ResultTy == CGM.getContext().getObjCInstanceType())
3454 ResultTy = CGM.getContext().getPointerType(
3455 QualType(OMethod->getClassInterface()->getTypeForDecl(), 0));
3457 Elts.push_back(getOrCreateType(ResultTy, F));
3460 if (
auto *SelfDecl = OMethod->getSelfDecl())
3461 SelfDeclTy = SelfDecl->getType();
3462 else if (
auto *FPT = dyn_cast<FunctionProtoType>(FnType))
3463 if (FPT->getNumParams() > 1)
3464 SelfDeclTy = FPT->getParamType(0);
3465 if (!SelfDeclTy.
isNull())
3467 CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F)));
3469 Elts.push_back(DBuilder.createArtificialType(
3470 getOrCreateType(CGM.getContext().getObjCSelType(), F)));
3472 for (
const auto *PI : OMethod->parameters())
3473 Elts.push_back(getOrCreateType(PI->getType(), F));
3475 if (OMethod->isVariadic())
3476 Elts.push_back(DBuilder.createUnspecifiedParameter());
3478 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
3479 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
3485 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
3489 if (
const auto *FPT = dyn_cast<FunctionProtoType>(FnType))
3490 for (
QualType ParamType : FPT->param_types())
3491 EltTys.push_back(getOrCreateType(ParamType, F));
3492 EltTys.push_back(DBuilder.createUnspecifiedParameter());
3493 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
3494 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
3498 return cast<llvm::DISubroutineType>(getOrCreateType(FnType, F));
3503 llvm::Function *Fn,
bool CurFuncIsThunk,
3507 StringRef LinkageName;
3509 FnBeginRegionCount.push_back(LexicalBlockStack.size());
3512 bool HasDecl = (D !=
nullptr);
3514 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3515 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
3516 llvm::DIFile *Unit = getOrCreateFile(Loc);
3517 llvm::DIScope *FDContext = Unit;
3518 llvm::DINodeArray TParamsArray;
3521 LinkageName = Fn->getName();
3522 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
3525 if (FI != SPCache.end()) {
3526 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
3527 if (SP && SP->isDefinition()) {
3528 LexicalBlockStack.emplace_back(SP);
3529 RegionMap[D].reset(SP);
3533 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
3534 TParamsArray, Flags);
3535 }
else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
3536 Name = getObjCMethodName(OMD);
3537 Flags |= llvm::DINode::FlagPrototyped;
3538 }
else if (isa<VarDecl>(D) &&
3545 Name = Fn->getName();
3546 Flags |= llvm::DINode::FlagPrototyped;
3548 if (Name.startswith(
"\01"))
3549 Name = Name.substr(1);
3552 Flags |= llvm::DINode::FlagArtificial;
3558 Flags |= llvm::DINode::FlagThunk;
3560 if (Fn->hasLocalLinkage())
3561 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
3562 if (CGM.getLangOpts().Optimize)
3563 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
3565 llvm::DINode::DIFlags FlagsForDef = Flags | getCallSiteRelatedAttrs();
3566 llvm::DISubprogram::DISPFlags SPFlagsForDef =
3567 SPFlags | llvm::DISubprogram::SPFlagDefinition;
3569 unsigned LineNo = getLineNumber(Loc);
3570 unsigned ScopeLine = getLineNumber(ScopeLoc);
3577 llvm::DISubprogram *SP = DBuilder.createFunction(
3578 FDContext, Name, LinkageName, Unit, LineNo,
3579 getOrCreateFunctionType(D, FnType, Unit), ScopeLine, FlagsForDef,
3580 SPFlagsForDef, TParamsArray.get(), getFunctionDeclaration(D));
3581 Fn->setSubprogram(SP);
3585 if (HasDecl && isa<FunctionDecl>(D))
3592 if (CGM.getCodeGenOpts().EnableDebugEntryValues && HasDecl)
3593 if (
auto *FD = dyn_cast<FunctionDecl>(D))
3595 SPDefCache[FD].reset(SP);
3597 if (CGM.getCodeGenOpts().DwarfVersion >= 5) {
3600 if (
const auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
3603 auto It = TypeCache.find(QTy.getAsOpaquePtr());
3604 if (It != TypeCache.end()) {
3605 llvm::DICompositeType *InterfaceDecl =
3606 cast<llvm::DICompositeType>(It->second);
3607 llvm::DISubprogram *FD = DBuilder.createFunction(
3608 InterfaceDecl, Name, LinkageName, Unit, LineNo,
3609 getOrCreateFunctionType(D, FnType, Unit), ScopeLine, Flags, SPFlags,
3610 TParamsArray.get());
3611 DBuilder.finalizeSubprogram(FD);
3612 ObjCMethodCache[
ID].push_back(FD);
3618 LexicalBlockStack.emplace_back(SP);
3621 RegionMap[D].reset(SP);
3625 QualType FnType, llvm::Function *Fn) {
3627 StringRef LinkageName;
3633 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3634 llvm::DIFile *Unit = getOrCreateFile(Loc);
3635 bool IsDeclForCallSite = Fn ?
true :
false;
3636 llvm::DIScope *FDContext =
3637 IsDeclForCallSite ? Unit : getDeclContextDescriptor(D);
3638 llvm::DINodeArray TParamsArray;
3639 if (isa<FunctionDecl>(D)) {
3641 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
3642 TParamsArray, Flags);
3643 }
else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
3644 Name = getObjCMethodName(OMD);
3645 Flags |= llvm::DINode::FlagPrototyped;
3647 llvm_unreachable(
"not a function or ObjC method");
3649 if (!Name.empty() && Name[0] ==
'\01')
3650 Name = Name.substr(1);
3653 Flags |= llvm::DINode::FlagArtificial;
3658 unsigned LineNo = getLineNumber(Loc);
3659 unsigned ScopeLine = 0;
3660 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
3661 if (CGM.getLangOpts().Optimize)
3662 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
3664 llvm::DISubprogram *SP = DBuilder.createFunction(
3665 FDContext, Name, LinkageName, Unit, LineNo,
3666 getOrCreateFunctionType(D, FnType, Unit), ScopeLine, Flags, SPFlags,
3667 TParamsArray.get(), getFunctionDeclaration(D));
3669 if (IsDeclForCallSite)
3670 Fn->setSubprogram(SP);
3672 DBuilder.retainType(SP);
3678 auto &CGOpts = CGM.getCodeGenOpts();
3679 if (!CGOpts.EnableDebugEntryValues || !CGM.getLangOpts().Optimize ||
3684 auto *Func = CallOrInvoke->getCalledFunction();
3691 if (Func->getSubprogram())
3695 EmitFunctionDecl(CalleeDecl, CalleeDecl->
getLocation(), CalleeType, Func);
3699 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
3702 llvm::DISubprogram *SP =
nullptr;
3703 if (FI != SPCache.end())
3704 SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
3705 if (!SP || !SP->isDefinition())
3706 SP = getFunctionStub(GD);
3707 FnBeginRegionCount.push_back(LexicalBlockStack.size());
3708 LexicalBlockStack.emplace_back(SP);
3709 setInlinedAt(Builder.getCurrentDebugLocation());
3714 assert(CurInlinedAt &&
"unbalanced inline scope stack");
3715 EmitFunctionEnd(Builder,
nullptr);
3716 setInlinedAt(llvm::DebugLoc(CurInlinedAt).getInlinedAt());
3723 if (CurLoc.isInvalid() || CurLoc.isMacroID() || LexicalBlockStack.empty())
3726 llvm::MDNode *
Scope = LexicalBlockStack.back();
3727 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
3728 getLineNumber(CurLoc), getColumnNumber(CurLoc), Scope, CurInlinedAt));
3732 llvm::MDNode *Back =
nullptr;
3733 if (!LexicalBlockStack.empty())
3734 Back = LexicalBlockStack.back().get();
3735 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
3736 cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
3737 getColumnNumber(CurLoc)));
3740 void CGDebugInfo::AppendAddressSpaceXDeref(
3743 CGM.getTarget().getDWARFAddressSpace(AddressSpace);
3744 if (!DWARFAddressSpace)
3747 Expr.push_back(llvm::dwarf::DW_OP_constu);
3748 Expr.push_back(DWARFAddressSpace.getValue());
3749 Expr.push_back(llvm::dwarf::DW_OP_swap);
3750 Expr.push_back(llvm::dwarf::DW_OP_xderef);
3759 Builder.SetCurrentDebugLocation(
3760 llvm::DebugLoc::get(getLineNumber(Loc), getColumnNumber(Loc),
3761 LexicalBlockStack.back(), CurInlinedAt));
3767 CreateLexicalBlock(Loc);
3772 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
3780 LexicalBlockStack.pop_back();
3784 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
3785 unsigned RCount = FnBeginRegionCount.back();
3786 assert(RCount <= LexicalBlockStack.size() &&
"Region stack mismatch");
3789 while (LexicalBlockStack.size() != RCount) {
3792 LexicalBlockStack.pop_back();
3794 FnBeginRegionCount.pop_back();
3796 if (Fn && Fn->getSubprogram())
3797 DBuilder.finalizeSubprogram(Fn->getSubprogram());
3800 CGDebugInfo::BlockByRefType
3801 CGDebugInfo::EmitTypeForVarWithBlocksAttr(
const VarDecl *VD,
3802 uint64_t *XOffset) {
3805 uint64_t FieldSize, FieldOffset;
3806 uint32_t FieldAlign;
3808 llvm::DIFile *Unit = getOrCreateFile(VD->
getLocation());
3812 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
3813 EltTys.push_back(CreateMemberType(Unit, FType,
"__isa", &FieldOffset));
3814 EltTys.push_back(CreateMemberType(Unit, FType,
"__forwarding", &FieldOffset));
3815 FType = CGM.getContext().IntTy;
3816 EltTys.push_back(CreateMemberType(Unit, FType,
"__flags", &FieldOffset));
3817 EltTys.push_back(CreateMemberType(Unit, FType,
"__size", &FieldOffset));
3819 bool HasCopyAndDispose = CGM.getContext().BlockRequiresCopying(Type, VD);
3820 if (HasCopyAndDispose) {
3821 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
3823 CreateMemberType(Unit, FType,
"__copy_helper", &FieldOffset));
3825 CreateMemberType(Unit, FType,
"__destroy_helper", &FieldOffset));
3827 bool HasByrefExtendedLayout;
3829 if (CGM.getContext().getByrefLifetime(Type, Lifetime,
3830 HasByrefExtendedLayout) &&
3831 HasByrefExtendedLayout) {
3832 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
3834 CreateMemberType(Unit, FType,
"__byref_variable_layout", &FieldOffset));
3837 CharUnits Align = CGM.getContext().getDeclAlign(VD);
3838 if (Align > CGM.getContext().toCharUnitsFromBits(
3839 CGM.getTarget().getPointerAlign(0))) {
3841 CGM.getContext().toCharUnitsFromBits(FieldOffset);
3843 CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;
3846 llvm::APInt pad(32, NumPaddingBytes.
getQuantity());
3847 FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy,
3849 EltTys.push_back(CreateMemberType(Unit, FType,
"", &FieldOffset));
3854 llvm::DIType *WrappedTy = getOrCreateType(FType, Unit);
3855 FieldSize = CGM.getContext().getTypeSize(FType);
3856 FieldAlign = CGM.getContext().toBits(Align);
3858 *XOffset = FieldOffset;
3859 llvm::DIType *FieldTy = DBuilder.createMemberType(
3860 Unit, VD->
getName(), Unit, 0, FieldSize, FieldAlign, FieldOffset,
3861 llvm::DINode::FlagZero, WrappedTy);
3862 EltTys.push_back(FieldTy);
3863 FieldOffset += FieldSize;
3865 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
3866 return {DBuilder.createStructType(Unit,
"", Unit, 0, FieldOffset, 0,
3867 llvm::DINode::FlagZero,
nullptr, Elements),
3871 llvm::DILocalVariable *CGDebugInfo::EmitDeclare(
const VarDecl *VD,
3875 const bool UsePointerValue) {
3877 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
3878 if (VD->
hasAttr<NoDebugAttr>())
3884 llvm::DIFile *Unit =
nullptr;
3888 uint64_t XOffset = 0;
3889 if (VD->
hasAttr<BlocksAttr>())
3890 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;
3892 Ty = getOrCreateType(VD->
getType(), Unit);
3901 unsigned Column = 0;
3907 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3909 Flags |= llvm::DINode::FlagArtificial;
3913 unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(VD->
getType());
3914 AppendAddressSpaceXDeref(AddressSpace, Expr);
3918 if (
const auto *IPD = dyn_cast<ImplicitParamDecl>(VD)) {
3921 Flags |= llvm::DINode::FlagObjectPointer;
3928 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
3929 StringRef Name = VD->
getName();
3930 if (!Name.empty()) {
3931 if (VD->
hasAttr<BlocksAttr>()) {
3934 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3936 offset = CGM.getContext().toCharUnitsFromBits(
3937 CGM.getTarget().getPointerWidth(0));
3939 Expr.push_back(llvm::dwarf::DW_OP_deref);
3940 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3942 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
3945 }
else if (
const auto *RT = dyn_cast<RecordType>(VD->
getType())) {
3957 for (
const auto *Field : RD->
fields()) {
3958 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
3959 StringRef FieldName = Field->getName();
3962 if (FieldName.empty() && !isa<RecordType>(Field->getType()))
3967 auto *D = DBuilder.createAutoVariable(
3968 Scope, FieldName, Unit, Line, FieldTy, CGM.getLangOpts().Optimize,
3969 Flags | llvm::DINode::FlagArtificial, FieldAlign);
3972 DBuilder.insertDeclare(
3973 Storage, D, DBuilder.createExpression(Expr),
3974 llvm::DebugLoc::get(Line, Column,
Scope, CurInlinedAt),
3975 Builder.GetInsertBlock());
3983 if (UsePointerValue) {
3984 assert(std::find(Expr.begin(), Expr.end(), llvm::dwarf::DW_OP_deref) ==
3986 "Debug info already contains DW_OP_deref.");
3987 Expr.push_back(llvm::dwarf::DW_OP_deref);
3991 auto *D = ArgNo ? DBuilder.createParameterVariable(
3992 Scope, Name, *ArgNo, Unit, Line, Ty,
3993 CGM.getLangOpts().Optimize, Flags)
3994 : DBuilder.createAutoVariable(
Scope, Name, Unit, Line, Ty,
3995 CGM.getLangOpts().Optimize,
3999 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
4000 llvm::DebugLoc::get(Line, Column,
Scope, CurInlinedAt),
4001 Builder.GetInsertBlock());
4003 if (CGM.getCodeGenOpts().EnableDebugEntryValues && ArgNo) {
4004 if (
auto *PD = dyn_cast<ParmVarDecl>(VD))
4005 ParamCache[PD].reset(D);
4011 llvm::DILocalVariable *
4014 const bool UsePointerValue) {
4016 return EmitDeclare(VD, Storage,
llvm::None, Builder, UsePointerValue);
4021 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4023 if (D->
hasAttr<NoDebugAttr>())
4026 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
4027 llvm::DIFile *Unit = getOrCreateFile(D->
getLocation());
4031 unsigned Column = getColumnNumber(D->
getLocation());
4033 StringRef Name = D->
getName();
4037 DBuilder.createLabel(
Scope, Name, Unit, Line, CGM.getLangOpts().Optimize);
4040 DBuilder.insertLabel(L,
4041 llvm::DebugLoc::get(Line, Column,
Scope, CurInlinedAt),
4042 Builder.GetInsertBlock());
4045 llvm::DIType *CGDebugInfo::CreateSelfType(
const QualType &QualTy,
4047 llvm::DIType *CachedTy = getTypeOrNull(QualTy);
4050 return DBuilder.createObjectPointerType(Ty);
4055 const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) {
4057 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4059 if (Builder.GetInsertBlock() ==
nullptr)
4061 if (VD->
hasAttr<NoDebugAttr>())
4064 bool isByRef = VD->
hasAttr<BlocksAttr>();
4066 uint64_t XOffset = 0;
4067 llvm::DIFile *Unit = getOrCreateFile(VD->
getLocation());
4070 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;
4072 Ty = getOrCreateType(VD->
getType(), Unit);
4076 if (
const auto *IPD = dyn_cast<ImplicitParamDecl>(VD))
4078 Ty = CreateSelfType(VD->
getType(), Ty);
4082 unsigned Column = getColumnNumber(VD->
getLocation());
4084 const llvm::DataLayout &target = CGM.getDataLayout();
4091 addr.push_back(llvm::dwarf::DW_OP_deref);
4092 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4095 addr.push_back(llvm::dwarf::DW_OP_deref);
4096 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4099 CGM.getContext().toCharUnitsFromBits(target.getPointerSizeInBits(0));
4101 addr.push_back(llvm::dwarf::DW_OP_deref);
4102 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4104 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
4110 auto *D = DBuilder.createAutoVariable(
4111 cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->
getName(), Unit,
4112 Line, Ty,
false, llvm::DINode::FlagZero, Align);
4116 llvm::DebugLoc::get(Line, Column, LexicalBlockStack.back(), CurInlinedAt);
4117 auto *Expr = DBuilder.createExpression(addr);
4119 DBuilder.insertDeclare(Storage, D, Expr, DL, InsertPoint);
4121 DBuilder.insertDeclare(Storage, D, Expr, DL, Builder.GetInsertBlock());
4128 EmitDeclare(VD, AI, ArgNo, Builder);
4132 struct BlockLayoutChunk {
4133 uint64_t OffsetInBits;
4136 bool operator<(
const BlockLayoutChunk &l,
const BlockLayoutChunk &
r) {
4137 return l.OffsetInBits < r.OffsetInBits;
4141 void CGDebugInfo::collectDefaultFieldsForBlockLiteralDeclare(
4143 const llvm::StructLayout &BlockLayout, llvm::DIFile *Unit,
4148 if (CGM.getLangOpts().OpenCL) {
4149 Fields.push_back(createFieldType(
"__size", Context.
IntTy, Loc,
AS_public,
4150 BlockLayout.getElementOffsetInBits(0),
4152 Fields.push_back(createFieldType(
"__align", Context.
IntTy, Loc,
AS_public,
4153 BlockLayout.getElementOffsetInBits(1),
4157 BlockLayout.getElementOffsetInBits(0),
4159 Fields.push_back(createFieldType(
"__flags", Context.
IntTy, Loc,
AS_public,
4160 BlockLayout.getElementOffsetInBits(1),
4164 BlockLayout.getElementOffsetInBits(2), Unit, Unit));
4166 auto FnPtrType = CGM.getContext().getPointerType(FnTy->desugar());
4167 Fields.push_back(createFieldType(
"__FuncPtr", FnPtrType, Loc,
AS_public,
4168 BlockLayout.getElementOffsetInBits(3),
4170 Fields.push_back(createFieldType(
4175 Loc,
AS_public, BlockLayout.getElementOffsetInBits(4), Unit, Unit));
4182 llvm::AllocaInst *Alloca,
4190 llvm::DIFile *tunit = getOrCreateFile(loc);
4191 unsigned line = getLineNumber(loc);
4192 unsigned column = getColumnNumber(loc);
4195 getDeclContextDescriptor(blockDecl);
4197 const llvm::StructLayout *blockLayout =
4201 collectDefaultFieldsForBlockLiteralDeclare(block, C, loc, *blockLayout, tunit,
4210 BlockLayoutChunk chunk;
4211 chunk.OffsetInBits =
4212 blockLayout->getElementOffsetInBits(block.
CXXThisIndex);
4213 chunk.Capture =
nullptr;
4214 chunks.push_back(chunk);
4218 for (
const auto &capture : blockDecl->
captures()) {
4219 const VarDecl *variable = capture.getVariable();
4226 BlockLayoutChunk chunk;
4227 chunk.OffsetInBits =
4228 blockLayout->getElementOffsetInBits(captureInfo.
getIndex());
4229 chunk.Capture = &capture;
4230 chunks.push_back(chunk);
4234 llvm::array_pod_sort(chunks.begin(), chunks.end());
4236 for (
const BlockLayoutChunk &Chunk : chunks) {
4237 uint64_t offsetInBits = Chunk.OffsetInBits;
4246 else if (
auto *RDecl = dyn_cast<CXXRecordDecl>(blockDecl->
getParent()))
4247 type =
QualType(RDecl->getTypeForDecl(), 0);
4249 llvm_unreachable(
"unexpected block declcontext");
4251 fields.push_back(createFieldType(
"this", type, loc,
AS_public,
4252 offsetInBits, tunit, tunit));
4259 llvm::DIType *fieldType;
4266 EmitTypeForVarWithBlocksAttr(variable, &xoffset).BlockByRefWrapper;
4267 fieldType = DBuilder.createPointerType(fieldType, PtrInfo.
Width);
4268 fieldType = DBuilder.createMemberType(tunit, name, tunit, line,
4269 PtrInfo.
Width, Align, offsetInBits,
4270 llvm::DINode::FlagZero, fieldType);
4274 offsetInBits, Align, tunit, tunit);
4276 fields.push_back(fieldType);
4280 llvm::raw_svector_ostream(typeName)
4281 <<
"__block_literal_" << CGM.getUniqueBlockCount();
4283 llvm::DINodeArray fieldsArray = DBuilder.getOrCreateArray(fields);
4285 llvm::DIType *type =
4286 DBuilder.createStructType(tunit, typeName.str(), tunit, line,
4287 CGM.getContext().toBits(block.
BlockSize), 0,
4288 llvm::DINode::FlagZero,
nullptr, fieldsArray);
4289 type = DBuilder.createPointerType(type, CGM.PointerWidthInBits);
4292 llvm::DINode::DIFlags flags = llvm::DINode::FlagArtificial;
4293 auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back());
4296 auto *debugVar = DBuilder.createParameterVariable(
4297 scope, Name, ArgNo, tunit, line, type, CGM.getLangOpts().Optimize, flags);
4300 DBuilder.insertDeclare(Alloca, debugVar, DBuilder.createExpression(),
4301 llvm::DebugLoc::get(line, column, scope, CurInlinedAt),
4302 Builder.GetInsertBlock());
4305 llvm::DIDerivedType *
4306 CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(
const VarDecl *D) {
4311 if (MI != StaticDataMemberCache.end()) {
4312 assert(MI->second &&
"Static data member declaration should still exist");
4319 auto *Ctxt = cast<llvm::DICompositeType>(getDeclContextDescriptor(D));
4320 return CreateRecordStaticField(D, Ctxt, cast<RecordDecl>(DC));
4323 llvm::DIGlobalVariableExpression *CGDebugInfo::CollectAnonRecordDecls(
4324 const RecordDecl *RD, llvm::DIFile *Unit,
unsigned LineNo,
4325 StringRef LinkageName, llvm::GlobalVariable *Var, llvm::DIScope *DContext) {
4326 llvm::DIGlobalVariableExpression *GVE =
nullptr;
4328 for (
const auto *Field : RD->
fields()) {
4329 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
4330 StringRef FieldName = Field->getName();
4333 if (FieldName.empty()) {
4334 if (
const auto *RT = dyn_cast<RecordType>(Field->getType()))
4335 GVE = CollectAnonRecordDecls(RT->getDecl(), Unit, LineNo, LinkageName,
4340 GVE = DBuilder.createGlobalVariableExpression(
4341 DContext, FieldName, LinkageName, Unit, LineNo, FieldTy,
4342 Var->hasLocalLinkage());
4343 Var->addDebugInfo(GVE);
4351 if (D->
hasAttr<NoDebugAttr>())
4357 if (Cached != DeclCache.end())
4358 return Var->addDebugInfo(
4359 cast<llvm::DIGlobalVariableExpression>(Cached->second));
4362 llvm::DIFile *Unit =
nullptr;
4363 llvm::DIScope *DContext =
nullptr;
4365 StringRef DeclName, LinkageName;
4367 llvm::MDTuple *TemplateParameters =
nullptr;
4368 collectVarDeclProps(D, Unit, LineNo, T, DeclName, LinkageName,
4369 TemplateParameters, DContext);
4373 llvm::DIGlobalVariableExpression *GVE =
nullptr;
4381 "unnamed non-anonymous struct or union?");
4382 GVE = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
4387 unsigned AddressSpace =
4388 CGM.getContext().getTargetAddressSpace(D->
getType());
4389 if (CGM.getLangOpts().CUDA && CGM.getLangOpts().CUDAIsDevice) {
4390 if (D->
hasAttr<CUDASharedAttr>())
4393 else if (D->
hasAttr<CUDAConstantAttr>())
4397 AppendAddressSpaceXDeref(AddressSpace, Expr);
4399 GVE = DBuilder.createGlobalVariableExpression(
4400 DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit),
4401 Var->hasLocalLinkage(),
4402 Expr.empty() ? nullptr : DBuilder.createExpression(Expr),
4403 getOrCreateStaticDataMemberDeclarationOrNull(D), TemplateParameters,
4405 Var->addDebugInfo(GVE);
4412 if (VD->
hasAttr<NoDebugAttr>())
4416 llvm::DIFile *Unit = getOrCreateFile(VD->
getLocation());
4417 StringRef Name = VD->
getName();
4418 llvm::DIType *Ty = getOrCreateType(VD->
getType(), Unit);
4421 if (
const auto *ECD = dyn_cast<EnumConstantDecl>(VD)) {
4422 const auto *ED = cast<EnumDecl>(ECD->getDeclContext());
4423 assert(isa<EnumType>(ED->getTypeForDecl()) &&
"Enum without EnumType?");
4430 if (!CGM.getCodeGenOpts().EmitCodeView ||
4431 isa<RecordDecl>(ED->getDeclContext()))
4435 llvm::DIScope *DContext =
nullptr;
4443 auto *VarD = dyn_cast<
VarDecl>(VD);
4444 if (VarD && VarD->isStaticDataMember()) {
4445 auto *RD = cast<RecordDecl>(VarD->getDeclContext());
4446 getDeclContextDescriptor(VarD);
4451 RetainedTypes.push_back(
4452 CGM.getContext().getRecordType(RD).getAsOpaquePtr());
4454 if (!CGM.getCodeGenOpts().EmitCodeView)
4458 DContext = getContextDescriptor(
4459 cast<Decl>(CGM.getContext().getTranslationUnitDecl()), TheCU);
4461 DContext = getDeclContextDescriptor(VD);
4464 auto &GV = DeclCache[VD];
4467 llvm::DIExpression *InitExpr =
nullptr;
4468 if (CGM.getContext().getTypeSize(VD->
getType()) <= 64) {
4472 DBuilder.createConstantValueExpression(Init.
getInt().getExtValue());
4474 InitExpr = DBuilder.createConstantValueExpression(
4475 Init.
getFloat().bitcastToAPInt().getZExtValue());
4478 llvm::MDTuple *TemplateParameters =
nullptr;
4480 if (isa<VarTemplateSpecializationDecl>(VD))
4482 llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VarD, &*Unit);
4483 TemplateParameters = parameterNodes.get();
4486 GV.reset(DBuilder.createGlobalVariableExpression(
4487 DContext, Name, StringRef(), Unit, getLineNumber(VD->
getLocation()), Ty,
4488 true, InitExpr, getOrCreateStaticDataMemberDeclarationOrNull(VarD),
4489 TemplateParameters, Align));
4492 llvm::DIScope *CGDebugInfo::getCurrentContextDescriptor(
const Decl *D) {
4493 if (!LexicalBlockStack.empty())
4494 return LexicalBlockStack.back();
4495 llvm::DIScope *Mod = getParentModuleOrNull(D);
4496 return getContextDescriptor(D, Mod ? Mod : TheCU);
4504 CGM.getCodeGenOpts().DebugExplicitImport) {
4506 DBuilder.createImportedModule(
4508 getOrCreateNamespace(NSDecl), getOrCreateFile(Loc), getLineNumber(Loc));
4516 "We shouldn't be codegening an invalid UsingDecl containing no decls");
4525 if (
const auto *FD = dyn_cast<FunctionDecl>(USD.getUnderlyingDecl()))
4526 if (
const auto *AT =
4528 if (AT->getDeducedType().isNull())
4530 if (llvm::DINode *
Target =
4531 getDeclarationOrDefinition(USD.getUnderlyingDecl())) {
4532 auto Loc = USD.getLocation();
4533 DBuilder.createImportedDeclaration(
4534 getCurrentContextDescriptor(cast<Decl>(USD.getDeclContext())),
Target,
4535 getOrCreateFile(Loc), getLineNumber(Loc));
4540 if (CGM.getCodeGenOpts().getDebuggerTuning() != llvm::DebuggerKind::LLDB)
4545 DBuilder.createImportedDeclaration(
4547 getOrCreateModuleRef(Info, DebugTypeExtRefs), getOrCreateFile(Loc),
4548 getLineNumber(Loc));
4552 llvm::DIImportedEntity *
4556 auto &VH = NamespaceAliasCache[&NA];
4558 return cast<llvm::DIImportedEntity>(VH);
4559 llvm::DIImportedEntity *R;
4561 if (
const auto *Underlying =
4564 R = DBuilder.createImportedDeclaration(
4566 EmitNamespaceAlias(*Underlying), getOrCreateFile(Loc),
4567 getLineNumber(Loc), NA.
getName());
4569 R = DBuilder.createImportedDeclaration(
4572 getOrCreateFile(Loc), getLineNumber(Loc), NA.
getName());
4578 CGDebugInfo::getOrCreateNamespace(
const NamespaceDecl *NSDecl) {
4582 auto I = NamespaceCache.find(NSDecl);
4583 if (I != NamespaceCache.end())
4584 return cast<llvm::DINamespace>(I->second);
4586 llvm::DIScope *Context = getDeclContextDescriptor(NSDecl);
4588 llvm::DINamespace *NS =
4589 DBuilder.createNameSpace(Context, NSDecl->
getName(), NSDecl->
isInline());
4590 NamespaceCache[NSDecl].reset(NS);
4595 assert(TheCU &&
"no main compile unit");
4596 TheCU->setDWOId(Signature);
4603 llvm::DenseMap<const FunctionDecl *, llvm::TrackingMDRef> &SPDefCache,
4604 llvm::DenseMap<const ParmVarDecl *, llvm::TrackingMDRef> &ParamCache) {
4605 for (
auto &SP : SPDefCache) {
4606 auto *FD = SP.first;
4607 assert(FD->
hasBody() &&
"Functions must have body here");
4608 const Stmt *FuncBody = (*FD).getBody();
4614 auto I = ParamCache.find(Parm);
4615 assert(I != ParamCache.end() &&
"Parameters should be already cached");
4616 auto *DIParm = cast<llvm::DILocalVariable>(I->second);
4617 DIParm->setIsNotModified();
4625 for (
size_t i = 0;
i != ObjCInterfaceCache.size(); ++
i) {
4626 ObjCInterfaceCacheEntry E = ObjCInterfaceCache[
i];
4627 llvm::DIType *Ty = E.
Type->getDecl()->getDefinition()
4628 ? CreateTypeDefinition(E.Type, E.Unit)
4630 DBuilder.replaceTemporary(llvm::TempDIType(E.Decl), Ty);
4633 if (CGM.getCodeGenOpts().DwarfVersion >= 5) {
4635 for (
const auto &
P : ObjCMethodCache) {
4636 if (
P.second.empty())
4639 QualType QTy(
P.first->getTypeForDecl(), 0);
4640 auto It = TypeCache.find(QTy.getAsOpaquePtr());
4641 assert(It != TypeCache.end());
4643 llvm::DICompositeType *InterfaceDecl =
4644 cast<llvm::DICompositeType>(It->second);
4647 auto CurrenetElts = InterfaceDecl->getElements();
4648 EltTys.append(CurrenetElts.begin(), CurrenetElts.end());
4649 for (
auto &MD :
P.second)
4650 EltTys.push_back(MD);
4651 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
4652 DBuilder.replaceArrays(InterfaceDecl, Elements);
4656 for (
const auto &
P : ReplaceMap) {
4658 auto *Ty = cast<llvm::DIType>(
P.second);
4659 assert(Ty->isForwardDecl());
4661 auto It = TypeCache.find(
P.first);
4662 assert(It != TypeCache.end());
4665 DBuilder.replaceTemporary(llvm::TempDIType(Ty),
4666 cast<llvm::DIType>(It->second));
4669 for (
const auto &
P : FwdDeclReplaceMap) {
4671 llvm::TempMDNode FwdDecl(cast<llvm::MDNode>(
P.second));
4672 llvm::Metadata *Repl;
4674 auto It = DeclCache.find(
P.first);
4678 if (It == DeclCache.end())
4683 if (
auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(Repl))
4684 Repl = GVE->getVariable();
4685 DBuilder.replaceTemporary(std::move(FwdDecl), cast<llvm::MDNode>(Repl));
4690 for (
auto &RT : RetainedTypes)
4691 if (
auto MD = TypeCache[RT])
4692 DBuilder.retainType(cast<llvm::DIType>(MD));
4694 if (CGM.getCodeGenOpts().EnableDebugEntryValues)
4698 DBuilder.finalize();
4705 if (
auto *DieTy = getOrCreateType(Ty, TheCU->getFile()))
4707 DBuilder.retainType(DieTy);
4711 if (LexicalBlockStack.empty())
4712 return llvm::DebugLoc();
4714 llvm::MDNode *
Scope = LexicalBlockStack.back();
4715 return llvm::DebugLoc::get(getLineNumber(Loc), getColumnNumber(Loc), Scope);
4718 llvm::DINode::DIFlags CGDebugInfo::getCallSiteRelatedAttrs()
const {
4723 return llvm::DINode::FlagZero;
4728 bool SupportsDWARFv4Ext =
4729 CGM.getCodeGenOpts().DwarfVersion == 4 &&
4730 (CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB ||
4731 (CGM.getCodeGenOpts().EnableDebugEntryValues &&
4732 CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::GDB));
4734 if (!SupportsDWARFv4Ext && CGM.getCodeGenOpts().DwarfVersion < 5)
4735 return llvm::DINode::FlagZero;
4737 return llvm::DINode::FlagAllCallsDescribed;
bool isNoReturn() const
Determines whether this function is known to be 'noreturn', through an attribute on its declaration o...
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Defines the clang::ASTContext interface.
CharUnits alignTo(const CharUnits &Align) const
alignTo - Returns the next integer (mod 2**64) that is greater than or equal to this quantity and is ...
const Type * getTypeForDecl() const
VarDecl * getCapturedVar() const
Retrieve the declaration of the local variable being captured.
const Capture & getCapture(const VarDecl *var) const
Represents a function declaration or definition.
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
std::string Name
The name of this module.
External linkage, which indicates that the entity can be referred to from other translation units...
static bool hasDefaultSetterName(const ObjCPropertyDecl *PD, const ObjCMethodDecl *Setter)
bool isObjCQualifiedIdType() const
True if this is equivalent to 'id.
const FunctionProtoType * getFunctionType() const
getFunctionType - Return the underlying function type for this block.
Smart pointer class that efficiently represents Objective-C method names.
A class which contains all the information about a particular captured value.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
StringRef getName(const PrintingPolicy &Policy) const
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getElementType() const
QualType getPointeeType() const
void EmitLocation(raw_ostream &o, const SourceManager &SM, SourceLocation L, const FIDMap &FM, unsigned indent)
bool isPrimaryBaseVirtual() const
isPrimaryBaseVirtual - Get whether the primary base for this record is virtual or not...
static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx)
A (possibly-)qualified type.
const CodeGenOptions & getCodeGenOpts() const
ObjCInterfaceDecl * getClassInterface()
void EmitExplicitCastType(QualType Ty)
Emit the type explicitly casted to.
ArrayRef< TemplateArgument > getPackAsArray() const
Return the array of arguments in this template argument pack.
Defines the clang::FileManager interface and associated types.
bool isMemberDataPointerType() const
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
void EmitLabel(const LabelDecl *D, CGBuilderTy &Builder)
Emit call to llvm.dbg.label for an label.
TypePropertyCache< Private > Cache
Stmt - This represents one statement.
llvm::DIType * getOrCreateRecordType(QualType Ty, SourceLocation L)
Emit record type's standalone debug info.
FunctionType - C99 6.7.5.3 - Function Declarators.
void EmitLexicalBlockEnd(CGBuilderTy &Builder, SourceLocation Loc)
Emit metadata to indicate the end of a new lexical block and pop the current block.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Defines the SourceManager interface.
QualType getThisType() const
Return the type of the this pointer.
static bool shouldOmitDefinition(codegenoptions::DebugInfoKind DebugKind, bool DebugTypeExtRefs, const RecordDecl *RD, const LangOptions &LangOpts)
The template argument is an expression, and we've not resolved it to one of the other forms yet...
bool isRecordType() const
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
const Type * getTypeForDecl() const
Decl - This represents one declaration (or definition), e.g.
TagDecl * getDecl() const
ArrayRef< NamedDecl * > asArray()
Selector getObjCSelector() const
Get the Objective-C selector stored in this declaration name.
Defines the C++ template declaration subclasses.
Parameter for C++ 'this' argument.
static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C)
static bool hasDefaultGetterName(const ObjCPropertyDecl *PD, const ObjCMethodDecl *Getter)
The base class of the type hierarchy.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Declaration of a variable template.
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Represent a C++ namespace.
NamedDecl * getParam(unsigned Idx)
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
RefQualifierKind RefQualifier
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
static bool needsTypeIdentifier(const TagDecl *TD, CodeGenModule &CGM, llvm::DICompileUnit *TheCU)
Describes the capture of a variable or of this, or of a C++1y init-capture.
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
MSInheritanceAttr::Spelling getMSInheritanceModel() const
Returns the inheritance model used for this record.
QualType getElementType() const
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
StringRef getBufferData(FileID FID, bool *Invalid=nullptr) const
Return a StringRef to the source buffer data for the specified FileID.
enumerator_range enumerators() const
Represents a variable declaration or definition.
void removeObjCLifetime()
QualType getReturnType() const
const T * getAs() const
Member-template getAs<specific type>'.
Analyzes whether any mutative operations are applied to an expression within a given statement...
Represents an empty template argument, e.g., one that has not been deduced.
Extra information about a function prototype.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
void EmitFuncDeclForCallSite(llvm::CallBase *CallOrInvoke, QualType CalleeType, const FunctionDecl *CalleeDecl)
Emit debug info for an extern function being called.
A this pointer adjustment.
Represents a variable template specialization, which refers to a variable template with a given set o...
ObjCMethodDecl - Represents an instance or class method declaration.
Stores a list of template parameters for a TemplateDecl and its derived classes.
Describes how types, statements, expressions, and declarations should be printed. ...
void completeTemplateDefinition(const ClassTemplateSpecializationDecl &SD)
bool hasDefinition() const
static const NamedDecl * getDefinition(const Decl *D)
Represents a parameter to a function.
QualType getIntegralType() const
Retrieve the type of the integral value.
static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD)
The collection of all-type qualifiers we support.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
void EmitInlineFunctionEnd(CGBuilderTy &Builder)
End an inlined function scope.
Represents a struct/union/class.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
std::map< std::string, std::string > DebugPrefixMap
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool SuppressNNS=false) const
Print the template name.
void addHeapAllocSiteMetadata(llvm::Instruction *CallSite, QualType Ty, SourceLocation Loc)
Add heapallocsite metadata for MSAllocator calls.
Represents a class type in Objective C.
QualType getPointeeType() const
CGDebugInfo * getDebugInfo()
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
bool isInline() const
Returns true if this is an inline namespace declaration.
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
static bool isFunctionLocalClass(const CXXRecordDecl *RD)
isFunctionLocalClass - Return true if CXXRecordDecl is defined inside a function. ...
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
void EmitImportDecl(const ImportDecl &ID)
Emit an declaration.
field_range fields() const
Represents a member of a struct/union/class.
StringRef getPath() const
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
prop_range properties() const
void completeClassData(const RecordDecl *RD)
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
llvm::DIMacro * CreateMacro(llvm::DIMacroFile *Parent, unsigned MType, SourceLocation LineLoc, StringRef Name, StringRef Value)
Create debug info for a macro defined by a #define directive or a macro undefined by a #undef directi...
method_iterator method_begin() const
Method begin iterator.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Describes a module or submodule.
QualType getParamTypeForDecl() const
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
ArrayRef< ParmVarDecl * > parameters() const
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Represents a C++ using-declaration.
Type(TypeClass tc, QualType canon, bool Dependent, bool InstantiationDependent, bool VariablyModified, bool ContainsUnexpandedParameterPack)
const TemplateArgumentList * TemplateArguments
The template arguments used to produce the function template specialization from the function templat...
static SmallString< 64 > constructSetterName(StringRef Name)
Return the default setter name for the given identifier.
ArrayRef< VTableComponent > vtable_components() const
unsigned Size
The total size of the bit-field, in bits.
An rvalue reference type, per C++11 [dcl.ref].
bool isBitField() const
Determines whether this field is a bitfield.
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this method.
An lvalue ref-qualifier was provided (&).
~ApplyInlineDebugLocation()
Restore everything back to the original state.
CharUnits - This is an opaque type for sizes expressed in character units.
bool capturesThis() const
Determine whether this capture handles the C++ this pointer.
APValue Val
Val - This is the value the expression can be folded to.
const BlockDecl * getBlockDecl() const
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
Emit location information but do not generate debug info in the output.
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
CharUnits StorageOffset
The offset of the bitfield storage from the start of the struct.
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
bool isTypeAlias() const
Determine if this template specialization type is for a type alias template that has been substituted...
void EmitGlobalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl)
Emit information about a global variable.
bool isByRef() const
Whether this is a "by ref" capture, i.e.
Represents a declaration of a type.
static bool hasCXXMangling(const TagDecl *TD, llvm::DICompileUnit *TheCU)
Module * Parent
The parent of this module.
const Type * getClass() const
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
bool isLambda() const
Determine whether this class describes a lambda function object.
Scope - A scope is a transient data structure that is used while parsing the program.
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R)
Returns the common set of qualifiers while removing them from the given sets.
llvm::DIType * getOrCreateInterfaceType(QualType Ty, SourceLocation Loc)
Emit an Objective-C interface type standalone debug info.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
field_iterator field_begin() const
bool isCompleteDefinitionRequired() const
Return true if this complete decl is required to be complete for some existing use.
unsigned Offset
The offset within a contiguous run of bitfields that are represented as a single "field" within the L...
static uint32_t getDeclAlignIfRequired(const Decl *D, const ASTContext &Ctx)
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
void EmitFunctionEnd(CGBuilderTy &Builder, llvm::Function *Fn)
Constructs the debug code for exiting a function.
llvm::DIImportedEntity * EmitNamespaceAlias(const NamespaceAliasDecl &NA)
Emit C++ namespace alias.
void * getAsOpaquePtr() const
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization, retrieves the function from which it was instantiated.
Represents an ObjC class declaration.
shadow_iterator shadow_begin() const
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
Module * getImportedModule() const
Retrieve the module that was imported by the import declaration.
const Module * getModuleOrNull() const
bool NeedsCopyDispose
True if the block has captures that would necessitate custom copy or dispose helper functions if the ...
unsigned getIndex() const
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
QualType getBlockDescriptorExtendedType() const
Gets the struct used to keep track of the extended descriptor for pointer to blocks.
static unsigned getDwarfCC(CallingConv CC)
QualType getBaseType() const
Gets the base type of this object type.
Represents a prototype with parameter type info, e.g.
bool isDynamicClass() const
unsigned MSVCFormatting
Use whitespace and punctuation like MSVC does.
ASTFileSignature getSignature() const
CGBlockInfo - Information to generate a block literal.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Represents a ValueDecl that came out of a declarator.
std::string getModuleName() const
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
ObjCTypeParamDecl * getDecl() const
void setDwoId(uint64_t Signature)
Module debugging: Support for building PCMs.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
capture_const_iterator captures_end() const
void EmitLocation(CGBuilderTy &Builder, SourceLocation Loc)
Emit metadata to indicate a change in line/column information in the source file. ...
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
ApplyInlineDebugLocation(CodeGenFunction &CGF, GlobalDecl InlinedFn)
Set up the CodeGenFunction's DebugInfo to produce inline locations for the function InlinedFn...
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
This represents one expression.
QualType getPointeeType() const
known_extensions_range known_extensions() const
Emit only debug info necessary for generating line number tables (-gline-tables-only).
bool isPositive() const
isPositive - Test whether the quantity is greater than zero.
bool isVariadic() const
Whether this function is variadic.
bool isInvalid() const
Return true if this object is invalid or uninitialized.
static void analyzeParametersModification(ASTContext &Ctx, llvm::DenseMap< const FunctionDecl *, llvm::TrackingMDRef > &SPDefCache, llvm::DenseMap< const ParmVarDecl *, llvm::TrackingMDRef > &ParamCache)
Analyzes each function parameter to determine whether it is constant throughout the function body...
void EmitInlineFunctionStart(CGBuilderTy &Builder, GlobalDecl GD)
Start a new scope for an inlined function.
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
const AnnotatedLine * Line
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to...
const T * castAs() const
Member-template castAs<specific type>.
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
unsigned getLine() const
Return the presumed line number of this location.
Represents a C++ destructor within a class.
Defines version macros and version-related utility functions for Clang.
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
llvm::DIMacroFile * CreateTempMacroFile(llvm::DIMacroFile *Parent, SourceLocation LineLoc, SourceLocation FileLoc)
Create debug info for a file referenced by an #include directive.
field_iterator field_end() const
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
DeclContext * getDeclContext()
ObjCInterfaceDecl * getSuperClass() const
const CXXRecordDecl * getPrimaryBase() const
getPrimaryBase - Get the primary base for this record.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
void completeUnusedClass(const CXXRecordDecl &D)
EnumDecl * getDefinition() const
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
clang::ObjCRuntime ObjCRuntime
bool hasExtendableVFPtr() const
hasVFPtr - Does this class have a virtual function table pointer that can be extended by a derived cl...
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl, 0 if there are none.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
method_iterator method_end() const
Method past-the-end iterator.
Represents an unpacked "presumed" location which can be presented to the user.
bool isInstanceMethod() const
QualType getBlockDescriptorType() const
Gets the struct used to keep track of the descriptor for pointer to blocks.
Represents a GCC generic vector type.
SourceLocation getCaretLocation() const
An lvalue reference type, per C++11 [dcl.ref].
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Selector getSelector() const
void printQualifiedName(raw_ostream &OS) const
Returns a human-readable qualified name for this declaration, like A::B::i, for i being member of nam...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
ImplicitParamDecl * getSelfDecl() const
static json::Object createFile(const FileEntry &FE)
CallingConv
CallingConv - Specifies the calling convention that a function uses.
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
GlobalDecl - represents a global declaration.
DynamicInitKind getDynamicInitKind() const
bool isVoidPointerType() const
bool isObjCOneArgSelector() const
The l-value was considered opaque, so the alignment was determined from a type.
RecordDecl * getDecl() const
const char * getFilename() const
Return the presumed filename of this location.
void EmitDeclareOfArgVariable(const VarDecl *Decl, llvm::Value *AI, unsigned ArgNo, CGBuilderTy &Builder)
Emit call to llvm.dbg.declare for an argument variable declaration.
bool capturesVariable() const
Determine whether this capture handles a variable.
Pass it as a pointer to temporary memory.
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
virtual void printName(raw_ostream &os) const
unsigned size_overridden_methods() const
StringRef getASTFile() const
static llvm::DINode::DIFlags getAccessFlag(AccessSpecifier Access, const RecordDecl *RD)
Convert an AccessSpecifier into the corresponding DINode flag.
std::string getAsString() const
Derive the full selector name (e.g.
virtual void mangleCXXRTTIName(QualType T, raw_ostream &)=0
ExtProtoInfo getExtProtoInfo() const
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
unsigned getColumn() const
Return the presumed column number of this location.
Encodes a location in the source.
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
QualType getReturnType() const
bool isPure() const
Whether this virtual function is pure, i.e.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Interfaces are the core concept in Objective-C for object oriented design.
llvm::StructType * StructureType
void completeRequiredType(const RecordDecl *RD)
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
Limit generated debug info to reduce size (-fno-standalone-debug).
Represents the declaration of a struct/union/class/enum.
ASTContext & getASTContext() const LLVM_READONLY
QualType getElementType() const
const Decl * getDecl() const
static QualType getUnderlyingType(const SubRegion *R)
Represents the declaration of a label.
Cached information about one file (either on disk or in the virtual file system). ...
Represents a static or instance method of a struct/union/class.
TypedefNameDecl * getTypedefNameForUnnamedTagDecl(const TagDecl *TD)
ObjCCategoryDecl - Represents a category declaration.
unsigned RemapFilePaths
Whether to apply -fdebug-prefix-map to any file paths.
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
llvm::Constant * emitAbstract(const Expr *E, QualType T)
Emit the result of the given expression as an abstract constant, asserting that it succeeded...
Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
void EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc, QualType FnType, llvm::Function *Fn=nullptr)
Emit debug info for a function declaration.
Represents one property declaration in an Objective-C interface.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
llvm::DILocalVariable * EmitDeclareOfAutoVariable(const VarDecl *Decl, llvm::Value *AI, CGBuilderTy &Builder, const bool UsePointerValue=false)
Emit call to llvm.dbg.declare for an automatic variable declaration.
const BlockExpr * getBlockExpr() const
TypeClass getTypeClass() const
MangleContext & getMangleContext()
Gets the mangle context.
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
constexpr XRayInstrMask None
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
VarDecl * getVariable() const
The variable being captured.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
EnumDecl * getDecl() const
unsigned CXXThisIndex
The field index of 'this' within the block, if there is one.
An rvalue ref-qualifier was provided (&&).
ObjCImplementationDecl * getImplementation() const
static bool hasExplicitMemberDefinition(CXXRecordDecl::method_iterator I, CXXRecordDecl::method_iterator End)
llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Loc)
Describes a module import declaration, which makes the contents of the named module visible in the cu...
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
StringRef getName() const
Return the actual identifier string.
Base class for declarations which introduce a typedef-name.
CXXRecordDecl * getMostRecentCXXRecordDecl() const
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Represents a template argument.
const llvm::MemoryBuffer * getBuffer(FileID FID, SourceLocation Loc, bool *Invalid=nullptr) const
Return the buffer for the specified FileID.
void completeClass(const RecordDecl *RD)
This class organizes the cross-function state that is used while generating LLVM code.
NamespaceDecl * getNominatedNamespace()
Returns the namespace nominated by this using-directive.
Dataflow Directional Tag Classes.
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
Appends a human-readable name for this declaration into the given stream.
bool isValid() const
Return true if this is a valid SourceLocation object.
A qualifier set is used to build a set of qualifiers.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
EvalResult is a struct with detailed info about an evaluated expression.
uint64_t Index
Method's index in the vftable.
ArrayRef< Capture > captures() const
static SmallString< 256 > getTypeIdentifier(const TagType *Ty, CodeGenModule &CGM, llvm::DICompileUnit *TheCU)
The template argument is a pack expansion of a template name that was provided for a template templat...
Parameter for Objective-C 'self' argument.
QualType getUnderlyingType() const
llvm::iterator_range< base_class_const_iterator > base_class_const_range
const Expr * getInit() const
AccessSpecifier getAccess() const
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
FileID getMainFileID() const
Returns the FileID of the main source file.
bool hasLocalQualifiers() const
Determine whether this particular QualType instance has any qualifiers, without looking through any t...
Emit only debug directives with the line numbers data.
This template specialization was instantiated from a template due to an explicit instantiation declar...
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Decl * getNonClosureContext()
Find the innermost non-closure ancestor of this declaration, walking up through blocks, lambdas, etc.
unsigned shadow_size() const
Return the number of shadowed declarations associated with this using declaration.
CGDebugInfo(CodeGenModule &CGM)
unsigned StorageSize
The storage size in bits which should be used when accessing this bitfield.
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
A pointer to member type per C++ 8.3.3 - Pointers to members.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Represents a pointer to an Objective C object.
bool isMutated(const Expr *Exp)
llvm::GlobalVariable::LinkageTypes getVTableLinkage(const CXXRecordDecl *RD)
Return the appropriate linkage for the vtable, VTT, and type information of the given class...
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
bool isIncompleteArrayType() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Complex values, per C99 6.2.5p11.
Don't generate debug info.
void EmitFunctionStart(GlobalDecl GD, SourceLocation Loc, SourceLocation ScopeLoc, QualType FnType, llvm::Function *Fn, bool CurFnIsThunk, CGBuilderTy &Builder)
Emit a call to llvm.dbg.function.start to indicate start of a new function.
llvm::DIType * getOrCreateStandaloneType(QualType Ty, SourceLocation Loc)
Emit standalone debug info for a type.
std::string remapDIPath(StringRef) const
Remap a given path with the current debug prefix map.
unsigned getOwningModuleID() const
Retrieve the global ID of the module that owns this particular declaration.
void completeType(const EnumDecl *ED)
DeclaratorDecl * getDeclaratorForUnnamedTagDecl(const TagDecl *TD)
The template argument is a type.
The template argument is actually a parameter pack.
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
bool capturesCXXThis() const
std::function< std::string(StringRef)> remapPath
When RemapFilePaths is true, this function performs the action.
A template argument list.
TypedefNameDecl * getDecl() const
void EmitUsingDecl(const UsingDecl &UD)
Emit C++ using declaration.
void EmitUsingDirective(const UsingDirectiveDecl &UD)
Emit C++ using directive.
void EmitLexicalBlockStart(CGBuilderTy &Builder, SourceLocation Loc)
Emit metadata to indicate the beginning of a new lexical block and push the block onto the stack...
ArgKind getKind() const
Return the kind of stored template argument.
Represents a type parameter type in Objective C.
CallingConv getCallConv() const
QualType getAliasedType() const
Get the aliased type, if this is a specialization of a type alias template.
TypedefNameDecl * getTypedefNameForAnonDecl() const
true
A convenience builder class for complex constant initializers, especially for anonymous global struct...
Represents a C++ struct/union/class.
ArrayRef< TemplateArgument > template_arguments() const
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
The template argument is a template name that was provided for a template template parameter...
ObjCIvarDecl - Represents an ObjC instance variable.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
void EmitDeclareOfBlockDeclRefVariable(const VarDecl *variable, llvm::Value *storage, CGBuilderTy &Builder, const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint=nullptr)
Emit call to llvm.dbg.declare for an imported variable declaration in a block.
This class is used for builtin types like 'int'.
void EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block, StringRef Name, unsigned ArgNo, llvm::AllocaInst *LocalAddr, CGBuilderTy &Builder)
Emit call to llvm.dbg.declare for the block-literal argument to a block invocation function...
SourceLocation getLocation() const
Retrieve the source location of the capture.
bool isComplexIntegerType() const
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
void setLocation(SourceLocation Loc)
Update the current source location.
CGCXXABI & getCXXABI() const
std::string getQualifiedNameAsString() const
Abstracts clang modules and precompiled header files and holds everything needed to generate debug in...
unsigned getNumElements() const
QualType getAsType() const
Retrieve the type for a type template argument.
Represents a type template specialization; the template must be a class template, a type alias templa...
const internal::VariadicDynCastAllOfMatcher< Decl, BlockDecl > blockDecl
Matches block declarations.
static bool isClassOrMethodDLLImport(const CXXRecordDecl *RD)
Return true if the class or any of its methods are marked dllimport.
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
capture_const_iterator captures_begin() const
bool isStaticDataMember() const
Determines whether this is a static data member.
static InputKind getInputKindForExtension(StringRef Extension)
getInputKindForExtension - Return the appropriate input kind for a file extension.
A wrapper class around a pointer that always points to its canonical declaration. ...
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
Represents a C++ namespace alias.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
static bool isDefinedInClangModule(const RecordDecl *RD)
Does a type definition exist in an imported clang module?
Represents C++ using-directive.
void removeAddressSpace()
bool isObjCZeroArgSelector() const
base_class_range vbases()
This class handles loading and caching of source files into memory.
SourceLocation getLocation() const
QualType getPointeeType() const
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
bool isExternallyVisible() const
Structure with information about how a bitfield should be accessed.
NamedDecl * getAliasedNamespace() const
Retrieve the namespace that this alias refers to, which may either be a NamespaceDecl or a NamespaceA...
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
method_range methods() const