37 #include "llvm/ADT/DenseSet.h"
38 #include "llvm/ADT/SmallVector.h"
39 #include "llvm/ADT/StringExtras.h"
40 #include "llvm/IR/Constants.h"
41 #include "llvm/IR/DataLayout.h"
42 #include "llvm/IR/DerivedTypes.h"
43 #include "llvm/IR/Instructions.h"
44 #include "llvm/IR/Intrinsics.h"
45 #include "llvm/IR/Metadata.h"
46 #include "llvm/IR/Module.h"
47 #include "llvm/Support/FileSystem.h"
48 #include "llvm/Support/MD5.h"
49 #include "llvm/Support/Path.h"
50 #include "llvm/Support/TimeProfiler.h"
51 using namespace clang;
68 : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
69 DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),
70 DBuilder(CGM.getModule()) {
72 DebugPrefixMap[KV.first] = KV.second;
77 assert(LexicalBlockStack.empty() &&
78 "Region stack mismatch, stack not empty!");
84 init(TemporaryLocation);
91 init(TemporaryLocation, DefaultToEmpty);
95 bool DefaultToEmpty) {
102 OriginalLocation = CGF->
Builder.getCurrentDebugLocation();
104 if (OriginalLocation && !DI->CGM.getExpressionLocationsEnabled())
107 if (TemporaryLocation.
isValid()) {
108 DI->EmitLocation(CGF->
Builder, TemporaryLocation);
112 if (DefaultToEmpty) {
113 CGF->
Builder.SetCurrentDebugLocation(llvm::DebugLoc());
118 assert(!DI->LexicalBlockStack.empty());
119 CGF->
Builder.SetCurrentDebugLocation(
120 llvm::DILocation::get(DI->LexicalBlockStack.back()->getContext(), 0, 0,
121 DI->LexicalBlockStack.back(), DI->getInlinedAt()));
135 OriginalLocation = CGF.
Builder.getCurrentDebugLocation();
137 CGF.
Builder.SetCurrentDebugLocation(std::move(Loc));
144 CGF->
Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
155 SavedLocation = DI.getLocation();
156 assert((DI.getInlinedAt() ==
157 CGF.
Builder.getCurrentDebugLocation()->getInlinedAt()) &&
158 "CGDebugInfo and IRBuilder are out of sync");
160 DI.EmitInlineFunctionStart(CGF.
Builder, InlinedFn);
168 DI.EmitLocation(CGF->
Builder, SavedLocation);
181 if (LexicalBlockStack.empty())
185 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
187 if (PCLoc.
isInvalid() ||
Scope->getFile() == getOrCreateFile(CurLoc))
190 if (
auto *LBF = dyn_cast<llvm::DILexicalBlockFile>(
Scope)) {
191 LexicalBlockStack.pop_back();
192 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlockFile(
193 LBF->getScope(), getOrCreateFile(CurLoc)));
194 }
else if (isa<llvm::DILexicalBlock>(
Scope) ||
195 isa<llvm::DISubprogram>(
Scope)) {
196 LexicalBlockStack.pop_back();
197 LexicalBlockStack.emplace_back(
198 DBuilder.createLexicalBlockFile(
Scope, getOrCreateFile(CurLoc)));
202 llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(
const Decl *D) {
203 llvm::DIScope *Mod = getParentModuleOrNull(D);
208 llvm::DIScope *CGDebugInfo::getContextDescriptor(
const Decl *Context,
209 llvm::DIScope *Default) {
213 auto I = RegionMap.find(Context);
214 if (I != RegionMap.end()) {
215 llvm::Metadata *
V = I->second;
216 return dyn_cast_or_null<llvm::DIScope>(
V);
220 if (
const auto *NSDecl = dyn_cast<NamespaceDecl>(Context))
221 return getOrCreateNamespace(NSDecl);
223 if (
const auto *RDecl = dyn_cast<RecordDecl>(Context))
224 if (!RDecl->isDependentType())
258 StringRef CGDebugInfo::getFunctionName(
const FunctionDecl *FD) {
259 return internString(GetName(FD));
262 StringRef CGDebugInfo::getObjCMethodName(
const ObjCMethodDecl *OMD) {
263 SmallString<256> MethodName;
264 llvm::raw_svector_ostream
OS(MethodName);
267 if (
const auto *OID = dyn_cast<ObjCImplementationDecl>(DC)) {
268 OS << OID->getName();
269 }
else if (
const auto *OID = dyn_cast<ObjCInterfaceDecl>(DC)) {
270 OS << OID->getName();
271 }
else if (
const auto *OC = dyn_cast<ObjCCategoryDecl>(DC)) {
272 if (OC->IsClassExtension()) {
273 OS << OC->getClassInterface()->getName();
275 OS << OC->getIdentifier()->getNameStart() <<
'('
276 << OC->getIdentifier()->getNameStart() <<
')';
278 }
else if (
const auto *OCD = dyn_cast<ObjCCategoryImplDecl>(DC)) {
279 OS << OCD->getClassInterface()->getName() <<
'(' << OCD->getName() <<
')';
283 return internString(
OS.str());
286 StringRef CGDebugInfo::getSelectorName(
Selector S) {
287 return internString(S.getAsString());
290 StringRef CGDebugInfo::getClassName(
const RecordDecl *RD) {
291 if (isa<ClassTemplateSpecializationDecl>(RD)) {
293 return internString(GetName(RD));
299 return II->getName();
307 "Typedef should not be in another decl context!");
308 assert(D->getDeclName().getAsIdentifierInfo() &&
309 "Typedef was not named!");
310 return D->getDeclName().getAsIdentifierInfo()->getName();
320 Name = DD->getName();
325 Name = TND->getName();
328 if (
const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
329 if (CXXRD->isLambda())
334 SmallString<256> UnnamedType(
"<unnamed-type-");
337 return internString(UnnamedType);
359 llvm::MD5::hash(llvm::arrayRefFromStringRef(MemBuffer->getBuffer())),
361 return llvm::DIFile::CSK_MD5;
369 bool SourceInvalid =
false;
370 StringRef Source =
SM.getBufferData(FID, &SourceInvalid);
387 FileName = TheCU->getFile()->getFilename();
392 if (FileName.empty()) {
393 FileName = TheCU->getFile()->getFilename();
401 auto It = DIFileCache.find(FileName.data());
402 if (It != DIFileCache.end()) {
404 if (llvm::Metadata *
V = It->second)
405 return cast<llvm::DIFile>(
V);
413 CSInfo.emplace(*CSKind, Checksum);
414 return createFile(FileName, CSInfo, getSource(
SM,
SM.getFileID(Loc)));
418 CGDebugInfo::createFile(StringRef FileName,
419 Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo,
427 if (llvm::sys::path::is_absolute(RemappedFile)) {
430 auto FileIt = llvm::sys::path::begin(RemappedFile);
431 auto FileE = llvm::sys::path::end(RemappedFile);
432 auto CurDirIt = llvm::sys::path::begin(CurDir);
433 auto CurDirE = llvm::sys::path::end(CurDir);
434 for (; CurDirIt != CurDirE && *CurDirIt == *FileIt; ++CurDirIt, ++FileIt)
435 llvm::sys::path::append(DirBuf, *CurDirIt);
436 if (llvm::sys::path::root_path(DirBuf) == DirBuf) {
442 for (; FileIt != FileE; ++FileIt)
443 llvm::sys::path::append(FileBuf, *FileIt);
448 if (!llvm::sys::path::is_absolute(FileName))
452 llvm::DIFile *F = DBuilder.createFile(File, Dir, CSInfo, Source);
453 DIFileCache[FileName.data()].reset(F);
458 if (DebugPrefixMap.empty())
462 for (
const auto &Entry : DebugPrefixMap)
463 if (llvm::sys::path::replace_path_prefix(
P, Entry.first, Entry.second))
465 return P.str().str();
472 return SM.getPresumedLoc(Loc).getLine();
475 unsigned CGDebugInfo::getColumnNumber(
SourceLocation Loc,
bool Force) {
488 StringRef CGDebugInfo::getCurrentDirname() {
492 if (!CWDName.empty())
494 SmallString<256> CWD;
495 llvm::sys::fs::current_path(CWD);
496 return CWDName = internString(CWD);
499 void CGDebugInfo::CreateCompileUnit() {
514 if (MainFileName.empty())
515 MainFileName =
"<stdin>";
523 SM.getFileEntryRefForID(
SM.getMainFileID())) {
524 MainFileDir =
std::string(MainFile->getDir().getName());
525 if (!llvm::sys::path::is_absolute(MainFileName)) {
527 llvm::sys::path::append(MainFileDirSS, MainFileName);
529 std::string(llvm::sys::path::remove_leading_dotslash(MainFileDirSS));
535 if (MainFile->getName() == MainFileName &&
537 MainFile->getName().rsplit(
'.').second)
539 MainFileName = CGM.
getModule().getName().str();
541 CSKind = computeChecksum(
SM.getMainFileID(), Checksum);
544 llvm::dwarf::SourceLanguage LangTag;
548 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
549 else if (LO.CPlusPlus14 && (!CGM.
getCodeGenOpts().DebugStrictDwarf ||
551 LangTag = llvm::dwarf::DW_LANG_C_plus_plus_14;
552 else if (LO.CPlusPlus11 && (!CGM.
getCodeGenOpts().DebugStrictDwarf ||
554 LangTag = llvm::dwarf::DW_LANG_C_plus_plus_11;
556 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
557 }
else if (LO.ObjC) {
558 LangTag = llvm::dwarf::DW_LANG_ObjC;
559 }
else if (LO.OpenCL && (!CGM.
getCodeGenOpts().DebugStrictDwarf ||
561 LangTag = llvm::dwarf::DW_LANG_OpenCL;
562 }
else if (LO.RenderScript) {
563 LangTag = llvm::dwarf::DW_LANG_GOOGLE_RenderScript;
565 LangTag = llvm::dwarf::DW_LANG_C99;
567 LangTag = llvm::dwarf::DW_LANG_C89;
573 unsigned RuntimeVers = 0;
577 llvm::DICompileUnit::DebugEmissionKind EmissionKind;
581 EmissionKind = llvm::DICompileUnit::NoDebug;
584 EmissionKind = llvm::DICompileUnit::LineTablesOnly;
593 EmissionKind = llvm::DICompileUnit::FullDebug;
604 CSInfo.emplace(*CSKind, Checksum);
605 llvm::DIFile *CUFile = DBuilder.createFile(
607 getSource(
SM,
SM.getMainFileID()));
609 StringRef Sysroot, SDK;
610 if (CGM.
getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB) {
612 auto B = llvm::sys::path::rbegin(Sysroot);
613 auto E = llvm::sys::path::rend(Sysroot);
614 auto It = std::find_if(B, E, [](
auto SDK) {
return SDK.endswith(
".sdk"); });
620 TheCU = DBuilder.createCompileUnit(
621 LangTag, CUFile, CGOpts.EmitVersionIdentMetadata ? Producer :
"",
622 LO.Optimize || CGOpts.PrepareForLTO || CGOpts.PrepareForThinLTO,
623 CGOpts.DwarfDebugFlags, RuntimeVers, CGOpts.SplitDwarfFile, EmissionKind,
624 DwoId, CGOpts.SplitDwarfInlining, CGOpts.DebugInfoForProfiling,
627 :
static_cast<llvm::DICompileUnit::DebugNameTableKind
>(
628 CGOpts.DebugNameTable),
629 CGOpts.DebugRangesBaseAddress,
remapDIPath(Sysroot), SDK);
632 llvm::DIType *CGDebugInfo::CreateType(
const BuiltinType *BT) {
636 #define BUILTIN_TYPE(Id, SingletonId)
637 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
638 #include "clang/AST/BuiltinTypes.def"
639 case BuiltinType::Dependent:
640 llvm_unreachable(
"Unexpected builtin type");
641 case BuiltinType::NullPtr:
642 return DBuilder.createNullPtrType();
643 case BuiltinType::Void:
645 case BuiltinType::ObjCClass:
648 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
649 "objc_class", TheCU, TheCU->getFile(), 0);
651 case BuiltinType::ObjCId: {
662 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
663 "objc_class", TheCU, TheCU->getFile(), 0);
667 auto *ISATy = DBuilder.createPointerType(ClassTy, Size);
669 ObjTy = DBuilder.createStructType(TheCU,
"objc_object", TheCU->getFile(), 0,
670 0, 0, llvm::DINode::FlagZero,
nullptr,
671 llvm::DINodeArray());
673 DBuilder.replaceArrays(
674 ObjTy, DBuilder.getOrCreateArray(&*DBuilder.createMemberType(
675 ObjTy,
"isa", TheCU->getFile(), 0, Size, 0, 0,
676 llvm::DINode::FlagZero, ISATy)));
679 case BuiltinType::ObjCSel: {
681 SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
682 "objc_selector", TheCU,
683 TheCU->getFile(), 0);
687 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
688 case BuiltinType::Id: \
689 return getOrCreateStructPtrType("opencl_" #ImgType "_" #Suffix "_t", \
691 #include "clang/Basic/OpenCLImageTypes.def"
692 case BuiltinType::OCLSampler:
693 return getOrCreateStructPtrType(
"opencl_sampler_t", OCLSamplerDITy);
694 case BuiltinType::OCLEvent:
695 return getOrCreateStructPtrType(
"opencl_event_t", OCLEventDITy);
696 case BuiltinType::OCLClkEvent:
697 return getOrCreateStructPtrType(
"opencl_clk_event_t", OCLClkEventDITy);
698 case BuiltinType::OCLQueue:
699 return getOrCreateStructPtrType(
"opencl_queue_t", OCLQueueDITy);
700 case BuiltinType::OCLReserveID:
701 return getOrCreateStructPtrType(
"opencl_reserve_id_t", OCLReserveIDDITy);
702 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
703 case BuiltinType::Id: \
704 return getOrCreateStructPtrType("opencl_" #ExtType, Id##Ty);
705 #include "clang/Basic/OpenCLExtensionTypes.def"
707 #define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
708 #include "clang/Basic/AArch64SVEACLETypes.def"
712 unsigned NumElemsPerVG = (Info.
EC.getKnownMinValue() * Info.
NumVectors) / 2;
722 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
725 {llvm::dwarf::DW_OP_constu, NumElemsPerVG, llvm::dwarf::DW_OP_bregx,
726 46, 0, llvm::dwarf::DW_OP_mul,
727 llvm::dwarf::DW_OP_constu, 1, llvm::dwarf::DW_OP_minus});
728 auto *UpperBound = DBuilder.createExpression(
Expr);
730 llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(
731 nullptr, LowerBound, UpperBound,
nullptr);
732 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
733 llvm::DIType *ElemTy =
734 getOrCreateType(Info.
ElementType, TheCU->getFile());
736 return DBuilder.createVectorType( 0, Align, ElemTy,
741 #define PPC_VECTOR_TYPE(Name, Id, size) \
742 case BuiltinType::Id:
743 #include "clang/Basic/PPCTypes.def"
746 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
747 #include "clang/Basic/RISCVVTypes.def"
752 unsigned ElementCount = Info.
EC.getKnownMinValue();
755 bool Fractional =
false;
757 unsigned FixedSize = ElementCount * SEW;
761 }
else if (FixedSize < 64) {
764 LMUL = 64 / FixedSize;
766 LMUL = FixedSize / 64;
774 {llvm::dwarf::DW_OP_bregx,
777 llvm::dwarf::DW_OP_constu,
779 llvm::dwarf::DW_OP_div, llvm::dwarf::DW_OP_constu, LMUL});
781 Expr.push_back(llvm::dwarf::DW_OP_div);
783 Expr.push_back(llvm::dwarf::DW_OP_mul);
785 Expr.append({llvm::dwarf::DW_OP_constu, 1, llvm::dwarf::DW_OP_minus});
788 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
790 auto *UpperBound = DBuilder.createExpression(
Expr);
791 llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(
792 nullptr, LowerBound, UpperBound,
nullptr);
793 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
794 llvm::DIType *ElemTy =
795 getOrCreateType(Info.
ElementType, TheCU->getFile());
798 return DBuilder.createVectorType(0, Align, ElemTy,
801 case BuiltinType::UChar:
802 case BuiltinType::Char_U:
803 Encoding = llvm::dwarf::DW_ATE_unsigned_char;
805 case BuiltinType::Char_S:
806 case BuiltinType::SChar:
807 Encoding = llvm::dwarf::DW_ATE_signed_char;
809 case BuiltinType::Char8:
810 case BuiltinType::Char16:
811 case BuiltinType::Char32:
814 case BuiltinType::UShort:
815 case BuiltinType::UInt:
816 case BuiltinType::UInt128:
817 case BuiltinType::ULong:
818 case BuiltinType::WChar_U:
819 case BuiltinType::ULongLong:
820 Encoding = llvm::dwarf::DW_ATE_unsigned;
822 case BuiltinType::Short:
823 case BuiltinType::Int:
824 case BuiltinType::Int128:
825 case BuiltinType::Long:
826 case BuiltinType::WChar_S:
827 case BuiltinType::LongLong:
828 Encoding = llvm::dwarf::DW_ATE_signed;
830 case BuiltinType::Bool:
831 Encoding = llvm::dwarf::DW_ATE_boolean;
833 case BuiltinType::Half:
835 case BuiltinType::LongDouble:
836 case BuiltinType::Float16:
837 case BuiltinType::BFloat16:
838 case BuiltinType::Float128:
839 case BuiltinType::Double:
840 case BuiltinType::Ibm128:
846 Encoding = llvm::dwarf::DW_ATE_float;
848 case BuiltinType::ShortAccum:
849 case BuiltinType::Accum:
850 case BuiltinType::LongAccum:
851 case BuiltinType::ShortFract:
852 case BuiltinType::Fract:
853 case BuiltinType::LongFract:
854 case BuiltinType::SatShortFract:
855 case BuiltinType::SatFract:
856 case BuiltinType::SatLongFract:
857 case BuiltinType::SatShortAccum:
858 case BuiltinType::SatAccum:
859 case BuiltinType::SatLongAccum:
860 Encoding = llvm::dwarf::DW_ATE_signed_fixed;
862 case BuiltinType::UShortAccum:
863 case BuiltinType::UAccum:
864 case BuiltinType::ULongAccum:
865 case BuiltinType::UShortFract:
866 case BuiltinType::UFract:
867 case BuiltinType::ULongFract:
868 case BuiltinType::SatUShortAccum:
869 case BuiltinType::SatUAccum:
870 case BuiltinType::SatULongAccum:
871 case BuiltinType::SatUShortFract:
872 case BuiltinType::SatUFract:
873 case BuiltinType::SatULongFract:
874 Encoding = llvm::dwarf::DW_ATE_unsigned_fixed;
881 return DBuilder.createBasicType(BTName, Size,
Encoding);
884 llvm::DIType *CGDebugInfo::CreateType(
const AutoType *Ty) {
885 return DBuilder.createUnspecifiedType(
"auto");
888 llvm::DIType *CGDebugInfo::CreateType(
const BitIntType *Ty) {
890 StringRef Name = Ty->
isUnsigned() ?
"unsigned _BitInt" :
"_BitInt";
892 ? llvm::dwarf::DW_ATE_unsigned
893 : llvm::dwarf::DW_ATE_signed;
899 llvm::DIType *CGDebugInfo::CreateType(
const ComplexType *Ty) {
901 llvm::dwarf::TypeKind
Encoding = llvm::dwarf::DW_ATE_complex_float;
903 Encoding = llvm::dwarf::DW_ATE_lo_user;
906 return DBuilder.createBasicType(
"complex", Size,
Encoding);
920 return llvm::dwarf::DW_TAG_const_type;
924 return llvm::dwarf::DW_TAG_volatile_type;
928 return llvm::dwarf::DW_TAG_restrict_type;
930 return (llvm::dwarf::Tag)0;
933 llvm::DIType *CGDebugInfo::CreateQualifiedType(
QualType Ty,
934 llvm::DIFile *Unit) {
944 assert(Qc.
empty() &&
"Unknown type qualifier for debug info");
945 return getOrCreateType(
QualType(T, 0), Unit);
952 return DBuilder.createQualifiedType(Tag, FromTy);
956 llvm::DIFile *Unit) {
965 assert(Q.
empty() &&
"Unknown type qualifier for debug info");
976 return DBuilder.createQualifiedType(Tag, FromTy);
980 llvm::DIFile *Unit) {
988 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
992 llvm::DIType *CGDebugInfo::CreateType(
const PointerType *Ty,
993 llvm::DIFile *Unit) {
994 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
1000 switch (TheCU->getSourceLanguage()) {
1001 case llvm::dwarf::DW_LANG_C_plus_plus:
1002 case llvm::dwarf::DW_LANG_C_plus_plus_11:
1003 case llvm::dwarf::DW_LANG_C_plus_plus_14:
1005 case llvm::dwarf::DW_LANG_ObjC_plus_plus:
1006 return isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD);
1034 llvm::DICompileUnit *TheCU) {
1052 llvm::DICompileUnit *TheCU) {
1058 if (
const auto *RD = dyn_cast<CXXRecordDecl>(TD))
1060 if (RD->isDynamicClass() &&
1073 llvm::dwarf::Tag Tag;
1075 Tag = llvm::dwarf::DW_TAG_structure_type;
1077 Tag = llvm::dwarf::DW_TAG_union_type;
1082 Tag = llvm::dwarf::DW_TAG_class_type;
1087 llvm::DICompositeType *
1088 CGDebugInfo::getOrCreateRecordFwdDecl(
const RecordType *Ty,
1089 llvm::DIScope *Ctx) {
1092 return cast<llvm::DICompositeType>(T);
1093 llvm::DIFile *DefUnit = getOrCreateFile(RD->
getLocation());
1094 const unsigned Line =
1096 StringRef RDName = getClassName(RD);
1105 llvm::DINode::DIFlags Flags = llvm::DINode::FlagFwdDecl;
1110 if (
const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1111 if (!CXXRD->hasDefinition() ||
1112 (CXXRD->hasDefinition() && !CXXRD->isTrivial()))
1113 Flags |= llvm::DINode::FlagNonTrivial;
1120 llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
1124 if (
auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
1125 DBuilder.replaceArrays(RetTy, llvm::DINodeArray(),
1126 CollectCXXTemplateParams(TSpecial, DefUnit));
1127 ReplaceMap.emplace_back(
1128 std::piecewise_construct, std::make_tuple(Ty),
1129 std::make_tuple(
static_cast<llvm::Metadata *
>(RetTy)));
1133 llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
1136 llvm::DIFile *Unit) {
1147 auto *BTFAttrTy = dyn_cast<BTFTagAttributedType>(PointeeTy);
1149 StringRef Tag = BTFAttrTy->getAttr()->getBTFTypeTag();
1151 llvm::Metadata *Ops[2] = {
1152 llvm::MDString::get(CGM.
getLLVMContext(), StringRef(
"btf_type_tag")),
1154 Annots.insert(Annots.begin(),
1157 BTFAttrTy = dyn_cast<BTFTagAttributedType>(BTFAttrTy->getWrappedType());
1160 llvm::DINodeArray Annotations =
nullptr;
1161 if (Annots.size() > 0)
1162 Annotations = DBuilder.getOrCreateArray(Annots);
1164 if (Tag == llvm::dwarf::DW_TAG_reference_type ||
1165 Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)
1166 return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit),
1167 Size, Align, DWARFAddressSpace);
1169 return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
1170 Align, DWARFAddressSpace, StringRef(),
1174 llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
1175 llvm::DIType *&
Cache) {
1178 Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
1179 TheCU, TheCU->getFile(), 0);
1181 Cache = DBuilder.createPointerType(
Cache, Size);
1185 uint64_t CGDebugInfo::collectDefaultElementTypesForBlockPointer(
1186 const BlockPointerType *Ty, llvm::DIFile *Unit, llvm::DIDerivedType *DescTy,
1192 uint64_t FieldOffset = 0;
1199 EltTys.push_back(CreateMemberType(Unit, FType,
"__size", &FieldOffset));
1200 EltTys.push_back(CreateMemberType(Unit, FType,
"__align", &FieldOffset));
1203 EltTys.push_back(CreateMemberType(Unit, FType,
"__isa", &FieldOffset));
1205 EltTys.push_back(CreateMemberType(Unit, FType,
"__flags", &FieldOffset));
1206 EltTys.push_back(CreateMemberType(Unit, FType,
"__reserved", &FieldOffset));
1208 EltTys.push_back(CreateMemberType(Unit, FType,
"__FuncPtr", &FieldOffset));
1212 EltTys.push_back(DBuilder.createMemberType(
1213 Unit,
"__descriptor",
nullptr, LineNo, FieldSize, FieldAlign,
1214 FieldOffset, llvm::DINode::FlagZero, DescTy));
1215 FieldOffset += FieldSize;
1222 llvm::DIFile *Unit) {
1225 uint64_t FieldOffset;
1226 llvm::DINodeArray Elements;
1230 EltTys.push_back(CreateMemberType(Unit, FType,
"reserved", &FieldOffset));
1231 EltTys.push_back(CreateMemberType(Unit, FType,
"Size", &FieldOffset));
1233 Elements = DBuilder.getOrCreateArray(EltTys);
1236 llvm::DINode::DIFlags Flags = llvm::DINode::FlagAppleBlock;
1239 DBuilder.createStructType(Unit,
"__block_descriptor",
nullptr, 0,
1240 FieldOffset, 0, Flags,
nullptr, Elements);
1245 auto *DescTy = DBuilder.createPointerType(EltTy, Size);
1247 FieldOffset = collectDefaultElementTypesForBlockPointer(Ty, Unit, DescTy,
1250 Elements = DBuilder.getOrCreateArray(EltTys);
1256 EltTy = DBuilder.createStructType(Unit,
"",
nullptr, 0, FieldOffset, 0,
1257 Flags,
nullptr, Elements);
1259 return DBuilder.createPointerType(EltTy, Size);
1263 llvm::DIFile *Unit) {
1269 ->getTemplatedDecl();
1275 llvm::raw_svector_ostream
OS(NS);
1281 return DBuilder.createTypedef(Src,
OS.str(), getOrCreateFile(Loc),
1283 getDeclContextDescriptor(AliasDecl));
1286 llvm::DIType *CGDebugInfo::CreateType(
const TypedefType *Ty,
1287 llvm::DIFile *Unit) {
1288 llvm::DIType *Underlying =
1300 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(Ty->
getDecl());
1301 return DBuilder.createTypedef(Underlying, Ty->
getDecl()->
getName(),
1302 getOrCreateFile(Loc), getLineNumber(Loc),
1303 getDeclContextDescriptor(Ty->
getDecl()), Align,
1314 return llvm::dwarf::DW_CC_BORLAND_stdcall;
1316 return llvm::dwarf::DW_CC_BORLAND_msfastcall;
1318 return llvm::dwarf::DW_CC_BORLAND_thiscall;
1320 return llvm::dwarf::DW_CC_LLVM_vectorcall;
1322 return llvm::dwarf::DW_CC_BORLAND_pascal;
1324 return llvm::dwarf::DW_CC_LLVM_Win64;
1326 return llvm::dwarf::DW_CC_LLVM_X86_64SysV;
1330 return llvm::dwarf::DW_CC_LLVM_AAPCS;
1332 return llvm::dwarf::DW_CC_LLVM_AAPCS_VFP;
1334 return llvm::dwarf::DW_CC_LLVM_IntelOclBicc;
1336 return llvm::dwarf::DW_CC_LLVM_SpirFunction;
1339 return llvm::dwarf::DW_CC_LLVM_OpenCLKernel;
1341 return llvm::dwarf::DW_CC_LLVM_Swift;
1344 return llvm::dwarf::DW_CC_LLVM_Swift;
1346 return llvm::dwarf::DW_CC_LLVM_PreserveMost;
1348 return llvm::dwarf::DW_CC_LLVM_PreserveAll;
1350 return llvm::dwarf::DW_CC_LLVM_X86RegCall;
1356 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1358 Flags |= llvm::DINode::FlagLValueReference;
1360 Flags |= llvm::DINode::FlagRValueReference;
1364 llvm::DIType *CGDebugInfo::CreateType(
const FunctionType *Ty,
1365 llvm::DIFile *Unit) {
1366 const auto *FPT = dyn_cast<FunctionProtoType>(Ty);
1368 if (llvm::DIType *QTy = CreateQualifiedType(FPT, Unit))
1377 EltTys.push_back(getOrCreateType(Ty->
getReturnType(), Unit));
1379 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1383 EltTys.push_back(DBuilder.createUnspecifiedParameter());
1386 for (
const QualType &ParamType : FPT->param_types())
1387 EltTys.push_back(getOrCreateType(ParamType, Unit));
1388 if (FPT->isVariadic())
1389 EltTys.push_back(DBuilder.createUnspecifiedParameter());
1392 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
1393 llvm::DIType *F = DBuilder.createSubroutineType(
1410 return llvm::DINode::FlagZero;
1414 return llvm::DINode::FlagPrivate;
1416 return llvm::DINode::FlagProtected;
1418 return llvm::DINode::FlagPublic;
1420 return llvm::DINode::FlagZero;
1422 llvm_unreachable(
"unexpected access enumerator");
1425 llvm::DIType *CGDebugInfo::createBitFieldType(
const FieldDecl *BitFieldDecl,
1426 llvm::DIScope *RecordTy,
1428 StringRef Name = BitFieldDecl->
getName();
1431 llvm::DIFile *VUnit = getOrCreateFile(Loc);
1432 llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);
1435 llvm::DIFile *
File = getOrCreateFile(Loc);
1436 unsigned Line = getLineNumber(Loc);
1440 uint64_t SizeInBits = BitFieldInfo.
Size;
1441 assert(SizeInBits > 0 &&
"found named 0-width bitfield");
1442 uint64_t StorageOffsetInBits =
1450 uint64_t OffsetInBits = StorageOffsetInBits +
Offset;
1452 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(BitFieldDecl);
1453 return DBuilder.createBitFieldMemberType(
1454 RecordTy, Name, File,
Line, SizeInBits, OffsetInBits, StorageOffsetInBits,
1455 Flags, DebugType, Annotations);
1458 llvm::DIType *CGDebugInfo::createFieldType(
1460 uint64_t offsetInBits, uint32_t AlignInBits, llvm::DIFile *tunit,
1461 llvm::DIScope *scope,
const RecordDecl *RD, llvm::DINodeArray Annotations) {
1462 llvm::DIType *debugType = getOrCreateType(
type, tunit);
1465 llvm::DIFile *file = getOrCreateFile(loc);
1466 const unsigned line = getLineNumber(loc.
isValid() ? loc : CurLoc);
1468 uint64_t SizeInBits = 0;
1469 auto Align = AlignInBits;
1470 if (!
type->isIncompleteArrayType()) {
1472 SizeInBits = TI.
Width;
1478 return DBuilder.createMemberType(scope,
name, file, line, SizeInBits, Align,
1479 offsetInBits, flags, debugType, Annotations);
1482 void CGDebugInfo::CollectRecordLambdaFields(
1484 llvm::DIType *RecordTy) {
1490 unsigned fieldno = 0;
1493 I != E; ++I, ++Field, ++fieldno) {
1495 if (
C.capturesVariable()) {
1497 assert(!
Field->isBitField() &&
"lambdas don't have bitfield members!");
1499 StringRef VName =
V->getName();
1500 llvm::DIFile *VUnit = getOrCreateFile(Loc);
1502 llvm::DIType *FieldType = createFieldType(
1503 VName,
Field->getType(), Loc,
Field->getAccess(),
1504 layout.
getFieldOffset(fieldno), Align, VUnit, RecordTy, CXXDecl);
1505 elements.push_back(FieldType);
1506 }
else if (
C.capturesThis()) {
1512 llvm::DIFile *VUnit = getOrCreateFile(f->
getLocation());
1514 llvm::DIType *fieldType = createFieldType(
1518 elements.push_back(fieldType);
1523 llvm::DIDerivedType *
1524 CGDebugInfo::CreateRecordStaticField(
const VarDecl *Var, llvm::DIType *RecordTy,
1529 llvm::DIFile *VUnit = getOrCreateFile(Var->
getLocation());
1530 llvm::DIType *VTy = getOrCreateType(Var->
getType(), VUnit);
1532 unsigned LineNumber = getLineNumber(Var->
getLocation());
1533 StringRef VName = Var->
getName();
1534 llvm::Constant *
C =
nullptr;
1540 if (
Value->isFloat())
1547 llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
1548 RecordTy, VName, VUnit, LineNumber, VTy, Flags, C, Align);
1553 void CGDebugInfo::CollectRecordNormalField(
1554 const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit,
1561 if (
name.empty() && !
type->isRecordType())
1564 llvm::DIType *FieldType;
1566 FieldType = createBitFieldType(field, RecordTy, RD);
1569 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(field);
1572 OffsetInBits, Align, tunit, RecordTy, RD, Annotations);
1575 elements.push_back(FieldType);
1578 void CGDebugInfo::CollectRecordNestedType(
1582 if (isa<InjectedClassNameType>(Ty))
1585 llvm::DIType *nestedType = getOrCreateType(Ty, getOrCreateFile(Loc));
1586 elements.push_back(nestedType);
1589 void CGDebugInfo::CollectRecordFields(
1590 const RecordDecl *record, llvm::DIFile *tunit,
1592 llvm::DICompositeType *RecordTy) {
1593 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(record);
1595 if (CXXDecl && CXXDecl->
isLambda())
1596 CollectRecordLambdaFields(CXXDecl, elements, RecordTy);
1601 unsigned fieldNo = 0;
1605 for (
const auto *I : record->
decls())
1606 if (
const auto *
V = dyn_cast<VarDecl>(I)) {
1607 if (
V->hasAttr<NoDebugAttr>())
1613 isa<VarTemplateSpecializationDecl>(
V))
1616 if (isa<VarTemplatePartialSpecializationDecl>(
V))
1620 auto MI = StaticDataMemberCache.find(
V->getCanonicalDecl());
1621 if (MI != StaticDataMemberCache.end()) {
1622 assert(MI->second &&
1623 "Static data member declaration should still exist");
1624 elements.push_back(MI->second);
1626 auto Field = CreateRecordStaticField(
V, RecordTy, record);
1627 elements.push_back(Field);
1629 }
else if (
const auto *field = dyn_cast<FieldDecl>(I)) {
1630 CollectRecordNormalField(field, layout.
getFieldOffset(fieldNo), tunit,
1631 elements, RecordTy, record);
1638 if (
const auto *nestedType = dyn_cast<TypeDecl>(I))
1639 if (!nestedType->isImplicit() &&
1640 nestedType->getDeclContext() == record)
1641 CollectRecordNestedType(nestedType, elements);
1646 llvm::DISubroutineType *
1647 CGDebugInfo::getOrCreateMethodType(
const CXXMethodDecl *Method,
1648 llvm::DIFile *Unit,
bool decl) {
1651 return cast_or_null<llvm::DISubroutineType>(
1652 getOrCreateType(
QualType(Func, 0), Unit));
1653 return getOrCreateInstanceMethodType(Method->
getThisType(), Func, Unit,
decl);
1656 llvm::DISubroutineType *
1657 CGDebugInfo::getOrCreateInstanceMethodType(
QualType ThisPtr,
1659 llvm::DIFile *Unit,
bool decl) {
1674 const auto *OriginalFunc = cast<llvm::DISubroutineType>(
1678 llvm::DITypeRefArray Args = OriginalFunc->getTypeArray();
1679 assert(Args.size() &&
"Invalid number of arguments!");
1685 const AutoType *AT = cast<AutoType>(temp);
1693 Elts.push_back(CreateType(AT));
1695 Elts.push_back(Args[0]);
1699 if (isa<ClassTemplateSpecializationDecl>(RD)) {
1701 const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr);
1706 llvm::DIType *PointeeType = getOrCreateType(PointeeTy, Unit);
1707 llvm::DIType *ThisPtrType =
1708 DBuilder.createPointerType(PointeeType, Size, Align);
1713 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1714 Elts.push_back(ThisPtrType);
1716 llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);
1718 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1719 Elts.push_back(ThisPtrType);
1723 for (
unsigned i = 1, e = Args.size(); i != e; ++i)
1724 Elts.push_back(Args[i]);
1726 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
1728 return DBuilder.createSubroutineType(EltTypeArray, OriginalFunc->getFlags(),
1735 if (
const auto *NRD = dyn_cast<CXXRecordDecl>(RD->
getDeclContext()))
1742 llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
1743 const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {
1745 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
1747 StringRef MethodName = getFunctionName(Method);
1748 llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit,
true);
1752 StringRef MethodLinkageName;
1762 llvm::DIFile *MethodDefUnit =
nullptr;
1763 unsigned MethodLine = 0;
1765 MethodDefUnit = getOrCreateFile(Method->
getLocation());
1766 MethodLine = getLineNumber(Method->
getLocation());
1770 llvm::DIType *ContainingType =
nullptr;
1771 unsigned VIndex = 0;
1772 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1773 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
1778 SPFlags |= llvm::DISubprogram::SPFlagPureVirtual;
1780 SPFlags |= llvm::DISubprogram::SPFlagVirtual;
1785 if (!isa<CXXDestructorDecl>(Method))
1790 const auto *DD = dyn_cast<CXXDestructorDecl>(Method);
1802 Flags |= llvm::DINode::FlagIntroducedVirtual;
1811 ContainingType = RecordTy;
1816 auto checkAttrDeleted = [&](
const auto *Method) {
1818 SPFlags |= llvm::DISubprogram::SPFlagDeleted;
1823 case Decl::CXXConstructor:
1824 case Decl::CXXDestructor:
1825 checkAttrDeleted(Method);
1827 case Decl::CXXMethod:
1830 checkAttrDeleted(Method);
1837 Flags |= llvm::DINode::FlagNoReturn;
1840 Flags |= llvm::DINode::FlagStaticMember;
1842 Flags |= llvm::DINode::FlagArtificial;
1844 if (
const auto *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
1845 if (CXXC->isExplicit())
1846 Flags |= llvm::DINode::FlagExplicit;
1847 }
else if (
const auto *CXXC = dyn_cast<CXXConversionDecl>(Method)) {
1848 if (CXXC->isExplicit())
1849 Flags |= llvm::DINode::FlagExplicit;
1852 Flags |= llvm::DINode::FlagPrototyped;
1854 Flags |= llvm::DINode::FlagLValueReference;
1856 Flags |= llvm::DINode::FlagRValueReference;
1858 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
1860 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
1868 llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
1869 llvm::DISubprogram *SP = DBuilder.createMethod(
1870 RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
1871 MethodTy, VIndex,
ThisAdjustment, ContainingType, Flags, SPFlags,
1872 TParamsArray.get());
1879 void CGDebugInfo::CollectCXXMemberFunctions(
1886 for (
const auto *I : RD->
decls()) {
1887 const auto *Method = dyn_cast<CXXMethodDecl>(I);
1911 EltTys.push_back(MI == SPCache.end()
1912 ? CreateCXXMemberFunction(Method, Unit, RecordTy)
1913 :
static_cast<llvm::Metadata *
>(MI->second));
1917 void CGDebugInfo::CollectCXXBases(
const CXXRecordDecl *RD, llvm::DIFile *Unit,
1919 llvm::DIType *RecordTy) {
1921 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->
bases(), SeenTypes,
1922 llvm::DINode::FlagZero);
1927 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->
vbases(), SeenTypes,
1928 llvm::DINode::FlagIndirectVirtualBase);
1932 void CGDebugInfo::CollectCXXBasesAux(
1937 llvm::DINode::DIFlags StartingFlags) {
1939 for (
const auto &BI : Bases) {
1942 if (!SeenTypes.insert(
Base).second)
1944 auto *BaseTy = getOrCreateType(BI.getType(), Unit);
1945 llvm::DINode::DIFlags BFlags = StartingFlags;
1946 uint64_t BaseOffset;
1947 uint32_t VBPtrOffset = 0;
1949 if (BI.isVirtual()) {
1966 BFlags |= llvm::DINode::FlagVirtual;
1973 llvm::DIType *DTy = DBuilder.createInheritance(RecordTy, BaseTy, BaseOffset,
1974 VBPtrOffset, BFlags);
1975 EltTys.push_back(DTy);
1981 llvm::DIFile *Unit) {
1983 return llvm::DINodeArray();
1984 TemplateArgs &Args = *OArgs;
1986 for (
unsigned i = 0, e = Args.Args.size(); i != e; ++i) {
1989 bool defaultParameter =
false;
1991 Name = Args.TList->getParam(i)->getName();
1994 llvm::DIType *TTy = getOrCreateType(TA.
getAsType(), Unit);
1997 if (
auto *templateType =
1998 dyn_cast_or_null<TemplateTypeParmDecl>(Args.TList->getParam(i)))
1999 if (templateType->hasDefaultArgument())
2001 templateType->getDefaultArgument() == TA.
getAsType();
2003 TemplateParams.push_back(DBuilder.createTemplateTypeParameter(
2004 TheCU, Name, TTy, defaultParameter));
2010 if (
auto *templateType = dyn_cast_or_null<NonTypeTemplateParmDecl>(
2011 Args.TList->getParam(i)))
2012 if (templateType->hasDefaultArgument() &&
2013 !templateType->getDefaultArgument()->isValueDependent())
2014 defaultParameter = llvm::APSInt::isSameValue(
2015 templateType->getDefaultArgument()->EvaluateKnownConstInt(
2019 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2020 TheCU, Name, TTy, defaultParameter,
2026 llvm::DIType *TTy = getOrCreateType(T, Unit);
2027 llvm::Constant *
V =
nullptr;
2031 !D->
hasAttr<CUDADeviceAttr>()) {
2035 if (
const auto *VD = dyn_cast<VarDecl>(D))
2039 else if ((MD = dyn_cast<CXXMethodDecl>(D)) && MD->
isInstance())
2041 else if (
const auto *FD = dyn_cast<FunctionDecl>(D))
2045 else if (
const auto *MPT =
2046 dyn_cast<MemberPointerType>(T.
getTypePtr())) {
2054 }
else if (
const auto *GD = dyn_cast<MSGuidDecl>(D)) {
2056 }
else if (
const auto *TPO = dyn_cast<TemplateParamObjectDecl>(D)) {
2063 assert(
V &&
"Failed to find template parameter pointer");
2064 V =
V->stripPointerCasts();
2066 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2067 TheCU, Name, TTy, defaultParameter, cast_or_null<llvm::Constant>(
V)));
2071 llvm::DIType *TTy = getOrCreateType(T, Unit);
2072 llvm::Constant *
V =
nullptr;
2075 if (
const auto *MPT = dyn_cast<MemberPointerType>(T.
getTypePtr()))
2081 if (MPT->isMemberDataPointer())
2084 V = llvm::ConstantInt::get(CGM.
Int8Ty, 0);
2085 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2086 TheCU, Name, TTy, defaultParameter,
V));
2090 llvm::raw_string_ostream
OS(QualName);
2092 OS, getPrintingPolicy());
2093 TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(
2094 TheCU, Name,
nullptr,
OS.str()));
2098 TemplateParams.push_back(DBuilder.createTemplateParameterPack(
2099 TheCU, Name,
nullptr,
2108 assert(
V &&
"Expression in template argument isn't constant");
2109 llvm::DIType *TTy = getOrCreateType(T, Unit);
2110 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2111 TheCU, Name, TTy, defaultParameter,
V->stripPointerCasts()));
2117 "These argument types shouldn't exist in concrete types");
2120 return DBuilder.getOrCreateArray(TemplateParams);
2124 CGDebugInfo::GetTemplateArgs(
const FunctionDecl *FD)
const {
2135 CGDebugInfo::GetTemplateArgs(
const VarDecl *VD)
const {
2139 auto *TS = dyn_cast<VarTemplateSpecializationDecl>(VD);
2144 auto TA = TS->getTemplateArgs().asArray();
2145 return {{TList, TA}};
2148 CGDebugInfo::GetTemplateArgs(
const RecordDecl *RD)
const {
2149 if (
auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
2154 TSpecial->getSpecializedTemplate()->getTemplateParameters();
2156 return {{TPList, TAList.
asArray()}};
2162 CGDebugInfo::CollectFunctionTemplateParams(
const FunctionDecl *FD,
2163 llvm::DIFile *Unit) {
2164 return CollectTemplateParams(GetTemplateArgs(FD), Unit);
2167 llvm::DINodeArray CGDebugInfo::CollectVarTemplateParams(
const VarDecl *VL,
2168 llvm::DIFile *Unit) {
2169 return CollectTemplateParams(GetTemplateArgs(VL), Unit);
2172 llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(
const RecordDecl *RD,
2173 llvm::DIFile *Unit) {
2174 return CollectTemplateParams(GetTemplateArgs(RD), Unit);
2177 llvm::DINodeArray CGDebugInfo::CollectBTFDeclTagAnnotations(
const Decl *D) {
2178 if (!D->
hasAttr<BTFDeclTagAttr>())
2183 llvm::Metadata *Ops[2] = {
2184 llvm::MDString::get(CGM.
getLLVMContext(), StringRef(
"btf_decl_tag")),
2186 Annotations.push_back(llvm::MDNode::get(CGM.
getLLVMContext(), Ops));
2188 return DBuilder.getOrCreateArray(Annotations);
2191 llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
2193 return VTablePtrType;
2198 llvm::Metadata *STy = getOrCreateType(Context.
IntTy, Unit);
2199 llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);
2200 llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements);
2206 llvm::DIType *vtbl_ptr_type = DBuilder.createPointerType(
2207 SubTy, Size, 0, DWARFAddressSpace,
"__vtbl_ptr_type");
2208 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
2209 return VTablePtrType;
2212 StringRef CGDebugInfo::getVTableName(
const CXXRecordDecl *RD) {
2217 StringRef CGDebugInfo::getDynamicInitializerName(
const VarDecl *VD,
2219 llvm::Function *InitFn) {
2224 return InitFn->getName();
2234 llvm::raw_svector_ostream
OS(QualifiedGV);
2236 std::tie(Quals, GVName) =
OS.str().rsplit(
"::");
2238 std::swap(Quals, GVName);
2242 llvm::raw_svector_ostream
OS(InitName);
2244 OS << Quals <<
"::";
2249 llvm_unreachable(
"not an initializer");
2251 OS <<
"`dynamic initializer for '";
2254 OS <<
"`dynamic atexit destructor for '";
2261 if (
const auto *VTpl = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
2263 getPrintingPolicy());
2268 return internString(
OS.str());
2271 void CGDebugInfo::CollectVTableInfo(
const CXXRecordDecl *RD, llvm::DIFile *Unit,
2288 llvm::DIType *VPtrTy =
nullptr;
2291 if (NeedVTableShape) {
2296 unsigned VSlotCount =
2298 unsigned VTableWidth = PtrWidth * VSlotCount;
2304 llvm::DIType *VTableType = DBuilder.createPointerType(
2305 nullptr, VTableWidth, 0, DWARFAddressSpace,
"__vtbl_ptr_type");
2306 EltTys.push_back(VTableType);
2309 VPtrTy = DBuilder.createPointerType(VTableType, PtrWidth);
2317 VPtrTy = getOrCreateVTablePtrType(Unit);
2320 llvm::DIType *VPtrMember =
2321 DBuilder.createMemberType(Unit, getVTableName(RD), Unit, 0, Size, 0, 0,
2322 llvm::DINode::FlagArtificial, VPtrTy);
2323 EltTys.push_back(VPtrMember);
2329 llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
2341 assert(!D.
isNull() &&
"null type");
2342 llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc));
2343 assert(T &&
"could not create debug info for type");
2359 node = getOrCreateType(AllocatedTy, getOrCreateFile(Loc));
2361 CI->setMetadata(
"heapallocsite",
node);
2369 auto I = TypeCache.find(TyPtr);
2370 if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())
2372 llvm::DIType *Res = CreateTypeDefinition(Ty->
castAs<
EnumType>());
2373 assert(!Res->isForwardDecl());
2374 TypeCache[TyPtr].reset(Res);
2385 if (RD->
hasAttr<DLLImportAttr>())
2388 if (MD->
hasAttr<DLLImportAttr>())
2401 if (
auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) {
2410 bool Explicit =
false;
2411 if (
auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(CXXDecl))
2412 Explicit = TD->isExplicitInstantiationOrSpecialization();
2426 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
2427 if (CXXRD->isDynamicClass() &&
2429 llvm::GlobalValue::AvailableExternallyLinkage &&
2444 auto I = TypeCache.find(TyPtr);
2445 if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
2448 assert(!Res->isForwardDecl());
2449 TypeCache[TyPtr].reset(Res);
2456 if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&
2496 RD->
hasAttr<StandaloneDebugAttr>())
2499 if (!LangOpts.CPlusPlus)
2505 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
2521 if (
const auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
2522 Spec = SD->getSpecializationKind();
2543 llvm::DIType *T = getTypeOrNull(Ty);
2544 if (T && T->isForwardDecl())
2548 llvm::DIType *CGDebugInfo::CreateType(
const RecordType *Ty) {
2550 llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(
QualType(Ty, 0)));
2554 T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));
2558 return CreateTypeDefinition(Ty);
2561 llvm::DIType *CGDebugInfo::CreateTypeDefinition(
const RecordType *Ty) {
2565 llvm::DIFile *DefUnit = getOrCreateFile(RD->
getLocation());
2573 llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty);
2579 if (
const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
2580 CollectContainingType(CXXDecl, FwdDecl);
2583 LexicalBlockStack.emplace_back(&*FwdDecl);
2584 RegionMap[Ty->
getDecl()].reset(FwdDecl);
2594 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
2596 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
2597 CollectVTableInfo(CXXDecl, DefUnit, EltTys);
2601 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
2603 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
2605 LexicalBlockStack.pop_back();
2606 RegionMap.erase(Ty->
getDecl());
2608 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2609 DBuilder.replaceArrays(FwdDecl, Elements);
2611 if (FwdDecl->isTemporary())
2613 llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
2615 RegionMap[Ty->
getDecl()].reset(FwdDecl);
2620 llvm::DIFile *Unit) {
2626 llvm::DIFile *Unit) {
2631 return DBuilder.createTypedef(
2633 Ty->
getDecl()->
getName(), getOrCreateFile(Loc), getLineNumber(Loc),
2634 getDeclContextDescriptor(Ty->
getDecl()));
2662 llvm::DIFile *Unit) {
2670 if (DebugTypeExtRefs &&
ID->isFromASTFile() &&
ID->getDefinition() &&
2671 !
ID->getImplementation())
2672 return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
2674 getDeclContextDescriptor(
ID), Unit, 0);
2677 llvm::DIFile *DefUnit = getOrCreateFile(
ID->getLocation());
2678 unsigned Line = getLineNumber(
ID->getLocation());
2680 static_cast<llvm::dwarf::SourceLanguage
>(TheCU->getSourceLanguage());
2686 llvm::DIScope *Mod = getParentModuleOrNull(
ID);
2687 llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(
2688 llvm::dwarf::DW_TAG_structure_type,
ID->getName(), Mod ? Mod : TheCU,
2689 DefUnit,
Line, RuntimeLang);
2690 ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit));
2694 return CreateTypeDefinition(Ty, Unit);
2698 bool CreateSkeletonCU) {
2703 auto ModRef = ModuleCache.find(M);
2704 if (ModRef != ModuleCache.end())
2705 return cast<llvm::DIModule>(ModRef->second);
2710 llvm::raw_svector_ostream
OS(ConfigMacros);
2714 for (
auto &M : PPOpts.Macros) {
2718 bool Undef = M.second;
2719 OS <<
"\"-" << (Undef ?
'U' :
'D');
2720 for (
char c : Macro)
2735 bool IsRootModule = M ? !M->
Parent :
true;
2739 if (CreateSkeletonCU && IsRootModule && Mod.
getASTFile().empty() && M)
2741 "clang module without ASTFile must be specified by -fmodule-name");
2744 auto RemapPath = [
this](StringRef Path) ->
std::string {
2746 StringRef Relative(Remapped);
2747 StringRef CompDir = TheCU->getDirectory();
2748 if (Relative.consume_front(CompDir))
2749 Relative.consume_front(llvm::sys::path::get_separator());
2751 return Relative.str();
2754 if (CreateSkeletonCU && IsRootModule && !Mod.
getASTFile().empty()) {
2759 uint64_t Signature = 0;
2761 Signature = ModSig.truncatedValue();
2767 if (!llvm::sys::path::is_absolute(Mod.
getASTFile()))
2769 llvm::sys::path::append(PCM, Mod.
getASTFile());
2770 DIB.createCompileUnit(
2771 TheCU->getSourceLanguage(),
2774 TheCU->getProducer(),
false, StringRef(), 0, RemapPath(PCM),
2775 llvm::DICompileUnit::FullDebug, Signature);
2780 IsRootModule ? nullptr
2784 llvm::DIModule *DIMod =
2786 RemapPath(IncludePath));
2787 ModuleCache[M].reset(DIMod);
2792 llvm::DIFile *Unit) {
2794 llvm::DIFile *DefUnit = getOrCreateFile(
ID->getLocation());
2795 unsigned Line = getLineNumber(
ID->getLocation());
2796 unsigned RuntimeLang = TheCU->getSourceLanguage();
2802 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2803 if (
ID->getImplementation())
2804 Flags |= llvm::DINode::FlagObjcClassComplete;
2806 llvm::DIScope *Mod = getParentModuleOrNull(
ID);
2807 llvm::DICompositeType *RealDecl = DBuilder.createStructType(
2808 Mod ? Mod : Unit,
ID->getName(), DefUnit,
Line, Size, Align, Flags,
2809 nullptr, llvm::DINodeArray(), RuntimeLang);
2812 TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl);
2815 LexicalBlockStack.emplace_back(RealDecl);
2816 RegionMap[Ty->
getDecl()].reset(RealDecl);
2823 llvm::DIType *SClassTy =
2828 llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0, 0,
2829 llvm::DINode::FlagZero);
2830 EltTys.push_back(InhTag);
2836 llvm::DIFile *PUnit = getOrCreateFile(Loc);
2837 unsigned PLine = getLineNumber(Loc);
2840 llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(
2841 PD->getName(), PUnit, PLine,
2843 : getSelectorName(PD->getGetterName()),
2845 : getSelectorName(PD->getSetterName()),
2846 PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit));
2847 EltTys.push_back(PropertyNode);
2852 typedef std::pair<char, const IdentifierInfo *> IsClassAndIdent;
2859 return std::make_pair(PD->isClassProperty(), PD->getIdentifier());
2862 for (
auto *PD : ClassExt->properties()) {
2863 PropertySet.insert(GetIsClassAndIdent(PD));
2866 for (
const auto *PD :
ID->properties()) {
2869 if (!PropertySet.insert(GetIsClassAndIdent(PD)).second)
2876 unsigned FieldNo = 0;
2878 Field =
Field->getNextIvar(), ++FieldNo) {
2879 llvm::DIType *FieldTy = getOrCreateType(
Field->getType(), Unit);
2883 StringRef FieldName =
Field->getName();
2886 if (FieldName.empty())
2890 llvm::DIFile *FieldDefUnit = getOrCreateFile(
Field->getLocation());
2891 unsigned FieldLine = getLineNumber(
Field->getLocation());
2893 uint64_t FieldSize = 0;
2894 uint32_t FieldAlign = 0;
2899 FieldSize =
Field->isBitField()
2905 uint64_t FieldOffset;
2910 if (
Field->isBitField()) {
2921 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2923 Flags = llvm::DINode::FlagProtected;
2925 Flags = llvm::DINode::FlagPrivate;
2927 Flags = llvm::DINode::FlagPublic;
2929 llvm::MDNode *PropertyNode =
nullptr;
2932 ImpD->FindPropertyImplIvarDecl(
Field->getIdentifier())) {
2935 llvm::DIFile *PUnit = getOrCreateFile(Loc);
2936 unsigned PLine = getLineNumber(Loc);
2939 PropertyNode = DBuilder.createObjCProperty(
2940 PD->getName(), PUnit, PLine,
2943 : getSelectorName(PD->getGetterName()),
2946 : getSelectorName(PD->getSetterName()),
2947 PD->getPropertyAttributes(),
2948 getOrCreateType(PD->getType(), PUnit));
2952 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine,
2953 FieldSize, FieldAlign, FieldOffset, Flags,
2954 FieldTy, PropertyNode);
2955 EltTys.push_back(FieldTy);
2958 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2959 DBuilder.replaceArrays(RealDecl, Elements);
2961 LexicalBlockStack.pop_back();
2965 llvm::DIType *CGDebugInfo::CreateType(
const VectorType *Ty,
2966 llvm::DIFile *Unit) {
2976 uint64_t NumVectorBytes =
Size / Ctx.getCharWidth();
2979 QualType CharVecTy = Ctx.getVectorType(Ctx.CharTy, NumVectorBytes,
2984 llvm::DIType *ElementTy = getOrCreateType(Ty->
getElementType(), Unit);
2987 llvm::Metadata *Subscript;
2989 auto SizeExpr = SizeExprCache.find(QTy);
2990 if (SizeExpr != SizeExprCache.end())
2991 Subscript = DBuilder.getOrCreateSubrange(
2992 SizeExpr->getSecond() ,
nullptr ,
2993 nullptr ,
nullptr );
2996 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
2997 llvm::Type::getInt64Ty(CGM.
getLLVMContext()), Count ? Count : -1));
2998 Subscript = DBuilder.getOrCreateSubrange(
2999 CountNode ,
nullptr ,
nullptr ,
3002 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
3007 return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
3011 llvm::DIFile *Unit) {
3015 llvm::DIType *ElementTy = getOrCreateType(Ty->
getElementType(), Unit);
3021 auto *ColumnCountNode =
3022 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
3024 auto *RowCountNode =
3025 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
3027 Subscripts.push_back(DBuilder.getOrCreateSubrange(
3028 ColumnCountNode ,
nullptr ,
nullptr ,
3030 Subscripts.push_back(DBuilder.getOrCreateSubrange(
3031 RowCountNode ,
nullptr ,
nullptr ,
3033 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
3034 return DBuilder.createArrayType(Size, Align, ElementTy, SubscriptArray);
3037 llvm::DIType *CGDebugInfo::CreateType(
const ArrayType *Ty, llvm::DIFile *Unit) {
3042 if (
const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
3066 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
3075 if (
const auto *CAT = dyn_cast<ConstantArrayType>(Ty))
3076 Count = CAT->getSize().getZExtValue();
3077 else if (
const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
3078 if (
Expr *Size = VAT->getSizeExpr()) {
3081 Count = Result.Val.getInt().getExtValue();
3085 auto SizeNode = SizeExprCache.find(EltTy);
3086 if (SizeNode != SizeExprCache.end())
3087 Subscripts.push_back(DBuilder.getOrCreateSubrange(
3088 SizeNode->getSecond() ,
nullptr ,
3089 nullptr ,
nullptr ));
3092 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
3094 Subscripts.push_back(DBuilder.getOrCreateSubrange(
3095 CountNode ,
nullptr ,
nullptr ,
3101 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
3103 return DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
3108 llvm::DIFile *Unit) {
3109 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty,
3114 llvm::DIFile *Unit) {
3115 llvm::dwarf::Tag Tag = llvm::dwarf::DW_TAG_rvalue_reference_type;
3119 Tag = llvm::dwarf::DW_TAG_reference_type;
3121 return CreatePointerLikeType(Tag, Ty, Ty->
getPointeeType(), Unit);
3126 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3136 Flags |= llvm::DINode::FlagSingleInheritance;
3139 Flags |= llvm::DINode::FlagMultipleInheritance;
3142 Flags |= llvm::DINode::FlagVirtualInheritance;
3152 return DBuilder.createMemberPointerType(
3158 return DBuilder.createMemberPointerType(
3159 getOrCreateInstanceMethodType(
3162 ClassType,
Size, 0, Flags);
3165 llvm::DIType *CGDebugInfo::CreateType(
const AtomicType *Ty, llvm::DIFile *
U) {
3167 return DBuilder.createQualifiedType(llvm::dwarf::DW_TAG_atomic_type, FromTy);
3170 llvm::DIType *CGDebugInfo::CreateType(
const PipeType *Ty, llvm::DIFile *
U) {
3174 llvm::DIType *CGDebugInfo::CreateEnumType(
const EnumType *Ty) {
3186 bool isImportedFromModule =
3198 llvm::DIScope *EDContext = getDeclContextDescriptor(ED);
3199 llvm::DIFile *DefUnit = getOrCreateFile(ED->
getLocation());
3200 llvm::TempDIScope TmpContext(DBuilder.createReplaceableCompositeType(
3201 llvm::dwarf::DW_TAG_enumeration_type,
"", TheCU, DefUnit, 0));
3204 StringRef EDName = ED->
getName();
3205 llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType(
3206 llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit,
Line,
3207 0, Size, Align, llvm::DINode::FlagFwdDecl,
Identifier);
3209 ReplaceMap.emplace_back(
3210 std::piecewise_construct, std::make_tuple(Ty),
3211 std::make_tuple(
static_cast<llvm::Metadata *
>(RetTy)));
3215 return CreateTypeDefinition(Ty);
3218 llvm::DIType *CGDebugInfo::CreateTypeDefinition(
const EnumType *Ty) {
3232 Enumerators.push_back(
3233 DBuilder.createEnumerator(
Enum->getName(),
Enum->getInitVal()));
3237 llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
3239 llvm::DIFile *DefUnit = getOrCreateFile(ED->
getLocation());
3241 llvm::DIScope *EnumContext = getDeclContextDescriptor(ED);
3242 llvm::DIType *ClassTy = getOrCreateType(ED->
getIntegerType(), DefUnit);
3243 return DBuilder.createEnumerationType(EnumContext, ED->
getName(), DefUnit,
3244 Line, Size, Align, EltArray, ClassTy,
3250 StringRef Name, StringRef
Value) {
3251 unsigned Line = LineLoc.
isInvalid() ? 0 : getLineNumber(LineLoc);
3258 llvm::DIFile *FName = getOrCreateFile(FileLoc);
3259 unsigned Line = LineLoc.
isInvalid() ? 0 : getLineNumber(LineLoc);
3260 return DBuilder.createTempMacroFile(
Parent,
Line, FName);
3270 Quals += InnerQuals;
3274 return C.getQualifiedType(T.
getTypePtr(), Quals);
3275 case Type::TemplateSpecialization: {
3276 const auto *Spec = cast<TemplateSpecializationType>(T);
3277 if (Spec->isTypeAlias())
3278 return C.getQualifiedType(T.
getTypePtr(), Quals);
3279 T = Spec->desugar();
3282 case Type::TypeOfExpr:
3283 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
3286 T = cast<TypeOfType>(T)->getUnderlyingType();
3288 case Type::Decltype:
3289 T = cast<DecltypeType>(T)->getUnderlyingType();
3291 case Type::UnaryTransform:
3292 T = cast<UnaryTransformType>(T)->getUnderlyingType();
3294 case Type::Attributed:
3295 T = cast<AttributedType>(T)->getEquivalentType();
3297 case Type::BTFTagAttributed:
3298 T = cast<BTFTagAttributedType>(T)->getWrappedType();
3300 case Type::Elaborated:
3301 T = cast<ElaboratedType>(T)->getNamedType();
3304 T = cast<UsingType>(T)->getUnderlyingType();
3307 T = cast<ParenType>(T)->getInnerType();
3309 case Type::MacroQualified:
3310 T = cast<MacroQualifiedType>(T)->getUnderlyingType();
3312 case Type::SubstTemplateTypeParm:
3313 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
3316 case Type::DeducedTemplateSpecialization: {
3317 QualType DT = cast<DeducedType>(T)->getDeducedType();
3318 assert(!DT.
isNull() &&
"Undeduced types shouldn't reach here.");
3322 case Type::Adjusted:
3325 T = cast<AdjustedType>(T)->getAdjustedType();
3329 assert(T != LastT &&
"Type unwrapping failed to unwrap!");
3334 llvm::DIType *CGDebugInfo::getTypeOrNull(
QualType Ty) {
3337 if (It != TypeCache.end()) {
3339 if (llvm::Metadata *
V = It->second)
3340 return cast<llvm::DIType>(
V);
3361 llvm::DIType *CGDebugInfo::getOrCreateType(
QualType Ty, llvm::DIFile *Unit) {
3365 llvm::TimeTraceScope TimeScope(
"DebugType", [&]() {
3367 llvm::raw_string_ostream OS(Name);
3368 Ty.
print(OS, getPrintingPolicy());
3375 if (
auto *T = getTypeOrNull(Ty))
3378 llvm::DIType *Res = CreateTypeNode(Ty, Unit);
3379 void *TyPtr = Ty.getAsOpaquePtr();
3382 TypeCache[TyPtr].reset(Res);
3387 llvm::DIModule *CGDebugInfo::getParentModuleOrNull(
const Decl *D) {
3389 if (isa<RecordDecl>(D) && !cast<RecordDecl>(D)->
getDefinition())
3395 auto Info = Reader->getSourceDescriptor(Idx);
3397 return getOrCreateModuleRef(*Info,
true);
3398 }
else if (ClangModuleMap) {
3412 return getOrCreateModuleRef(Info,
false);
3415 return getOrCreateModuleRef(PCHDescriptor,
false);
3422 llvm::DIType *CGDebugInfo::CreateTypeNode(
QualType Ty, llvm::DIFile *Unit) {
3425 return CreateQualifiedType(Ty, Unit);
3429 #define TYPE(Class, Base)
3430 #define ABSTRACT_TYPE(Class, Base)
3431 #define NON_CANONICAL_TYPE(Class, Base)
3432 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
3433 #include "clang/AST/TypeNodes.inc"
3434 llvm_unreachable(
"Dependent types cannot show up in debug information");
3436 case Type::ExtVector:
3438 return CreateType(cast<VectorType>(Ty), Unit);
3439 case Type::ConstantMatrix:
3440 return CreateType(cast<ConstantMatrixType>(Ty), Unit);
3441 case Type::ObjCObjectPointer:
3442 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
3443 case Type::ObjCObject:
3444 return CreateType(cast<ObjCObjectType>(Ty), Unit);
3445 case Type::ObjCTypeParam:
3446 return CreateType(cast<ObjCTypeParamType>(Ty), Unit);
3447 case Type::ObjCInterface:
3448 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
3450 return CreateType(cast<BuiltinType>(Ty));
3452 return CreateType(cast<ComplexType>(Ty));
3454 return CreateType(cast<PointerType>(Ty), Unit);
3455 case Type::BlockPointer:
3456 return CreateType(cast<BlockPointerType>(Ty), Unit);
3458 return CreateType(cast<TypedefType>(Ty), Unit);
3460 return CreateType(cast<RecordType>(Ty));
3462 return CreateEnumType(cast<EnumType>(Ty));
3463 case Type::FunctionProto:
3464 case Type::FunctionNoProto:
3465 return CreateType(cast<FunctionType>(Ty), Unit);
3466 case Type::ConstantArray:
3467 case Type::VariableArray:
3468 case Type::IncompleteArray:
3469 return CreateType(cast<ArrayType>(Ty), Unit);
3471 case Type::LValueReference:
3472 return CreateType(cast<LValueReferenceType>(Ty), Unit);
3473 case Type::RValueReference:
3474 return CreateType(cast<RValueReferenceType>(Ty), Unit);
3476 case Type::MemberPointer:
3477 return CreateType(cast<MemberPointerType>(Ty), Unit);
3480 return CreateType(cast<AtomicType>(Ty), Unit);
3483 return CreateType(cast<BitIntType>(Ty));
3485 return CreateType(cast<PipeType>(Ty), Unit);
3487 case Type::TemplateSpecialization:
3488 return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
3491 case Type::Attributed:
3492 case Type::BTFTagAttributed:
3493 case Type::Adjusted:
3495 case Type::DeducedTemplateSpecialization:
3496 case Type::Elaborated:
3499 case Type::MacroQualified:
3500 case Type::SubstTemplateTypeParm:
3501 case Type::TypeOfExpr:
3503 case Type::Decltype:
3504 case Type::UnaryTransform:
3508 llvm_unreachable(
"type should have been unwrapped!");
3511 llvm::DICompositeType *
3512 CGDebugInfo::getOrCreateLimitedType(
const RecordType *Ty) {
3515 auto *T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));
3520 if (T && !T->isForwardDecl())
3524 llvm::DICompositeType *Res = CreateLimitedType(Ty);
3529 DBuilder.replaceArrays(Res, T ? T->getElements() : llvm::DINodeArray());
3532 TypeCache[QTy.getAsOpaquePtr()].reset(Res);
3537 llvm::DICompositeType *CGDebugInfo::CreateLimitedType(
const RecordType *Ty) {
3541 StringRef RDName = getClassName(RD);
3543 llvm::DIFile *DefUnit =
nullptr;
3546 DefUnit = getOrCreateFile(Loc);
3547 Line = getLineNumber(Loc);
3550 llvm::DIScope *RDContext = getDeclContextDescriptor(RD);
3554 auto *T = cast_or_null<llvm::DICompositeType>(
3563 return getOrCreateRecordFwdDecl(Ty, RDContext);
3576 auto Flags = llvm::DINode::FlagZero;
3577 if (
auto CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3579 Flags |= llvm::DINode::FlagTypePassByReference;
3581 Flags |= llvm::DINode::FlagTypePassByValue;
3584 if (!CXXRD->isTrivial())
3585 Flags |= llvm::DINode::FlagNonTrivial;
3588 if (CXXRD->isAnonymousStructOrUnion())
3589 Flags |= llvm::DINode::FlagExportSymbols;
3592 dyn_cast<CXXRecordDecl>(CXXRD->getDeclContext()));
3595 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(D);
3596 llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
3602 switch (RealDecl->getTag()) {
3604 llvm_unreachable(
"invalid composite type tag");
3606 case llvm::dwarf::DW_TAG_array_type:
3607 case llvm::dwarf::DW_TAG_enumeration_type:
3616 case llvm::dwarf::DW_TAG_structure_type:
3617 case llvm::dwarf::DW_TAG_union_type:
3618 case llvm::dwarf::DW_TAG_class_type:
3621 llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
3625 RegionMap[Ty->
getDecl()].reset(RealDecl);
3628 if (
const auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
3629 DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),
3630 CollectCXXTemplateParams(TSpecial, DefUnit));
3634 void CGDebugInfo::CollectContainingType(
const CXXRecordDecl *RD,
3635 llvm::DICompositeType *RealDecl) {
3637 llvm::DICompositeType *ContainingType =
nullptr;
3649 ContainingType = cast<llvm::DICompositeType>(
3650 getOrCreateType(
QualType(PBase->getTypeForDecl(), 0),
3653 ContainingType = RealDecl;
3655 DBuilder.replaceVTableHolder(RealDecl, ContainingType);
3658 llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit,
QualType FType,
3659 StringRef Name, uint64_t *
Offset) {
3660 llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
3664 DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize, FieldAlign,
3665 *
Offset, llvm::DINode::FlagZero, FieldTy);
3670 void CGDebugInfo::collectFunctionDeclProps(
GlobalDecl GD, llvm::DIFile *Unit,
3672 StringRef &LinkageName,
3673 llvm::DIScope *&FDContext,
3674 llvm::DINodeArray &TParamsArray,
3675 llvm::DINode::DIFlags &Flags) {
3677 Name = getFunctionName(FD);
3682 Flags |= llvm::DINode::FlagPrototyped;
3686 if (LinkageName == Name || (!CGM.
getCodeGenOpts().EmitGcovArcs &&
3691 LinkageName = StringRef();
3700 FDContext = getOrCreateNamespace(NSDecl);
3703 llvm::DIScope *Mod = getParentModuleOrNull(RDecl);
3704 FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU);
3710 Flags |= llvm::DINode::FlagNoReturn;
3712 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
3716 void CGDebugInfo::collectVarDeclProps(
const VarDecl *VD, llvm::DIFile *&Unit,
3718 StringRef &Name, StringRef &LinkageName,
3719 llvm::MDTuple *&TemplateParameters,
3720 llvm::DIScope *&VDContext) {
3740 if (LinkageName == Name)
3741 LinkageName = StringRef();
3743 if (isa<VarTemplateSpecializationDecl>(VD)) {
3744 llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VD, &*Unit);
3745 TemplateParameters = parameterNodes.get();
3747 TemplateParameters =
nullptr;
3767 llvm::DIScope *Mod = getParentModuleOrNull(VD);
3768 VDContext = getContextDescriptor(cast<Decl>(DC), Mod ? Mod : TheCU);
3771 llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(
GlobalDecl GD,
3773 llvm::DINodeArray TParamsArray;
3774 StringRef Name, LinkageName;
3775 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3776 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
3778 llvm::DIFile *Unit = getOrCreateFile(Loc);
3779 llvm::DIScope *DContext = Unit;
3780 unsigned Line = getLineNumber(Loc);
3781 collectFunctionDeclProps(GD, Unit, Name, LinkageName, DContext, TParamsArray,
3783 auto *FD = cast<FunctionDecl>(GD.
getDecl());
3788 ArgTypes.push_back(Parm->getType());
3794 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
3796 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
3799 Flags |= getCallSiteRelatedAttrs();
3800 SPFlags |= llvm::DISubprogram::SPFlagDefinition;
3801 return DBuilder.createFunction(
3802 DContext, Name, LinkageName, Unit,
Line,
3803 getOrCreateFunctionType(GD.
getDecl(), FnType, Unit), 0, Flags, SPFlags,
3804 TParamsArray.get(), getFunctionDeclaration(FD));
3807 llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
3808 DContext, Name, LinkageName, Unit,
Line,
3809 getOrCreateFunctionType(GD.
getDecl(), FnType, Unit), 0, Flags, SPFlags,
3810 TParamsArray.get(), getFunctionDeclaration(FD));
3812 FwdDeclReplaceMap.emplace_back(std::piecewise_construct,
3813 std::make_tuple(CanonDecl),
3814 std::make_tuple(SP));
3818 llvm::DISubprogram *CGDebugInfo::getFunctionForwardDeclaration(
GlobalDecl GD) {
3819 return getFunctionFwdDeclOrStub(GD,
false);
3822 llvm::DISubprogram *CGDebugInfo::getFunctionStub(
GlobalDecl GD) {
3823 return getFunctionFwdDeclOrStub(GD,
true);
3826 llvm::DIGlobalVariable *
3827 CGDebugInfo::getGlobalVariableForwardDeclaration(
const VarDecl *VD) {
3829 StringRef Name, LinkageName;
3831 llvm::DIFile *Unit = getOrCreateFile(Loc);
3832 llvm::DIScope *DContext = Unit;
3833 unsigned Line = getLineNumber(Loc);
3834 llvm::MDTuple *TemplateParameters =
nullptr;
3836 collectVarDeclProps(VD, Unit,
Line, T, Name, LinkageName, TemplateParameters,
3839 auto *GV = DBuilder.createTempGlobalVariableFwdDecl(
3840 DContext, Name, LinkageName, Unit,
Line, getOrCreateType(T, Unit),
3842 FwdDeclReplaceMap.emplace_back(
3843 std::piecewise_construct,
3845 std::make_tuple(
static_cast<llvm::Metadata *
>(GV)));
3849 llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(
const Decl *D) {
3854 if (
const auto *TD = dyn_cast<TypeDecl>(D))
3859 if (I != DeclCache.end()) {
3861 if (
auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(N))
3862 return GVE->getVariable();
3863 return cast<llvm::DINode>(N);
3870 if (IE != ImportedDeclCache.end()) {
3871 auto N = IE->second;
3872 if (
auto *GVE = dyn_cast_or_null<llvm::DIImportedEntity>(N))
3873 return cast<llvm::DINode>(GVE);
3874 return dyn_cast_or_null<llvm::DINode>(N);
3879 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
3880 return getFunctionForwardDeclaration(FD);
3881 else if (
const auto *VD = dyn_cast<VarDecl>(D))
3882 return getGlobalVariableForwardDeclaration(VD);
3887 llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(
const Decl *D) {
3891 const auto *FD = dyn_cast<FunctionDecl>(D);
3896 auto *S = getDeclContextDescriptor(D);
3899 if (MI == SPCache.end()) {
3901 return CreateCXXMemberFunction(MD, getOrCreateFile(MD->
getLocation()),
3902 cast<llvm::DICompositeType>(S));
3905 if (MI != SPCache.end()) {
3906 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3907 if (SP && !SP->isDefinition())
3911 for (
auto NextFD : FD->
redecls()) {
3912 auto MI = SPCache.find(NextFD->getCanonicalDecl());
3913 if (MI != SPCache.end()) {
3914 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3915 if (SP && !SP->isDefinition())
3922 llvm::DISubprogram *CGDebugInfo::getObjCMethodDeclaration(
3923 const Decl *D, llvm::DISubroutineType *FnType,
unsigned LineNo,
3924 llvm::DINode::DIFlags Flags, llvm::DISubprogram::DISPFlags SPFlags) {
3928 const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
3936 SPFlags |= llvm::DISubprogram::SPFlagObjCDirect;
3946 auto It = TypeCache.find(QTy.getAsOpaquePtr());
3947 if (It == TypeCache.end())
3949 auto *InterfaceType = cast<llvm::DICompositeType>(It->second);
3950 llvm::DISubprogram *FD = DBuilder.createFunction(
3951 InterfaceType, getObjCMethodName(OMD), StringRef(),
3952 InterfaceType->getFile(), LineNo, FnType, LineNo, Flags, SPFlags);
3953 DBuilder.finalizeSubprogram(FD);
3960 llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(
const Decl *D,
3969 return DBuilder.createSubroutineType(DBuilder.getOrCreateTypeArray(None));
3971 if (
const auto *Method = dyn_cast<CXXMethodDecl>(D))
3972 return getOrCreateMethodType(Method, F,
false);
3977 if (
const auto *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
3982 QualType ResultTy = OMethod->getReturnType();
3987 QualType(OMethod->getClassInterface()->getTypeForDecl(), 0));
3989 Elts.push_back(getOrCreateType(ResultTy, F));
3992 if (
auto *SelfDecl = OMethod->getSelfDecl())
3993 SelfDeclTy = SelfDecl->getType();
3994 else if (
auto *FPT = dyn_cast<FunctionProtoType>(FnType))
3997 if (!SelfDeclTy.
isNull())
3999 CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F)));
4001 Elts.push_back(DBuilder.createArtificialType(
4004 for (
const auto *PI : OMethod->parameters())
4005 Elts.push_back(getOrCreateType(PI->getType(), F));
4007 if (OMethod->isVariadic())
4008 Elts.push_back(DBuilder.createUnspecifiedParameter());
4010 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
4011 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
4017 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
4018 if (FD->isVariadic()) {
4020 EltTys.push_back(getOrCreateType(FD->getReturnType(), F));
4021 if (
const auto *FPT = dyn_cast<FunctionProtoType>(FnType))
4023 EltTys.push_back(getOrCreateType(ParamType, F));
4024 EltTys.push_back(DBuilder.createUnspecifiedParameter());
4025 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
4026 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
4030 return cast<llvm::DISubroutineType>(getOrCreateType(FnType, F));
4039 CC = SrcFnTy->getCallConv();
4041 for (
const VarDecl *VD : Args)
4042 ArgTypes.push_back(VD->
getType());
4049 llvm::Function *Fn,
bool CurFuncIsThunk) {
4051 StringRef LinkageName;
4053 FnBeginRegionCount.push_back(LexicalBlockStack.size());
4056 bool HasDecl = (D !=
nullptr);
4058 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
4059 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
4060 llvm::DIFile *Unit = getOrCreateFile(Loc);
4061 llvm::DIScope *FDContext = Unit;
4062 llvm::DINodeArray TParamsArray;
4065 LinkageName = Fn->getName();
4066 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
4068 auto FI = SPCache.find(FD->getCanonicalDecl());
4069 if (FI != SPCache.end()) {
4070 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
4071 if (SP && SP->isDefinition()) {
4072 LexicalBlockStack.emplace_back(SP);
4073 RegionMap[D].reset(SP);
4077 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
4078 TParamsArray, Flags);
4079 }
else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
4080 Name = getObjCMethodName(OMD);
4081 Flags |= llvm::DINode::FlagPrototyped;
4082 }
else if (isa<VarDecl>(D) &&
4088 Name = Fn->getName();
4090 if (isa<BlockDecl>(D))
4093 Flags |= llvm::DINode::FlagPrototyped;
4095 if (Name.startswith(
"\01"))
4096 Name = Name.substr(1);
4100 Flags |= llvm::DINode::FlagArtificial;
4106 Flags |= llvm::DINode::FlagThunk;
4108 if (Fn->hasLocalLinkage())
4109 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
4111 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
4113 llvm::DINode::DIFlags FlagsForDef = Flags | getCallSiteRelatedAttrs();
4114 llvm::DISubprogram::DISPFlags SPFlagsForDef =
4115 SPFlags | llvm::DISubprogram::SPFlagDefinition;
4117 const unsigned LineNo = getLineNumber(Loc.
isValid() ? Loc : CurLoc);
4118 unsigned ScopeLine = getLineNumber(ScopeLoc);
4119 llvm::DISubroutineType *DIFnType = getOrCreateFunctionType(D, FnType, Unit);
4120 llvm::DISubprogram *
Decl =
nullptr;
4121 llvm::DINodeArray Annotations =
nullptr;
4123 Decl = isa<ObjCMethodDecl>(D)
4124 ? getObjCMethodDeclaration(D, DIFnType, LineNo, Flags, SPFlags)
4125 : getFunctionDeclaration(D);
4126 Annotations = CollectBTFDeclTagAnnotations(D);
4134 llvm::DISubprogram *SP = DBuilder.createFunction(
4135 FDContext, Name, LinkageName, Unit, LineNo, DIFnType, ScopeLine,
4136 FlagsForDef, SPFlagsForDef, TParamsArray.get(),
Decl,
nullptr,
4138 Fn->setSubprogram(SP);
4142 if (HasDecl && isa<FunctionDecl>(D))
4146 LexicalBlockStack.emplace_back(SP);
4149 RegionMap[D].reset(SP);
4153 QualType FnType, llvm::Function *Fn) {
4155 StringRef LinkageName;
4161 llvm::TimeTraceScope TimeScope(
"DebugFunction", [&]() {
4162 return GetName(D,
true);
4165 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
4166 llvm::DIFile *Unit = getOrCreateFile(Loc);
4167 bool IsDeclForCallSite = Fn ?
true :
false;
4168 llvm::DIScope *FDContext =
4169 IsDeclForCallSite ? Unit : getDeclContextDescriptor(D);
4170 llvm::DINodeArray TParamsArray;
4171 if (isa<FunctionDecl>(D)) {
4173 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
4174 TParamsArray, Flags);
4175 }
else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
4176 Name = getObjCMethodName(OMD);
4177 Flags |= llvm::DINode::FlagPrototyped;
4179 llvm_unreachable(
"not a function or ObjC method");
4181 if (!Name.empty() && Name[0] ==
'\01')
4182 Name = Name.substr(1);
4185 Flags |= llvm::DINode::FlagArtificial;
4190 unsigned LineNo = getLineNumber(Loc);
4191 unsigned ScopeLine = 0;
4192 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
4194 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
4196 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(D);
4197 llvm::DISubprogram *SP = DBuilder.createFunction(
4198 FDContext, Name, LinkageName, Unit, LineNo,
4199 getOrCreateFunctionType(D, FnType, Unit), ScopeLine, Flags, SPFlags,
4200 TParamsArray.get(), getFunctionDeclaration(D),
nullptr, Annotations);
4202 if (IsDeclForCallSite)
4203 Fn->setSubprogram(SP);
4205 DBuilder.finalizeSubprogram(SP);
4213 auto *Func = CallOrInvoke->getCalledFunction();
4216 if (Func->getSubprogram())
4225 getCallSiteRelatedAttrs() == llvm::DINode::FlagZero)
4239 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4241 auto FI = SPCache.find(FD->getCanonicalDecl());
4242 llvm::DISubprogram *SP =
nullptr;
4243 if (FI != SPCache.end())
4244 SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
4245 if (!SP || !SP->isDefinition())
4246 SP = getFunctionStub(GD);
4247 FnBeginRegionCount.push_back(LexicalBlockStack.size());
4248 LexicalBlockStack.emplace_back(SP);
4254 assert(CurInlinedAt &&
"unbalanced inline scope stack");
4263 if (CurLoc.isInvalid() || CurLoc.isMacroID() || LexicalBlockStack.empty())
4266 llvm::MDNode *
Scope = LexicalBlockStack.back();
4267 Builder.SetCurrentDebugLocation(
4268 llvm::DILocation::get(CGM.
getLLVMContext(), getLineNumber(CurLoc),
4269 getColumnNumber(CurLoc),
Scope, CurInlinedAt));
4273 llvm::MDNode *Back =
nullptr;
4274 if (!LexicalBlockStack.empty())
4275 Back = LexicalBlockStack.back().get();
4276 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
4277 cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
4278 getColumnNumber(CurLoc)));
4281 void CGDebugInfo::AppendAddressSpaceXDeref(
4285 if (!DWARFAddressSpace)
4288 Expr.push_back(llvm::dwarf::DW_OP_constu);
4289 Expr.push_back(DWARFAddressSpace.getValue());
4290 Expr.push_back(llvm::dwarf::DW_OP_swap);
4291 Expr.push_back(llvm::dwarf::DW_OP_xderef);
4300 Builder.SetCurrentDebugLocation(llvm::DILocation::get(
4302 LexicalBlockStack.back(), CurInlinedAt));
4308 CreateLexicalBlock(Loc);
4313 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4321 LexicalBlockStack.pop_back();
4325 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4326 unsigned RCount = FnBeginRegionCount.back();
4327 assert(RCount <= LexicalBlockStack.size() &&
"Region stack mismatch");
4330 while (LexicalBlockStack.size() != RCount) {
4333 LexicalBlockStack.pop_back();
4335 FnBeginRegionCount.pop_back();
4337 if (Fn && Fn->getSubprogram())
4338 DBuilder.finalizeSubprogram(Fn->getSubprogram());
4341 CGDebugInfo::BlockByRefType
4342 CGDebugInfo::EmitTypeForVarWithBlocksAttr(
const VarDecl *VD,
4343 uint64_t *XOffset) {
4346 uint64_t FieldSize, FieldOffset;
4347 uint32_t FieldAlign;
4349 llvm::DIFile *Unit = getOrCreateFile(VD->
getLocation());
4354 EltTys.push_back(CreateMemberType(Unit, FType,
"__isa", &FieldOffset));
4355 EltTys.push_back(CreateMemberType(Unit, FType,
"__forwarding", &FieldOffset));
4357 EltTys.push_back(CreateMemberType(Unit, FType,
"__flags", &FieldOffset));
4358 EltTys.push_back(CreateMemberType(Unit, FType,
"__size", &FieldOffset));
4361 if (HasCopyAndDispose) {
4364 CreateMemberType(Unit, FType,
"__copy_helper", &FieldOffset));
4366 CreateMemberType(Unit, FType,
"__destroy_helper", &FieldOffset));
4368 bool HasByrefExtendedLayout;
4371 HasByrefExtendedLayout) &&
4372 HasByrefExtendedLayout) {
4375 CreateMemberType(Unit, FType,
"__byref_variable_layout", &FieldOffset));
4384 CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;
4390 EltTys.push_back(CreateMemberType(Unit, FType,
"", &FieldOffset));
4395 llvm::DIType *WrappedTy = getOrCreateType(FType, Unit);
4399 *XOffset = FieldOffset;
4400 llvm::DIType *FieldTy = DBuilder.createMemberType(
4401 Unit, VD->
getName(), Unit, 0, FieldSize, FieldAlign, FieldOffset,
4402 llvm::DINode::FlagZero, WrappedTy);
4403 EltTys.push_back(FieldTy);
4404 FieldOffset += FieldSize;
4406 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
4407 return {DBuilder.createStructType(Unit,
"", Unit, 0, FieldOffset, 0,
4408 llvm::DINode::FlagZero,
nullptr, Elements),
4412 llvm::DILocalVariable *CGDebugInfo::EmitDeclare(
const VarDecl *VD,
4413 llvm::Value *Storage,
4416 const bool UsePointerValue) {
4418 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4419 if (VD->
hasAttr<NoDebugAttr>())
4425 llvm::DIFile *Unit =
nullptr;
4429 uint64_t XOffset = 0;
4430 if (VD->
hasAttr<BlocksAttr>())
4431 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;
4433 Ty = getOrCreateType(VD->
getType(), Unit);
4442 unsigned Column = 0;
4448 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
4450 Flags |= llvm::DINode::FlagArtificial;
4455 AppendAddressSpaceXDeref(AddressSpace,
Expr);
4459 if (
const auto *IPD = dyn_cast<ImplicitParamDecl>(VD)) {
4462 Flags |= llvm::DINode::FlagObjectPointer;
4469 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
4470 StringRef Name = VD->
getName();
4471 if (!Name.empty()) {
4477 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4482 Expr.push_back(llvm::dwarf::DW_OP_deref);
4483 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4488 }
else if (
const auto *RT = dyn_cast<RecordType>(VD->
getType())) {
4500 for (
const auto *Field : RD->
fields()) {
4501 llvm::DIType *FieldTy = getOrCreateType(
Field->getType(), Unit);
4502 StringRef FieldName =
Field->getName();
4505 if (FieldName.empty() && !isa<RecordType>(
Field->getType()))
4510 auto *D = DBuilder.createAutoVariable(
4512 Flags | llvm::DINode::FlagArtificial, FieldAlign);
4515 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(
Expr),
4519 Builder.GetInsertBlock());
4527 if (UsePointerValue) {
4528 assert(!llvm::is_contained(
Expr, llvm::dwarf::DW_OP_deref) &&
4529 "Debug info already contains DW_OP_deref.");
4530 Expr.push_back(llvm::dwarf::DW_OP_deref);
4534 llvm::DILocalVariable *D =
nullptr;
4536 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(VD);
4537 D = DBuilder.createParameterVariable(
Scope, Name, *ArgNo, Unit,
Line, Ty,
4548 auto RemapCoroArgToLocalVar = [&]() -> llvm::DILocalVariable * {
4551 if (!isa<llvm::DISubprogram>(
Scope) || !
Scope->isDistinct())
4554 auto Iter = llvm::find_if(CoroutineParameterMappings, [&](
auto &Pair) {
4555 Stmt *StmtPtr =
const_cast<Stmt *
>(Pair.second);
4556 if (
DeclStmt *DeclStmtPtr = dyn_cast<DeclStmt>(StmtPtr)) {
4559 if (VD == dyn_cast_or_null<VarDecl>(
Decl))
4565 if (Iter != CoroutineParameterMappings.end()) {
4567 auto Iter2 = llvm::find_if(ParamDbgMappings, [&](
auto &DbgPair) {
4568 return DbgPair.first == PD && DbgPair.second->getScope() ==
Scope;
4570 if (Iter2 != ParamDbgMappings.end())
4571 return const_cast<llvm::DILocalVariable *
>(Iter2->second);
4577 D = RemapCoroArgToLocalVar();
4580 D = DBuilder.createAutoVariable(
Scope, Name, Unit,
Line, Ty,
4584 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(
Expr),
4586 Column,
Scope, CurInlinedAt),
4587 Builder.GetInsertBlock());
4592 llvm::DILocalVariable *CGDebugInfo::EmitDeclare(
const BindingDecl *BD,
4593 llvm::Value *Storage,
4596 const bool UsePointerValue) {
4598 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4599 if (BD->
hasAttr<NoDebugAttr>())
4606 llvm::DIFile *Unit = getOrCreateFile(BD->
getLocation());
4607 llvm::DIType *Ty = getOrCreateType(BD->
getType(), Unit);
4618 AppendAddressSpaceXDeref(AddressSpace,
Expr);
4623 if (UsePointerValue) {
4624 assert(!llvm::is_contained(
Expr, llvm::dwarf::DW_OP_deref) &&
4625 "Debug info already contains DW_OP_deref.");
4626 Expr.push_back(llvm::dwarf::DW_OP_deref);
4630 unsigned Column = getColumnNumber(BD->
getLocation());
4631 StringRef Name = BD->
getName();
4632 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
4634 llvm::DILocalVariable *D = DBuilder.createAutoVariable(
4636 llvm::DINode::FlagZero, Align);
4639 if (
const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
4640 const unsigned fieldIndex = FD->getFieldIndex();
4647 if (fieldOffset != 0) {
4648 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4654 dyn_cast<ArraySubscriptExpr>(BD->
getBinding())) {
4655 if (
const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(ASE->getIdx())) {
4656 const uint64_t value = IL->getValue().getZExtValue();
4660 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4669 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(
Expr),
4671 Column,
Scope, CurInlinedAt),
4672 Builder.GetInsertBlock());
4677 llvm::DILocalVariable *
4680 const bool UsePointerValue) {
4683 if (
auto *DD = dyn_cast<DecompositionDecl>(VD))
4684 for (
auto *B : DD->bindings()) {
4685 EmitDeclare(B, Storage, llvm::None, Builder,
4689 return EmitDeclare(VD, Storage, llvm::None, Builder, UsePointerValue);
4694 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4696 if (D->
hasAttr<NoDebugAttr>())
4699 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
4700 llvm::DIFile *Unit = getOrCreateFile(D->
getLocation());
4704 unsigned Column = getColumnNumber(D->
getLocation());
4706 StringRef Name = D->
getName();
4713 DBuilder.insertLabel(L,
4715 Scope, CurInlinedAt),
4716 Builder.GetInsertBlock());
4719 llvm::DIType *CGDebugInfo::CreateSelfType(
const QualType &QualTy,
4721 llvm::DIType *CachedTy = getTypeOrNull(QualTy);
4724 return DBuilder.createObjectPointerType(Ty);
4729 const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) {
4731 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4733 if (Builder.GetInsertBlock() ==
nullptr)
4735 if (VD->
hasAttr<NoDebugAttr>())
4738 bool isByRef = VD->
hasAttr<BlocksAttr>();
4740 uint64_t XOffset = 0;
4741 llvm::DIFile *Unit = getOrCreateFile(VD->
getLocation());
4744 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;
4746 Ty = getOrCreateType(VD->
getType(), Unit);
4750 if (
const auto *IPD = dyn_cast<ImplicitParamDecl>(VD))
4752 Ty = CreateSelfType(VD->
getType(), Ty);
4755 const unsigned Line =
4757 unsigned Column = getColumnNumber(VD->
getLocation());
4766 addr.push_back(llvm::dwarf::DW_OP_deref);
4767 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4770 addr.push_back(llvm::dwarf::DW_OP_deref);
4771 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4776 addr.push_back(llvm::dwarf::DW_OP_deref);
4777 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4785 auto *D = DBuilder.createAutoVariable(
4786 cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->
getName(), Unit,
4787 Line, Ty,
false, llvm::DINode::FlagZero, Align);
4791 LexicalBlockStack.back(), CurInlinedAt);
4792 auto *
Expr = DBuilder.createExpression(addr);
4794 DBuilder.insertDeclare(Storage, D,
Expr, DL, InsertPoint);
4796 DBuilder.insertDeclare(Storage, D,
Expr, DL, Builder.GetInsertBlock());
4799 llvm::DILocalVariable *
4803 return EmitDeclare(VD, AI, ArgNo, Builder);
4807 struct BlockLayoutChunk {
4808 uint64_t OffsetInBits;
4811 bool operator<(
const BlockLayoutChunk &l,
const BlockLayoutChunk &r) {
4812 return l.OffsetInBits < r.OffsetInBits;
4816 void CGDebugInfo::collectDefaultFieldsForBlockLiteralDeclare(
4818 const llvm::StructLayout &BlockLayout, llvm::DIFile *Unit,
4824 Fields.push_back(createFieldType(
"__size", Context.
IntTy, Loc,
AS_public,
4825 BlockLayout.getElementOffsetInBits(0),
4827 Fields.push_back(createFieldType(
"__align", Context.
IntTy, Loc,
AS_public,
4828 BlockLayout.getElementOffsetInBits(1),
4832 BlockLayout.getElementOffsetInBits(0),
4834 Fields.push_back(createFieldType(
"__flags", Context.
IntTy, Loc,
AS_public,
4835 BlockLayout.getElementOffsetInBits(1),
4839 BlockLayout.getElementOffsetInBits(2), Unit, Unit));
4840 auto *FnTy =
Block.getBlockExpr()->getFunctionType();
4842 Fields.push_back(createFieldType(
"__FuncPtr", FnPtrType, Loc,
AS_public,
4843 BlockLayout.getElementOffsetInBits(3),
4845 Fields.push_back(createFieldType(
4850 Loc,
AS_public, BlockLayout.getElementOffsetInBits(4), Unit, Unit));
4857 llvm::AllocaInst *Alloca,
4865 llvm::DIFile *tunit = getOrCreateFile(loc);
4866 unsigned line = getLineNumber(loc);
4867 unsigned column = getColumnNumber(loc);
4872 const llvm::StructLayout *blockLayout =
4876 collectDefaultFieldsForBlockLiteralDeclare(block, C, loc, *blockLayout, tunit,
4885 BlockLayoutChunk chunk;
4886 chunk.OffsetInBits =
4887 blockLayout->getElementOffsetInBits(block.
CXXThisIndex);
4888 chunk.Capture =
nullptr;
4889 chunks.push_back(chunk);
4893 for (
const auto &capture :
blockDecl->captures()) {
4894 const VarDecl *variable = capture.getVariable();
4901 BlockLayoutChunk chunk;
4902 chunk.OffsetInBits =
4903 blockLayout->getElementOffsetInBits(captureInfo.
getIndex());
4904 chunk.Capture = &capture;
4905 chunks.push_back(chunk);
4909 llvm::array_pod_sort(chunks.begin(), chunks.end());
4911 for (
const BlockLayoutChunk &Chunk : chunks) {
4912 uint64_t offsetInBits = Chunk.OffsetInBits;
4919 cast_or_null<CXXMethodDecl>(
blockDecl->getNonClosureContext()))
4921 else if (
auto *RDecl = dyn_cast<CXXRecordDecl>(
blockDecl->getParent()))
4924 llvm_unreachable(
"unexpected block declcontext");
4926 fields.push_back(createFieldType(
"this",
type, loc,
AS_public,
4927 offsetInBits, tunit, tunit));
4934 llvm::DIType *fieldType;
4936 TypeInfo PtrInfo = C.getTypeInfo(C.VoidPtrTy);
4941 EmitTypeForVarWithBlocksAttr(variable, &xoffset).BlockByRefWrapper;
4942 fieldType = DBuilder.createPointerType(fieldType, PtrInfo.
Width);
4943 fieldType = DBuilder.createMemberType(tunit,
name, tunit, line,
4944 PtrInfo.
Width, Align, offsetInBits,
4945 llvm::DINode::FlagZero, fieldType);
4949 offsetInBits, Align, tunit, tunit);
4951 fields.push_back(fieldType);
4955 llvm::raw_svector_ostream(typeName)
4958 llvm::DINodeArray fieldsArray = DBuilder.getOrCreateArray(fields);
4960 llvm::DIType *
type =
4961 DBuilder.createStructType(tunit, typeName.str(), tunit, line,
4963 llvm::DINode::FlagZero,
nullptr, fieldsArray);
4967 llvm::DINode::DIFlags flags = llvm::DINode::FlagArtificial;
4968 auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back());
4971 auto *debugVar = DBuilder.createParameterVariable(
4972 scope, Name, ArgNo, tunit, line,
type, CGM.
getLangOpts().Optimize, flags);
4975 DBuilder.insertDeclare(Alloca, debugVar, DBuilder.createExpression(),
4977 column, scope, CurInlinedAt),
4978 Builder.GetInsertBlock());
4981 llvm::DIDerivedType *
4982 CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(
const VarDecl *D) {
4987 if (MI != StaticDataMemberCache.end()) {
4988 assert(MI->second &&
"Static data member declaration should still exist");
4995 auto *Ctxt = cast<llvm::DICompositeType>(getDeclContextDescriptor(D));
4996 return CreateRecordStaticField(D, Ctxt, cast<RecordDecl>(DC));
4999 llvm::DIGlobalVariableExpression *CGDebugInfo::CollectAnonRecordDecls(
5000 const RecordDecl *RD, llvm::DIFile *Unit,
unsigned LineNo,
5001 StringRef LinkageName, llvm::GlobalVariable *Var, llvm::DIScope *DContext) {
5002 llvm::DIGlobalVariableExpression *GVE =
nullptr;
5004 for (
const auto *Field : RD->
fields()) {
5005 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
5006 StringRef FieldName = Field->getName();
5009 if (FieldName.empty()) {
5010 if (
const auto *RT = dyn_cast<RecordType>(Field->getType()))
5011 GVE = CollectAnonRecordDecls(RT->getDecl(), Unit, LineNo, LinkageName,
5016 GVE = DBuilder.createGlobalVariableExpression(
5017 DContext, FieldName, LinkageName, Unit, LineNo, FieldTy,
5018 Var->hasLocalLinkage());
5019 Var->addDebugInfo(GVE);
5031 const auto *RD = dyn_cast<CXXRecordDecl>(RT->
getDecl());
5036 auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD);
5044 case TemplateArgument::Pack:
5045 return ReferencesAnonymousEntity(TA.getPackAsArray());
5046 case TemplateArgument::Type: {
5047 struct ReferencesAnonymous
5048 : public RecursiveASTVisitor<ReferencesAnonymous> {
5049 bool RefAnon = false;
5050 bool VisitRecordType(RecordType *RT) {
5051 if (ReferencesAnonymousEntity(RT)) {
5058 ReferencesAnonymous RT;
5059 RT.TraverseType(TA.getAsType());
5072 bool Reconstitutable =
true;
5074 Reconstitutable =
false;
5078 Reconstitutable =
false;
5081 bool VisitType(
Type *T) {
5085 Reconstitutable =
false;
5090 bool TraverseEnumType(
EnumType *ET) {
5093 if (
const auto *ED = dyn_cast<EnumDecl>(ET->
getDecl())) {
5095 Reconstitutable =
false;
5099 Reconstitutable =
false;
5109 return Reconstitutable;
5113 Reconstitutable =
false;
5123 ReconstitutableType T;
5125 return T.Reconstitutable;
5130 llvm::raw_string_ostream
OS(Name);
5131 const NamedDecl *ND = dyn_cast<NamedDecl>(D);
5135 CGM.getCodeGenOpts().getDebugSimpleTemplateNames();
5137 if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
5142 bool IsOperatorOverload =
false;
5143 if (
auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
5144 Args = GetTemplateArgs(RD);
5145 }
else if (
auto *FD = dyn_cast<FunctionDecl>(ND)) {
5146 Args = GetTemplateArgs(FD);
5148 IsOperatorOverload |=
5151 }
else if (
auto *VD = dyn_cast<VarDecl>(ND)) {
5152 Args = GetTemplateArgs(VD);
5158 case TemplateArgument::Template:
5165 case TemplateArgument::Declaration:
5173 case TemplateArgument::NullPtr:
5177 case TemplateArgument::Pack:
5179 return HasReconstitutableArgs(TA.getPackAsArray());
5180 case TemplateArgument::Integral:
5185 return TA.getAsIntegral().getBitWidth() <= 64 &&
5186 IsReconstitutableType(TA.getIntegralType());
5187 case TemplateArgument::Type:
5188 return IsReconstitutableType(TA.getAsType());
5190 llvm_unreachable(
"Other, unresolved, template arguments should "
5191 "not be seen here");
5216 bool Reconstitutable =
5217 Args && HasReconstitutableArgs(Args->Args) && !IsOperatorOverload;
5233 llvm::raw_string_ostream EncodedOriginalNameOS(EncodedOriginalName);
5242 llvm::raw_string_ostream OriginalOS(CanonicalOriginalName);
5244 assert(EncodedOriginalNameOS.str() == OriginalOS.str());
5251 void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
5253 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
5254 if (D->
hasAttr<NoDebugAttr>())
5257 llvm::TimeTraceScope TimeScope(
"DebugGlobalVariable", [&]() {
5258 return GetName(D,
true);
5264 if (Cached != DeclCache.end())
5265 return Var->addDebugInfo(
5266 cast<llvm::DIGlobalVariableExpression>(Cached->second));
5269 llvm::DIFile *Unit =
nullptr;
5270 llvm::DIScope *DContext =
nullptr;
5272 StringRef DeclName, LinkageName;
5274 llvm::MDTuple *TemplateParameters =
nullptr;
5275 collectVarDeclProps(D, Unit, LineNo, T, DeclName, LinkageName,
5276 TemplateParameters, DContext);
5280 llvm::DIGlobalVariableExpression *GVE =
nullptr;
5288 "unnamed non-anonymous struct or union?");
5289 GVE = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
5294 unsigned AddressSpace =
5295 CGM.getContext().getTargetAddressSpace(D->
getType());
5296 if (CGM.getLangOpts().CUDA && CGM.getLangOpts().CUDAIsDevice) {
5297 if (D->
hasAttr<CUDASharedAttr>())
5300 else if (D->
hasAttr<CUDAConstantAttr>())
5304 AppendAddressSpaceXDeref(AddressSpace,
Expr);
5306 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(D);
5307 GVE = DBuilder.createGlobalVariableExpression(
5308 DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit),
5309 Var->hasLocalLinkage(),
true,
5310 Expr.empty() ?
nullptr : DBuilder.createExpression(
Expr),
5311 getOrCreateStaticDataMemberDeclarationOrNull(D), TemplateParameters,
5312 Align, Annotations);
5313 Var->addDebugInfo(GVE);
5319 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
5320 if (VD->
hasAttr<NoDebugAttr>())
5322 llvm::TimeTraceScope TimeScope(
"DebugConstGlobalVariable", [&]() {
5323 return GetName(VD,
true);
5328 llvm::DIFile *Unit = getOrCreateFile(VD->
getLocation());
5329 StringRef Name = VD->
getName();
5330 llvm::DIType *Ty = getOrCreateType(VD->
getType(), Unit);
5332 if (
const auto *ECD = dyn_cast<EnumConstantDecl>(VD)) {
5333 const auto *ED = cast<EnumDecl>(ECD->getDeclContext());
5334 assert(isa<EnumType>(ED->
getTypeForDecl()) &&
"Enum without EnumType?");
5336 if (CGM.getCodeGenOpts().EmitCodeView) {
5347 llvm::DIType *EDTy =
5349 assert (EDTy->getTag() == llvm::dwarf::DW_TAG_enumeration_type);
5360 auto *VarD = dyn_cast<VarDecl>(VD);
5361 if (VarD && VarD->isStaticDataMember()) {
5362 auto *RD = cast<RecordDecl>(VarD->getDeclContext());
5363 getDeclContextDescriptor(VarD);
5368 RetainedTypes.push_back(
5369 CGM.getContext().getRecordType(RD).getAsOpaquePtr());
5373 llvm::DIScope *DContext = getDeclContextDescriptor(VD);
5375 auto &GV = DeclCache[VD];
5378 llvm::DIExpression *InitExpr =
nullptr;
5379 if (CGM.getContext().getTypeSize(VD->
getType()) <= 64) {
5383 DBuilder.createConstantValueExpression(Init.getInt().getExtValue());
5384 else if (Init.isFloat())
5385 InitExpr = DBuilder.createConstantValueExpression(
5386 Init.getFloat().bitcastToAPInt().getZExtValue());
5389 llvm::MDTuple *TemplateParameters =
nullptr;
5391 if (isa<VarTemplateSpecializationDecl>(VD))
5393 llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VarD, &*Unit);
5394 TemplateParameters = parameterNodes.get();
5397 GV.reset(DBuilder.createGlobalVariableExpression(
5398 DContext, Name, StringRef(), Unit, getLineNumber(VD->
getLocation()), Ty,
5399 true,
true, InitExpr, getOrCreateStaticDataMemberDeclarationOrNull(VarD),
5400 TemplateParameters, Align));
5403 void CGDebugInfo::EmitExternalVariable(llvm::GlobalVariable *Var,
5405 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
5406 if (D->
hasAttr<NoDebugAttr>())
5410 llvm::DIFile *Unit = getOrCreateFile(D->
getLocation());
5411 StringRef Name = D->
getName();
5412 llvm::DIType *Ty = getOrCreateType(D->
getType(), Unit);
5414 llvm::DIScope *DContext = getDeclContextDescriptor(D);
5415 llvm::DIGlobalVariableExpression *GVE =
5416 DBuilder.createGlobalVariableExpression(
5417 DContext, Name, StringRef(), Unit, getLineNumber(D->
getLocation()),
5418 Ty,
false,
false,
nullptr,
nullptr,
nullptr, Align);
5419 Var->addDebugInfo(GVE);
5422 void CGDebugInfo::EmitGlobalAlias(
const llvm::GlobalValue *GV,
5427 if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
5430 const auto *D = cast<ValueDecl>(GD.
getDecl());
5431 if (D->
hasAttr<NoDebugAttr>())
5434 auto AliaseeDecl = CGM.getMangledNameDecl(GV->getName());
5449 if (!(DI = getDeclarationOrDefinition(
5450 AliaseeDecl.getCanonicalDecl().getDecl())))
5453 llvm::DIScope *DContext = getDeclContextDescriptor(D);
5456 llvm::DIImportedEntity *ImportDI = DBuilder.createImportedDeclaration(
5457 DContext, DI, getOrCreateFile(Loc), getLineNumber(Loc), D->getName());
5463 void CGDebugInfo::AddStringLiteralDebugInfo(llvm::GlobalVariable *GV,
5466 PresumedLoc PLoc = CGM.getContext().getSourceManager().getPresumedLoc(Loc);
5470 llvm::DIFile *
File = getOrCreateFile(Loc);
5471 llvm::DIGlobalVariableExpression *Debug =
5472 DBuilder.createGlobalVariableExpression(
5473 nullptr, StringRef(), StringRef(), getOrCreateFile(Loc),
5474 getLineNumber(Loc), getOrCreateType(S->getType(),
File),
true);
5475 GV->addDebugInfo(Debug);
5478 llvm::DIScope *CGDebugInfo::getCurrentContextDescriptor(
const Decl *D) {
5479 if (!LexicalBlockStack.empty())
5480 return LexicalBlockStack.back();
5481 llvm::DIScope *Mod = getParentModuleOrNull(D);
5482 return getContextDescriptor(D, Mod ? Mod : TheCU);
5486 if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
5490 CGM.getCodeGenOpts().DebugExplicitImport) {
5494 DBuilder.createImportedModule(
5496 getOrCreateNamespace(NSDecl), getOrCreateFile(Loc), getLineNumber(Loc));
5501 if (llvm::DINode *
Target =
5504 DBuilder.createImportedDeclaration(
5506 getOrCreateFile(Loc), getLineNumber(Loc));
5511 if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
5514 "We shouldn't be codegening an invalid UsingDecl containing no decls");
5516 for (
const auto *USD : UD.
shadows()) {
5521 if (
const auto *FD = dyn_cast<FunctionDecl>(USD->getUnderlyingDecl()))
5522 if (
const auto *AT = FD->getType()
5528 EmitUsingShadowDecl(*USD);
5536 if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
5539 "We shouldn't be codegening an invalid UsingEnumDecl"
5540 " containing no decls");
5542 for (
const auto *USD : UD.
shadows())
5543 EmitUsingShadowDecl(*USD);
5547 if (CGM.getCodeGenOpts().getDebuggerTuning() != llvm::DebuggerKind::LLDB)
5549 if (
Module *M =
ID.getImportedModule()) {
5551 auto Loc =
ID.getLocation();
5552 DBuilder.createImportedDeclaration(
5553 getCurrentContextDescriptor(cast<Decl>(
ID.getDeclContext())),
5554 getOrCreateModuleRef(Info, DebugTypeExtRefs), getOrCreateFile(Loc),
5555 getLineNumber(Loc));
5559 llvm::DIImportedEntity *
5561 if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
5563 auto &VH = NamespaceAliasCache[&NA];
5565 return cast<llvm::DIImportedEntity>(VH);
5566 llvm::DIImportedEntity *R;
5568 if (
const auto *Underlying =
5571 R = DBuilder.createImportedDeclaration(
5573 EmitNamespaceAlias(*Underlying), getOrCreateFile(Loc),
5574 getLineNumber(Loc), NA.
getName());
5576 R = DBuilder.createImportedDeclaration(
5579 getOrCreateFile(Loc), getLineNumber(Loc), NA.
getName());
5585 CGDebugInfo::getOrCreateNamespace(
const NamespaceDecl *NSDecl) {
5589 auto I = NamespaceCache.find(NSDecl);
5590 if (I != NamespaceCache.end())
5591 return cast<llvm::DINamespace>(I->second);
5593 llvm::DIScope *Context = getDeclContextDescriptor(NSDecl);
5595 llvm::DINamespace *NS =
5596 DBuilder.createNameSpace(Context, NSDecl->
getName(), NSDecl->
isInline());
5597 NamespaceCache[NSDecl].reset(NS);
5601 void CGDebugInfo::setDwoId(uint64_t Signature) {
5602 assert(TheCU &&
"no main compile unit");
5603 TheCU->setDWOId(Signature);
5609 for (
size_t i = 0; i != ObjCInterfaceCache.size(); ++i) {
5610 ObjCInterfaceCacheEntry E = ObjCInterfaceCache[i];
5611 llvm::DIType *Ty = E.Type->getDecl()->getDefinition()
5612 ? CreateTypeDefinition(E.Type, E.Unit)
5614 DBuilder.replaceTemporary(llvm::TempDIType(E.Decl), Ty);
5618 for (
const auto &
P : ObjCMethodCache) {
5619 if (
P.second.empty())
5622 QualType QTy(
P.first->getTypeForDecl(), 0);
5624 assert(It != TypeCache.end());
5626 llvm::DICompositeType *InterfaceDecl =
5627 cast<llvm::DICompositeType>(It->second);
5629 auto CurElts = InterfaceDecl->getElements();
5633 for (
auto &SubprogramDirect :
P.second)
5634 if (CGM.getCodeGenOpts().DwarfVersion >= 5 || SubprogramDirect.getInt())
5635 EltTys.push_back(SubprogramDirect.getPointer());
5637 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
5638 DBuilder.replaceArrays(InterfaceDecl, Elements);
5641 for (
const auto &
P : ReplaceMap) {
5643 auto *Ty = cast<llvm::DIType>(
P.second);
5644 assert(Ty->isForwardDecl());
5646 auto It = TypeCache.find(
P.first);
5647 assert(It != TypeCache.end());
5650 DBuilder.replaceTemporary(llvm::TempDIType(Ty),
5651 cast<llvm::DIType>(It->second));
5654 for (
const auto &
P : FwdDeclReplaceMap) {
5656 llvm::TempMDNode FwdDecl(cast<llvm::MDNode>(
P.second));
5657 llvm::Metadata *Repl;
5659 auto It = DeclCache.find(
P.first);
5663 if (It == DeclCache.end())
5668 if (
auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(Repl))
5669 Repl = GVE->getVariable();
5670 DBuilder.replaceTemporary(std::move(FwdDecl), cast<llvm::MDNode>(Repl));
5675 for (
auto &RT : RetainedTypes)
5676 if (
auto MD = TypeCache[RT])
5677 DBuilder.retainType(cast<llvm::DIType>(MD));
5679 DBuilder.finalize();
5684 if (CGM.getCodeGenOpts().hasReducedDebugInfo())
5685 if (
auto *DieTy = getOrCreateType(Ty, TheCU->getFile()))
5686 DBuilder.retainType(DieTy);
5690 if (CGM.getCodeGenOpts().hasMaybeUnusedDebugInfo())
5691 if (
auto *DieTy = getOrCreateType(Ty, TheCU->getFile()))
5692 DBuilder.retainType(DieTy);
5696 if (LexicalBlockStack.empty())
5697 return llvm::DebugLoc();
5699 llvm::MDNode *
Scope = LexicalBlockStack.back();
5700 return llvm::DILocation::get(CGM.getLLVMContext(), getLineNumber(Loc),
5701 getColumnNumber(Loc),
Scope);
5704 llvm::DINode::DIFlags CGDebugInfo::getCallSiteRelatedAttrs()
const {
5709 return llvm::DINode::FlagZero;
5714 bool SupportsDWARFv4Ext =
5715 CGM.getCodeGenOpts().DwarfVersion == 4 &&
5716 (CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB ||
5717 CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::GDB);
5719 if (!SupportsDWARFv4Ext && CGM.getCodeGenOpts().DwarfVersion < 5)
5720 return llvm::DINode::FlagZero;