38#include "llvm/ADT/DenseSet.h"
39#include "llvm/ADT/SmallVector.h"
40#include "llvm/ADT/StringExtras.h"
41#include "llvm/IR/Constants.h"
42#include "llvm/IR/DataLayout.h"
43#include "llvm/IR/DerivedTypes.h"
44#include "llvm/IR/Instructions.h"
45#include "llvm/IR/Intrinsics.h"
46#include "llvm/IR/Metadata.h"
47#include "llvm/IR/Module.h"
48#include "llvm/Support/FileSystem.h"
49#include "llvm/Support/MD5.h"
50#include "llvm/Support/Path.h"
51#include "llvm/Support/SHA1.h"
52#include "llvm/Support/SHA256.h"
53#include "llvm/Support/TimeProfiler.h"
72 : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
73 DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),
74 DBuilder(CGM.getModule()) {
76 DebugPrefixMap[KV.first] = KV.second;
81 assert(LexicalBlockStack.empty() &&
82 "Region stack mismatch, stack not empty!");
88 init(TemporaryLocation);
95 init(TemporaryLocation, DefaultToEmpty);
99 bool DefaultToEmpty) {
106 OriginalLocation = CGF->
Builder.getCurrentDebugLocation();
108 if (OriginalLocation && !DI->CGM.getExpressionLocationsEnabled())
111 if (TemporaryLocation.
isValid()) {
112 DI->EmitLocation(CGF->
Builder, TemporaryLocation);
116 if (DefaultToEmpty) {
117 CGF->
Builder.SetCurrentDebugLocation(llvm::DebugLoc());
122 assert(!DI->LexicalBlockStack.empty());
123 CGF->
Builder.SetCurrentDebugLocation(
124 llvm::DILocation::get(DI->LexicalBlockStack.back()->getContext(), 0, 0,
125 DI->LexicalBlockStack.back(), DI->getInlinedAt()));
139 OriginalLocation = CGF.
Builder.getCurrentDebugLocation();
141 CGF.
Builder.SetCurrentDebugLocation(std::move(Loc));
148 CGF->
Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
159 SavedLocation = DI.getLocation();
160 assert((DI.getInlinedAt() ==
161 CGF.
Builder.getCurrentDebugLocation()->getInlinedAt()) &&
162 "CGDebugInfo and IRBuilder are out of sync");
164 DI.EmitInlineFunctionStart(CGF.
Builder, InlinedFn);
172 DI.EmitLocation(CGF->
Builder, SavedLocation);
185 if (LexicalBlockStack.empty())
189 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
191 if (PCLoc.
isInvalid() ||
Scope->getFile() == getOrCreateFile(CurLoc))
194 if (
auto *LBF = dyn_cast<llvm::DILexicalBlockFile>(
Scope)) {
195 LexicalBlockStack.pop_back();
196 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlockFile(
197 LBF->getScope(), getOrCreateFile(CurLoc)));
198 }
else if (isa<llvm::DILexicalBlock>(
Scope) ||
199 isa<llvm::DISubprogram>(
Scope)) {
200 LexicalBlockStack.pop_back();
201 LexicalBlockStack.emplace_back(
202 DBuilder.createLexicalBlockFile(
Scope, getOrCreateFile(CurLoc)));
206llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(
const Decl *D) {
207 llvm::DIScope *Mod = getParentModuleOrNull(D);
212llvm::DIScope *CGDebugInfo::getContextDescriptor(
const Decl *Context,
217 auto I = RegionMap.find(Context);
218 if (I != RegionMap.end()) {
219 llvm::Metadata *
V = I->second;
220 return dyn_cast_or_null<llvm::DIScope>(
V);
224 if (
const auto *NSDecl = dyn_cast<NamespaceDecl>(Context))
225 return getOrCreateNamespace(NSDecl);
227 if (
const auto *RDecl = dyn_cast<RecordDecl>(Context))
228 if (!RDecl->isDependentType())
262StringRef CGDebugInfo::getFunctionName(
const FunctionDecl *FD) {
263 return internString(GetName(FD));
266StringRef CGDebugInfo::getObjCMethodName(
const ObjCMethodDecl *OMD) {
268 llvm::raw_svector_ostream
OS(MethodName);
271 if (
const auto *OID = dyn_cast<ObjCImplementationDecl>(DC)) {
272 OS << OID->getName();
273 }
else if (
const auto *OID = dyn_cast<ObjCInterfaceDecl>(DC)) {
274 OS << OID->getName();
275 }
else if (
const auto *OC = dyn_cast<ObjCCategoryDecl>(DC)) {
276 if (OC->IsClassExtension()) {
277 OS << OC->getClassInterface()->getName();
279 OS << OC->getIdentifier()->getNameStart() <<
'('
280 << OC->getIdentifier()->getNameStart() <<
')';
282 }
else if (
const auto *OCD = dyn_cast<ObjCCategoryImplDecl>(DC)) {
283 OS << OCD->getClassInterface()->getName() <<
'(' << OCD->getName() <<
')';
287 return internString(
OS.str());
290StringRef CGDebugInfo::getSelectorName(
Selector S) {
291 return internString(S.getAsString());
294StringRef CGDebugInfo::getClassName(
const RecordDecl *RD) {
295 if (isa<ClassTemplateSpecializationDecl>(RD)) {
297 return internString(GetName(RD));
303 return II->getName();
311 "Typedef should not be in another decl context!");
312 assert(D->getDeclName().getAsIdentifierInfo() &&
313 "Typedef was not named!");
314 return D->getDeclName().getAsIdentifierInfo()->getName();
324 Name = DD->getName();
329 Name = TND->getName();
332 if (
const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
333 if (CXXRD->isLambda())
341 return internString(UnnamedType);
349std::optional<llvm::DIFile::ChecksumKind>
358 std::optional<llvm::MemoryBufferRef> MemBuffer =
SM.getBufferOrNone(FID);
362 auto Data = llvm::arrayRefFromStringRef(MemBuffer->getBuffer());
365 llvm::toHex(llvm::MD5::hash(
Data),
true, Checksum);
366 return llvm::DIFile::CSK_MD5;
368 llvm::toHex(llvm::SHA1::hash(
Data),
true, Checksum);
369 return llvm::DIFile::CSK_SHA1;
371 llvm::toHex(llvm::SHA256::hash(
Data),
true, Checksum);
372 return llvm::DIFile::CSK_SHA256;
374 llvm_unreachable(
"Unhandled DebugSrcHashKind enum");
377std::optional<StringRef> CGDebugInfo::getSource(
const SourceManager &
SM,
382 bool SourceInvalid =
false;
383 StringRef Source =
SM.getBufferData(FID, &SourceInvalid);
400 FileName = TheCU->getFile()->getFilename();
405 if (FileName.empty()) {
406 FileName = TheCU->getFile()->getFilename();
414 auto It = DIFileCache.find(FileName.data());
415 if (It != DIFileCache.end()) {
417 if (llvm::Metadata *
V = It->second)
418 return cast<llvm::DIFile>(
V);
423 std::optional<llvm::DIFile::ChecksumKind> CSKind =
424 computeChecksum(FID, Checksum);
425 std::optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo;
427 CSInfo.emplace(*CSKind, Checksum);
428 return createFile(FileName, CSInfo, getSource(
SM,
SM.getFileID(Loc)));
431llvm::DIFile *CGDebugInfo::createFile(
433 std::optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo,
434 std::optional<StringRef> Source) {
438 std::string CurDir =
remapDIPath(getCurrentDirname());
441 if (llvm::sys::path::is_absolute(RemappedFile)) {
444 auto FileIt = llvm::sys::path::begin(RemappedFile);
445 auto FileE = llvm::sys::path::end(RemappedFile);
446 auto CurDirIt = llvm::sys::path::begin(CurDir);
447 auto CurDirE = llvm::sys::path::end(CurDir);
448 for (; CurDirIt != CurDirE && *CurDirIt == *FileIt; ++CurDirIt, ++FileIt)
449 llvm::sys::path::append(DirBuf, *CurDirIt);
450 if (llvm::sys::path::root_path(DirBuf) == DirBuf) {
456 for (; FileIt != FileE; ++FileIt)
457 llvm::sys::path::append(FileBuf, *FileIt);
462 if (!llvm::sys::path::is_absolute(FileName))
466 llvm::DIFile *F = DBuilder.createFile(
File, Dir, CSInfo, Source);
467 DIFileCache[FileName.data()].reset(F);
472 if (DebugPrefixMap.empty())
476 for (
const auto &Entry : DebugPrefixMap)
477 if (llvm::sys::path::replace_path_prefix(
P, Entry.first, Entry.second))
479 return P.str().str();
486 return SM.getPresumedLoc(Loc).getLine();
489unsigned CGDebugInfo::getColumnNumber(
SourceLocation Loc,
bool Force) {
502StringRef CGDebugInfo::getCurrentDirname() {
506 if (!CWDName.empty())
508 llvm::ErrorOr<std::string> CWD =
512 return CWDName = internString(*CWD);
515void CGDebugInfo::CreateCompileUnit() {
517 std::optional<llvm::DIFile::ChecksumKind> CSKind;
518 std::optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo;
531 if (MainFileName.empty())
532 MainFileName =
"<stdin>";
538 std::string MainFileDir;
540 SM.getFileEntryRefForID(
SM.getMainFileID())) {
541 MainFileDir = std::string(MainFile->getDir().getName());
542 if (!llvm::sys::path::is_absolute(MainFileName)) {
544 llvm::sys::path::append(MainFileDirSS, MainFileName);
546 std::string(llvm::sys::path::remove_leading_dotslash(MainFileDirSS));
552 if (MainFile->getName() == MainFileName &&
554 MainFile->getName().rsplit(
'.').second)
556 MainFileName = CGM.
getModule().getName().str();
558 CSKind = computeChecksum(
SM.getMainFileID(), Checksum);
561 llvm::dwarf::SourceLanguage LangTag;
565 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
566 else if (CGO.DebugStrictDwarf && CGO.DwarfVersion < 5)
567 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
568 else if (LO.CPlusPlus14)
569 LangTag = llvm::dwarf::DW_LANG_C_plus_plus_14;
570 else if (LO.CPlusPlus11)
571 LangTag = llvm::dwarf::DW_LANG_C_plus_plus_11;
573 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
574 }
else if (LO.ObjC) {
575 LangTag = llvm::dwarf::DW_LANG_ObjC;
576 }
else if (LO.OpenCL && (!CGM.
getCodeGenOpts().DebugStrictDwarf ||
578 LangTag = llvm::dwarf::DW_LANG_OpenCL;
579 }
else if (LO.RenderScript) {
580 LangTag = llvm::dwarf::DW_LANG_GOOGLE_RenderScript;
581 }
else if (LO.C11 && !(CGO.DebugStrictDwarf && CGO.DwarfVersion < 5)) {
582 LangTag = llvm::dwarf::DW_LANG_C11;
584 LangTag = llvm::dwarf::DW_LANG_C99;
586 LangTag = llvm::dwarf::DW_LANG_C89;
592 unsigned RuntimeVers = 0;
596 llvm::DICompileUnit::DebugEmissionKind EmissionKind;
600 EmissionKind = llvm::DICompileUnit::NoDebug;
603 EmissionKind = llvm::DICompileUnit::LineTablesOnly;
606 EmissionKind = llvm::DICompileUnit::DebugDirectivesOnly;
612 EmissionKind = llvm::DICompileUnit::FullDebug;
623 CSInfo.emplace(*CSKind, Checksum);
624 llvm::DIFile *CUFile = DBuilder.createFile(
626 getSource(
SM,
SM.getMainFileID()));
628 StringRef Sysroot, SDK;
629 if (CGM.
getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB) {
631 auto B = llvm::sys::path::rbegin(Sysroot);
632 auto E = llvm::sys::path::rend(Sysroot);
633 auto It = std::find_if(B, E, [](
auto SDK) {
return SDK.endswith(
".sdk"); });
639 TheCU = DBuilder.createCompileUnit(
640 LangTag, CUFile, CGOpts.EmitVersionIdentMetadata ? Producer :
"",
641 LO.Optimize || CGOpts.PrepareForLTO || CGOpts.PrepareForThinLTO,
642 CGOpts.DwarfDebugFlags, RuntimeVers, CGOpts.SplitDwarfFile, EmissionKind,
643 DwoId, CGOpts.SplitDwarfInlining, CGOpts.DebugInfoForProfiling,
645 ? llvm::DICompileUnit::DebugNameTableKind::None
646 :
static_cast<llvm::DICompileUnit::DebugNameTableKind
>(
647 CGOpts.DebugNameTable),
648 CGOpts.DebugRangesBaseAddress,
remapDIPath(Sysroot), SDK);
651llvm::DIType *CGDebugInfo::CreateType(
const BuiltinType *BT) {
655#define BUILTIN_TYPE(Id, SingletonId)
656#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
657#include "clang/AST/BuiltinTypes.def"
658 case BuiltinType::Dependent:
659 llvm_unreachable(
"Unexpected builtin type");
660 case BuiltinType::NullPtr:
661 return DBuilder.createNullPtrType();
662 case BuiltinType::Void:
664 case BuiltinType::ObjCClass:
667 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
668 "objc_class", TheCU, TheCU->getFile(), 0);
670 case BuiltinType::ObjCId: {
681 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
682 "objc_class", TheCU, TheCU->getFile(), 0);
686 auto *ISATy = DBuilder.createPointerType(ClassTy, Size);
688 ObjTy = DBuilder.createStructType(TheCU,
"objc_object", TheCU->getFile(), 0,
689 0, 0, llvm::DINode::FlagZero,
nullptr,
690 llvm::DINodeArray());
692 DBuilder.replaceArrays(
693 ObjTy, DBuilder.getOrCreateArray(&*DBuilder.createMemberType(
694 ObjTy,
"isa", TheCU->getFile(), 0, Size, 0, 0,
695 llvm::DINode::FlagZero, ISATy)));
698 case BuiltinType::ObjCSel: {
700 SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
701 "objc_selector", TheCU,
702 TheCU->getFile(), 0);
706#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
707 case BuiltinType::Id: \
708 return getOrCreateStructPtrType("opencl_" #ImgType "_" #Suffix "_t", \
710#include "clang/Basic/OpenCLImageTypes.def"
711 case BuiltinType::OCLSampler:
712 return getOrCreateStructPtrType(
"opencl_sampler_t", OCLSamplerDITy);
713 case BuiltinType::OCLEvent:
714 return getOrCreateStructPtrType(
"opencl_event_t", OCLEventDITy);
715 case BuiltinType::OCLClkEvent:
716 return getOrCreateStructPtrType(
"opencl_clk_event_t", OCLClkEventDITy);
717 case BuiltinType::OCLQueue:
718 return getOrCreateStructPtrType(
"opencl_queue_t", OCLQueueDITy);
719 case BuiltinType::OCLReserveID:
720 return getOrCreateStructPtrType(
"opencl_reserve_id_t", OCLReserveIDDITy);
721#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
722 case BuiltinType::Id: \
723 return getOrCreateStructPtrType("opencl_" #ExtType, Id##Ty);
724#include "clang/Basic/OpenCLExtensionTypes.def"
726#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
727#include "clang/Basic/AArch64SVEACLETypes.def"
731 BT->
getKind() == BuiltinType::SveCount
735 : CGM.getContext().getBuiltinVectorTypeInfo(BT);
742 "Unsupported number of vectors for svcount_t");
746 unsigned NumElems = Info.
EC.getKnownMinValue() * Info.
NumVectors;
752 llvm::Metadata *LowerBound, *UpperBound;
753 LowerBound = llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
755 if (Info.
EC.isScalable()) {
756 unsigned NumElemsPerVG = NumElems / 2;
758 {llvm::dwarf::DW_OP_constu, NumElemsPerVG, llvm::dwarf::DW_OP_bregx,
759 46, 0, llvm::dwarf::DW_OP_mul,
760 llvm::dwarf::DW_OP_constu, 1, llvm::dwarf::DW_OP_minus});
761 UpperBound = DBuilder.createExpression(
Expr);
763 UpperBound = llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
766 llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(
767 nullptr, LowerBound, UpperBound,
nullptr);
768 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
769 llvm::DIType *ElemTy =
770 getOrCreateType(Info.
ElementType, TheCU->getFile());
772 return DBuilder.createVectorType( 0, Align, ElemTy,
777#define PPC_VECTOR_TYPE(Name, Id, size) \
778 case BuiltinType::Id:
779#include "clang/Basic/PPCTypes.def"
782#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
783#include "clang/Basic/RISCVVTypes.def"
788 unsigned ElementCount = Info.
EC.getKnownMinValue();
791 bool Fractional =
false;
793 unsigned FixedSize = ElementCount * SEW;
797 }
else if (FixedSize < 64) {
800 LMUL = 64 / FixedSize;
802 LMUL = FixedSize / 64;
810 {llvm::dwarf::DW_OP_bregx,
813 llvm::dwarf::DW_OP_constu,
815 llvm::dwarf::DW_OP_div, llvm::dwarf::DW_OP_constu, LMUL});
817 Expr.push_back(llvm::dwarf::DW_OP_div);
819 Expr.push_back(llvm::dwarf::DW_OP_mul);
821 Expr.append({llvm::dwarf::DW_OP_constu, 1, llvm::dwarf::DW_OP_minus});
824 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
826 auto *UpperBound = DBuilder.createExpression(
Expr);
827 llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(
828 nullptr, LowerBound, UpperBound,
nullptr);
829 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
830 llvm::DIType *ElemTy =
831 getOrCreateType(Info.
ElementType, TheCU->getFile());
834 return DBuilder.createVectorType(0, Align, ElemTy,
838#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS) \
839 case BuiltinType::Id: { \
842 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, \
843 MangledName, TheCU, TheCU->getFile(), 0); \
844 return SingletonId; \
846#include "clang/Basic/WebAssemblyReferenceTypes.def"
848 case BuiltinType::UChar:
849 case BuiltinType::Char_U:
850 Encoding = llvm::dwarf::DW_ATE_unsigned_char;
852 case BuiltinType::Char_S:
853 case BuiltinType::SChar:
854 Encoding = llvm::dwarf::DW_ATE_signed_char;
856 case BuiltinType::Char8:
857 case BuiltinType::Char16:
858 case BuiltinType::Char32:
861 case BuiltinType::UShort:
862 case BuiltinType::UInt:
863 case BuiltinType::UInt128:
864 case BuiltinType::ULong:
865 case BuiltinType::WChar_U:
866 case BuiltinType::ULongLong:
867 Encoding = llvm::dwarf::DW_ATE_unsigned;
869 case BuiltinType::Short:
870 case BuiltinType::Int:
871 case BuiltinType::Int128:
872 case BuiltinType::Long:
873 case BuiltinType::WChar_S:
874 case BuiltinType::LongLong:
875 Encoding = llvm::dwarf::DW_ATE_signed;
877 case BuiltinType::Bool:
878 Encoding = llvm::dwarf::DW_ATE_boolean;
880 case BuiltinType::Half:
881 case BuiltinType::Float:
882 case BuiltinType::LongDouble:
883 case BuiltinType::Float16:
884 case BuiltinType::BFloat16:
885 case BuiltinType::Float128:
886 case BuiltinType::Double:
887 case BuiltinType::Ibm128:
893 Encoding = llvm::dwarf::DW_ATE_float;
895 case BuiltinType::ShortAccum:
896 case BuiltinType::Accum:
897 case BuiltinType::LongAccum:
898 case BuiltinType::ShortFract:
899 case BuiltinType::Fract:
900 case BuiltinType::LongFract:
901 case BuiltinType::SatShortFract:
902 case BuiltinType::SatFract:
903 case BuiltinType::SatLongFract:
904 case BuiltinType::SatShortAccum:
905 case BuiltinType::SatAccum:
906 case BuiltinType::SatLongAccum:
907 Encoding = llvm::dwarf::DW_ATE_signed_fixed;
909 case BuiltinType::UShortAccum:
910 case BuiltinType::UAccum:
911 case BuiltinType::ULongAccum:
912 case BuiltinType::UShortFract:
913 case BuiltinType::UFract:
914 case BuiltinType::ULongFract:
915 case BuiltinType::SatUShortAccum:
916 case BuiltinType::SatUAccum:
917 case BuiltinType::SatULongAccum:
918 case BuiltinType::SatUShortFract:
919 case BuiltinType::SatUFract:
920 case BuiltinType::SatULongFract:
921 Encoding = llvm::dwarf::DW_ATE_unsigned_fixed;
928 return DBuilder.createBasicType(BTName, Size, Encoding);
931llvm::DIType *CGDebugInfo::CreateType(
const BitIntType *Ty) {
933 StringRef Name = Ty->
isUnsigned() ?
"unsigned _BitInt" :
"_BitInt";
935 ? llvm::dwarf::DW_ATE_unsigned
936 : llvm::dwarf::DW_ATE_signed;
942llvm::DIType *CGDebugInfo::CreateType(
const ComplexType *Ty) {
944 llvm::dwarf::TypeKind
Encoding = llvm::dwarf::DW_ATE_complex_float;
946 Encoding = llvm::dwarf::DW_ATE_lo_user;
949 return DBuilder.createBasicType(
"complex", Size, Encoding);
963 return llvm::dwarf::DW_TAG_const_type;
967 return llvm::dwarf::DW_TAG_volatile_type;
971 return llvm::dwarf::DW_TAG_restrict_type;
973 return (llvm::dwarf::Tag)0;
976llvm::DIType *CGDebugInfo::CreateQualifiedType(
QualType Ty,
977 llvm::DIFile *Unit) {
987 assert(Qc.
empty() &&
"Unknown type qualifier for debug info");
988 return getOrCreateType(
QualType(T, 0), Unit);
995 return DBuilder.createQualifiedType(Tag, FromTy);
999 llvm::DIFile *Unit) {
1008 assert(Q.
empty() &&
"Unknown type qualifier for debug info");
1019 return DBuilder.createQualifiedType(Tag, FromTy);
1023 llvm::DIFile *Unit) {
1031 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
1035llvm::DIType *CGDebugInfo::CreateType(
const PointerType *Ty,
1036 llvm::DIFile *Unit) {
1037 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
1043 switch (TheCU->getSourceLanguage()) {
1044 case llvm::dwarf::DW_LANG_C_plus_plus:
1045 case llvm::dwarf::DW_LANG_C_plus_plus_11:
1046 case llvm::dwarf::DW_LANG_C_plus_plus_14:
1048 case llvm::dwarf::DW_LANG_ObjC_plus_plus:
1049 return isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD);
1077 llvm::DICompileUnit *TheCU) {
1095 llvm::DICompileUnit *TheCU) {
1101 if (
const auto *RD = dyn_cast<CXXRecordDecl>(TD))
1103 if (RD->isDynamicClass() &&
1116 llvm::dwarf::Tag Tag;
1118 Tag = llvm::dwarf::DW_TAG_structure_type;
1120 Tag = llvm::dwarf::DW_TAG_union_type;
1125 Tag = llvm::dwarf::DW_TAG_class_type;
1130llvm::DICompositeType *
1131CGDebugInfo::getOrCreateRecordFwdDecl(
const RecordType *Ty,
1132 llvm::DIScope *Ctx) {
1135 return cast<llvm::DICompositeType>(T);
1136 llvm::DIFile *DefUnit = getOrCreateFile(RD->
getLocation());
1137 const unsigned Line =
1139 StringRef RDName = getClassName(RD);
1148 llvm::DINode::DIFlags Flags = llvm::DINode::FlagFwdDecl;
1153 if (
const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1154 if (!CXXRD->hasDefinition() ||
1155 (CXXRD->hasDefinition() && !CXXRD->isTrivial()))
1156 Flags |= llvm::DINode::FlagNonTrivial;
1163 llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
1164 getTagForRecord(RD), RDName, Ctx, DefUnit, Line, 0, Size, Align, Flags,
1167 if (
auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
1168 DBuilder.replaceArrays(RetTy, llvm::DINodeArray(),
1169 CollectCXXTemplateParams(TSpecial, DefUnit));
1170 ReplaceMap.emplace_back(
1171 std::piecewise_construct, std::make_tuple(Ty),
1172 std::make_tuple(
static_cast<llvm::Metadata *
>(RetTy)));
1176llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
1179 llvm::DIFile *Unit) {
1184 std::optional<unsigned> DWARFAddressSpace =
1189 auto *BTFAttrTy = dyn_cast<BTFTagAttributedType>(PointeeTy);
1191 StringRef Tag = BTFAttrTy->getAttr()->getBTFTypeTag();
1193 llvm::Metadata *Ops[2] = {
1194 llvm::MDString::get(CGM.
getLLVMContext(), StringRef(
"btf_type_tag")),
1196 Annots.insert(Annots.begin(),
1199 BTFAttrTy = dyn_cast<BTFTagAttributedType>(BTFAttrTy->getWrappedType());
1202 llvm::DINodeArray Annotations =
nullptr;
1203 if (Annots.size() > 0)
1204 Annotations = DBuilder.getOrCreateArray(Annots);
1206 if (Tag == llvm::dwarf::DW_TAG_reference_type ||
1207 Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)
1208 return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit),
1209 Size, Align, DWARFAddressSpace);
1211 return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
1212 Align, DWARFAddressSpace, StringRef(),
1216llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
1217 llvm::DIType *&
Cache) {
1220 Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
1221 TheCU, TheCU->getFile(), 0);
1223 Cache = DBuilder.createPointerType(
Cache, Size);
1227uint64_t CGDebugInfo::collectDefaultElementTypesForBlockPointer(
1228 const BlockPointerType *Ty, llvm::DIFile *Unit, llvm::DIDerivedType *DescTy,
1241 EltTys.push_back(CreateMemberType(Unit, FType,
"__size", &FieldOffset));
1242 EltTys.push_back(CreateMemberType(Unit, FType,
"__align", &FieldOffset));
1245 EltTys.push_back(CreateMemberType(Unit, FType,
"__isa", &FieldOffset));
1247 EltTys.push_back(CreateMemberType(Unit, FType,
"__flags", &FieldOffset));
1248 EltTys.push_back(CreateMemberType(Unit, FType,
"__reserved", &FieldOffset));
1250 EltTys.push_back(CreateMemberType(Unit, FType,
"__FuncPtr", &FieldOffset));
1254 EltTys.push_back(DBuilder.createMemberType(
1255 Unit,
"__descriptor",
nullptr, LineNo, FieldSize, FieldAlign,
1256 FieldOffset, llvm::DINode::FlagZero, DescTy));
1257 FieldOffset += FieldSize;
1264 llvm::DIFile *Unit) {
1268 llvm::DINodeArray Elements;
1272 EltTys.push_back(CreateMemberType(Unit, FType,
"reserved", &FieldOffset));
1273 EltTys.push_back(CreateMemberType(Unit, FType,
"Size", &FieldOffset));
1275 Elements = DBuilder.getOrCreateArray(EltTys);
1278 llvm::DINode::DIFlags Flags = llvm::DINode::FlagAppleBlock;
1281 DBuilder.createStructType(Unit,
"__block_descriptor",
nullptr, 0,
1282 FieldOffset, 0, Flags,
nullptr, Elements);
1287 auto *DescTy = DBuilder.createPointerType(EltTy, Size);
1289 FieldOffset = collectDefaultElementTypesForBlockPointer(Ty, Unit, DescTy,
1292 Elements = DBuilder.getOrCreateArray(EltTys);
1298 EltTy = DBuilder.createStructType(Unit,
"",
nullptr, 0, FieldOffset, 0,
1299 Flags,
nullptr, Elements);
1301 return DBuilder.createPointerType(EltTy, Size);
1305 llvm::DIFile *Unit) {
1310 if (isa<BuiltinTemplateDecl>(TD))
1313 const auto *
AliasDecl = cast<TypeAliasTemplateDecl>(TD)->getTemplatedDecl();
1318 llvm::raw_svector_ostream
OS(NS);
1320 auto PP = getPrintingPolicy();
1336 return DBuilder.createTypedef(Src,
OS.str(), getOrCreateFile(Loc),
1353 return llvm::DINode::FlagZero;
1357 return llvm::DINode::FlagPrivate;
1359 return llvm::DINode::FlagProtected;
1361 return llvm::DINode::FlagPublic;
1363 return llvm::DINode::FlagZero;
1365 llvm_unreachable(
"unexpected access enumerator");
1368llvm::DIType *CGDebugInfo::CreateType(
const TypedefType *Ty,
1369 llvm::DIFile *Unit) {
1370 llvm::DIType *Underlying =
1382 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(Ty->
getDecl());
1384 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1386 if (isa<RecordDecl>(DC))
1389 return DBuilder.createTypedef(Underlying, Ty->
getDecl()->
getName(),
1390 getOrCreateFile(Loc), getLineNumber(Loc),
1391 getDeclContextDescriptor(Ty->
getDecl()), Align,
1392 Flags, Annotations);
1402 return llvm::dwarf::DW_CC_BORLAND_stdcall;
1404 return llvm::dwarf::DW_CC_BORLAND_msfastcall;
1406 return llvm::dwarf::DW_CC_BORLAND_thiscall;
1408 return llvm::dwarf::DW_CC_LLVM_vectorcall;
1410 return llvm::dwarf::DW_CC_BORLAND_pascal;
1412 return llvm::dwarf::DW_CC_LLVM_Win64;
1414 return llvm::dwarf::DW_CC_LLVM_X86_64SysV;
1418 return llvm::dwarf::DW_CC_LLVM_AAPCS;
1420 return llvm::dwarf::DW_CC_LLVM_AAPCS_VFP;
1422 return llvm::dwarf::DW_CC_LLVM_IntelOclBicc;
1424 return llvm::dwarf::DW_CC_LLVM_SpirFunction;
1427 return llvm::dwarf::DW_CC_LLVM_OpenCLKernel;
1429 return llvm::dwarf::DW_CC_LLVM_Swift;
1432 return llvm::dwarf::DW_CC_LLVM_Swift;
1434 return llvm::dwarf::DW_CC_LLVM_PreserveMost;
1436 return llvm::dwarf::DW_CC_LLVM_PreserveAll;
1438 return llvm::dwarf::DW_CC_LLVM_X86RegCall;
1444 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1446 Flags |= llvm::DINode::FlagLValueReference;
1448 Flags |= llvm::DINode::FlagRValueReference;
1452llvm::DIType *CGDebugInfo::CreateType(
const FunctionType *Ty,
1453 llvm::DIFile *Unit) {
1454 const auto *FPT = dyn_cast<FunctionProtoType>(Ty);
1456 if (llvm::DIType *QTy = CreateQualifiedType(FPT, Unit))
1465 EltTys.push_back(getOrCreateType(Ty->
getReturnType(), Unit));
1467 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1471 EltTys.push_back(DBuilder.createUnspecifiedParameter());
1474 for (
const QualType &ParamType : FPT->param_types())
1475 EltTys.push_back(getOrCreateType(ParamType, Unit));
1476 if (FPT->isVariadic())
1477 EltTys.push_back(DBuilder.createUnspecifiedParameter());
1480 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
1481 llvm::DIType *F = DBuilder.createSubroutineType(
1486llvm::DIType *CGDebugInfo::createBitFieldType(
const FieldDecl *BitFieldDecl,
1487 llvm::DIScope *RecordTy,
1489 StringRef Name = BitFieldDecl->
getName();
1492 llvm::DIFile *VUnit = getOrCreateFile(Loc);
1493 llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);
1496 llvm::DIFile *
File = getOrCreateFile(Loc);
1497 unsigned Line = getLineNumber(Loc);
1502 assert(SizeInBits > 0 &&
"found named 0-width bitfield");
1513 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(BitFieldDecl);
1514 return DBuilder.createBitFieldMemberType(
1515 RecordTy, Name,
File, Line, SizeInBits, OffsetInBits, StorageOffsetInBits,
1516 Flags, DebugType, Annotations);
1519llvm::DIType *CGDebugInfo::createFieldType(
1521 uint64_t offsetInBits, uint32_t AlignInBits, llvm::DIFile *tunit,
1522 llvm::DIScope *scope,
const RecordDecl *RD, llvm::DINodeArray Annotations) {
1523 llvm::DIType *debugType = getOrCreateType(
type, tunit);
1526 llvm::DIFile *file = getOrCreateFile(loc);
1527 const unsigned line = getLineNumber(loc.
isValid() ? loc : CurLoc);
1530 auto Align = AlignInBits;
1531 if (!
type->isIncompleteArrayType()) {
1533 SizeInBits = TI.
Width;
1539 return DBuilder.createMemberType(scope, name, file, line, SizeInBits, Align,
1540 offsetInBits, flags, debugType, Annotations);
1543void CGDebugInfo::CollectRecordLambdaFields(
1545 llvm::DIType *RecordTy) {
1551 unsigned fieldno = 0;
1554 I != E; ++I, ++Field, ++fieldno) {
1556 if (
C.capturesVariable()) {
1558 assert(!
Field->isBitField() &&
"lambdas don't have bitfield members!");
1560 StringRef VName =
V->getName();
1561 llvm::DIFile *VUnit = getOrCreateFile(Loc);
1563 llvm::DIType *FieldType = createFieldType(
1564 VName,
Field->getType(), Loc,
Field->getAccess(),
1565 layout.
getFieldOffset(fieldno), Align, VUnit, RecordTy, CXXDecl);
1566 elements.push_back(FieldType);
1567 }
else if (
C.capturesThis()) {
1573 llvm::DIFile *VUnit = getOrCreateFile(f->
getLocation());
1575 llvm::DIType *fieldType = createFieldType(
1579 elements.push_back(fieldType);
1584llvm::DIDerivedType *
1585CGDebugInfo::CreateRecordStaticField(
const VarDecl *Var, llvm::DIType *RecordTy,
1590 llvm::DIFile *VUnit = getOrCreateFile(Var->
getLocation());
1591 llvm::DIType *VTy = getOrCreateType(Var->
getType(), VUnit);
1593 unsigned LineNumber = getLineNumber(Var->
getLocation());
1594 StringRef VName = Var->
getName();
1595 llvm::Constant *
C =
nullptr;
1601 if (
Value->isFloat())
1608 llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
1609 RecordTy, VName, VUnit, LineNumber, VTy, Flags,
C, Align);
1614void CGDebugInfo::CollectRecordNormalField(
1615 const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit,
1622 if (
name.empty() && !
type->isRecordType())
1625 llvm::DIType *FieldType;
1627 FieldType = createBitFieldType(field, RecordTy, RD);
1630 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(field);
1633 OffsetInBits, Align, tunit, RecordTy, RD, Annotations);
1636 elements.push_back(FieldType);
1639void CGDebugInfo::CollectRecordNestedType(
1643 if (isa<InjectedClassNameType>(Ty))
1646 llvm::DIType *nestedType = getOrCreateType(Ty, getOrCreateFile(Loc));
1647 elements.push_back(nestedType);
1650void CGDebugInfo::CollectRecordFields(
1651 const RecordDecl *record, llvm::DIFile *tunit,
1653 llvm::DICompositeType *RecordTy) {
1654 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(record);
1656 if (CXXDecl && CXXDecl->
isLambda())
1657 CollectRecordLambdaFields(CXXDecl, elements, RecordTy);
1662 unsigned fieldNo = 0;
1666 for (
const auto *I : record->
decls())
1667 if (
const auto *
V = dyn_cast<VarDecl>(I)) {
1668 if (
V->hasAttr<NoDebugAttr>())
1674 isa<VarTemplateSpecializationDecl>(
V))
1677 if (isa<VarTemplatePartialSpecializationDecl>(
V))
1681 auto MI = StaticDataMemberCache.find(
V->getCanonicalDecl());
1682 if (MI != StaticDataMemberCache.end()) {
1683 assert(MI->second &&
1684 "Static data member declaration should still exist");
1685 elements.push_back(MI->second);
1687 auto Field = CreateRecordStaticField(
V, RecordTy, record);
1688 elements.push_back(Field);
1690 }
else if (
const auto *field = dyn_cast<FieldDecl>(I)) {
1691 CollectRecordNormalField(field, layout.
getFieldOffset(fieldNo), tunit,
1692 elements, RecordTy, record);
1699 if (
const auto *nestedType = dyn_cast<TypeDecl>(I)) {
1701 if (isa<RecordDecl>(I) &&
1702 cast<RecordDecl>(I)->isAnonymousStructOrUnion())
1704 if (!nestedType->isImplicit() &&
1705 nestedType->getDeclContext() == record)
1706 CollectRecordNestedType(nestedType, elements);
1712llvm::DISubroutineType *
1713CGDebugInfo::getOrCreateMethodType(
const CXXMethodDecl *Method,
1714 llvm::DIFile *Unit) {
1717 return cast_or_null<llvm::DISubroutineType>(
1718 getOrCreateType(
QualType(Func, 0), Unit));
1719 return getOrCreateInstanceMethodType(Method->
getThisType(), Func, Unit);
1722llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType(
1738 const auto *OriginalFunc = cast<llvm::DISubroutineType>(
1742 llvm::DITypeRefArray Args = OriginalFunc->getTypeArray();
1743 assert(Args.size() &&
"Invalid number of arguments!");
1748 Elts.push_back(Args[0]);
1752 if (isa<ClassTemplateSpecializationDecl>(RD)) {
1754 const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr);
1757 llvm::DIType *PointeeType =
1759 llvm::DIType *ThisPtrType =
1760 DBuilder.createPointerType(PointeeType, Size, Align);
1765 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1766 Elts.push_back(ThisPtrType);
1768 llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);
1770 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1771 Elts.push_back(ThisPtrType);
1775 for (
unsigned i = 1, e = Args.size(); i != e; ++i)
1776 Elts.push_back(Args[i]);
1778 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
1780 return DBuilder.createSubroutineType(EltTypeArray, OriginalFunc->getFlags(),
1787 if (
const auto *NRD = dyn_cast<CXXRecordDecl>(RD->
getDeclContext()))
1794llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
1795 const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {
1797 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
1799 StringRef MethodName = getFunctionName(Method);
1800 llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit);
1804 StringRef MethodLinkageName;
1814 llvm::DIFile *MethodDefUnit =
nullptr;
1815 unsigned MethodLine = 0;
1817 MethodDefUnit = getOrCreateFile(Method->
getLocation());
1818 MethodLine = getLineNumber(Method->
getLocation());
1822 llvm::DIType *ContainingType =
nullptr;
1823 unsigned VIndex = 0;
1824 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1825 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
1830 SPFlags |= llvm::DISubprogram::SPFlagPureVirtual;
1832 SPFlags |= llvm::DISubprogram::SPFlagVirtual;
1837 if (!isa<CXXDestructorDecl>(Method))
1842 const auto *DD = dyn_cast<CXXDestructorDecl>(Method);
1854 Flags |= llvm::DINode::FlagIntroducedVirtual;
1863 ContainingType = RecordTy;
1868 auto checkAttrDeleted = [&](
const auto *Method) {
1870 SPFlags |= llvm::DISubprogram::SPFlagDeleted;
1875 case Decl::CXXConstructor:
1876 case Decl::CXXDestructor:
1877 checkAttrDeleted(Method);
1879 case Decl::CXXMethod:
1882 checkAttrDeleted(Method);
1889 Flags |= llvm::DINode::FlagNoReturn;
1892 Flags |= llvm::DINode::FlagStaticMember;
1894 Flags |= llvm::DINode::FlagArtificial;
1896 if (
const auto *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
1897 if (CXXC->isExplicit())
1898 Flags |= llvm::DINode::FlagExplicit;
1899 }
else if (
const auto *CXXC = dyn_cast<CXXConversionDecl>(Method)) {
1900 if (CXXC->isExplicit())
1901 Flags |= llvm::DINode::FlagExplicit;
1904 Flags |= llvm::DINode::FlagPrototyped;
1906 Flags |= llvm::DINode::FlagLValueReference;
1908 Flags |= llvm::DINode::FlagRValueReference;
1910 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
1912 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
1920 llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
1921 llvm::DISubprogram *SP = DBuilder.createMethod(
1922 RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
1923 MethodTy, VIndex,
ThisAdjustment, ContainingType, Flags, SPFlags,
1924 TParamsArray.get());
1931void CGDebugInfo::CollectCXXMemberFunctions(
1938 for (
const auto *I : RD->
decls()) {
1939 const auto *Method = dyn_cast<CXXMethodDecl>(I);
1963 EltTys.push_back(MI == SPCache.end()
1964 ? CreateCXXMemberFunction(Method, Unit, RecordTy)
1965 :
static_cast<llvm::Metadata *
>(MI->second));
1969void CGDebugInfo::CollectCXXBases(
const CXXRecordDecl *RD, llvm::DIFile *Unit,
1971 llvm::DIType *RecordTy) {
1973 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->
bases(), SeenTypes,
1974 llvm::DINode::FlagZero);
1979 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->
vbases(), SeenTypes,
1980 llvm::DINode::FlagIndirectVirtualBase);
1984void CGDebugInfo::CollectCXXBasesAux(
1989 llvm::DINode::DIFlags StartingFlags) {
1991 for (
const auto &BI : Bases) {
1994 if (!SeenTypes.insert(
Base).second)
1996 auto *BaseTy = getOrCreateType(BI.getType(), Unit);
1997 llvm::DINode::DIFlags BFlags = StartingFlags;
1999 uint32_t VBPtrOffset = 0;
2001 if (BI.isVirtual()) {
2018 BFlags |= llvm::DINode::FlagVirtual;
2025 llvm::DIType *DTy = DBuilder.createInheritance(RecordTy, BaseTy, BaseOffset,
2026 VBPtrOffset, BFlags);
2027 EltTys.push_back(DTy);
2032CGDebugInfo::CollectTemplateParams(std::optional<TemplateArgs> OArgs,
2033 llvm::DIFile *Unit) {
2035 return llvm::DINodeArray();
2036 TemplateArgs &Args = *OArgs;
2038 for (
unsigned i = 0, e = Args.Args.size(); i != e; ++i) {
2043 Name = Args.TList->getParam(i)->getName();
2047 llvm::DIType *TTy = getOrCreateType(TA.
getAsType(), Unit);
2048 TemplateParams.push_back(DBuilder.createTemplateTypeParameter(
2049 TheCU, Name, TTy, defaultParameter));
2054 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2055 TheCU, Name, TTy, defaultParameter,
2061 llvm::DIType *TTy = getOrCreateType(T, Unit);
2062 llvm::Constant *
V =
nullptr;
2066 !D->
hasAttr<CUDADeviceAttr>()) {
2070 if (
const auto *VD = dyn_cast<VarDecl>(D))
2074 else if ((MD = dyn_cast<CXXMethodDecl>(D)) && MD->
isInstance())
2076 else if (
const auto *FD = dyn_cast<FunctionDecl>(D))
2080 else if (
const auto *MPT =
2081 dyn_cast<MemberPointerType>(T.
getTypePtr())) {
2089 }
else if (
const auto *GD = dyn_cast<MSGuidDecl>(D)) {
2091 }
else if (
const auto *TPO = dyn_cast<TemplateParamObjectDecl>(D)) {
2098 assert(
V &&
"Failed to find template parameter pointer");
2099 V =
V->stripPointerCasts();
2101 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2102 TheCU, Name, TTy, defaultParameter, cast_or_null<llvm::Constant>(
V)));
2106 llvm::DIType *TTy = getOrCreateType(T, Unit);
2107 llvm::Constant *
V =
nullptr;
2110 if (
const auto *MPT = dyn_cast<MemberPointerType>(T.
getTypePtr()))
2116 if (MPT->isMemberDataPointer())
2119 V = llvm::ConstantInt::get(CGM.
Int8Ty, 0);
2120 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2121 TheCU, Name, TTy, defaultParameter,
V));
2124 std::string QualName;
2125 llvm::raw_string_ostream
OS(QualName);
2127 OS, getPrintingPolicy());
2128 TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(
2129 TheCU, Name,
nullptr,
OS.str(), defaultParameter));
2133 TemplateParams.push_back(DBuilder.createTemplateParameterPack(
2134 TheCU, Name,
nullptr,
2143 assert(
V &&
"Expression in template argument isn't constant");
2144 llvm::DIType *TTy = getOrCreateType(T, Unit);
2145 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2146 TheCU, Name, TTy, defaultParameter,
V->stripPointerCasts()));
2152 "These argument types shouldn't exist in concrete types");
2155 return DBuilder.getOrCreateArray(TemplateParams);
2158std::optional<CGDebugInfo::TemplateArgs>
2159CGDebugInfo::GetTemplateArgs(
const FunctionDecl *FD)
const {
2167 return std::nullopt;
2169std::optional<CGDebugInfo::TemplateArgs>
2170CGDebugInfo::GetTemplateArgs(
const VarDecl *VD)
const {
2174 auto *TS = dyn_cast<VarTemplateSpecializationDecl>(VD);
2176 return std::nullopt;
2179 auto TA = TS->getTemplateArgs().asArray();
2180 return {{TList, TA}};
2182std::optional<CGDebugInfo::TemplateArgs>
2183CGDebugInfo::GetTemplateArgs(
const RecordDecl *RD)
const {
2184 if (
auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
2189 TSpecial->getSpecializedTemplate()->getTemplateParameters();
2191 return {{TPList, TAList.
asArray()}};
2193 return std::nullopt;
2197CGDebugInfo::CollectFunctionTemplateParams(
const FunctionDecl *FD,
2198 llvm::DIFile *Unit) {
2199 return CollectTemplateParams(GetTemplateArgs(FD), Unit);
2202llvm::DINodeArray CGDebugInfo::CollectVarTemplateParams(
const VarDecl *VL,
2203 llvm::DIFile *Unit) {
2204 return CollectTemplateParams(GetTemplateArgs(VL), Unit);
2207llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(
const RecordDecl *RD,
2208 llvm::DIFile *Unit) {
2209 return CollectTemplateParams(GetTemplateArgs(RD), Unit);
2212llvm::DINodeArray CGDebugInfo::CollectBTFDeclTagAnnotations(
const Decl *D) {
2213 if (!D->
hasAttr<BTFDeclTagAttr>())
2218 llvm::Metadata *Ops[2] = {
2219 llvm::MDString::get(CGM.
getLLVMContext(), StringRef(
"btf_decl_tag")),
2221 Annotations.push_back(llvm::MDNode::get(CGM.
getLLVMContext(), Ops));
2223 return DBuilder.getOrCreateArray(Annotations);
2226llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
2228 return VTablePtrType;
2233 llvm::Metadata *STy = getOrCreateType(Context.
IntTy, Unit);
2234 llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);
2235 llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements);
2238 std::optional<unsigned> DWARFAddressSpace =
2241 llvm::DIType *vtbl_ptr_type = DBuilder.createPointerType(
2242 SubTy, Size, 0, DWARFAddressSpace,
"__vtbl_ptr_type");
2243 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
2244 return VTablePtrType;
2247StringRef CGDebugInfo::getVTableName(
const CXXRecordDecl *RD) {
2252StringRef CGDebugInfo::getDynamicInitializerName(
const VarDecl *VD,
2254 llvm::Function *InitFn) {
2259 return InitFn->getName();
2269 llvm::raw_svector_ostream
OS(QualifiedGV);
2271 std::tie(Quals, GVName) =
OS.str().rsplit(
"::");
2273 std::swap(Quals, GVName);
2277 llvm::raw_svector_ostream
OS(InitName);
2279 OS << Quals <<
"::";
2284 llvm_unreachable(
"not an initializer");
2286 OS <<
"`dynamic initializer for '";
2289 OS <<
"`dynamic atexit destructor for '";
2296 if (
const auto *VTpl = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
2298 getPrintingPolicy());
2303 return internString(
OS.str());
2306void CGDebugInfo::CollectVTableInfo(
const CXXRecordDecl *RD, llvm::DIFile *Unit,
2323 llvm::DIType *VPtrTy =
nullptr;
2326 if (NeedVTableShape) {
2331 unsigned VSlotCount =
2333 unsigned VTableWidth = PtrWidth * VSlotCount;
2335 std::optional<unsigned> DWARFAddressSpace =
2339 llvm::DIType *VTableType = DBuilder.createPointerType(
2340 nullptr, VTableWidth, 0, DWARFAddressSpace,
"__vtbl_ptr_type");
2341 EltTys.push_back(VTableType);
2344 VPtrTy = DBuilder.createPointerType(VTableType, PtrWidth);
2352 VPtrTy = getOrCreateVTablePtrType(Unit);
2355 llvm::DIType *VPtrMember =
2356 DBuilder.createMemberType(Unit, getVTableName(RD), Unit, 0, Size, 0, 0,
2357 llvm::DINode::FlagArtificial, VPtrTy);
2358 EltTys.push_back(VPtrMember);
2364 llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
2376 assert(!D.
isNull() &&
"null type");
2377 llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc));
2378 assert(T &&
"could not create debug info for type");
2394 node = getOrCreateType(AllocatedTy, getOrCreateFile(Loc));
2396 CI->setMetadata(
"heapallocsite", node);
2404 auto I = TypeCache.find(TyPtr);
2405 if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())
2407 llvm::DIType *Res = CreateTypeDefinition(Ty->
castAs<
EnumType>());
2408 assert(!Res->isForwardDecl());
2409 TypeCache[TyPtr].reset(Res);
2420 if (RD->
hasAttr<DLLImportAttr>())
2423 if (MD->
hasAttr<DLLImportAttr>())
2436 if (
auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) {
2445 bool Explicit =
false;
2446 if (
auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(CXXDecl))
2447 Explicit = TD->isExplicitInstantiationOrSpecialization();
2461 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
2462 if (CXXRD->isDynamicClass() &&
2464 llvm::GlobalValue::AvailableExternallyLinkage &&
2479 auto I = TypeCache.find(TyPtr);
2480 if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
2483 assert(!Res->isForwardDecl());
2484 TypeCache[TyPtr].reset(Res);
2491 if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&
2515 if (Ctor->isCopyOrMoveConstructor())
2517 if (!Ctor->isDeleted())
2540 RD->
hasAttr<StandaloneDebugAttr>())
2543 if (!LangOpts.CPlusPlus)
2549 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
2565 if (
const auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
2566 Spec = SD->getSpecializationKind();
2587 llvm::DIType *T = getTypeOrNull(Ty);
2588 if (T && T->isForwardDecl())
2592llvm::DIType *CGDebugInfo::CreateType(
const RecordType *Ty) {
2594 llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(
QualType(Ty, 0)));
2598 T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));
2602 return CreateTypeDefinition(Ty);
2605llvm::DIType *CGDebugInfo::CreateTypeDefinition(
const RecordType *Ty) {
2609 llvm::DIFile *DefUnit = getOrCreateFile(RD->
getLocation());
2617 llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty);
2623 if (
const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
2624 CollectContainingType(CXXDecl, FwdDecl);
2627 LexicalBlockStack.emplace_back(&*FwdDecl);
2628 RegionMap[Ty->
getDecl()].reset(FwdDecl);
2638 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
2640 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
2641 CollectVTableInfo(CXXDecl, DefUnit, EltTys);
2645 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
2647 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
2649 LexicalBlockStack.pop_back();
2650 RegionMap.erase(Ty->
getDecl());
2652 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2653 DBuilder.replaceArrays(FwdDecl, Elements);
2655 if (FwdDecl->isTemporary())
2657 llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
2659 RegionMap[Ty->
getDecl()].reset(FwdDecl);
2664 llvm::DIFile *Unit) {
2670 llvm::DIFile *Unit) {
2675 return DBuilder.createTypedef(
2677 Ty->
getDecl()->
getName(), getOrCreateFile(Loc), getLineNumber(Loc),
2678 getDeclContextDescriptor(Ty->
getDecl()));
2706 llvm::DIFile *Unit) {
2714 if (DebugTypeExtRefs &&
ID->isFromASTFile() &&
ID->getDefinition() &&
2715 !
ID->getImplementation())
2716 return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
2718 getDeclContextDescriptor(ID), Unit, 0);
2721 llvm::DIFile *DefUnit = getOrCreateFile(
ID->getLocation());
2722 unsigned Line = getLineNumber(
ID->getLocation());
2724 static_cast<llvm::dwarf::SourceLanguage
>(TheCU->getSourceLanguage());
2730 llvm::DIScope *Mod = getParentModuleOrNull(ID);
2731 llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(
2732 llvm::dwarf::DW_TAG_structure_type,
ID->getName(), Mod ? Mod : TheCU,
2733 DefUnit, Line, RuntimeLang);
2734 ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit));
2738 return CreateTypeDefinition(Ty, Unit);
2742 bool CreateSkeletonCU) {
2747 auto ModRef = ModuleCache.find(M);
2748 if (ModRef != ModuleCache.end())
2749 return cast<llvm::DIModule>(ModRef->second);
2754 llvm::raw_svector_ostream
OS(ConfigMacros);
2758 for (
auto &M : PPOpts.Macros) {
2761 const std::string &
Macro = M.first;
2762 bool Undef = M.second;
2763 OS <<
"\"-" << (Undef ?
'U' :
'D');
2764 for (
char c : Macro)
2779 bool IsRootModule = M ? !M->
Parent :
true;
2783 if (CreateSkeletonCU && IsRootModule && Mod.
getASTFile().empty() && M)
2785 "clang module without ASTFile must be specified by -fmodule-name");
2788 auto RemapPath = [
this](StringRef Path) -> std::string {
2790 StringRef Relative(Remapped);
2791 StringRef CompDir = TheCU->getDirectory();
2792 if (Relative.consume_front(CompDir))
2793 Relative.consume_front(llvm::sys::path::get_separator());
2795 return Relative.str();
2798 if (CreateSkeletonCU && IsRootModule && !Mod.
getASTFile().empty()) {
2805 Signature = ModSig.truncatedValue();
2811 if (!llvm::sys::path::is_absolute(Mod.
getASTFile())) {
2813 PCM = getCurrentDirname();
2817 llvm::sys::path::append(PCM, Mod.
getASTFile());
2818 DIB.createCompileUnit(
2819 TheCU->getSourceLanguage(),
2822 TheCU->getProducer(),
false, StringRef(), 0, RemapPath(PCM),
2823 llvm::DICompileUnit::FullDebug, Signature);
2828 IsRootModule ? nullptr
2831 std::string IncludePath = Mod.
getPath().str();
2832 llvm::DIModule *DIMod =
2834 RemapPath(IncludePath));
2835 ModuleCache[M].reset(DIMod);
2840 llvm::DIFile *Unit) {
2842 llvm::DIFile *DefUnit = getOrCreateFile(
ID->getLocation());
2843 unsigned Line = getLineNumber(
ID->getLocation());
2844 unsigned RuntimeLang = TheCU->getSourceLanguage();
2850 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2851 if (
ID->getImplementation())
2852 Flags |= llvm::DINode::FlagObjcClassComplete;
2854 llvm::DIScope *Mod = getParentModuleOrNull(ID);
2855 llvm::DICompositeType *RealDecl = DBuilder.createStructType(
2856 Mod ? Mod : Unit,
ID->getName(), DefUnit, Line, Size, Align, Flags,
2857 nullptr, llvm::DINodeArray(), RuntimeLang);
2860 TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl);
2863 LexicalBlockStack.emplace_back(RealDecl);
2864 RegionMap[Ty->
getDecl()].reset(RealDecl);
2871 llvm::DIType *SClassTy =
2876 llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0, 0,
2877 llvm::DINode::FlagZero);
2878 EltTys.push_back(InhTag);
2884 llvm::DIFile *PUnit = getOrCreateFile(Loc);
2885 unsigned PLine = getLineNumber(Loc);
2888 llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(
2889 PD->getName(), PUnit, PLine,
2891 : getSelectorName(PD->getGetterName()),
2893 : getSelectorName(PD->getSetterName()),
2894 PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit));
2895 EltTys.push_back(PropertyNode);
2900 typedef std::pair<char, const IdentifierInfo *> IsClassAndIdent;
2907 return std::make_pair(PD->isClassProperty(), PD->getIdentifier());
2910 for (
auto *PD : ClassExt->properties()) {
2911 PropertySet.insert(GetIsClassAndIdent(PD));
2914 for (
const auto *PD :
ID->properties()) {
2917 if (!PropertySet.insert(GetIsClassAndIdent(PD)).second)
2924 unsigned FieldNo = 0;
2926 Field =
Field->getNextIvar(), ++FieldNo) {
2927 llvm::DIType *FieldTy = getOrCreateType(
Field->getType(), Unit);
2931 StringRef FieldName =
Field->getName();
2934 if (FieldName.empty())
2938 llvm::DIFile *FieldDefUnit = getOrCreateFile(
Field->getLocation());
2939 unsigned FieldLine = getLineNumber(
Field->getLocation());
2942 uint32_t FieldAlign = 0;
2947 FieldSize =
Field->isBitField()
2958 if (
Field->isBitField()) {
2969 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2971 Flags = llvm::DINode::FlagProtected;
2973 Flags = llvm::DINode::FlagPrivate;
2975 Flags = llvm::DINode::FlagPublic;
2977 if (
Field->isBitField())
2978 Flags |= llvm::DINode::FlagBitField;
2980 llvm::MDNode *PropertyNode =
nullptr;
2983 ImpD->FindPropertyImplIvarDecl(
Field->getIdentifier())) {
2986 llvm::DIFile *PUnit = getOrCreateFile(Loc);
2987 unsigned PLine = getLineNumber(Loc);
2990 PropertyNode = DBuilder.createObjCProperty(
2991 PD->getName(), PUnit, PLine,
2994 : getSelectorName(PD->getGetterName()),
2997 : getSelectorName(PD->getSetterName()),
2998 PD->getPropertyAttributes(),
2999 getOrCreateType(PD->getType(), PUnit));
3003 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine,
3004 FieldSize, FieldAlign, FieldOffset, Flags,
3005 FieldTy, PropertyNode);
3006 EltTys.push_back(FieldTy);
3009 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
3010 DBuilder.replaceArrays(RealDecl, Elements);
3012 LexicalBlockStack.pop_back();
3016llvm::DIType *CGDebugInfo::CreateType(
const VectorType *Ty,
3017 llvm::DIFile *Unit) {
3030 QualType CharVecTy = Ctx.getVectorType(Ctx.CharTy, NumVectorBytes,
3035 llvm::DIType *ElementTy = getOrCreateType(Ty->
getElementType(), Unit);
3038 llvm::Metadata *Subscript;
3040 auto SizeExpr = SizeExprCache.find(QTy);
3041 if (SizeExpr != SizeExprCache.end())
3042 Subscript = DBuilder.getOrCreateSubrange(
3043 SizeExpr->getSecond() ,
nullptr ,
3044 nullptr ,
nullptr );
3047 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
3048 llvm::Type::getInt64Ty(CGM.
getLLVMContext()), Count ? Count : -1));
3049 Subscript = DBuilder.getOrCreateSubrange(
3050 CountNode ,
nullptr ,
nullptr ,
3053 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
3058 return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
3062 llvm::DIFile *Unit) {
3066 llvm::DIType *ElementTy = getOrCreateType(Ty->
getElementType(), Unit);
3072 auto *ColumnCountNode =
3073 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
3075 auto *RowCountNode =
3076 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
3078 Subscripts.push_back(DBuilder.getOrCreateSubrange(
3079 ColumnCountNode ,
nullptr ,
nullptr ,
3081 Subscripts.push_back(DBuilder.getOrCreateSubrange(
3082 RowCountNode ,
nullptr ,
nullptr ,
3084 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
3085 return DBuilder.createArrayType(Size, Align, ElementTy, SubscriptArray);
3088llvm::DIType *CGDebugInfo::CreateType(
const ArrayType *Ty, llvm::DIFile *Unit) {
3093 if (
const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
3117 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
3126 if (
const auto *CAT = dyn_cast<ConstantArrayType>(Ty))
3127 Count = CAT->getSize().getZExtValue();
3128 else if (
const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
3129 if (
Expr *Size = VAT->getSizeExpr()) {
3132 Count =
Result.Val.getInt().getExtValue();
3136 auto SizeNode = SizeExprCache.find(EltTy);
3137 if (SizeNode != SizeExprCache.end())
3138 Subscripts.push_back(DBuilder.getOrCreateSubrange(
3139 SizeNode->getSecond() ,
nullptr ,
3140 nullptr ,
nullptr ));
3143 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
3145 Subscripts.push_back(DBuilder.getOrCreateSubrange(
3146 CountNode ,
nullptr ,
nullptr ,
3152 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
3154 return DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
3159 llvm::DIFile *Unit) {
3160 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty,
3165 llvm::DIFile *Unit) {
3166 llvm::dwarf::Tag Tag = llvm::dwarf::DW_TAG_rvalue_reference_type;
3170 Tag = llvm::dwarf::DW_TAG_reference_type;
3172 return CreatePointerLikeType(Tag, Ty, Ty->
getPointeeType(), Unit);
3177 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3187 Flags |= llvm::DINode::FlagSingleInheritance;
3190 Flags |= llvm::DINode::FlagMultipleInheritance;
3193 Flags |= llvm::DINode::FlagVirtualInheritance;
3203 return DBuilder.createMemberPointerType(
3209 return DBuilder.createMemberPointerType(
3210 getOrCreateInstanceMethodType(
3213 ClassType,
Size, 0, Flags);
3216llvm::DIType *CGDebugInfo::CreateType(
const AtomicType *Ty, llvm::DIFile *
U) {
3218 return DBuilder.createQualifiedType(llvm::dwarf::DW_TAG_atomic_type, FromTy);
3221llvm::DIType *CGDebugInfo::CreateType(
const PipeType *Ty, llvm::DIFile *
U) {
3225llvm::DIType *CGDebugInfo::CreateEnumType(
const EnumType *Ty) {
3237 bool isImportedFromModule =
3249 llvm::DIScope *EDContext = getDeclContextDescriptor(ED);
3250 llvm::DIFile *DefUnit = getOrCreateFile(ED->
getLocation());
3251 llvm::TempDIScope TmpContext(DBuilder.createReplaceableCompositeType(
3252 llvm::dwarf::DW_TAG_enumeration_type,
"", TheCU, DefUnit, 0));
3255 StringRef EDName = ED->
getName();
3256 llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType(
3257 llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit, Line,
3258 0, Size, Align, llvm::DINode::FlagFwdDecl,
Identifier);
3260 ReplaceMap.emplace_back(
3261 std::piecewise_construct, std::make_tuple(Ty),
3262 std::make_tuple(
static_cast<llvm::Metadata *
>(RetTy)));
3266 return CreateTypeDefinition(Ty);
3269llvm::DIType *CGDebugInfo::CreateTypeDefinition(
const EnumType *Ty) {
3283 Enumerators.push_back(
3284 DBuilder.createEnumerator(
Enum->getName(),
Enum->getInitVal()));
3288 llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
3290 llvm::DIFile *DefUnit = getOrCreateFile(ED->
getLocation());
3292 llvm::DIScope *EnumContext = getDeclContextDescriptor(ED);
3293 llvm::DIType *ClassTy = getOrCreateType(ED->
getIntegerType(), DefUnit);
3294 return DBuilder.createEnumerationType(EnumContext, ED->
getName(), DefUnit,
3295 Line, Size, Align, EltArray, ClassTy,
3301 StringRef Name, StringRef
Value) {
3302 unsigned Line = LineLoc.
isInvalid() ? 0 : getLineNumber(LineLoc);
3303 return DBuilder.createMacro(
Parent, Line, MType, Name,
Value);
3309 llvm::DIFile *FName = getOrCreateFile(FileLoc);
3310 unsigned Line = LineLoc.
isInvalid() ? 0 : getLineNumber(LineLoc);
3311 return DBuilder.createTempMacroFile(
Parent, Line, FName);
3321 Quals += InnerQuals;
3326 case Type::TemplateSpecialization: {
3327 const auto *Spec = cast<TemplateSpecializationType>(T);
3328 if (Spec->isTypeAlias())
3330 T = Spec->desugar();
3333 case Type::TypeOfExpr:
3334 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
3337 T = cast<TypeOfType>(T)->getUnmodifiedType();
3339 case Type::Decltype:
3340 T = cast<DecltypeType>(T)->getUnderlyingType();
3342 case Type::UnaryTransform:
3343 T = cast<UnaryTransformType>(T)->getUnderlyingType();
3345 case Type::Attributed:
3346 T = cast<AttributedType>(T)->getEquivalentType();
3348 case Type::BTFTagAttributed:
3349 T = cast<BTFTagAttributedType>(T)->getWrappedType();
3351 case Type::Elaborated:
3352 T = cast<ElaboratedType>(T)->getNamedType();
3355 T = cast<UsingType>(T)->getUnderlyingType();
3358 T = cast<ParenType>(T)->getInnerType();
3360 case Type::MacroQualified:
3361 T = cast<MacroQualifiedType>(T)->getUnderlyingType();
3363 case Type::SubstTemplateTypeParm:
3364 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
3367 case Type::DeducedTemplateSpecialization: {
3368 QualType DT = cast<DeducedType>(T)->getDeducedType();
3369 assert(!DT.
isNull() &&
"Undeduced types shouldn't reach here.");
3373 case Type::Adjusted:
3376 T = cast<AdjustedType>(T)->getAdjustedType();
3380 assert(T != LastT &&
"Type unwrapping failed to unwrap!");
3385llvm::DIType *CGDebugInfo::getTypeOrNull(
QualType Ty) {
3388 if (It != TypeCache.end()) {
3390 if (llvm::Metadata *
V = It->second)
3391 return cast<llvm::DIType>(
V);
3412llvm::DIType *CGDebugInfo::getOrCreateType(
QualType Ty, llvm::DIFile *Unit) {
3416 llvm::TimeTraceScope TimeScope(
"DebugType", [&]() {
3418 llvm::raw_string_ostream
OS(Name);
3419 Ty.
print(
OS, getPrintingPolicy());
3426 if (
auto *T = getTypeOrNull(Ty))
3429 llvm::DIType *Res = CreateTypeNode(Ty, Unit);
3430 void *TyPtr = Ty.getAsOpaquePtr();
3433 TypeCache[TyPtr].reset(Res);
3438llvm::DIModule *CGDebugInfo::getParentModuleOrNull(
const Decl *D) {
3440 if (isa<RecordDecl>(D) && !cast<RecordDecl>(D)->
getDefinition())
3446 auto Info = Reader->getSourceDescriptor(Idx);
3448 return getOrCreateModuleRef(*Info,
true);
3449 }
else if (ClangModuleMap) {
3463 return getOrCreateModuleRef(Info,
false);
3466 return getOrCreateModuleRef(PCHDescriptor,
false);
3473llvm::DIType *CGDebugInfo::CreateTypeNode(
QualType Ty, llvm::DIFile *Unit) {
3476 return CreateQualifiedType(Ty, Unit);
3480#define TYPE(Class, Base)
3481#define ABSTRACT_TYPE(Class, Base)
3482#define NON_CANONICAL_TYPE(Class, Base)
3483#define DEPENDENT_TYPE(Class, Base) case Type::Class:
3484#include "clang/AST/TypeNodes.inc"
3485 llvm_unreachable(
"Dependent types cannot show up in debug information");
3487 case Type::ExtVector:
3489 return CreateType(cast<VectorType>(Ty), Unit);
3490 case Type::ConstantMatrix:
3491 return CreateType(cast<ConstantMatrixType>(Ty), Unit);
3492 case Type::ObjCObjectPointer:
3493 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
3494 case Type::ObjCObject:
3495 return CreateType(cast<ObjCObjectType>(Ty), Unit);
3496 case Type::ObjCTypeParam:
3497 return CreateType(cast<ObjCTypeParamType>(Ty), Unit);
3498 case Type::ObjCInterface:
3499 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
3501 return CreateType(cast<BuiltinType>(Ty));
3503 return CreateType(cast<ComplexType>(Ty));
3505 return CreateType(cast<PointerType>(Ty), Unit);
3506 case Type::BlockPointer:
3507 return CreateType(cast<BlockPointerType>(Ty), Unit);
3509 return CreateType(cast<TypedefType>(Ty), Unit);
3511 return CreateType(cast<RecordType>(Ty));
3513 return CreateEnumType(cast<EnumType>(Ty));
3514 case Type::FunctionProto:
3515 case Type::FunctionNoProto:
3516 return CreateType(cast<FunctionType>(Ty), Unit);
3517 case Type::ConstantArray:
3518 case Type::VariableArray:
3519 case Type::IncompleteArray:
3520 return CreateType(cast<ArrayType>(Ty), Unit);
3522 case Type::LValueReference:
3523 return CreateType(cast<LValueReferenceType>(Ty), Unit);
3524 case Type::RValueReference:
3525 return CreateType(cast<RValueReferenceType>(Ty), Unit);
3527 case Type::MemberPointer:
3528 return CreateType(cast<MemberPointerType>(Ty), Unit);
3531 return CreateType(cast<AtomicType>(Ty), Unit);
3534 return CreateType(cast<BitIntType>(Ty));
3536 return CreateType(cast<PipeType>(Ty), Unit);
3538 case Type::TemplateSpecialization:
3539 return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
3542 case Type::Attributed:
3543 case Type::BTFTagAttributed:
3544 case Type::Adjusted:
3546 case Type::DeducedTemplateSpecialization:
3547 case Type::Elaborated:
3550 case Type::MacroQualified:
3551 case Type::SubstTemplateTypeParm:
3552 case Type::TypeOfExpr:
3554 case Type::Decltype:
3555 case Type::UnaryTransform:
3559 llvm_unreachable(
"type should have been unwrapped!");
3562llvm::DICompositeType *
3563CGDebugInfo::getOrCreateLimitedType(
const RecordType *Ty) {
3566 auto *T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));
3571 if (T && !T->isForwardDecl())
3575 llvm::DICompositeType *Res = CreateLimitedType(Ty);
3580 DBuilder.replaceArrays(Res, T ? T->getElements() : llvm::DINodeArray());
3583 TypeCache[QTy.getAsOpaquePtr()].reset(Res);
3588llvm::DICompositeType *CGDebugInfo::CreateLimitedType(
const RecordType *Ty) {
3592 StringRef RDName = getClassName(RD);
3594 llvm::DIFile *DefUnit =
nullptr;
3597 DefUnit = getOrCreateFile(Loc);
3598 Line = getLineNumber(Loc);
3601 llvm::DIScope *RDContext = getDeclContextDescriptor(RD);
3605 auto *T = cast_or_null<llvm::DICompositeType>(
3614 return getOrCreateRecordFwdDecl(Ty, RDContext);
3627 auto Flags = llvm::DINode::FlagZero;
3628 if (
auto CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3630 Flags |= llvm::DINode::FlagTypePassByReference;
3632 Flags |= llvm::DINode::FlagTypePassByValue;
3635 if (!CXXRD->isTrivial())
3636 Flags |= llvm::DINode::FlagNonTrivial;
3639 if (CXXRD->isAnonymousStructOrUnion())
3640 Flags |= llvm::DINode::FlagExportSymbols;
3643 dyn_cast<CXXRecordDecl>(CXXRD->getDeclContext()));
3646 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(D);
3647 llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
3648 getTagForRecord(RD), RDName, RDContext, DefUnit, Line, 0, Size, Align,
3653 switch (RealDecl->getTag()) {
3655 llvm_unreachable(
"invalid composite type tag");
3657 case llvm::dwarf::DW_TAG_array_type:
3658 case llvm::dwarf::DW_TAG_enumeration_type:
3667 case llvm::dwarf::DW_TAG_structure_type:
3668 case llvm::dwarf::DW_TAG_union_type:
3669 case llvm::dwarf::DW_TAG_class_type:
3672 llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
3676 RegionMap[Ty->
getDecl()].reset(RealDecl);
3679 if (
const auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
3680 DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),
3681 CollectCXXTemplateParams(TSpecial, DefUnit));
3685void CGDebugInfo::CollectContainingType(
const CXXRecordDecl *RD,
3686 llvm::DICompositeType *RealDecl) {
3688 llvm::DICompositeType *ContainingType =
nullptr;
3700 ContainingType = cast<llvm::DICompositeType>(
3701 getOrCreateType(
QualType(PBase->getTypeForDecl(), 0),
3704 ContainingType = RealDecl;
3706 DBuilder.replaceVTableHolder(RealDecl, ContainingType);
3709llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit,
QualType FType,
3710 StringRef Name, uint64_t *
Offset) {
3711 llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
3715 DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize, FieldAlign,
3716 *
Offset, llvm::DINode::FlagZero, FieldTy);
3721void CGDebugInfo::collectFunctionDeclProps(
GlobalDecl GD, llvm::DIFile *Unit,
3723 StringRef &LinkageName,
3724 llvm::DIScope *&FDContext,
3725 llvm::DINodeArray &TParamsArray,
3726 llvm::DINode::DIFlags &Flags) {
3728 Name = getFunctionName(FD);
3733 Flags |= llvm::DINode::FlagPrototyped;
3737 if (LinkageName == Name || (!CGM.
getCodeGenOpts().EmitGcovArcs &&
3742 LinkageName = StringRef();
3751 FDContext = getOrCreateNamespace(NSDecl);
3754 llvm::DIScope *Mod = getParentModuleOrNull(RDecl);
3755 FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU);
3761 Flags |= llvm::DINode::FlagNoReturn;
3763 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
3767void CGDebugInfo::collectVarDeclProps(
const VarDecl *VD, llvm::DIFile *&Unit,
3769 StringRef &Name, StringRef &LinkageName,
3770 llvm::MDTuple *&TemplateParameters,
3771 llvm::DIScope *&VDContext) {
3780 llvm::APInt ConstVal(32, 1);
3791 if (LinkageName == Name)
3792 LinkageName = StringRef();
3794 if (isa<VarTemplateSpecializationDecl>(VD)) {
3795 llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VD, &*Unit);
3796 TemplateParameters = parameterNodes.get();
3798 TemplateParameters =
nullptr;
3818 llvm::DIScope *Mod = getParentModuleOrNull(VD);
3819 VDContext = getContextDescriptor(cast<Decl>(DC), Mod ? Mod : TheCU);
3822llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(
GlobalDecl GD,
3824 llvm::DINodeArray TParamsArray;
3825 StringRef Name, LinkageName;
3826 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3827 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
3829 llvm::DIFile *Unit = getOrCreateFile(Loc);
3830 llvm::DIScope *DContext = Unit;
3831 unsigned Line = getLineNumber(Loc);
3832 collectFunctionDeclProps(GD, Unit, Name, LinkageName, DContext, TParamsArray,
3834 auto *FD = cast<FunctionDecl>(GD.
getDecl());
3839 ArgTypes.push_back(Parm->getType());
3845 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
3847 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
3850 Flags |= getCallSiteRelatedAttrs();
3851 SPFlags |= llvm::DISubprogram::SPFlagDefinition;
3852 return DBuilder.createFunction(
3853 DContext, Name, LinkageName, Unit, Line,
3854 getOrCreateFunctionType(GD.
getDecl(), FnType, Unit), 0, Flags, SPFlags,
3855 TParamsArray.get(), getFunctionDeclaration(FD));
3858 llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
3859 DContext, Name, LinkageName, Unit, Line,
3860 getOrCreateFunctionType(GD.
getDecl(), FnType, Unit), 0, Flags, SPFlags,
3861 TParamsArray.get(), getFunctionDeclaration(FD));
3863 FwdDeclReplaceMap.emplace_back(std::piecewise_construct,
3864 std::make_tuple(CanonDecl),
3865 std::make_tuple(SP));
3869llvm::DISubprogram *CGDebugInfo::getFunctionForwardDeclaration(
GlobalDecl GD) {
3870 return getFunctionFwdDeclOrStub(GD,
false);
3873llvm::DISubprogram *CGDebugInfo::getFunctionStub(
GlobalDecl GD) {
3874 return getFunctionFwdDeclOrStub(GD,
true);
3877llvm::DIGlobalVariable *
3878CGDebugInfo::getGlobalVariableForwardDeclaration(
const VarDecl *VD) {
3880 StringRef Name, LinkageName;
3882 llvm::DIFile *Unit = getOrCreateFile(Loc);
3883 llvm::DIScope *DContext = Unit;
3884 unsigned Line = getLineNumber(Loc);
3885 llvm::MDTuple *TemplateParameters =
nullptr;
3887 collectVarDeclProps(VD, Unit, Line, T, Name, LinkageName, TemplateParameters,
3890 auto *GV = DBuilder.createTempGlobalVariableFwdDecl(
3891 DContext, Name, LinkageName, Unit, Line, getOrCreateType(T, Unit),
3893 FwdDeclReplaceMap.emplace_back(
3894 std::piecewise_construct,
3896 std::make_tuple(
static_cast<llvm::Metadata *
>(GV)));
3900llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(
const Decl *D) {
3905 if (
const auto *TD = dyn_cast<TypeDecl>(D))
3910 if (I != DeclCache.end()) {
3912 if (
auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(N))
3913 return GVE->getVariable();
3914 return cast<llvm::DINode>(N);
3921 if (IE != ImportedDeclCache.end()) {
3922 auto N = IE->second;
3923 if (
auto *GVE = dyn_cast_or_null<llvm::DIImportedEntity>(N))
3924 return cast<llvm::DINode>(GVE);
3925 return dyn_cast_or_null<llvm::DINode>(N);
3930 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
3931 return getFunctionForwardDeclaration(FD);
3932 else if (
const auto *VD = dyn_cast<VarDecl>(D))
3933 return getGlobalVariableForwardDeclaration(VD);
3938llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(
const Decl *D) {
3942 const auto *FD = dyn_cast<FunctionDecl>(D);
3947 auto *S = getDeclContextDescriptor(D);
3950 if (MI == SPCache.end()) {
3952 return CreateCXXMemberFunction(MD, getOrCreateFile(MD->
getLocation()),
3953 cast<llvm::DICompositeType>(S));
3956 if (MI != SPCache.end()) {
3957 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3958 if (SP && !SP->isDefinition())
3962 for (
auto *NextFD : FD->
redecls()) {
3963 auto MI = SPCache.find(NextFD->getCanonicalDecl());
3964 if (MI != SPCache.end()) {
3965 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3966 if (SP && !SP->isDefinition())
3973llvm::DISubprogram *CGDebugInfo::getObjCMethodDeclaration(
3974 const Decl *D, llvm::DISubroutineType *FnType,
unsigned LineNo,
3975 llvm::DINode::DIFlags Flags, llvm::DISubprogram::DISPFlags SPFlags) {
3979 const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
3987 SPFlags |= llvm::DISubprogram::SPFlagObjCDirect;
3997 auto It = TypeCache.find(QTy.getAsOpaquePtr());
3998 if (It == TypeCache.end())
4000 auto *InterfaceType = cast<llvm::DICompositeType>(It->second);
4001 llvm::DISubprogram *FD = DBuilder.createFunction(
4002 InterfaceType, getObjCMethodName(OMD), StringRef(),
4003 InterfaceType->getFile(), LineNo, FnType, LineNo, Flags, SPFlags);
4004 DBuilder.finalizeSubprogram(FD);
4011llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(
const Decl *D,
4020 return DBuilder.createSubroutineType(
4021 DBuilder.getOrCreateTypeArray(std::nullopt));
4023 if (
const auto *Method = dyn_cast<CXXMethodDecl>(D))
4024 return getOrCreateMethodType(Method, F);
4029 if (
const auto *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
4034 QualType ResultTy = OMethod->getReturnType();
4039 QualType(OMethod->getClassInterface()->getTypeForDecl(), 0));
4041 Elts.push_back(getOrCreateType(ResultTy, F));
4044 if (
auto *SelfDecl = OMethod->getSelfDecl())
4045 SelfDeclTy = SelfDecl->getType();
4046 else if (
auto *FPT = dyn_cast<FunctionProtoType>(FnType))
4049 if (!SelfDeclTy.
isNull())
4051 CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F)));
4053 Elts.push_back(DBuilder.createArtificialType(
4056 for (
const auto *PI : OMethod->parameters())
4057 Elts.push_back(getOrCreateType(PI->getType(), F));
4059 if (OMethod->isVariadic())
4060 Elts.push_back(DBuilder.createUnspecifiedParameter());
4062 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
4063 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
4069 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
4070 if (FD->isVariadic()) {
4072 EltTys.push_back(getOrCreateType(FD->getReturnType(), F));
4073 if (
const auto *FPT = dyn_cast<FunctionProtoType>(FnType))
4075 EltTys.push_back(getOrCreateType(ParamType, F));
4076 EltTys.push_back(DBuilder.createUnspecifiedParameter());
4077 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
4078 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
4082 return cast<llvm::DISubroutineType>(getOrCreateType(FnType, F));
4091 CC = SrcFnTy->getCallConv();
4093 for (
const VarDecl *VD : Args)
4094 ArgTypes.push_back(VD->
getType());
4101 llvm::Function *Fn,
bool CurFuncIsThunk) {
4103 StringRef LinkageName;
4105 FnBeginRegionCount.push_back(LexicalBlockStack.size());
4108 bool HasDecl = (D !=
nullptr);
4110 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
4111 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
4112 llvm::DIFile *Unit = getOrCreateFile(Loc);
4113 llvm::DIScope *FDContext = Unit;
4114 llvm::DINodeArray TParamsArray;
4117 LinkageName = Fn->getName();
4118 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
4120 auto FI = SPCache.find(FD->getCanonicalDecl());
4121 if (FI != SPCache.end()) {
4122 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
4123 if (SP && SP->isDefinition()) {
4124 LexicalBlockStack.emplace_back(SP);
4125 RegionMap[D].reset(SP);
4129 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
4130 TParamsArray, Flags);
4131 }
else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
4132 Name = getObjCMethodName(OMD);
4133 Flags |= llvm::DINode::FlagPrototyped;
4134 }
else if (isa<VarDecl>(D) &&
4140 Name = Fn->getName();
4142 if (isa<BlockDecl>(D))
4145 Flags |= llvm::DINode::FlagPrototyped;
4147 if (Name.startswith(
"\01"))
4148 Name = Name.substr(1);
4150 assert((!D || !isa<VarDecl>(D) ||
4152 "Unexpected DynamicInitKind !");
4155 isa<VarDecl>(D) || isa<CapturedDecl>(D)) {
4156 Flags |= llvm::DINode::FlagArtificial;
4162 Flags |= llvm::DINode::FlagThunk;
4164 if (Fn->hasLocalLinkage())
4165 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
4167 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
4169 llvm::DINode::DIFlags FlagsForDef = Flags | getCallSiteRelatedAttrs();
4170 llvm::DISubprogram::DISPFlags SPFlagsForDef =
4171 SPFlags | llvm::DISubprogram::SPFlagDefinition;
4173 const unsigned LineNo = getLineNumber(Loc.
isValid() ? Loc : CurLoc);
4174 unsigned ScopeLine = getLineNumber(ScopeLoc);
4175 llvm::DISubroutineType *DIFnType = getOrCreateFunctionType(D, FnType, Unit);
4176 llvm::DISubprogram *
Decl =
nullptr;
4177 llvm::DINodeArray Annotations =
nullptr;
4179 Decl = isa<ObjCMethodDecl>(D)
4180 ? getObjCMethodDeclaration(D, DIFnType, LineNo, Flags, SPFlags)
4181 : getFunctionDeclaration(D);
4182 Annotations = CollectBTFDeclTagAnnotations(D);
4190 llvm::DISubprogram *SP = DBuilder.createFunction(
4191 FDContext, Name, LinkageName, Unit, LineNo, DIFnType, ScopeLine,
4192 FlagsForDef, SPFlagsForDef, TParamsArray.get(),
Decl,
nullptr,
4194 Fn->setSubprogram(SP);
4198 if (HasDecl && isa<FunctionDecl>(D))
4202 LexicalBlockStack.emplace_back(SP);
4205 RegionMap[D].reset(SP);
4209 QualType FnType, llvm::Function *Fn) {
4211 StringRef LinkageName;
4217 llvm::TimeTraceScope TimeScope(
"DebugFunction", [&]() {
4218 return GetName(D,
true);
4221 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
4222 llvm::DIFile *Unit = getOrCreateFile(Loc);
4223 bool IsDeclForCallSite = Fn ?
true :
false;
4224 llvm::DIScope *FDContext =
4225 IsDeclForCallSite ? Unit : getDeclContextDescriptor(D);
4226 llvm::DINodeArray TParamsArray;
4227 if (isa<FunctionDecl>(D)) {
4229 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
4230 TParamsArray, Flags);
4231 }
else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
4232 Name = getObjCMethodName(OMD);
4233 Flags |= llvm::DINode::FlagPrototyped;
4235 llvm_unreachable(
"not a function or ObjC method");
4237 if (!Name.empty() && Name[0] ==
'\01')
4238 Name = Name.substr(1);
4241 Flags |= llvm::DINode::FlagArtificial;
4246 unsigned LineNo = getLineNumber(Loc);
4247 unsigned ScopeLine = 0;
4248 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
4250 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
4252 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(D);
4253 llvm::DISubroutineType *STy = getOrCreateFunctionType(D, FnType, Unit);
4254 llvm::DISubprogram *SP = DBuilder.createFunction(
4255 FDContext, Name, LinkageName, Unit, LineNo, STy, ScopeLine, Flags,
4256 SPFlags, TParamsArray.get(),
nullptr,
nullptr, Annotations);
4262 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
4263 llvm::DITypeRefArray ParamTypes = STy->getTypeArray();
4266 llvm::DINodeArray ParamAnnotations = CollectBTFDeclTagAnnotations(PD);
4267 DBuilder.createParameterVariable(
4268 SP, PD->getName(), ArgNo, Unit, LineNo, ParamTypes[ArgNo],
true,
4269 llvm::DINode::FlagZero, ParamAnnotations);
4275 if (IsDeclForCallSite)
4276 Fn->setSubprogram(SP);
4278 DBuilder.finalizeSubprogram(SP);
4286 auto *Func = CallOrInvoke->getCalledFunction();
4289 if (Func->getSubprogram())
4294 if (CalleeDecl->
hasAttr<NoDebugAttr>() ||
4295 getCallSiteRelatedAttrs() == llvm::DINode::FlagZero)
4306 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4308 auto FI = SPCache.find(FD->getCanonicalDecl());
4309 llvm::DISubprogram *SP =
nullptr;
4310 if (FI != SPCache.end())
4311 SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
4312 if (!SP || !SP->isDefinition())
4313 SP = getFunctionStub(GD);
4314 FnBeginRegionCount.push_back(LexicalBlockStack.size());
4315 LexicalBlockStack.emplace_back(SP);
4321 assert(CurInlinedAt &&
"unbalanced inline scope stack");
4330 if (CurLoc.isInvalid() || CurLoc.isMacroID() || LexicalBlockStack.empty())
4333 llvm::MDNode *
Scope = LexicalBlockStack.back();
4334 Builder.SetCurrentDebugLocation(
4335 llvm::DILocation::get(CGM.
getLLVMContext(), getLineNumber(CurLoc),
4336 getColumnNumber(CurLoc),
Scope, CurInlinedAt));
4340 llvm::MDNode *Back =
nullptr;
4341 if (!LexicalBlockStack.empty())
4342 Back = LexicalBlockStack.back().get();
4343 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
4344 cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
4345 getColumnNumber(CurLoc)));
4348void CGDebugInfo::AppendAddressSpaceXDeref(
4350 std::optional<unsigned> DWARFAddressSpace =
4352 if (!DWARFAddressSpace)
4355 Expr.push_back(llvm::dwarf::DW_OP_constu);
4356 Expr.push_back(*DWARFAddressSpace);
4357 Expr.push_back(llvm::dwarf::DW_OP_swap);
4358 Expr.push_back(llvm::dwarf::DW_OP_xderef);
4367 Builder.SetCurrentDebugLocation(llvm::DILocation::get(
4369 LexicalBlockStack.back(), CurInlinedAt));
4375 CreateLexicalBlock(Loc);
4380 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4388 LexicalBlockStack.pop_back();
4392 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4393 unsigned RCount = FnBeginRegionCount.back();
4394 assert(RCount <= LexicalBlockStack.size() &&
"Region stack mismatch");
4397 while (LexicalBlockStack.size() != RCount) {
4400 LexicalBlockStack.pop_back();
4402 FnBeginRegionCount.pop_back();
4404 if (Fn && Fn->getSubprogram())
4405 DBuilder.finalizeSubprogram(Fn->getSubprogram());
4408CGDebugInfo::BlockByRefType
4409CGDebugInfo::EmitTypeForVarWithBlocksAttr(
const VarDecl *VD,
4410 uint64_t *XOffset) {
4413 uint64_t FieldSize, FieldOffset;
4414 uint32_t FieldAlign;
4416 llvm::DIFile *Unit = getOrCreateFile(VD->
getLocation());
4421 EltTys.push_back(CreateMemberType(Unit, FType,
"__isa", &FieldOffset));
4422 EltTys.push_back(CreateMemberType(Unit, FType,
"__forwarding", &FieldOffset));
4424 EltTys.push_back(CreateMemberType(Unit, FType,
"__flags", &FieldOffset));
4425 EltTys.push_back(CreateMemberType(Unit, FType,
"__size", &FieldOffset));
4428 if (HasCopyAndDispose) {
4431 CreateMemberType(Unit, FType,
"__copy_helper", &FieldOffset));
4433 CreateMemberType(Unit, FType,
"__destroy_helper", &FieldOffset));
4435 bool HasByrefExtendedLayout;
4438 HasByrefExtendedLayout) &&
4439 HasByrefExtendedLayout) {
4442 CreateMemberType(Unit, FType,
"__byref_variable_layout", &FieldOffset));
4451 CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;
4454 llvm::APInt pad(32, NumPaddingBytes.
getQuantity());
4457 EltTys.push_back(CreateMemberType(Unit, FType,
"", &FieldOffset));
4462 llvm::DIType *WrappedTy = getOrCreateType(FType, Unit);
4466 *XOffset = FieldOffset;
4467 llvm::DIType *FieldTy = DBuilder.createMemberType(
4468 Unit, VD->
getName(), Unit, 0, FieldSize, FieldAlign, FieldOffset,
4469 llvm::DINode::FlagZero, WrappedTy);
4470 EltTys.push_back(FieldTy);
4471 FieldOffset += FieldSize;
4473 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
4474 return {DBuilder.createStructType(Unit,
"", Unit, 0, FieldOffset, 0,
4475 llvm::DINode::FlagZero,
nullptr, Elements),
4479llvm::DILocalVariable *CGDebugInfo::EmitDeclare(
const VarDecl *VD,
4480 llvm::Value *Storage,
4481 std::optional<unsigned> ArgNo,
4483 const bool UsePointerValue) {
4485 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4486 if (VD->
hasAttr<NoDebugAttr>())
4492 llvm::DIFile *Unit =
nullptr;
4497 if (VD->
hasAttr<BlocksAttr>())
4498 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;
4500 Ty = getOrCreateType(VD->
getType(), Unit);
4509 unsigned Column = 0;
4515 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
4517 Flags |= llvm::DINode::FlagArtificial;
4522 AppendAddressSpaceXDeref(AddressSpace,
Expr);
4526 if (
const auto *IPD = dyn_cast<ImplicitParamDecl>(VD)) {
4529 Flags |= llvm::DINode::FlagObjectPointer;
4536 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
4537 StringRef Name = VD->
getName();
4538 if (!Name.empty()) {
4544 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4549 Expr.push_back(llvm::dwarf::DW_OP_deref);
4550 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4555 }
else if (
const auto *RT = dyn_cast<RecordType>(VD->
getType())) {
4567 for (
const auto *Field : RD->
fields()) {
4568 llvm::DIType *FieldTy = getOrCreateType(
Field->getType(), Unit);
4569 StringRef FieldName =
Field->getName();
4572 if (FieldName.empty() && !isa<RecordType>(
Field->getType()))
4577 auto *D = DBuilder.createAutoVariable(
4579 Flags | llvm::DINode::FlagArtificial, FieldAlign);
4582 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(
Expr),
4586 Builder.GetInsertBlock());
4594 if (UsePointerValue) {
4595 assert(!llvm::is_contained(
Expr, llvm::dwarf::DW_OP_deref) &&
4596 "Debug info already contains DW_OP_deref.");
4597 Expr.push_back(llvm::dwarf::DW_OP_deref);
4601 llvm::DILocalVariable *D =
nullptr;
4603 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(VD);
4604 D = DBuilder.createParameterVariable(
Scope, Name, *ArgNo, Unit, Line, Ty,
4615 auto RemapCoroArgToLocalVar = [&]() -> llvm::DILocalVariable * {
4618 if (!isa<llvm::DISubprogram>(
Scope) || !
Scope->isDistinct())
4621 auto Iter = llvm::find_if(CoroutineParameterMappings, [&](
auto &Pair) {
4622 Stmt *StmtPtr =
const_cast<Stmt *
>(Pair.second);
4623 if (
DeclStmt *DeclStmtPtr = dyn_cast<DeclStmt>(StmtPtr)) {
4626 if (VD == dyn_cast_or_null<VarDecl>(
Decl))
4632 if (Iter != CoroutineParameterMappings.end()) {
4634 auto Iter2 = llvm::find_if(ParamDbgMappings, [&](
auto &DbgPair) {
4635 return DbgPair.first == PD && DbgPair.second->getScope() ==
Scope;
4637 if (Iter2 != ParamDbgMappings.end())
4638 return const_cast<llvm::DILocalVariable *
>(Iter2->second);
4644 D = RemapCoroArgToLocalVar();
4647 D = DBuilder.createAutoVariable(
Scope, Name, Unit, Line, Ty,
4651 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(
Expr),
4653 Column,
Scope, CurInlinedAt),
4654 Builder.GetInsertBlock());
4659llvm::DILocalVariable *CGDebugInfo::EmitDeclare(
const BindingDecl *BD,
4660 llvm::Value *Storage,
4661 std::optional<unsigned> ArgNo,
4663 const bool UsePointerValue) {
4665 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4666 if (BD->
hasAttr<NoDebugAttr>())
4673 llvm::DIFile *Unit = getOrCreateFile(BD->
getLocation());
4674 llvm::DIType *Ty = getOrCreateType(BD->
getType(), Unit);
4685 AppendAddressSpaceXDeref(AddressSpace,
Expr);
4690 if (UsePointerValue) {
4691 assert(!llvm::is_contained(
Expr, llvm::dwarf::DW_OP_deref) &&
4692 "Debug info already contains DW_OP_deref.");
4693 Expr.push_back(llvm::dwarf::DW_OP_deref);
4697 unsigned Column = getColumnNumber(BD->
getLocation());
4698 StringRef Name = BD->
getName();
4699 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
4701 llvm::DILocalVariable *D = DBuilder.createAutoVariable(
4703 llvm::DINode::FlagZero, Align);
4706 if (
const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
4707 const unsigned fieldIndex = FD->getFieldIndex();
4714 if (fieldOffset != 0) {
4715 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4721 dyn_cast<ArraySubscriptExpr>(BD->
getBinding())) {
4722 if (
const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(ASE->getIdx())) {
4723 const uint64_t value = IL->getValue().getZExtValue();
4727 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4736 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(
Expr),
4738 Column,
Scope, CurInlinedAt),
4739 Builder.GetInsertBlock());
4744llvm::DILocalVariable *
4747 const bool UsePointerValue) {
4750 if (
auto *DD = dyn_cast<DecompositionDecl>(VD))
4751 for (
auto *B : DD->bindings()) {
4752 EmitDeclare(B, Storage, std::nullopt, Builder,
4756 return EmitDeclare(VD, Storage, std::nullopt, Builder, UsePointerValue);
4761 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4763 if (D->
hasAttr<NoDebugAttr>())
4766 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
4767 llvm::DIFile *Unit = getOrCreateFile(D->
getLocation());
4771 unsigned Column = getColumnNumber(D->
getLocation());
4773 StringRef Name = D->
getName();
4780 DBuilder.insertLabel(L,
4782 Scope, CurInlinedAt),
4783 Builder.GetInsertBlock());
4786llvm::DIType *CGDebugInfo::CreateSelfType(
const QualType &QualTy,
4788 llvm::DIType *CachedTy = getTypeOrNull(QualTy);
4791 return DBuilder.createObjectPointerType(Ty);
4796 const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) {
4798 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4800 if (Builder.GetInsertBlock() ==
nullptr)
4802 if (VD->
hasAttr<NoDebugAttr>())
4805 bool isByRef = VD->
hasAttr<BlocksAttr>();
4807 uint64_t XOffset = 0;
4808 llvm::DIFile *Unit = getOrCreateFile(VD->
getLocation());
4811 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;
4813 Ty = getOrCreateType(VD->
getType(), Unit);
4817 if (
const auto *IPD = dyn_cast<ImplicitParamDecl>(VD))
4819 Ty = CreateSelfType(VD->
getType(), Ty);
4822 const unsigned Line =
4824 unsigned Column = getColumnNumber(VD->
getLocation());
4833 addr.push_back(llvm::dwarf::DW_OP_deref);
4834 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4837 addr.push_back(llvm::dwarf::DW_OP_deref);
4838 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4843 addr.push_back(llvm::dwarf::DW_OP_deref);
4844 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4852 auto *D = DBuilder.createAutoVariable(
4853 cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->
getName(), Unit,
4854 Line, Ty,
false, llvm::DINode::FlagZero, Align);
4857 auto DL = llvm::DILocation::get(CGM.
getLLVMContext(), Line, Column,
4858 LexicalBlockStack.back(), CurInlinedAt);
4859 auto *
Expr = DBuilder.createExpression(addr);
4861 DBuilder.insertDeclare(Storage, D,
Expr, DL, InsertPoint);
4863 DBuilder.insertDeclare(Storage, D,
Expr, DL, Builder.GetInsertBlock());
4866llvm::DILocalVariable *
4869 bool UsePointerValue) {
4871 return EmitDeclare(VD, AI, ArgNo, Builder, UsePointerValue);
4875struct BlockLayoutChunk {
4876 uint64_t OffsetInBits;
4879bool operator<(
const BlockLayoutChunk &l,
const BlockLayoutChunk &r) {
4880 return l.OffsetInBits < r.OffsetInBits;
4884void CGDebugInfo::collectDefaultFieldsForBlockLiteralDeclare(
4886 const llvm::StructLayout &BlockLayout, llvm::DIFile *Unit,
4892 Fields.push_back(createFieldType(
"__size", Context.
IntTy, Loc,
AS_public,
4893 BlockLayout.getElementOffsetInBits(0),
4895 Fields.push_back(createFieldType(
"__align", Context.
IntTy, Loc,
AS_public,
4896 BlockLayout.getElementOffsetInBits(1),
4900 BlockLayout.getElementOffsetInBits(0),
4902 Fields.push_back(createFieldType(
"__flags", Context.
IntTy, Loc,
AS_public,
4903 BlockLayout.getElementOffsetInBits(1),
4907 BlockLayout.getElementOffsetInBits(2), Unit, Unit));
4908 auto *FnTy =
Block.getBlockExpr()->getFunctionType();
4910 Fields.push_back(createFieldType(
"__FuncPtr", FnPtrType, Loc,
AS_public,
4911 BlockLayout.getElementOffsetInBits(3),
4913 Fields.push_back(createFieldType(
4918 Loc,
AS_public, BlockLayout.getElementOffsetInBits(4), Unit, Unit));
4925 llvm::AllocaInst *Alloca,
4933 llvm::DIFile *tunit = getOrCreateFile(loc);
4934 unsigned line = getLineNumber(loc);
4935 unsigned column = getColumnNumber(loc);
4940 const llvm::StructLayout *blockLayout =
4944 collectDefaultFieldsForBlockLiteralDeclare(block,
C, loc, *blockLayout, tunit,
4953 BlockLayoutChunk chunk;
4954 chunk.OffsetInBits =
4955 blockLayout->getElementOffsetInBits(block.
CXXThisIndex);
4956 chunk.Capture =
nullptr;
4957 chunks.push_back(chunk);
4961 for (
const auto &capture :
blockDecl->captures()) {
4962 const VarDecl *variable = capture.getVariable();
4969 BlockLayoutChunk chunk;
4970 chunk.OffsetInBits =
4971 blockLayout->getElementOffsetInBits(captureInfo.
getIndex());
4972 chunk.Capture = &capture;
4973 chunks.push_back(chunk);
4977 llvm::array_pod_sort(chunks.begin(), chunks.end());
4979 for (
const BlockLayoutChunk &Chunk : chunks) {
4980 uint64_t offsetInBits = Chunk.OffsetInBits;
4987 cast_or_null<CXXMethodDecl>(
blockDecl->getNonClosureContext()))
4989 else if (
auto *RDecl = dyn_cast<CXXRecordDecl>(
blockDecl->getParent()))
4992 llvm_unreachable(
"unexpected block declcontext");
4994 fields.push_back(createFieldType(
"this",
type, loc,
AS_public,
4995 offsetInBits, tunit, tunit));
5000 StringRef name = variable->
getName();
5002 llvm::DIType *fieldType;
5004 TypeInfo PtrInfo =
C.getTypeInfo(
C.VoidPtrTy);
5009 EmitTypeForVarWithBlocksAttr(variable, &xoffset).BlockByRefWrapper;
5010 fieldType = DBuilder.createPointerType(fieldType, PtrInfo.
Width);
5011 fieldType = DBuilder.createMemberType(tunit, name, tunit, line,
5012 PtrInfo.
Width, Align, offsetInBits,
5013 llvm::DINode::FlagZero, fieldType);
5017 offsetInBits, Align, tunit, tunit);
5019 fields.push_back(fieldType);
5023 llvm::raw_svector_ostream(typeName)
5026 llvm::DINodeArray fieldsArray = DBuilder.getOrCreateArray(fields);
5028 llvm::DIType *
type =
5029 DBuilder.createStructType(tunit, typeName.str(), tunit, line,
5031 llvm::DINode::FlagZero,
nullptr, fieldsArray);
5035 llvm::DINode::DIFlags flags = llvm::DINode::FlagArtificial;
5036 auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back());
5039 auto *debugVar = DBuilder.createParameterVariable(
5040 scope, Name, ArgNo, tunit, line,
type, CGM.
getLangOpts().Optimize, flags);
5043 DBuilder.insertDeclare(Alloca, debugVar, DBuilder.createExpression(),
5045 column, scope, CurInlinedAt),
5046 Builder.GetInsertBlock());
5049llvm::DIDerivedType *
5050CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(
const VarDecl *D) {
5055 if (MI != StaticDataMemberCache.end()) {
5056 assert(MI->second &&
"Static data member declaration should still exist");
5063 auto *Ctxt = cast<llvm::DICompositeType>(getDeclContextDescriptor(D));
5064 return CreateRecordStaticField(D, Ctxt, cast<RecordDecl>(DC));
5067llvm::DIGlobalVariableExpression *CGDebugInfo::CollectAnonRecordDecls(
5068 const RecordDecl *RD, llvm::DIFile *Unit,
unsigned LineNo,
5069 StringRef LinkageName, llvm::GlobalVariable *Var, llvm::DIScope *DContext) {
5070 llvm::DIGlobalVariableExpression *GVE =
nullptr;
5072 for (
const auto *Field : RD->
fields()) {
5073 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
5074 StringRef FieldName = Field->getName();
5077 if (FieldName.empty()) {
5078 if (
const auto *RT = dyn_cast<RecordType>(Field->getType()))
5079 GVE = CollectAnonRecordDecls(RT->getDecl(), Unit, LineNo, LinkageName,
5084 GVE = DBuilder.createGlobalVariableExpression(
5085 DContext, FieldName, LinkageName, Unit, LineNo, FieldTy,
5086 Var->hasLocalLinkage());
5087 Var->addDebugInfo(GVE);
5099 const auto *RD = dyn_cast<CXXRecordDecl>(RT->
getDecl());
5104 auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD);
5112 case TemplateArgument::Pack:
5113 return ReferencesAnonymousEntity(TA.getPackAsArray());
5114 case TemplateArgument::Type: {
5115 struct ReferencesAnonymous
5116 : public RecursiveASTVisitor<ReferencesAnonymous> {
5117 bool RefAnon = false;
5118 bool VisitRecordType(RecordType *RT) {
5119 if (ReferencesAnonymousEntity(RT)) {
5126 ReferencesAnonymous RT;
5127 RT.TraverseType(TA.getAsType());
5140 bool Reconstitutable =
true;
5142 Reconstitutable =
false;
5146 Reconstitutable =
false;
5149 bool VisitType(
Type *T) {
5153 Reconstitutable =
false;
5158 bool TraverseEnumType(
EnumType *ET) {
5161 if (
const auto *ED = dyn_cast<EnumDecl>(ET->
getDecl())) {
5163 Reconstitutable =
false;
5167 Reconstitutable =
false;
5177 return Reconstitutable;
5181 Reconstitutable =
false;
5191 ReconstitutableType T;
5193 return T.Reconstitutable;
5196std::string CGDebugInfo::GetName(
const Decl *D,
bool Qualified)
const {
5198 llvm::raw_string_ostream
OS(Name);
5199 const NamedDecl *ND = dyn_cast<NamedDecl>(D);
5208 std::optional<TemplateArgs> Args;
5210 bool IsOperatorOverload =
false;
5211 if (
auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
5212 Args = GetTemplateArgs(RD);
5213 }
else if (
auto *FD = dyn_cast<FunctionDecl>(ND)) {
5214 Args = GetTemplateArgs(FD);
5216 IsOperatorOverload |=
5219 }
else if (
auto *VD = dyn_cast<VarDecl>(ND)) {
5220 Args = GetTemplateArgs(VD);
5226 case TemplateArgument::Template:
5233 case TemplateArgument::Declaration:
5241 case TemplateArgument::NullPtr:
5245 case TemplateArgument::Pack:
5247 return HasReconstitutableArgs(TA.getPackAsArray());
5248 case TemplateArgument::Integral:
5253 return TA.getAsIntegral().getBitWidth() <= 64 &&
5254 IsReconstitutableType(TA.getIntegralType());
5255 case TemplateArgument::Type:
5256 return IsReconstitutableType(TA.getAsType());
5258 llvm_unreachable(
"Other, unresolved, template arguments should "
5259 "not be seen here");
5284 bool Reconstitutable =
5285 Args && HasReconstitutableArgs(Args->Args) && !IsOperatorOverload;
5300 std::string EncodedOriginalName;
5301 llvm::raw_string_ostream EncodedOriginalNameOS(EncodedOriginalName);
5309 std::string CanonicalOriginalName;
5310 llvm::raw_string_ostream OriginalOS(CanonicalOriginalName);
5312 assert(EncodedOriginalNameOS.str() == OriginalOS.str());
5322 if (D->
hasAttr<NoDebugAttr>())
5325 llvm::TimeTraceScope TimeScope(
"DebugGlobalVariable", [&]() {
5326 return GetName(D,
true);
5332 if (Cached != DeclCache.end())
5333 return Var->addDebugInfo(
5334 cast<llvm::DIGlobalVariableExpression>(Cached->second));
5337 llvm::DIFile *Unit =
nullptr;
5338 llvm::DIScope *DContext =
nullptr;
5340 StringRef DeclName, LinkageName;
5342 llvm::MDTuple *TemplateParameters =
nullptr;
5343 collectVarDeclProps(D, Unit, LineNo, T, DeclName, LinkageName,
5344 TemplateParameters, DContext);
5348 llvm::DIGlobalVariableExpression *GVE =
nullptr;
5356 "unnamed non-anonymous struct or union?");
5357 GVE = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
5364 if (D->
hasAttr<CUDASharedAttr>())
5367 else if (D->
hasAttr<CUDAConstantAttr>())
5371 AppendAddressSpaceXDeref(AddressSpace,
Expr);
5373 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(D);
5374 GVE = DBuilder.createGlobalVariableExpression(
5375 DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit),
5376 Var->hasLocalLinkage(),
true,
5377 Expr.empty() ?
nullptr : DBuilder.createExpression(
Expr),
5378 getOrCreateStaticDataMemberDeclarationOrNull(D), TemplateParameters,
5379 Align, Annotations);
5380 Var->addDebugInfo(GVE);