40#include "llvm/ADT/DenseSet.h"
41#include "llvm/ADT/SmallVector.h"
42#include "llvm/ADT/StringExtras.h"
43#include "llvm/IR/Constants.h"
44#include "llvm/IR/DataLayout.h"
45#include "llvm/IR/DerivedTypes.h"
46#include "llvm/IR/Instructions.h"
47#include "llvm/IR/Intrinsics.h"
48#include "llvm/IR/Metadata.h"
49#include "llvm/IR/Module.h"
50#include "llvm/Support/MD5.h"
51#include "llvm/Support/Path.h"
52#include "llvm/Support/SHA1.h"
53#include "llvm/Support/SHA256.h"
54#include "llvm/Support/TimeProfiler.h"
61 if (TI.isAlignRequired())
89 llvm::dyn_cast_or_null<DeclRefExpr>(
Init->IgnoreUnlessSpelledInSource());
93 return llvm::dyn_cast_or_null<DecompositionDecl>(RefExpr->getDecl());
111 : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
112 DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),
113 DBuilder(CGM.getModule()) {
118 assert(LexicalBlockStack.empty() &&
119 "Region stack mismatch, stack not empty!");
125 init(TemporaryLocation);
132 init(TemporaryLocation, DefaultToEmpty);
136 bool DefaultToEmpty) {
143 OriginalLocation = CGF->
Builder.getCurrentDebugLocation();
145 if (OriginalLocation && !DI->CGM.getExpressionLocationsEnabled())
148 if (TemporaryLocation.
isValid()) {
149 DI->EmitLocation(CGF->
Builder, TemporaryLocation);
153 if (DefaultToEmpty) {
154 CGF->
Builder.SetCurrentDebugLocation(llvm::DebugLoc());
159 assert(!DI->LexicalBlockStack.empty());
160 CGF->
Builder.SetCurrentDebugLocation(
161 llvm::DILocation::get(DI->LexicalBlockStack.back()->getContext(), 0, 0,
162 DI->LexicalBlockStack.back(), DI->getInlinedAt()));
176 OriginalLocation = CGF.
Builder.getCurrentDebugLocation();
178 CGF.
Builder.SetCurrentDebugLocation(std::move(
Loc));
185 CGF->
Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
196 SavedLocation = DI.getLocation();
197 assert((DI.getInlinedAt() ==
198 CGF.
Builder.getCurrentDebugLocation()->getInlinedAt()) &&
199 "CGDebugInfo and IRBuilder are out of sync");
201 DI.EmitInlineFunctionStart(CGF.
Builder, InlinedFn);
209 DI.EmitLocation(CGF->
Builder, SavedLocation);
222 if (LexicalBlockStack.empty())
226 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
228 if (PCLoc.
isInvalid() ||
Scope->getFile() == getOrCreateFile(CurLoc))
231 if (
auto *LBF = dyn_cast<llvm::DILexicalBlockFile>(
Scope)) {
232 LexicalBlockStack.pop_back();
233 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlockFile(
234 LBF->getScope(), getOrCreateFile(CurLoc)));
235 }
else if (isa<llvm::DILexicalBlock>(
Scope) ||
236 isa<llvm::DISubprogram>(
Scope)) {
237 LexicalBlockStack.pop_back();
238 LexicalBlockStack.emplace_back(
239 DBuilder.createLexicalBlockFile(
Scope, getOrCreateFile(CurLoc)));
243llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(
const Decl *
D) {
244 llvm::DIScope *Mod = getParentModuleOrNull(
D);
249llvm::DIScope *CGDebugInfo::getContextDescriptor(
const Decl *Context,
254 auto I = RegionMap.find(Context);
255 if (I != RegionMap.end()) {
256 llvm::Metadata *
V = I->second;
257 return dyn_cast_or_null<llvm::DIScope>(
V);
261 if (
const auto *NSDecl = dyn_cast<NamespaceDecl>(Context))
262 return getOrCreateNamespace(NSDecl);
264 if (
const auto *RDecl = dyn_cast<RecordDecl>(Context))
265 if (!RDecl->isDependentType())
300StringRef CGDebugInfo::getFunctionName(
const FunctionDecl *FD) {
301 return internString(GetName(FD));
304StringRef CGDebugInfo::getObjCMethodName(
const ObjCMethodDecl *OMD) {
306 llvm::raw_svector_ostream OS(MethodName);
309 if (
const auto *OID = dyn_cast<ObjCImplementationDecl>(DC)) {
310 OS << OID->getName();
311 }
else if (
const auto *OID = dyn_cast<ObjCInterfaceDecl>(DC)) {
312 OS << OID->getName();
313 }
else if (
const auto *OC = dyn_cast<ObjCCategoryDecl>(DC)) {
314 if (OC->IsClassExtension()) {
315 OS << OC->getClassInterface()->getName();
317 OS << OC->getIdentifier()->getNameStart() <<
'('
318 << OC->getIdentifier()->getNameStart() <<
')';
320 }
else if (
const auto *OCD = dyn_cast<ObjCCategoryImplDecl>(DC)) {
321 OS << OCD->getClassInterface()->getName() <<
'(' << OCD->getName() <<
')';
325 return internString(OS.str());
328StringRef CGDebugInfo::getSelectorName(
Selector S) {
329 return internString(S.getAsString());
332StringRef CGDebugInfo::getClassName(
const RecordDecl *RD) {
333 if (isa<ClassTemplateSpecializationDecl>(RD)) {
335 return internString(GetName(RD));
341 return II->getName();
349 "Typedef should not be in another decl context!");
350 assert(
D->getDeclName().getAsIdentifierInfo() &&
351 "Typedef was not named!");
352 return D->getDeclName().getAsIdentifierInfo()->getName();
362 Name = DD->getName();
367 Name = TND->getName();
370 if (
const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
371 if (CXXRD->isLambda())
379 return internString(UnnamedType);
387std::optional<llvm::DIFile::ChecksumKind>
396 std::optional<llvm::MemoryBufferRef> MemBuffer =
SM.getBufferOrNone(FID);
400 auto Data = llvm::arrayRefFromStringRef(MemBuffer->getBuffer());
403 llvm::toHex(llvm::MD5::hash(
Data),
true, Checksum);
404 return llvm::DIFile::CSK_MD5;
406 llvm::toHex(llvm::SHA1::hash(
Data),
true, Checksum);
407 return llvm::DIFile::CSK_SHA1;
409 llvm::toHex(llvm::SHA256::hash(
Data),
true, Checksum);
410 return llvm::DIFile::CSK_SHA256;
412 llvm_unreachable(
"Unhandled DebugSrcHashKind enum");
415std::optional<StringRef> CGDebugInfo::getSource(
const SourceManager &
SM,
420 bool SourceInvalid =
false;
421 StringRef Source =
SM.getBufferData(FID, &SourceInvalid);
433 std::optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo;
439 FileName = TheCU->getFile()->getFilename();
440 CSInfo = TheCU->getFile()->getChecksum();
446 FileName = TheCU->getFile()->getFilename();
454 auto It = DIFileCache.find(
FileName.data());
455 if (It != DIFileCache.end()) {
457 if (llvm::Metadata *
V = It->second)
458 return cast<llvm::DIFile>(
V);
464 std::optional<llvm::DIFile::ChecksumKind> CSKind =
465 computeChecksum(FID, Checksum);
467 CSInfo.emplace(*CSKind, Checksum);
472llvm::DIFile *CGDebugInfo::createFile(
474 std::optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo,
475 std::optional<StringRef> Source) {
479 std::string CurDir =
remapDIPath(getCurrentDirname());
482 if (llvm::sys::path::is_absolute(RemappedFile)) {
485 auto FileIt = llvm::sys::path::begin(RemappedFile);
486 auto FileE = llvm::sys::path::end(RemappedFile);
487 auto CurDirIt = llvm::sys::path::begin(CurDir);
488 auto CurDirE = llvm::sys::path::end(CurDir);
489 for (; CurDirIt != CurDirE && *CurDirIt == *FileIt; ++CurDirIt, ++FileIt)
490 llvm::sys::path::append(DirBuf, *CurDirIt);
491 if (llvm::sys::path::root_path(DirBuf) == DirBuf) {
497 for (; FileIt != FileE; ++FileIt)
498 llvm::sys::path::append(FileBuf, *FileIt);
503 if (!llvm::sys::path::is_absolute(
FileName))
507 llvm::DIFile *F = DBuilder.createFile(
File, Dir, CSInfo, Source);
508 DIFileCache[
FileName.data()].reset(F);
515 if (llvm::sys::path::replace_path_prefix(
P, From, To))
517 return P.str().str();
524 return SM.getPresumedLoc(
Loc).getLine();
540StringRef CGDebugInfo::getCurrentDirname() {
544 if (!CWDName.empty())
546 llvm::ErrorOr<std::string> CWD =
550 return CWDName = internString(*CWD);
553void CGDebugInfo::CreateCompileUnit() {
555 std::optional<llvm::DIFile::ChecksumKind> CSKind;
556 std::optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo;
569 std::string MainFileName = CGO.MainFileName;
570 if (MainFileName.empty())
571 MainFileName =
"<stdin>";
577 std::string MainFileDir;
579 SM.getFileEntryRefForID(
SM.getMainFileID())) {
580 MainFileDir = std::string(MainFile->getDir().getName());
581 if (!llvm::sys::path::is_absolute(MainFileName)) {
583 llvm::sys::path::Style Style =
586 ? llvm::sys::path::Style::windows_backslash
587 : llvm::sys::path::Style::posix)
588 : llvm::sys::path::Style::native;
589 llvm::sys::path::append(MainFileDirSS, Style, MainFileName);
590 MainFileName = std::string(
591 llvm::sys::path::remove_leading_dotslash(MainFileDirSS, Style));
598 if (MainFile->getName() == MainFileName &&
600 MainFile->getName().rsplit(
'.').second)
602 MainFileName = CGM.
getModule().getName().str();
604 CSKind = computeChecksum(
SM.getMainFileID(), Checksum);
608 llvm::dwarf::SourceLanguage LangTag;
611 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
612 else if (CGO.DebugStrictDwarf && CGO.DwarfVersion < 5)
613 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
614 else if (LO.CPlusPlus14)
615 LangTag = llvm::dwarf::DW_LANG_C_plus_plus_14;
616 else if (LO.CPlusPlus11)
617 LangTag = llvm::dwarf::DW_LANG_C_plus_plus_11;
619 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
620 }
else if (LO.ObjC) {
621 LangTag = llvm::dwarf::DW_LANG_ObjC;
622 }
else if (LO.OpenCL && (!CGM.
getCodeGenOpts().DebugStrictDwarf ||
624 LangTag = llvm::dwarf::DW_LANG_OpenCL;
625 }
else if (LO.C11 && !(CGO.DebugStrictDwarf && CGO.DwarfVersion < 5)) {
626 LangTag = llvm::dwarf::DW_LANG_C11;
628 LangTag = llvm::dwarf::DW_LANG_C99;
630 LangTag = llvm::dwarf::DW_LANG_C89;
636 unsigned RuntimeVers = 0;
640 llvm::DICompileUnit::DebugEmissionKind EmissionKind;
642 case llvm::codegenoptions::NoDebugInfo:
643 case llvm::codegenoptions::LocTrackingOnly:
644 EmissionKind = llvm::DICompileUnit::NoDebug;
646 case llvm::codegenoptions::DebugLineTablesOnly:
647 EmissionKind = llvm::DICompileUnit::LineTablesOnly;
649 case llvm::codegenoptions::DebugDirectivesOnly:
650 EmissionKind = llvm::DICompileUnit::DebugDirectivesOnly;
652 case llvm::codegenoptions::DebugInfoConstructor:
653 case llvm::codegenoptions::LimitedDebugInfo:
654 case llvm::codegenoptions::FullDebugInfo:
655 case llvm::codegenoptions::UnusedTypeInfo:
656 EmissionKind = llvm::DICompileUnit::FullDebug;
667 CSInfo.emplace(*CSKind, Checksum);
668 llvm::DIFile *CUFile = DBuilder.createFile(
670 getSource(
SM,
SM.getMainFileID()));
672 StringRef Sysroot, SDK;
673 if (CGM.
getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB) {
675 auto B = llvm::sys::path::rbegin(Sysroot);
676 auto E = llvm::sys::path::rend(Sysroot);
678 std::find_if(B,
E, [](
auto SDK) {
return SDK.ends_with(
".sdk"); });
683 llvm::DICompileUnit::DebugNameTableKind NameTableKind =
684 static_cast<llvm::DICompileUnit::DebugNameTableKind
>(
685 CGOpts.DebugNameTable);
687 NameTableKind = llvm::DICompileUnit::DebugNameTableKind::None;
689 NameTableKind = llvm::DICompileUnit::DebugNameTableKind::Apple;
692 TheCU = DBuilder.createCompileUnit(
693 LangTag, CUFile, CGOpts.EmitVersionIdentMetadata ? Producer :
"",
694 LO.Optimize || CGOpts.PrepareForLTO || CGOpts.PrepareForThinLTO,
695 CGOpts.DwarfDebugFlags, RuntimeVers, CGOpts.SplitDwarfFile, EmissionKind,
696 DwoId, CGOpts.SplitDwarfInlining, CGOpts.DebugInfoForProfiling,
697 NameTableKind, CGOpts.DebugRangesBaseAddress,
remapDIPath(Sysroot), SDK);
700llvm::DIType *CGDebugInfo::CreateType(
const BuiltinType *BT) {
704#define BUILTIN_TYPE(Id, SingletonId)
705#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
706#include "clang/AST/BuiltinTypes.def"
707 case BuiltinType::Dependent:
708 llvm_unreachable(
"Unexpected builtin type");
709 case BuiltinType::NullPtr:
710 return DBuilder.createNullPtrType();
711 case BuiltinType::Void:
713 case BuiltinType::ObjCClass:
716 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
717 "objc_class", TheCU, TheCU->getFile(), 0);
719 case BuiltinType::ObjCId: {
730 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
731 "objc_class", TheCU, TheCU->getFile(), 0);
735 auto *ISATy = DBuilder.createPointerType(ClassTy, Size);
737 ObjTy = DBuilder.createStructType(TheCU,
"objc_object", TheCU->getFile(), 0,
738 0, 0, llvm::DINode::FlagZero,
nullptr,
739 llvm::DINodeArray());
741 DBuilder.replaceArrays(
742 ObjTy, DBuilder.getOrCreateArray(&*DBuilder.createMemberType(
743 ObjTy,
"isa", TheCU->getFile(), 0, Size, 0, 0,
744 llvm::DINode::FlagZero, ISATy)));
747 case BuiltinType::ObjCSel: {
749 SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
750 "objc_selector", TheCU,
751 TheCU->getFile(), 0);
755#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
756 case BuiltinType::Id: \
757 return getOrCreateStructPtrType("opencl_" #ImgType "_" #Suffix "_t", \
759#include "clang/Basic/OpenCLImageTypes.def"
760 case BuiltinType::OCLSampler:
761 return getOrCreateStructPtrType(
"opencl_sampler_t", OCLSamplerDITy);
762 case BuiltinType::OCLEvent:
763 return getOrCreateStructPtrType(
"opencl_event_t", OCLEventDITy);
764 case BuiltinType::OCLClkEvent:
765 return getOrCreateStructPtrType(
"opencl_clk_event_t", OCLClkEventDITy);
766 case BuiltinType::OCLQueue:
767 return getOrCreateStructPtrType(
"opencl_queue_t", OCLQueueDITy);
768 case BuiltinType::OCLReserveID:
769 return getOrCreateStructPtrType(
"opencl_reserve_id_t", OCLReserveIDDITy);
770#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
771 case BuiltinType::Id: \
772 return getOrCreateStructPtrType("opencl_" #ExtType, Id##Ty);
773#include "clang/Basic/OpenCLExtensionTypes.def"
774#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
775 case BuiltinType::Id: \
776 return getOrCreateStructPtrType(#Name, SingletonId);
777#include "clang/Basic/HLSLIntangibleTypes.def"
779#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
780#include "clang/Basic/AArch64SVEACLETypes.def"
782 if (BT->
getKind() == BuiltinType::MFloat8) {
783 Encoding = llvm::dwarf::DW_ATE_unsigned_char;
787 return DBuilder.createBasicType(BTName, Size, Encoding);
791 BT->
getKind() == BuiltinType::SveCount
795 : CGM.getContext().getBuiltinVectorTypeInfo(BT);
802 "Unsupported number of vectors for svcount_t");
806 unsigned NumElems = Info.
EC.getKnownMinValue() * Info.
NumVectors;
812 llvm::Metadata *LowerBound, *UpperBound;
813 LowerBound = llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
815 if (Info.
EC.isScalable()) {
816 unsigned NumElemsPerVG = NumElems / 2;
818 {llvm::dwarf::DW_OP_constu, NumElemsPerVG, llvm::dwarf::DW_OP_bregx,
819 46, 0, llvm::dwarf::DW_OP_mul,
820 llvm::dwarf::DW_OP_constu, 1, llvm::dwarf::DW_OP_minus});
821 UpperBound = DBuilder.createExpression(
Expr);
823 UpperBound = llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
826 llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(
827 nullptr, LowerBound, UpperBound,
nullptr);
828 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
829 llvm::DIType *ElemTy =
830 getOrCreateType(Info.
ElementType, TheCU->getFile());
832 return DBuilder.createVectorType( 0, Align, ElemTy,
837#define PPC_VECTOR_TYPE(Name, Id, size) \
838 case BuiltinType::Id:
839#include "clang/Basic/PPCTypes.def"
842#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
843#include "clang/Basic/RISCVVTypes.def"
848 unsigned ElementCount = Info.
EC.getKnownMinValue();
851 bool Fractional =
false;
853 unsigned FixedSize = ElementCount * SEW;
857 }
else if (FixedSize < 64) {
860 LMUL = 64 / FixedSize;
862 LMUL = FixedSize / 64;
870 {llvm::dwarf::DW_OP_bregx,
873 llvm::dwarf::DW_OP_constu,
875 llvm::dwarf::DW_OP_div, llvm::dwarf::DW_OP_constu, LMUL});
877 Expr.push_back(llvm::dwarf::DW_OP_div);
879 Expr.push_back(llvm::dwarf::DW_OP_mul);
881 Expr.append({llvm::dwarf::DW_OP_constu, 1, llvm::dwarf::DW_OP_minus});
884 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
886 auto *UpperBound = DBuilder.createExpression(
Expr);
887 llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(
888 nullptr, LowerBound, UpperBound,
nullptr);
889 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
890 llvm::DIType *ElemTy =
891 getOrCreateType(Info.
ElementType, TheCU->getFile());
894 return DBuilder.createVectorType(0, Align, ElemTy,
898#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS) \
899 case BuiltinType::Id: { \
902 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, \
903 MangledName, TheCU, TheCU->getFile(), 0); \
904 return SingletonId; \
906#include "clang/Basic/WebAssemblyReferenceTypes.def"
907#define AMDGPU_OPAQUE_PTR_TYPE(Name, Id, SingletonId, Width, Align, AS) \
908 case BuiltinType::Id: { \
911 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name, \
912 TheCU, TheCU->getFile(), 0); \
913 return SingletonId; \
915#define AMDGPU_NAMED_BARRIER_TYPE(Name, Id, SingletonId, Width, Align, Scope) \
916 case BuiltinType::Id: { \
919 DBuilder.createBasicType(Name, Width, llvm::dwarf::DW_ATE_unsigned); \
920 return SingletonId; \
922#include "clang/Basic/AMDGPUTypes.def"
923 case BuiltinType::UChar:
924 case BuiltinType::Char_U:
925 Encoding = llvm::dwarf::DW_ATE_unsigned_char;
927 case BuiltinType::Char_S:
928 case BuiltinType::SChar:
929 Encoding = llvm::dwarf::DW_ATE_signed_char;
931 case BuiltinType::Char8:
932 case BuiltinType::Char16:
933 case BuiltinType::Char32:
936 case BuiltinType::UShort:
937 case BuiltinType::UInt:
938 case BuiltinType::UInt128:
939 case BuiltinType::ULong:
940 case BuiltinType::WChar_U:
941 case BuiltinType::ULongLong:
942 Encoding = llvm::dwarf::DW_ATE_unsigned;
944 case BuiltinType::Short:
945 case BuiltinType::Int:
946 case BuiltinType::Int128:
947 case BuiltinType::Long:
948 case BuiltinType::WChar_S:
949 case BuiltinType::LongLong:
950 Encoding = llvm::dwarf::DW_ATE_signed;
952 case BuiltinType::Bool:
953 Encoding = llvm::dwarf::DW_ATE_boolean;
955 case BuiltinType::Half:
956 case BuiltinType::Float:
957 case BuiltinType::LongDouble:
958 case BuiltinType::Float16:
959 case BuiltinType::BFloat16:
960 case BuiltinType::Float128:
961 case BuiltinType::Double:
962 case BuiltinType::Ibm128:
968 Encoding = llvm::dwarf::DW_ATE_float;
970 case BuiltinType::ShortAccum:
971 case BuiltinType::Accum:
972 case BuiltinType::LongAccum:
973 case BuiltinType::ShortFract:
974 case BuiltinType::Fract:
975 case BuiltinType::LongFract:
976 case BuiltinType::SatShortFract:
977 case BuiltinType::SatFract:
978 case BuiltinType::SatLongFract:
979 case BuiltinType::SatShortAccum:
980 case BuiltinType::SatAccum:
981 case BuiltinType::SatLongAccum:
982 Encoding = llvm::dwarf::DW_ATE_signed_fixed;
984 case BuiltinType::UShortAccum:
985 case BuiltinType::UAccum:
986 case BuiltinType::ULongAccum:
987 case BuiltinType::UShortFract:
988 case BuiltinType::UFract:
989 case BuiltinType::ULongFract:
990 case BuiltinType::SatUShortAccum:
991 case BuiltinType::SatUAccum:
992 case BuiltinType::SatULongAccum:
993 case BuiltinType::SatUShortFract:
994 case BuiltinType::SatUFract:
995 case BuiltinType::SatULongFract:
996 Encoding = llvm::dwarf::DW_ATE_unsigned_fixed;
1003 return DBuilder.createBasicType(BTName, Size, Encoding);
1006llvm::DIType *CGDebugInfo::CreateType(
const BitIntType *Ty) {
1008 StringRef Name = Ty->
isUnsigned() ?
"unsigned _BitInt" :
"_BitInt";
1010 ? llvm::dwarf::DW_ATE_unsigned
1011 : llvm::dwarf::DW_ATE_signed;
1017llvm::DIType *CGDebugInfo::CreateType(
const ComplexType *Ty) {
1019 llvm::dwarf::TypeKind
Encoding = llvm::dwarf::DW_ATE_complex_float;
1021 Encoding = llvm::dwarf::DW_ATE_lo_user;
1024 return DBuilder.createBasicType(
"complex", Size, Encoding);
1038 return llvm::dwarf::DW_TAG_const_type;
1042 return llvm::dwarf::DW_TAG_volatile_type;
1046 return llvm::dwarf::DW_TAG_restrict_type;
1048 return (llvm::dwarf::Tag)0;
1051llvm::DIType *CGDebugInfo::CreateQualifiedType(
QualType Ty,
1052 llvm::DIFile *Unit) {
1062 assert(Qc.
empty() &&
"Unknown type qualifier for debug info");
1063 return getOrCreateType(
QualType(
T, 0), Unit);
1070 return DBuilder.createQualifiedType(Tag, FromTy);
1074 llvm::DIFile *Unit) {
1083 assert(Q.
empty() &&
"Unknown type qualifier for debug info");
1094 return DBuilder.createQualifiedType(Tag, FromTy);
1098 llvm::DIFile *Unit) {
1106 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
1110llvm::DIType *CGDebugInfo::CreateType(
const PointerType *Ty,
1111 llvm::DIFile *Unit) {
1112 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
1118 switch (TheCU->getSourceLanguage()) {
1119 case llvm::dwarf::DW_LANG_C_plus_plus:
1120 case llvm::dwarf::DW_LANG_C_plus_plus_11:
1121 case llvm::dwarf::DW_LANG_C_plus_plus_14:
1123 case llvm::dwarf::DW_LANG_ObjC_plus_plus:
1124 return isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD);
1152 llvm::DICompileUnit *TheCU) {
1170 llvm::DICompileUnit *TheCU) {
1176 if (
const auto *RD = dyn_cast<CXXRecordDecl>(TD))
1178 if (RD->isDynamicClass() &&
1191 llvm::dwarf::Tag Tag;
1193 Tag = llvm::dwarf::DW_TAG_structure_type;
1195 Tag = llvm::dwarf::DW_TAG_union_type;
1200 Tag = llvm::dwarf::DW_TAG_class_type;
1205llvm::DICompositeType *
1206CGDebugInfo::getOrCreateRecordFwdDecl(
const RecordType *Ty,
1207 llvm::DIScope *Ctx) {
1210 return cast<llvm::DICompositeType>(
T);
1211 llvm::DIFile *DefUnit = getOrCreateFile(RD->
getLocation());
1212 const unsigned Line =
1214 StringRef RDName = getClassName(RD);
1220 if (
D &&
D->isCompleteDefinition())
1223 llvm::DINode::DIFlags Flags = llvm::DINode::FlagFwdDecl;
1228 if (
const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1229 if (!CXXRD->hasDefinition() ||
1230 (CXXRD->hasDefinition() && !CXXRD->isTrivial()))
1231 Flags |= llvm::DINode::FlagNonTrivial;
1238 llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
1242 if (
auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
1243 DBuilder.replaceArrays(RetTy, llvm::DINodeArray(),
1244 CollectCXXTemplateParams(TSpecial, DefUnit));
1245 ReplaceMap.emplace_back(
1246 std::piecewise_construct, std::make_tuple(Ty),
1247 std::make_tuple(
static_cast<llvm::Metadata *
>(RetTy)));
1251llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
1254 llvm::DIFile *Unit) {
1259 std::optional<unsigned> DWARFAddressSpace =
1265 BTFAttrTy = dyn_cast<BTFTagAttributedType>(
Atomic->getValueType());
1267 BTFAttrTy = dyn_cast<BTFTagAttributedType>(PointeeTy);
1270 StringRef
Tag = BTFAttrTy->
getAttr()->getBTFTypeTag();
1272 llvm::Metadata *Ops[2] = {
1273 llvm::MDString::get(CGM.
getLLVMContext(), StringRef(
"btf_type_tag")),
1275 Annots.insert(Annots.begin(),
1278 BTFAttrTy = dyn_cast<BTFTagAttributedType>(BTFAttrTy->
getWrappedType());
1281 llvm::DINodeArray Annotations =
nullptr;
1282 if (Annots.size() > 0)
1283 Annotations = DBuilder.getOrCreateArray(Annots);
1285 if (Tag == llvm::dwarf::DW_TAG_reference_type ||
1286 Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)
1287 return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit),
1288 Size, Align, DWARFAddressSpace);
1290 return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
1291 Align, DWARFAddressSpace, StringRef(),
1295llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
1296 llvm::DIType *&
Cache) {
1299 Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
1300 TheCU, TheCU->getFile(), 0);
1302 Cache = DBuilder.createPointerType(
Cache, Size);
1306uint64_t CGDebugInfo::collectDefaultElementTypesForBlockPointer(
1307 const BlockPointerType *Ty, llvm::DIFile *Unit, llvm::DIDerivedType *DescTy,
1320 EltTys.push_back(CreateMemberType(Unit, FType,
"__size", &FieldOffset));
1321 EltTys.push_back(CreateMemberType(Unit, FType,
"__align", &FieldOffset));
1324 EltTys.push_back(CreateMemberType(Unit, FType,
"__isa", &FieldOffset));
1326 EltTys.push_back(CreateMemberType(Unit, FType,
"__flags", &FieldOffset));
1327 EltTys.push_back(CreateMemberType(Unit, FType,
"__reserved", &FieldOffset));
1329 EltTys.push_back(CreateMemberType(Unit, FType,
"__FuncPtr", &FieldOffset));
1333 EltTys.push_back(DBuilder.createMemberType(
1334 Unit,
"__descriptor",
nullptr, LineNo, FieldSize, FieldAlign,
1335 FieldOffset, llvm::DINode::FlagZero, DescTy));
1336 FieldOffset += FieldSize;
1343 llvm::DIFile *Unit) {
1347 llvm::DINodeArray Elements;
1351 EltTys.push_back(CreateMemberType(Unit, FType,
"reserved", &FieldOffset));
1352 EltTys.push_back(CreateMemberType(Unit, FType,
"Size", &FieldOffset));
1354 Elements = DBuilder.getOrCreateArray(EltTys);
1357 llvm::DINode::DIFlags Flags = llvm::DINode::FlagAppleBlock;
1360 DBuilder.createStructType(Unit,
"__block_descriptor",
nullptr, 0,
1361 FieldOffset, 0, Flags,
nullptr, Elements);
1366 auto *DescTy = DBuilder.createPointerType(EltTy, Size);
1368 FieldOffset = collectDefaultElementTypesForBlockPointer(Ty, Unit, DescTy,
1371 Elements = DBuilder.getOrCreateArray(EltTys);
1377 EltTy = DBuilder.createStructType(Unit,
"",
nullptr, 0, FieldOffset, 0,
1378 Flags,
nullptr, Elements);
1380 return DBuilder.createPointerType(EltTy, Size);
1397 if (Param->isParameterPack()) {
1406 if (SubstArgs.empty()) {
1415 SpecArgs.push_back(SubstArgs.front());
1416 SubstArgs = SubstArgs.drop_front();
1422 llvm::DIFile *Unit) {
1427 if (isa<BuiltinTemplateDecl>(TD))
1430 const auto *
AliasDecl = cast<TypeAliasTemplateDecl>(TD)->getTemplatedDecl();
1435 llvm::raw_svector_ostream OS(NS);
1437 auto PP = getPrintingPolicy();
1464 auto ArgVector = ::GetTemplateArgs(TD, Ty);
1473 llvm::raw_string_ostream OS(Name);
1476 llvm::codegenoptions::DebugTemplateNamesKind::Simple ||
1477 !HasReconstitutableArgs(Args.Args))
1480 llvm::DIDerivedType *AliasTy = DBuilder.createTemplateAlias(
1481 Src, Name, getOrCreateFile(
Loc), getLineNumber(
Loc),
1482 getDeclContextDescriptor(
AliasDecl), CollectTemplateParams(Args, Unit));
1488 return DBuilder.createTypedef(Src, OS.str(), getOrCreateFile(
Loc),
1505 return llvm::DINode::FlagZero;
1509 return llvm::DINode::FlagPrivate;
1511 return llvm::DINode::FlagProtected;
1513 return llvm::DINode::FlagPublic;
1515 return llvm::DINode::FlagZero;
1517 llvm_unreachable(
"unexpected access enumerator");
1520llvm::DIType *CGDebugInfo::CreateType(
const TypedefType *Ty,
1521 llvm::DIFile *Unit) {
1522 llvm::DIType *Underlying =
1534 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(Ty->
getDecl());
1536 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1538 if (isa<RecordDecl>(DC))
1541 return DBuilder.createTypedef(Underlying, Ty->
getDecl()->
getName(),
1542 getOrCreateFile(
Loc), getLineNumber(
Loc),
1543 getDeclContextDescriptor(Ty->
getDecl()), Align,
1544 Flags, Annotations);
1554 return llvm::dwarf::DW_CC_BORLAND_stdcall;
1556 return llvm::dwarf::DW_CC_BORLAND_msfastcall;
1558 return llvm::dwarf::DW_CC_BORLAND_thiscall;
1560 return llvm::dwarf::DW_CC_LLVM_vectorcall;
1562 return llvm::dwarf::DW_CC_BORLAND_pascal;
1564 return llvm::dwarf::DW_CC_LLVM_Win64;
1566 return llvm::dwarf::DW_CC_LLVM_X86_64SysV;
1570 return llvm::dwarf::DW_CC_LLVM_AAPCS;
1572 return llvm::dwarf::DW_CC_LLVM_AAPCS_VFP;
1574 return llvm::dwarf::DW_CC_LLVM_IntelOclBicc;
1576 return llvm::dwarf::DW_CC_LLVM_SpirFunction;
1579 return llvm::dwarf::DW_CC_LLVM_OpenCLKernel;
1581 return llvm::dwarf::DW_CC_LLVM_Swift;
1583 return llvm::dwarf::DW_CC_LLVM_SwiftTail;
1585 return llvm::dwarf::DW_CC_LLVM_PreserveMost;
1587 return llvm::dwarf::DW_CC_LLVM_PreserveAll;
1589 return llvm::dwarf::DW_CC_LLVM_X86RegCall;
1591 return llvm::dwarf::DW_CC_LLVM_M68kRTD;
1593 return llvm::dwarf::DW_CC_LLVM_PreserveNone;
1595 return llvm::dwarf::DW_CC_LLVM_RISCVVectorCall;
1601 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1603 Flags |= llvm::DINode::FlagLValueReference;
1605 Flags |= llvm::DINode::FlagRValueReference;
1609llvm::DIType *CGDebugInfo::CreateType(
const FunctionType *Ty,
1610 llvm::DIFile *Unit) {
1611 const auto *FPT = dyn_cast<FunctionProtoType>(Ty);
1613 if (llvm::DIType *QTy = CreateQualifiedType(FPT, Unit))
1622 EltTys.push_back(getOrCreateType(Ty->
getReturnType(), Unit));
1624 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1628 EltTys.push_back(DBuilder.createUnspecifiedParameter());
1631 for (
const QualType &ParamType : FPT->param_types())
1632 EltTys.push_back(getOrCreateType(ParamType, Unit));
1633 if (FPT->isVariadic())
1634 EltTys.push_back(DBuilder.createUnspecifiedParameter());
1637 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
1638 llvm::DIType *F = DBuilder.createSubroutineType(
1643llvm::DIDerivedType *
1644CGDebugInfo::createBitFieldType(
const FieldDecl *BitFieldDecl,
1645 llvm::DIScope *RecordTy,
const RecordDecl *RD) {
1646 StringRef Name = BitFieldDecl->
getName();
1648 if (BitFieldDecl->
hasAttr<PreferredTypeAttr>())
1649 Ty = BitFieldDecl->
getAttr<PreferredTypeAttr>()->getType();
1651 llvm::DIFile *VUnit = getOrCreateFile(
Loc);
1652 llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);
1655 llvm::DIFile *
File = getOrCreateFile(
Loc);
1656 unsigned Line = getLineNumber(
Loc);
1661 assert(SizeInBits > 0 &&
"found named 0-width bitfield");
1670 uint64_t OffsetInBits = StorageOffsetInBits + Offset;
1672 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(BitFieldDecl);
1673 return DBuilder.createBitFieldMemberType(
1674 RecordTy, Name,
File,
Line, SizeInBits, OffsetInBits, StorageOffsetInBits,
1675 Flags, DebugType, Annotations);
1678llvm::DIDerivedType *CGDebugInfo::createBitFieldSeparatorIfNeeded(
1679 const FieldDecl *BitFieldDecl,
const llvm::DIDerivedType *BitFieldDI,
1707 if (PreviousFieldsDI.empty())
1711 auto *PreviousMDEntry =
1712 PreviousFieldsDI.empty() ? nullptr : PreviousFieldsDI.back();
1713 auto *PreviousMDField =
1714 dyn_cast_or_null<llvm::DIDerivedType>(PreviousMDEntry);
1715 if (!PreviousMDField || !PreviousMDField->isBitField() ||
1716 PreviousMDField->getSizeInBits() == 0)
1720 std::advance(PreviousBitfield, BitFieldDecl->
getFieldIndex() - 1);
1722 assert(PreviousBitfield->isBitField());
1725 if (!PreviousBitfield->isZeroLengthBitField(Context))
1728 QualType Ty = PreviousBitfield->getType();
1730 llvm::DIFile *VUnit = getOrCreateFile(
Loc);
1731 llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);
1732 llvm::DIScope *RecordTy = BitFieldDI->getScope();
1734 llvm::DIFile *
File = getOrCreateFile(
Loc);
1735 unsigned Line = getLineNumber(
Loc);
1738 cast<llvm::ConstantInt>(BitFieldDI->getStorageOffsetInBits())
1741 llvm::DINode::DIFlags Flags =
1743 llvm::DINodeArray Annotations =
1744 CollectBTFDeclTagAnnotations(*PreviousBitfield);
1745 return DBuilder.createBitFieldMemberType(
1746 RecordTy,
"",
File,
Line, 0, StorageOffsetInBits, StorageOffsetInBits,
1747 Flags, DebugType, Annotations);
1750llvm::DIType *CGDebugInfo::createFieldType(
1752 uint64_t offsetInBits, uint32_t AlignInBits, llvm::DIFile *tunit,
1753 llvm::DIScope *scope,
const RecordDecl *RD, llvm::DINodeArray Annotations) {
1754 llvm::DIType *debugType = getOrCreateType(
type, tunit);
1757 llvm::DIFile *file = getOrCreateFile(loc);
1758 const unsigned line = getLineNumber(loc.
isValid() ? loc : CurLoc);
1761 auto Align = AlignInBits;
1762 if (!
type->isIncompleteArrayType()) {
1764 SizeInBits = TI.
Width;
1770 return DBuilder.createMemberType(scope, name, file, line, SizeInBits, Align,
1771 offsetInBits, flags, debugType, Annotations);
1775CGDebugInfo::createInlinedTrapSubprogram(StringRef FuncName,
1776 llvm::DIFile *FileScope) {
1780 llvm::DISubprogram *&SP = InlinedTrapFuncMap[FuncName];
1783 llvm::DISubroutineType *DIFnTy = DBuilder.createSubroutineType(
nullptr);
1784 SP = DBuilder.createFunction(
1785 FileScope, FuncName, StringRef(),
1786 FileScope, 0, DIFnTy,
1788 llvm::DINode::FlagArtificial,
1789 llvm::DISubprogram::SPFlagDefinition,
1790 nullptr,
nullptr,
nullptr);
1796void CGDebugInfo::CollectRecordLambdaFields(
1798 llvm::DIType *RecordTy) {
1804 unsigned fieldno = 0;
1807 I !=
E; ++I, ++Field, ++fieldno) {
1809 if (
C.capturesVariable()) {
1811 assert(!
Field->isBitField() &&
"lambdas don't have bitfield members!");
1813 StringRef VName =
V->getName();
1814 llvm::DIFile *VUnit = getOrCreateFile(
Loc);
1816 llvm::DIType *FieldType = createFieldType(
1818 layout.
getFieldOffset(fieldno), Align, VUnit, RecordTy, CXXDecl);
1819 elements.push_back(FieldType);
1820 }
else if (
C.capturesThis()) {
1826 llvm::DIFile *VUnit = getOrCreateFile(f->
getLocation());
1828 StringRef ThisName =
1830 llvm::DIType *fieldType = createFieldType(
1834 elements.push_back(fieldType);
1839llvm::DIDerivedType *
1840CGDebugInfo::CreateRecordStaticField(
const VarDecl *Var, llvm::DIType *RecordTy,
1845 llvm::DIFile *VUnit = getOrCreateFile(Var->
getLocation());
1846 llvm::DIType *VTy = getOrCreateType(Var->
getType(), VUnit);
1848 unsigned LineNumber = getLineNumber(Var->
getLocation());
1849 StringRef VName = Var->
getName();
1853 llvm::Constant *
C =
nullptr;
1859 if (
Value->isFloat())
1866 ? llvm::dwarf::DW_TAG_variable
1867 : llvm::dwarf::DW_TAG_member;
1869 llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
1870 RecordTy, VName, VUnit, LineNumber, VTy, Flags,
C, Tag, Align);
1875void CGDebugInfo::CollectRecordNormalField(
1876 const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit,
1883 if (
name.empty() && !
type->isRecordType())
1886 llvm::DIType *FieldType;
1888 llvm::DIDerivedType *BitFieldType;
1889 FieldType = BitFieldType = createBitFieldType(field, RecordTy, RD);
1890 if (llvm::DIType *Separator =
1891 createBitFieldSeparatorIfNeeded(field, BitFieldType, elements, RD))
1892 elements.push_back(Separator);
1895 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(field);
1898 OffsetInBits, Align, tunit, RecordTy, RD, Annotations);
1901 elements.push_back(FieldType);
1904void CGDebugInfo::CollectRecordNestedType(
1908 if (isa<InjectedClassNameType>(Ty))
1911 llvm::DIType *nestedType = getOrCreateType(Ty, getOrCreateFile(
Loc));
1912 elements.push_back(nestedType);
1915void CGDebugInfo::CollectRecordFields(
1916 const RecordDecl *record, llvm::DIFile *tunit,
1918 llvm::DICompositeType *RecordTy) {
1919 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(record);
1921 if (CXXDecl && CXXDecl->
isLambda())
1922 CollectRecordLambdaFields(CXXDecl, elements, RecordTy);
1927 unsigned fieldNo = 0;
1931 for (
const auto *I : record->
decls())
1932 if (
const auto *
V = dyn_cast<VarDecl>(I)) {
1933 if (
V->hasAttr<NoDebugAttr>())
1939 isa<VarTemplateSpecializationDecl>(
V))
1942 if (isa<VarTemplatePartialSpecializationDecl>(
V))
1946 auto MI = StaticDataMemberCache.find(
V->getCanonicalDecl());
1947 if (MI != StaticDataMemberCache.end()) {
1948 assert(MI->second &&
1949 "Static data member declaration should still exist");
1950 elements.push_back(MI->second);
1952 auto Field = CreateRecordStaticField(
V, RecordTy, record);
1953 elements.push_back(Field);
1955 }
else if (
const auto *field = dyn_cast<FieldDecl>(I)) {
1956 CollectRecordNormalField(field, layout.
getFieldOffset(fieldNo), tunit,
1957 elements, RecordTy, record);
1964 if (
const auto *nestedType = dyn_cast<TypeDecl>(I)) {
1966 if (isa<RecordDecl>(I) &&
1967 cast<RecordDecl>(I)->isAnonymousStructOrUnion())
1969 if (!nestedType->isImplicit() &&
1970 nestedType->getDeclContext() == record)
1971 CollectRecordNestedType(nestedType, elements);
1977llvm::DISubroutineType *
1978CGDebugInfo::getOrCreateMethodType(
const CXXMethodDecl *Method,
1979 llvm::DIFile *Unit) {
1982 return cast_or_null<llvm::DISubroutineType>(
1989 return getOrCreateInstanceMethodType(ThisType,
Func, Unit);
1992llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType(
2008 const auto *OriginalFunc = cast<llvm::DISubroutineType>(
2010 Func->getReturnType(),
Func->getParamTypes(), EPI),
2012 llvm::DITypeRefArray Args = OriginalFunc->getTypeArray();
2013 assert(Args.size() &&
"Invalid number of arguments!");
2018 Elts.push_back(Args[0]);
2024 llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);
2026 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
2027 Elts.push_back(ThisPtrType);
2031 for (
unsigned i = 1, e = Args.size(); i != e; ++i)
2032 Elts.push_back(Args[i]);
2034 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
2036 return DBuilder.createSubroutineType(EltTypeArray, OriginalFunc->getFlags(),
2043 if (
const auto *NRD = dyn_cast<CXXRecordDecl>(RD->
getDeclContext()))
2050llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
2051 const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {
2053 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
2055 StringRef MethodName = getFunctionName(Method);
2056 llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit);
2060 StringRef MethodLinkageName;
2070 llvm::DIFile *MethodDefUnit =
nullptr;
2071 unsigned MethodLine = 0;
2073 MethodDefUnit = getOrCreateFile(Method->
getLocation());
2074 MethodLine = getLineNumber(Method->
getLocation());
2078 llvm::DIType *ContainingType =
nullptr;
2079 unsigned VIndex = 0;
2080 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2081 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
2086 SPFlags |= llvm::DISubprogram::SPFlagPureVirtual;
2088 SPFlags |= llvm::DISubprogram::SPFlagVirtual;
2093 if (!isa<CXXDestructorDecl>(Method))
2098 const auto *DD = dyn_cast<CXXDestructorDecl>(Method);
2110 Flags |= llvm::DINode::FlagIntroducedVirtual;
2119 ContainingType = RecordTy;
2123 SPFlags |= llvm::DISubprogram::SPFlagDeleted;
2126 Flags |= llvm::DINode::FlagNoReturn;
2129 Flags |= llvm::DINode::FlagStaticMember;
2131 Flags |= llvm::DINode::FlagArtificial;
2133 if (
const auto *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
2134 if (CXXC->isExplicit())
2135 Flags |= llvm::DINode::FlagExplicit;
2136 }
else if (
const auto *CXXC = dyn_cast<CXXConversionDecl>(Method)) {
2137 if (CXXC->isExplicit())
2138 Flags |= llvm::DINode::FlagExplicit;
2141 Flags |= llvm::DINode::FlagPrototyped;
2143 Flags |= llvm::DINode::FlagLValueReference;
2145 Flags |= llvm::DINode::FlagRValueReference;
2147 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
2149 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
2153 if (DebugKind == llvm::codegenoptions::DebugInfoConstructor)
2157 llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
2158 llvm::DISubprogram *SP = DBuilder.createMethod(
2159 RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
2160 MethodTy, VIndex,
ThisAdjustment, ContainingType, Flags, SPFlags,
2161 TParamsArray.get());
2168void CGDebugInfo::CollectCXXMemberFunctions(
2175 for (
const auto *I : RD->
decls()) {
2176 const auto *Method = dyn_cast<CXXMethodDecl>(I);
2200 EltTys.push_back(MI == SPCache.end()
2201 ? CreateCXXMemberFunction(Method, Unit, RecordTy)
2202 :
static_cast<llvm::Metadata *
>(MI->second));
2206void CGDebugInfo::CollectCXXBases(
const CXXRecordDecl *RD, llvm::DIFile *Unit,
2208 llvm::DIType *RecordTy) {
2209 llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> SeenTypes;
2210 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->
bases(), SeenTypes,
2211 llvm::DINode::FlagZero);
2216 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->
vbases(), SeenTypes,
2217 llvm::DINode::FlagIndirectVirtualBase);
2221void CGDebugInfo::CollectCXXBasesAux(
2226 llvm::DINode::DIFlags StartingFlags) {
2228 for (
const auto &BI : Bases) {
2231 if (!SeenTypes.insert(
Base).second)
2233 auto *BaseTy = getOrCreateType(BI.getType(), Unit);
2234 llvm::DINode::DIFlags BFlags = StartingFlags;
2238 if (BI.isVirtual()) {
2255 BFlags |= llvm::DINode::FlagVirtual;
2262 llvm::DIType *DTy = DBuilder.createInheritance(RecordTy, BaseTy, BaseOffset,
2263 VBPtrOffset, BFlags);
2264 EltTys.push_back(DTy);
2269CGDebugInfo::CollectTemplateParams(std::optional<TemplateArgs> OArgs,
2270 llvm::DIFile *Unit) {
2272 return llvm::DINodeArray();
2273 TemplateArgs &Args = *OArgs;
2275 for (
unsigned i = 0, e = Args.Args.size(); i != e; ++i) {
2280 Name = Args.TList->getParam(i)->getName();
2284 llvm::DIType *TTy = getOrCreateType(TA.
getAsType(), Unit);
2285 TemplateParams.push_back(DBuilder.createTemplateTypeParameter(
2286 TheCU, Name, TTy, defaultParameter));
2291 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2292 TheCU, Name, TTy, defaultParameter,
2298 llvm::DIType *TTy = getOrCreateType(
T, Unit);
2299 llvm::Constant *
V =
nullptr;
2306 if (
const auto *VD = dyn_cast<VarDecl>(
D))
2310 else if (
const auto *MD = dyn_cast<CXXMethodDecl>(
D);
2311 MD && MD->isImplicitObjectMemberFunction())
2313 else if (
const auto *FD = dyn_cast<FunctionDecl>(
D))
2317 else if (
const auto *MPT =
2318 dyn_cast<MemberPointerType>(
T.getTypePtr())) {
2326 }
else if (
const auto *GD = dyn_cast<MSGuidDecl>(
D)) {
2328 }
else if (
const auto *TPO = dyn_cast<TemplateParamObjectDecl>(
D)) {
2335 assert(
V &&
"Failed to find template parameter pointer");
2336 V =
V->stripPointerCasts();
2338 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2339 TheCU, Name, TTy, defaultParameter, cast_or_null<llvm::Constant>(
V)));
2343 llvm::DIType *TTy = getOrCreateType(
T, Unit);
2344 llvm::Constant *
V =
nullptr;
2347 if (
const auto *MPT = dyn_cast<MemberPointerType>(
T.getTypePtr()))
2353 if (MPT->isMemberDataPointer())
2356 V = llvm::ConstantInt::get(CGM.
Int8Ty, 0);
2357 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2358 TheCU, Name, TTy, defaultParameter,
V));
2362 llvm::DIType *TTy = getOrCreateType(
T, Unit);
2365 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2366 TheCU, Name, TTy, defaultParameter,
V));
2369 std::string QualName;
2370 llvm::raw_string_ostream OS(QualName);
2372 OS, getPrintingPolicy());
2373 TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(
2374 TheCU, Name,
nullptr, QualName, defaultParameter));
2378 TemplateParams.push_back(DBuilder.createTemplateParameterPack(
2379 TheCU, Name,
nullptr,
2388 assert(
V &&
"Expression in template argument isn't constant");
2389 llvm::DIType *TTy = getOrCreateType(
T, Unit);
2390 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
2391 TheCU, Name, TTy, defaultParameter,
V->stripPointerCasts()));
2397 "These argument types shouldn't exist in concrete types");
2400 return DBuilder.getOrCreateArray(TemplateParams);
2403std::optional<CGDebugInfo::TemplateArgs>
2404CGDebugInfo::GetTemplateArgs(
const FunctionDecl *FD)
const {
2412 return std::nullopt;
2414std::optional<CGDebugInfo::TemplateArgs>
2415CGDebugInfo::GetTemplateArgs(
const VarDecl *VD)
const {
2419 auto *TS = dyn_cast<VarTemplateSpecializationDecl>(VD);
2421 return std::nullopt;
2424 auto TA = TS->getTemplateArgs().asArray();
2425 return {{TList, TA}};
2427std::optional<CGDebugInfo::TemplateArgs>
2428CGDebugInfo::GetTemplateArgs(
const RecordDecl *RD)
const {
2429 if (
auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
2434 TSpecial->getSpecializedTemplate()->getTemplateParameters();
2436 return {{TPList, TAList.
asArray()}};
2438 return std::nullopt;
2442CGDebugInfo::CollectFunctionTemplateParams(
const FunctionDecl *FD,
2443 llvm::DIFile *Unit) {
2444 return CollectTemplateParams(GetTemplateArgs(FD), Unit);
2447llvm::DINodeArray CGDebugInfo::CollectVarTemplateParams(
const VarDecl *VL,
2448 llvm::DIFile *Unit) {
2449 return CollectTemplateParams(GetTemplateArgs(VL), Unit);
2452llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(
const RecordDecl *RD,
2453 llvm::DIFile *Unit) {
2454 return CollectTemplateParams(GetTemplateArgs(RD), Unit);
2457llvm::DINodeArray CGDebugInfo::CollectBTFDeclTagAnnotations(
const Decl *
D) {
2463 llvm::Metadata *Ops[2] = {
2464 llvm::MDString::get(CGM.
getLLVMContext(), StringRef(
"btf_decl_tag")),
2466 Annotations.push_back(llvm::MDNode::get(CGM.
getLLVMContext(), Ops));
2468 return DBuilder.getOrCreateArray(Annotations);
2471llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
2473 return VTablePtrType;
2478 llvm::Metadata *STy = getOrCreateType(Context.
IntTy, Unit);
2479 llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);
2480 llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements);
2483 std::optional<unsigned> DWARFAddressSpace =
2486 llvm::DIType *vtbl_ptr_type = DBuilder.createPointerType(
2487 SubTy, Size, 0, DWARFAddressSpace,
"__vtbl_ptr_type");
2488 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
2489 return VTablePtrType;
2492StringRef CGDebugInfo::getVTableName(
const CXXRecordDecl *RD) {
2497StringRef CGDebugInfo::getDynamicInitializerName(
const VarDecl *VD,
2499 llvm::Function *InitFn) {
2504 return InitFn->getName();
2514 llvm::raw_svector_ostream OS(QualifiedGV);
2516 std::tie(Quals, GVName) = OS.str().rsplit(
"::");
2518 std::swap(Quals, GVName);
2522 llvm::raw_svector_ostream OS(InitName);
2524 OS << Quals <<
"::";
2529 llvm_unreachable(
"not an initializer");
2531 OS <<
"`dynamic initializer for '";
2534 OS <<
"`dynamic atexit destructor for '";
2541 if (
const auto *VTpl = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
2543 getPrintingPolicy());
2548 return internString(OS.str());
2551void CGDebugInfo::CollectVTableInfo(
const CXXRecordDecl *RD, llvm::DIFile *Unit,
2568 llvm::DIType *VPtrTy =
nullptr;
2571 if (NeedVTableShape) {
2576 unsigned VSlotCount =
2578 unsigned VTableWidth = PtrWidth * VSlotCount;
2580 std::optional<unsigned> DWARFAddressSpace =
2584 llvm::DIType *VTableType = DBuilder.createPointerType(
2585 nullptr, VTableWidth, 0, DWARFAddressSpace,
"__vtbl_ptr_type");
2586 EltTys.push_back(VTableType);
2589 VPtrTy = DBuilder.createPointerType(VTableType, PtrWidth);
2597 VPtrTy = getOrCreateVTablePtrType(Unit);
2600 llvm::DIType *VPtrMember =
2601 DBuilder.createMemberType(Unit, getVTableName(RD), Unit, 0, Size, 0, 0,
2602 llvm::DINode::FlagArtificial, VPtrTy);
2603 EltTys.push_back(VPtrMember);
2609 llvm::DIType *
T = getOrCreateType(RTy, getOrCreateFile(
Loc));
2621 assert(!
D.isNull() &&
"null type");
2622 llvm::DIType *
T = getOrCreateType(
D, getOrCreateFile(
Loc));
2623 assert(
T &&
"could not create debug info for type");
2625 RetainedTypes.push_back(
D.getAsOpaquePtr());
2633 llvm::codegenoptions::DebugLineTablesOnly)
2639 node = getOrCreateType(AllocatedTy, getOrCreateFile(
Loc));
2641 CI->setMetadata(
"heapallocsite", node);
2645 if (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)
2649 auto I = TypeCache.find(TyPtr);
2650 if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())
2652 llvm::DIType *Res = CreateTypeDefinition(Ty->
castAs<
EnumType>());
2653 assert(!Res->isForwardDecl());
2654 TypeCache[TyPtr].reset(Res);
2658 if (DebugKind > llvm::codegenoptions::LimitedDebugInfo ||
2665 if (RD->
hasAttr<DLLImportAttr>())
2668 if (MD->hasAttr<DLLImportAttr>())
2681 if (
auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) {
2691 if (
auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(CXXDecl))
2692 Explicit = TD->isExplicitInstantiationOrSpecialization();
2706 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
2707 if (CXXRD->isDynamicClass() &&
2709 llvm::GlobalValue::AvailableExternallyLinkage &&
2720 if (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)
2724 auto I = TypeCache.find(TyPtr);
2725 if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
2732 assert(!Res->isForwardDecl());
2733 TypeCache[TyPtr].reset(Res);
2740 if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&
2741 !MD->getMemberSpecializationInfo()->isExplicitSpecialization())
2764 if (Ctor->isCopyOrMoveConstructor())
2766 if (!Ctor->isDeleted())
2785 if (DebugKind == llvm::codegenoptions::DebugLineTablesOnly)
2788 if (DebugKind > llvm::codegenoptions::LimitedDebugInfo ||
2789 RD->
hasAttr<StandaloneDebugAttr>())
2792 if (!LangOpts.CPlusPlus)
2798 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
2814 if (
const auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
2815 Spec = SD->getSpecializationKind();
2824 if ((DebugKind == llvm::codegenoptions::DebugInfoConstructor) &&
2836 llvm::DIType *
T = getTypeOrNull(Ty);
2837 if (
T &&
T->isForwardDecl())
2841llvm::DIType *CGDebugInfo::CreateType(
const RecordType *Ty) {
2843 llvm::DIType *
T = cast_or_null<llvm::DIType>(getTypeOrNull(
QualType(Ty, 0)));
2847 T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));
2851 auto [Def, Pref] = CreateTypeDefinition(Ty);
2853 return Pref ? Pref : Def;
2856llvm::DIType *CGDebugInfo::GetPreferredNameType(
const CXXRecordDecl *RD,
2857 llvm::DIFile *Unit) {
2861 auto const *PNA = RD->
getAttr<PreferredNameAttr>();
2865 return getOrCreateType(PNA->getTypedefType(), Unit);
2868std::pair<llvm::DIType *, llvm::DIType *>
2869CGDebugInfo::CreateTypeDefinition(
const RecordType *Ty) {
2873 llvm::DIFile *DefUnit = getOrCreateFile(RD->
getLocation());
2881 llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty);
2884 if (!
D || !
D->isCompleteDefinition())
2885 return {FwdDecl,
nullptr};
2887 if (
const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
2888 CollectContainingType(CXXDecl, FwdDecl);
2891 LexicalBlockStack.emplace_back(&*FwdDecl);
2892 RegionMap[Ty->
getDecl()].reset(FwdDecl);
2902 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
2904 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
2905 CollectVTableInfo(CXXDecl, DefUnit, EltTys);
2909 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
2910 if (CXXDecl && !CGM.
getCodeGenOpts().DebugOmitUnreferencedMethods)
2911 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
2913 LexicalBlockStack.pop_back();
2914 RegionMap.erase(Ty->
getDecl());
2916 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2917 DBuilder.replaceArrays(FwdDecl, Elements);
2919 if (FwdDecl->isTemporary())
2921 llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
2923 RegionMap[Ty->
getDecl()].reset(FwdDecl);
2925 if (CGM.
getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB)
2926 if (
auto *PrefDI = GetPreferredNameType(CXXDecl, DefUnit))
2927 return {FwdDecl, PrefDI};
2929 return {FwdDecl,
nullptr};
2933 llvm::DIFile *Unit) {
2939 llvm::DIFile *Unit) {
2944 return DBuilder.createTypedef(
2947 getDeclContextDescriptor(Ty->
getDecl()));
2975 llvm::DIFile *Unit) {
2981 static_cast<llvm::dwarf::SourceLanguage
>(TheCU->getSourceLanguage());
2986 if (DebugTypeExtRefs &&
ID->isFromASTFile() &&
ID->getDefinition() &&
2987 !
ID->getImplementation())
2988 return DBuilder.createForwardDecl(
2989 llvm::dwarf::DW_TAG_structure_type,
ID->getName(),
2990 getDeclContextDescriptor(ID), Unit, 0, RuntimeLang);
2993 llvm::DIFile *DefUnit = getOrCreateFile(
ID->getLocation());
2994 unsigned Line = getLineNumber(
ID->getLocation());
3000 llvm::DIScope *Mod = getParentModuleOrNull(ID);
3001 llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(
3002 llvm::dwarf::DW_TAG_structure_type,
ID->getName(), Mod ? Mod : TheCU,
3003 DefUnit,
Line, RuntimeLang);
3004 ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit));
3008 return CreateTypeDefinition(Ty, Unit);
3012 bool CreateSkeletonCU) {
3017 auto ModRef = ModuleCache.find(M);
3018 if (ModRef != ModuleCache.end())
3019 return cast<llvm::DIModule>(ModRef->second);
3024 llvm::raw_svector_ostream OS(ConfigMacros);
3028 for (
auto &M : PPOpts.Macros) {
3031 const std::string &
Macro = M.first;
3032 bool Undef = M.second;
3033 OS <<
"\"-" << (Undef ?
'U' :
'D');
3034 for (
char c : Macro)
3049 bool IsRootModule = M ? !M->
Parent :
true;
3053 if (CreateSkeletonCU && IsRootModule && Mod.
getASTFile().empty() && M)
3055 "clang module without ASTFile must be specified by -fmodule-name");
3058 auto RemapPath = [
this](StringRef
Path) -> std::string {
3060 StringRef Relative(Remapped);
3061 StringRef CompDir = TheCU->getDirectory();
3062 if (Relative.consume_front(CompDir))
3063 Relative.consume_front(llvm::sys::path::get_separator());
3065 return Relative.str();
3068 if (CreateSkeletonCU && IsRootModule && !Mod.
getASTFile().empty()) {
3075 Signature = ModSig.truncatedValue();
3081 if (!llvm::sys::path::is_absolute(Mod.
getASTFile())) {
3083 PCM = getCurrentDirname();
3087 llvm::sys::path::append(PCM, Mod.
getASTFile());
3088 DIB.createCompileUnit(
3089 TheCU->getSourceLanguage(),
3092 TheCU->getProducer(),
false, StringRef(), 0, RemapPath(PCM),
3093 llvm::DICompileUnit::FullDebug, Signature);
3098 IsRootModule ? nullptr
3101 std::string IncludePath = Mod.
getPath().str();
3102 llvm::DIModule *DIMod =
3104 RemapPath(IncludePath));
3105 ModuleCache[M].reset(DIMod);
3110 llvm::DIFile *Unit) {
3112 llvm::DIFile *DefUnit = getOrCreateFile(
ID->getLocation());
3113 unsigned Line = getLineNumber(
ID->getLocation());
3114 unsigned RuntimeLang = TheCU->getSourceLanguage();
3120 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3121 if (
ID->getImplementation())
3122 Flags |= llvm::DINode::FlagObjcClassComplete;
3124 llvm::DIScope *Mod = getParentModuleOrNull(ID);
3125 llvm::DICompositeType *RealDecl = DBuilder.createStructType(
3126 Mod ? Mod : Unit,
ID->getName(), DefUnit,
Line, Size, Align, Flags,
3127 nullptr, llvm::DINodeArray(), RuntimeLang);
3130 TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl);
3133 LexicalBlockStack.emplace_back(RealDecl);
3134 RegionMap[Ty->
getDecl()].reset(RealDecl);
3141 llvm::DIType *SClassTy =
3146 llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0, 0,
3147 llvm::DINode::FlagZero);
3148 EltTys.push_back(InhTag);
3154 llvm::DIFile *PUnit = getOrCreateFile(
Loc);
3155 unsigned PLine = getLineNumber(
Loc);
3158 llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(
3159 PD->getName(), PUnit, PLine,
3161 : getSelectorName(PD->getGetterName()),
3163 : getSelectorName(PD->getSetterName()),
3164 PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit));
3165 EltTys.push_back(PropertyNode);
3170 typedef std::pair<char, const IdentifierInfo *> IsClassAndIdent;
3174 llvm::DenseSet<IsClassAndIdent> PropertySet;
3177 return std::make_pair(PD->isClassProperty(), PD->getIdentifier());
3180 for (
auto *PD : ClassExt->properties()) {
3181 PropertySet.insert(GetIsClassAndIdent(PD));
3184 for (
const auto *PD :
ID->properties()) {
3187 if (!PropertySet.insert(GetIsClassAndIdent(PD)).second)
3194 unsigned FieldNo = 0;
3196 Field =
Field->getNextIvar(), ++FieldNo) {
3197 llvm::DIType *FieldTy = getOrCreateType(
Field->getType(), Unit);
3201 StringRef FieldName =
Field->getName();
3204 if (FieldName.empty())
3208 llvm::DIFile *FieldDefUnit = getOrCreateFile(
Field->getLocation());
3209 unsigned FieldLine = getLineNumber(
Field->getLocation());
3217 FieldSize =
Field->isBitField()
3228 if (
Field->isBitField()) {
3239 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3241 Flags = llvm::DINode::FlagProtected;
3243 Flags = llvm::DINode::FlagPrivate;
3245 Flags = llvm::DINode::FlagPublic;
3247 if (
Field->isBitField())
3248 Flags |= llvm::DINode::FlagBitField;
3250 llvm::MDNode *PropertyNode =
nullptr;
3253 ImpD->FindPropertyImplIvarDecl(
Field->getIdentifier())) {
3256 llvm::DIFile *PUnit = getOrCreateFile(
Loc);
3257 unsigned PLine = getLineNumber(
Loc);
3260 PropertyNode = DBuilder.createObjCProperty(
3261 PD->getName(), PUnit, PLine,
3264 : getSelectorName(PD->getGetterName()),
3267 : getSelectorName(PD->getSetterName()),
3268 PD->getPropertyAttributes(),
3269 getOrCreateType(PD->getType(), PUnit));
3273 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine,
3274 FieldSize, FieldAlign, FieldOffset, Flags,
3275 FieldTy, PropertyNode);
3276 EltTys.push_back(FieldTy);
3279 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
3280 DBuilder.replaceArrays(RealDecl, Elements);
3282 LexicalBlockStack.pop_back();
3286llvm::DIType *CGDebugInfo::CreateType(
const VectorType *Ty,
3287 llvm::DIFile *Unit) {
3305 llvm::DIType *ElementTy = getOrCreateType(Ty->
getElementType(), Unit);
3308 llvm::Metadata *Subscript;
3310 auto SizeExpr = SizeExprCache.find(QTy);
3311 if (SizeExpr != SizeExprCache.end())
3312 Subscript = DBuilder.getOrCreateSubrange(
3313 SizeExpr->getSecond() ,
nullptr ,
3314 nullptr ,
nullptr );
3317 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
3318 llvm::Type::getInt64Ty(CGM.
getLLVMContext()), Count ? Count : -1));
3319 Subscript = DBuilder.getOrCreateSubrange(
3320 CountNode ,
nullptr ,
nullptr ,
3323 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
3328 return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
3332 llvm::DIFile *Unit) {
3336 llvm::DIType *ElementTy = getOrCreateType(Ty->
getElementType(), Unit);
3342 auto *ColumnCountNode =
3343 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
3345 auto *RowCountNode =
3346 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
3348 Subscripts.push_back(DBuilder.getOrCreateSubrange(
3349 ColumnCountNode ,
nullptr ,
nullptr ,
3351 Subscripts.push_back(DBuilder.getOrCreateSubrange(
3352 RowCountNode ,
nullptr ,
nullptr ,
3354 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
3355 return DBuilder.createArrayType(Size, Align, ElementTy, SubscriptArray);
3358llvm::DIType *CGDebugInfo::CreateType(
const ArrayType *Ty, llvm::DIFile *Unit) {
3363 if (
const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
3387 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
3396 if (
const auto *CAT = dyn_cast<ConstantArrayType>(Ty))
3397 Count = CAT->getZExtSize();
3398 else if (
const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
3399 if (
Expr *Size = VAT->getSizeExpr()) {
3402 Count =
Result.Val.getInt().getExtValue();
3406 auto SizeNode = SizeExprCache.find(EltTy);
3407 if (SizeNode != SizeExprCache.end())
3408 Subscripts.push_back(DBuilder.getOrCreateSubrange(
3409 SizeNode->getSecond() ,
nullptr ,
3410 nullptr ,
nullptr ));
3413 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
3415 Subscripts.push_back(DBuilder.getOrCreateSubrange(
3416 CountNode ,
nullptr ,
nullptr ,
3422 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
3424 return DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
3429 llvm::DIFile *Unit) {
3430 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty,
3435 llvm::DIFile *Unit) {
3436 llvm::dwarf::Tag
Tag = llvm::dwarf::DW_TAG_rvalue_reference_type;
3440 Tag = llvm::dwarf::DW_TAG_reference_type;
3442 return CreatePointerLikeType(Tag, Ty, Ty->
getPointeeType(), Unit);
3447 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3457 Flags |= llvm::DINode::FlagSingleInheritance;
3460 Flags |= llvm::DINode::FlagMultipleInheritance;
3463 Flags |= llvm::DINode::FlagVirtualInheritance;
3473 return DBuilder.createMemberPointerType(
3479 return DBuilder.createMemberPointerType(
3480 getOrCreateInstanceMethodType(
3483 ClassType,
Size, 0, Flags);
3486llvm::DIType *CGDebugInfo::CreateType(
const AtomicType *Ty, llvm::DIFile *
U) {
3488 return DBuilder.createQualifiedType(llvm::dwarf::DW_TAG_atomic_type, FromTy);
3491llvm::DIType *CGDebugInfo::CreateType(
const PipeType *Ty, llvm::DIFile *
U) {
3495llvm::DIType *CGDebugInfo::CreateEnumType(
const EnumType *Ty) {
3507 bool isImportedFromModule =
3519 llvm::DIScope *EDContext = getDeclContextDescriptor(ED);
3520 llvm::DIFile *DefUnit = getOrCreateFile(ED->
getLocation());
3521 llvm::TempDIScope TmpContext(DBuilder.createReplaceableCompositeType(
3522 llvm::dwarf::DW_TAG_enumeration_type,
"", TheCU, DefUnit, 0));
3525 StringRef EDName = ED->
getName();
3526 llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType(
3527 llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit,
Line,
3528 0, Size, Align, llvm::DINode::FlagFwdDecl,
Identifier);
3530 ReplaceMap.emplace_back(
3531 std::piecewise_construct, std::make_tuple(Ty),
3532 std::make_tuple(
static_cast<llvm::Metadata *
>(RetTy)));
3536 return CreateTypeDefinition(Ty);
3539llvm::DIType *CGDebugInfo::CreateTypeDefinition(
const EnumType *Ty) {
3552 assert(ED &&
"An enumeration definition is required");
3554 Enumerators.push_back(
3555 DBuilder.createEnumerator(
Enum->getName(),
Enum->getInitVal()));
3559 llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
3561 llvm::DIFile *DefUnit = getOrCreateFile(ED->
getLocation());
3563 llvm::DIScope *EnumContext = getDeclContextDescriptor(ED);
3564 llvm::DIType *ClassTy = getOrCreateType(ED->
getIntegerType(), DefUnit);
3565 return DBuilder.createEnumerationType(
3566 EnumContext, ED->
getName(), DefUnit,
Line, Size, Align, EltArray, ClassTy,
3572 StringRef Name, StringRef
Value) {
3573 unsigned Line = LineLoc.
isInvalid() ? 0 : getLineNumber(LineLoc);
3580 llvm::DIFile *FName = getOrCreateFile(FileLoc);
3581 unsigned Line = LineLoc.
isInvalid() ? 0 : getLineNumber(LineLoc);
3582 return DBuilder.createTempMacroFile(
Parent,
Line, FName);
3586 llvm::DebugLoc TrapLocation, StringRef
Category, StringRef FailureMsg) {
3594 FuncName += FailureMsg;
3596 llvm::DISubprogram *TrapSP =
3597 createInlinedTrapSubprogram(FuncName, TrapLocation->getFile());
3599 TrapSP, TrapLocation);
3609 Quals += InnerQuals;
3613 return C.getQualifiedType(
T.getTypePtr(), Quals);
3614 case Type::TemplateSpecialization: {
3615 const auto *Spec = cast<TemplateSpecializationType>(
T);
3616 if (Spec->isTypeAlias())
3617 return C.getQualifiedType(
T.getTypePtr(), Quals);
3621 case Type::TypeOfExpr:
3622 T = cast<TypeOfExprType>(
T)->getUnderlyingExpr()->getType();
3625 T = cast<TypeOfType>(
T)->getUnmodifiedType();
3627 case Type::Decltype:
3628 T = cast<DecltypeType>(
T)->getUnderlyingType();
3630 case Type::UnaryTransform:
3631 T = cast<UnaryTransformType>(
T)->getUnderlyingType();
3633 case Type::Attributed:
3634 T = cast<AttributedType>(
T)->getEquivalentType();
3636 case Type::BTFTagAttributed:
3637 T = cast<BTFTagAttributedType>(
T)->getWrappedType();
3639 case Type::CountAttributed:
3640 T = cast<CountAttributedType>(
T)->
desugar();
3642 case Type::Elaborated:
3643 T = cast<ElaboratedType>(
T)->getNamedType();
3646 T = cast<UsingType>(
T)->getUnderlyingType();
3649 T = cast<ParenType>(
T)->getInnerType();
3651 case Type::MacroQualified:
3652 T = cast<MacroQualifiedType>(
T)->getUnderlyingType();
3654 case Type::SubstTemplateTypeParm:
3655 T = cast<SubstTemplateTypeParmType>(
T)->getReplacementType();
3658 case Type::DeducedTemplateSpecialization: {
3659 QualType DT = cast<DeducedType>(
T)->getDeducedType();
3660 assert(!DT.
isNull() &&
"Undeduced types shouldn't reach here.");
3664 case Type::PackIndexing: {
3665 T = cast<PackIndexingType>(
T)->getSelectedType();
3668 case Type::Adjusted:
3671 T = cast<AdjustedType>(
T)->getAdjustedType();
3675 assert(
T != LastT &&
"Type unwrapping failed to unwrap!");
3680llvm::DIType *CGDebugInfo::getTypeOrNull(
QualType Ty) {
3683 if (It != TypeCache.end()) {
3685 if (llvm::Metadata *
V = It->second)
3686 return cast<llvm::DIType>(
V);
3698 if (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly ||
3708llvm::DIType *CGDebugInfo::getOrCreateType(
QualType Ty, llvm::DIFile *Unit) {
3712 llvm::TimeTraceScope TimeScope(
"DebugType", [&]() {
3714 llvm::raw_string_ostream OS(Name);
3715 Ty.
print(OS, getPrintingPolicy());
3722 if (
auto *
T = getTypeOrNull(Ty))
3725 llvm::DIType *Res = CreateTypeNode(Ty, Unit);
3726 void *TyPtr = Ty.getAsOpaquePtr();
3729 TypeCache[TyPtr].reset(Res);
3734llvm::DIModule *CGDebugInfo::getParentModuleOrNull(
const Decl *
D) {
3742 auto Info = Reader->getSourceDescriptor(Idx);
3744 return getOrCreateModuleRef(*Info,
true);
3745 }
else if (ClangModuleMap) {
3759 return getOrCreateModuleRef(Info,
false);
3762 return getOrCreateModuleRef(PCHDescriptor,
false);
3769llvm::DIType *CGDebugInfo::CreateTypeNode(
QualType Ty, llvm::DIFile *Unit) {
3772 return CreateQualifiedType(Ty, Unit);
3776#define TYPE(Class, Base)
3777#define ABSTRACT_TYPE(Class, Base)
3778#define NON_CANONICAL_TYPE(Class, Base)
3779#define DEPENDENT_TYPE(Class, Base) case Type::Class:
3780#include "clang/AST/TypeNodes.inc"
3781 llvm_unreachable(
"Dependent types cannot show up in debug information");
3783 case Type::ExtVector:
3785 return CreateType(cast<VectorType>(Ty), Unit);
3786 case Type::ConstantMatrix:
3787 return CreateType(cast<ConstantMatrixType>(Ty), Unit);
3788 case Type::ObjCObjectPointer:
3789 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
3790 case Type::ObjCObject:
3791 return CreateType(cast<ObjCObjectType>(Ty), Unit);
3792 case Type::ObjCTypeParam:
3793 return CreateType(cast<ObjCTypeParamType>(Ty), Unit);
3794 case Type::ObjCInterface:
3795 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
3797 return CreateType(cast<BuiltinType>(Ty));
3799 return CreateType(cast<ComplexType>(Ty));
3801 return CreateType(cast<PointerType>(Ty), Unit);
3802 case Type::BlockPointer:
3803 return CreateType(cast<BlockPointerType>(Ty), Unit);
3805 return CreateType(cast<TypedefType>(Ty), Unit);
3807 return CreateType(cast<RecordType>(Ty));
3809 return CreateEnumType(cast<EnumType>(Ty));
3810 case Type::FunctionProto:
3811 case Type::FunctionNoProto:
3812 return CreateType(cast<FunctionType>(Ty), Unit);
3813 case Type::ConstantArray:
3814 case Type::VariableArray:
3815 case Type::IncompleteArray:
3816 case Type::ArrayParameter:
3817 return CreateType(cast<ArrayType>(Ty), Unit);
3819 case Type::LValueReference:
3820 return CreateType(cast<LValueReferenceType>(Ty), Unit);
3821 case Type::RValueReference:
3822 return CreateType(cast<RValueReferenceType>(Ty), Unit);
3824 case Type::MemberPointer:
3825 return CreateType(cast<MemberPointerType>(Ty), Unit);
3828 return CreateType(cast<AtomicType>(Ty), Unit);
3831 return CreateType(cast<BitIntType>(Ty));
3833 return CreateType(cast<PipeType>(Ty), Unit);
3835 case Type::TemplateSpecialization:
3836 return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
3838 case Type::CountAttributed:
3840 case Type::Attributed:
3841 case Type::BTFTagAttributed:
3842 case Type::HLSLAttributedResource:
3843 case Type::Adjusted:
3845 case Type::DeducedTemplateSpecialization:
3846 case Type::Elaborated:
3849 case Type::MacroQualified:
3850 case Type::SubstTemplateTypeParm:
3851 case Type::TypeOfExpr:
3853 case Type::Decltype:
3854 case Type::PackIndexing:
3855 case Type::UnaryTransform:
3859 llvm_unreachable(
"type should have been unwrapped!");
3862llvm::DICompositeType *
3863CGDebugInfo::getOrCreateLimitedType(
const RecordType *Ty) {
3866 auto *
T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));
3871 if (
T && !
T->isForwardDecl())
3875 llvm::DICompositeType *Res = CreateLimitedType(Ty);
3880 DBuilder.replaceArrays(Res,
T ?
T->getElements() : llvm::DINodeArray());
3883 TypeCache[QTy.getAsOpaquePtr()].reset(Res);
3888llvm::DICompositeType *CGDebugInfo::CreateLimitedType(
const RecordType *Ty) {
3892 StringRef RDName = getClassName(RD);
3894 llvm::DIFile *DefUnit =
nullptr;
3897 DefUnit = getOrCreateFile(
Loc);
3901 llvm::DIScope *RDContext = getDeclContextDescriptor(RD);
3905 auto *
T = cast_or_null<llvm::DICompositeType>(
3913 if (!
D || !
D->isCompleteDefinition())
3914 return getOrCreateRecordFwdDecl(Ty, RDContext);
3927 auto Flags = llvm::DINode::FlagZero;
3928 if (
auto CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3930 Flags |= llvm::DINode::FlagTypePassByReference;
3932 Flags |= llvm::DINode::FlagTypePassByValue;
3935 if (!CXXRD->isTrivial())
3936 Flags |= llvm::DINode::FlagNonTrivial;
3939 if (CXXRD->isAnonymousStructOrUnion())
3940 Flags |= llvm::DINode::FlagExportSymbols;
3943 dyn_cast<CXXRecordDecl>(CXXRD->getDeclContext()));
3946 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(
D);
3947 llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
3953 switch (RealDecl->getTag()) {
3955 llvm_unreachable(
"invalid composite type tag");
3957 case llvm::dwarf::DW_TAG_array_type:
3958 case llvm::dwarf::DW_TAG_enumeration_type:
3967 case llvm::dwarf::DW_TAG_structure_type:
3968 case llvm::dwarf::DW_TAG_union_type:
3969 case llvm::dwarf::DW_TAG_class_type:
3972 llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
3976 RegionMap[Ty->
getDecl()].reset(RealDecl);
3979 if (
const auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
3980 DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),
3981 CollectCXXTemplateParams(TSpecial, DefUnit));
3985void CGDebugInfo::CollectContainingType(
const CXXRecordDecl *RD,
3986 llvm::DICompositeType *RealDecl) {
3988 llvm::DIType *ContainingType =
nullptr;
4000 ContainingType = getOrCreateType(
QualType(PBase->getTypeForDecl(), 0),
4003 ContainingType = RealDecl;
4005 DBuilder.replaceVTableHolder(RealDecl, ContainingType);
4008llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit,
QualType FType,
4009 StringRef Name, uint64_t *Offset) {
4010 llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
4014 DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize, FieldAlign,
4015 *Offset, llvm::DINode::FlagZero, FieldTy);
4016 *Offset += FieldSize;
4020void CGDebugInfo::collectFunctionDeclProps(
GlobalDecl GD, llvm::DIFile *Unit,
4022 StringRef &LinkageName,
4023 llvm::DIScope *&FDContext,
4024 llvm::DINodeArray &TParamsArray,
4025 llvm::DINode::DIFlags &Flags) {
4027 Name = getFunctionName(FD);
4032 Flags |= llvm::DINode::FlagPrototyped;
4036 if (LinkageName == Name ||
4041 DebugKind <= llvm::codegenoptions::DebugLineTablesOnly))
4042 LinkageName = StringRef();
4047 (DebugKind == llvm::codegenoptions::DebugLineTablesOnly &&
4051 FDContext = getOrCreateNamespace(NSDecl);
4054 llvm::DIScope *Mod = getParentModuleOrNull(RDecl);
4055 FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU);
4061 Flags |= llvm::DINode::FlagNoReturn;
4063 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
4067void CGDebugInfo::collectVarDeclProps(
const VarDecl *VD, llvm::DIFile *&Unit,
4069 StringRef &Name, StringRef &LinkageName,
4070 llvm::MDTuple *&TemplateParameters,
4071 llvm::DIScope *&VDContext) {
4080 llvm::APInt ConstVal(32, 1);
4091 if (LinkageName == Name)
4092 LinkageName = StringRef();
4094 if (isa<VarTemplateSpecializationDecl>(VD)) {
4095 llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VD, &*Unit);
4096 TemplateParameters = parameterNodes.get();
4098 TemplateParameters =
nullptr;
4118 llvm::DIScope *Mod = getParentModuleOrNull(VD);
4119 VDContext = getContextDescriptor(cast<Decl>(DC), Mod ? Mod : TheCU);
4122llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(
GlobalDecl GD,
4124 llvm::DINodeArray TParamsArray;
4125 StringRef Name, LinkageName;
4126 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
4127 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
4129 llvm::DIFile *Unit = getOrCreateFile(
Loc);
4130 llvm::DIScope *DContext = Unit;
4131 unsigned Line = getLineNumber(
Loc);
4132 collectFunctionDeclProps(GD, Unit, Name, LinkageName, DContext, TParamsArray,
4134 auto *FD = cast<FunctionDecl>(GD.
getDecl());
4139 ArgTypes.push_back(Parm->getType());
4145 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
4147 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
4150 Flags |= getCallSiteRelatedAttrs();
4151 SPFlags |= llvm::DISubprogram::SPFlagDefinition;
4152 return DBuilder.createFunction(
4153 DContext, Name, LinkageName, Unit,
Line,
4154 getOrCreateFunctionType(GD.
getDecl(), FnType, Unit), 0, Flags, SPFlags,
4155 TParamsArray.get(), getFunctionDeclaration(FD));
4158 llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
4159 DContext, Name, LinkageName, Unit,
Line,
4160 getOrCreateFunctionType(GD.
getDecl(), FnType, Unit), 0, Flags, SPFlags,
4161 TParamsArray.get(), getFunctionDeclaration(FD));
4163 FwdDeclReplaceMap.emplace_back(std::piecewise_construct,
4164 std::make_tuple(CanonDecl),
4165 std::make_tuple(SP));
4169llvm::DISubprogram *CGDebugInfo::getFunctionForwardDeclaration(
GlobalDecl GD) {
4170 return getFunctionFwdDeclOrStub(GD,
false);
4173llvm::DISubprogram *CGDebugInfo::getFunctionStub(
GlobalDecl GD) {
4174 return getFunctionFwdDeclOrStub(GD,
true);
4177llvm::DIGlobalVariable *
4178CGDebugInfo::getGlobalVariableForwardDeclaration(
const VarDecl *VD) {
4180 StringRef Name, LinkageName;
4182 llvm::DIFile *Unit = getOrCreateFile(
Loc);
4183 llvm::DIScope *DContext = Unit;
4184 unsigned Line = getLineNumber(
Loc);
4185 llvm::MDTuple *TemplateParameters =
nullptr;
4187 collectVarDeclProps(VD, Unit,
Line,
T, Name, LinkageName, TemplateParameters,
4190 auto *GV = DBuilder.createTempGlobalVariableFwdDecl(
4191 DContext, Name, LinkageName, Unit,
Line, getOrCreateType(
T, Unit),
4193 FwdDeclReplaceMap.emplace_back(
4194 std::piecewise_construct,
4196 std::make_tuple(
static_cast<llvm::Metadata *
>(GV)));
4200llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(
const Decl *
D) {
4205 if (
const auto *TD = dyn_cast<TypeDecl>(
D))
4210 if (I != DeclCache.end()) {
4212 if (
auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(N))
4213 return GVE->getVariable();
4214 return cast<llvm::DINode>(N);
4221 if (IE != ImportedDeclCache.end()) {
4222 auto N = IE->second;
4223 if (
auto *GVE = dyn_cast_or_null<llvm::DIImportedEntity>(N))
4224 return cast<llvm::DINode>(GVE);
4225 return dyn_cast_or_null<llvm::DINode>(N);
4230 if (
const auto *FD = dyn_cast<FunctionDecl>(
D))
4231 return getFunctionForwardDeclaration(FD);
4232 else if (
const auto *VD = dyn_cast<VarDecl>(
D))
4233 return getGlobalVariableForwardDeclaration(VD);
4238llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(
const Decl *
D) {
4239 if (!
D || DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)
4242 const auto *FD = dyn_cast<FunctionDecl>(
D);
4247 auto *S = getDeclContextDescriptor(
D);
4250 if (MI == SPCache.end()) {
4252 return CreateCXXMemberFunction(MD, getOrCreateFile(MD->getLocation()),
4253 cast<llvm::DICompositeType>(S));
4256 if (MI != SPCache.end()) {
4257 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
4258 if (SP && !SP->isDefinition())
4262 for (
auto *NextFD : FD->
redecls()) {
4263 auto MI = SPCache.find(NextFD->getCanonicalDecl());
4264 if (MI != SPCache.end()) {
4265 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
4266 if (SP && !SP->isDefinition())
4273llvm::DISubprogram *CGDebugInfo::getObjCMethodDeclaration(
4274 const Decl *
D, llvm::DISubroutineType *FnType,
unsigned LineNo,
4275 llvm::DINode::DIFlags Flags, llvm::DISubprogram::DISPFlags SPFlags) {
4276 if (!
D || DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)
4279 const auto *OMD = dyn_cast<ObjCMethodDecl>(
D);
4287 SPFlags |= llvm::DISubprogram::SPFlagObjCDirect;
4297 auto It = TypeCache.find(QTy.getAsOpaquePtr());
4298 if (It == TypeCache.end())
4300 auto *InterfaceType = cast<llvm::DICompositeType>(It->second);
4301 llvm::DISubprogram *FD = DBuilder.createFunction(
4302 InterfaceType, getObjCMethodName(OMD), StringRef(),
4303 InterfaceType->getFile(), LineNo, FnType, LineNo, Flags, SPFlags);
4304 DBuilder.finalizeSubprogram(FD);
4311llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(
const Decl *
D,
4316 if (!
D || (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly &&
4320 return DBuilder.createSubroutineType(DBuilder.getOrCreateTypeArray({}));
4322 if (
const auto *Method = dyn_cast<CXXMethodDecl>(
D))
4323 return getOrCreateMethodType(Method, F);
4328 if (
const auto *OMethod = dyn_cast<ObjCMethodDecl>(
D)) {
4333 QualType ResultTy = OMethod->getReturnType();
4338 QualType(OMethod->getClassInterface()->getTypeForDecl(), 0));
4340 Elts.push_back(getOrCreateType(ResultTy, F));
4343 if (
auto *SelfDecl = OMethod->getSelfDecl())
4344 SelfDeclTy = SelfDecl->getType();
4345 else if (
auto *FPT = dyn_cast<FunctionProtoType>(FnType))
4348 if (!SelfDeclTy.
isNull())
4350 CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F)));
4352 Elts.push_back(DBuilder.createArtificialType(
4355 for (
const auto *PI : OMethod->parameters())
4356 Elts.push_back(getOrCreateType(PI->getType(), F));
4358 if (OMethod->isVariadic())
4359 Elts.push_back(DBuilder.createUnspecifiedParameter());
4361 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
4362 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
4368 if (
const auto *FD = dyn_cast<FunctionDecl>(
D))
4369 if (FD->isVariadic()) {
4371 EltTys.push_back(getOrCreateType(FD->getReturnType(), F));
4372 if (
const auto *FPT = dyn_cast<FunctionProtoType>(FnType))
4374 EltTys.push_back(getOrCreateType(ParamType, F));
4375 EltTys.push_back(DBuilder.createUnspecifiedParameter());
4376 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
4377 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
4381 return cast<llvm::DISubroutineType>(getOrCreateType(FnType, F));
4390 CC = SrcFnTy->getCallConv();
4392 for (
const VarDecl *VD : Args)
4393 ArgTypes.push_back(VD->
getType());
4400 llvm::Function *Fn,
bool CurFuncIsThunk) {
4402 StringRef LinkageName;
4404 FnBeginRegionCount.push_back(LexicalBlockStack.size());
4407 bool HasDecl = (
D !=
nullptr);
4409 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
4410 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
4411 llvm::DIFile *Unit = getOrCreateFile(
Loc);
4412 llvm::DIScope *FDContext = Unit;
4413 llvm::DINodeArray TParamsArray;
4416 LinkageName = Fn->getName();
4417 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
4419 auto FI = SPCache.find(FD->getCanonicalDecl());
4420 if (FI != SPCache.end()) {
4421 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
4422 if (SP && SP->isDefinition()) {
4423 LexicalBlockStack.emplace_back(SP);
4424 RegionMap[
D].reset(SP);
4428 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
4429 TParamsArray, Flags);
4430 }
else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(
D)) {
4431 Name = getObjCMethodName(OMD);
4432 Flags |= llvm::DINode::FlagPrototyped;
4433 }
else if (isa<VarDecl>(
D) &&
4439 Name = Fn->getName();
4441 if (isa<BlockDecl>(
D))
4444 Flags |= llvm::DINode::FlagPrototyped;
4446 if (Name.starts_with(
"\01"))
4447 Name = Name.substr(1);
4449 assert((!
D || !isa<VarDecl>(
D) ||
4451 "Unexpected DynamicInitKind !");
4454 isa<VarDecl>(
D) || isa<CapturedDecl>(
D)) {
4455 Flags |= llvm::DINode::FlagArtificial;
4461 Flags |= llvm::DINode::FlagThunk;
4463 if (Fn->hasLocalLinkage())
4464 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
4466 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
4468 llvm::DINode::DIFlags FlagsForDef = Flags | getCallSiteRelatedAttrs();
4469 llvm::DISubprogram::DISPFlags SPFlagsForDef =
4470 SPFlags | llvm::DISubprogram::SPFlagDefinition;
4472 const unsigned LineNo = getLineNumber(
Loc.
isValid() ?
Loc : CurLoc);
4473 unsigned ScopeLine = getLineNumber(ScopeLoc);
4474 llvm::DISubroutineType *DIFnType = getOrCreateFunctionType(
D, FnType, Unit);
4475 llvm::DISubprogram *
Decl =
nullptr;
4476 llvm::DINodeArray Annotations =
nullptr;
4478 Decl = isa<ObjCMethodDecl>(
D)
4479 ? getObjCMethodDeclaration(
D, DIFnType, LineNo, Flags, SPFlags)
4480 : getFunctionDeclaration(
D);
4481 Annotations = CollectBTFDeclTagAnnotations(
D);
4489 llvm::DISubprogram *SP = DBuilder.createFunction(
4490 FDContext, Name, LinkageName, Unit, LineNo, DIFnType, ScopeLine,
4491 FlagsForDef, SPFlagsForDef, TParamsArray.get(),
Decl,
nullptr,
4493 Fn->setSubprogram(SP);
4497 if (HasDecl && isa<FunctionDecl>(
D))
4501 LexicalBlockStack.emplace_back(SP);
4504 RegionMap[
D].reset(SP);
4508 QualType FnType, llvm::Function *Fn) {
4510 StringRef LinkageName;
4516 llvm::TimeTraceScope TimeScope(
"DebugFunction", [&]() {
4517 return GetName(
D,
true);
4520 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
4521 llvm::DIFile *Unit = getOrCreateFile(
Loc);
4522 bool IsDeclForCallSite = Fn ?
true :
false;
4523 llvm::DIScope *FDContext =
4524 IsDeclForCallSite ? Unit : getDeclContextDescriptor(
D);
4525 llvm::DINodeArray TParamsArray;
4526 if (isa<FunctionDecl>(
D)) {
4528 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
4529 TParamsArray, Flags);
4530 }
else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(
D)) {
4531 Name = getObjCMethodName(OMD);
4532 Flags |= llvm::DINode::FlagPrototyped;
4534 llvm_unreachable(
"not a function or ObjC method");
4536 if (!Name.empty() && Name[0] ==
'\01')
4537 Name = Name.substr(1);
4540 Flags |= llvm::DINode::FlagArtificial;
4545 unsigned LineNo = getLineNumber(
Loc);
4546 unsigned ScopeLine = 0;
4547 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
4549 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
4551 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(
D);
4552 llvm::DISubroutineType *STy = getOrCreateFunctionType(
D, FnType, Unit);
4553 llvm::DISubprogram *SP = DBuilder.createFunction(
4554 FDContext, Name, LinkageName, Unit, LineNo, STy, ScopeLine, Flags,
4555 SPFlags, TParamsArray.get(),
nullptr,
nullptr, Annotations);
4561 if (
auto *FD = dyn_cast<FunctionDecl>(
D)) {
4562 llvm::DITypeRefArray ParamTypes = STy->getTypeArray();
4565 llvm::DINodeArray ParamAnnotations = CollectBTFDeclTagAnnotations(PD);
4566 DBuilder.createParameterVariable(
4567 SP, PD->getName(), ArgNo, Unit, LineNo, ParamTypes[ArgNo],
true,
4568 llvm::DINode::FlagZero, ParamAnnotations);
4574 if (IsDeclForCallSite)
4575 Fn->setSubprogram(SP);
4577 DBuilder.finalizeSubprogram(SP);
4585 auto *
Func = CallOrInvoke->getCalledFunction();
4588 if (
Func->getSubprogram())
4593 if (CalleeDecl->
hasAttr<NoDebugAttr>() ||
4594 getCallSiteRelatedAttrs() == llvm::DINode::FlagZero)
4605 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4607 auto FI = SPCache.find(FD->getCanonicalDecl());
4608 llvm::DISubprogram *SP =
nullptr;
4609 if (FI != SPCache.end())
4610 SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
4611 if (!SP || !SP->isDefinition())
4612 SP = getFunctionStub(GD);
4613 FnBeginRegionCount.push_back(LexicalBlockStack.size());
4614 LexicalBlockStack.emplace_back(SP);
4620 assert(CurInlinedAt &&
"unbalanced inline scope stack");
4629 if (CurLoc.isInvalid() || CurLoc.isMacroID() || LexicalBlockStack.empty())
4632 llvm::MDNode *
Scope = LexicalBlockStack.back();
4633 Builder.SetCurrentDebugLocation(
4634 llvm::DILocation::get(CGM.
getLLVMContext(), getLineNumber(CurLoc),
4635 getColumnNumber(CurLoc),
Scope, CurInlinedAt));
4639 llvm::MDNode *Back =
nullptr;
4640 if (!LexicalBlockStack.empty())
4641 Back = LexicalBlockStack.back().get();
4642 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
4643 cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
4644 getColumnNumber(CurLoc)));
4647void CGDebugInfo::AppendAddressSpaceXDeref(
4649 std::optional<unsigned> DWARFAddressSpace =
4651 if (!DWARFAddressSpace)
4654 Expr.push_back(llvm::dwarf::DW_OP_constu);
4655 Expr.push_back(*DWARFAddressSpace);
4656 Expr.push_back(llvm::dwarf::DW_OP_swap);
4657 Expr.push_back(llvm::dwarf::DW_OP_xderef);
4666 Builder.SetCurrentDebugLocation(llvm::DILocation::get(
4668 LexicalBlockStack.back(), CurInlinedAt));
4670 if (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)
4674 CreateLexicalBlock(
Loc);
4679 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4684 if (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)
4687 LexicalBlockStack.pop_back();
4691 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4692 unsigned RCount = FnBeginRegionCount.back();
4693 assert(RCount <= LexicalBlockStack.size() &&
"Region stack mismatch");
4696 while (LexicalBlockStack.size() != RCount) {
4699 LexicalBlockStack.pop_back();
4701 FnBeginRegionCount.pop_back();
4703 if (Fn && Fn->getSubprogram())
4704 DBuilder.finalizeSubprogram(Fn->getSubprogram());
4707CGDebugInfo::BlockByRefType
4708CGDebugInfo::EmitTypeForVarWithBlocksAttr(
const VarDecl *VD,
4709 uint64_t *XOffset) {
4712 uint64_t FieldSize, FieldOffset;
4713 uint32_t FieldAlign;
4715 llvm::DIFile *Unit = getOrCreateFile(VD->
getLocation());
4720 EltTys.push_back(CreateMemberType(Unit, FType,
"__isa", &FieldOffset));
4721 EltTys.push_back(CreateMemberType(Unit, FType,
"__forwarding", &FieldOffset));
4723 EltTys.push_back(CreateMemberType(Unit, FType,
"__flags", &FieldOffset));
4724 EltTys.push_back(CreateMemberType(Unit, FType,
"__size", &FieldOffset));
4727 if (HasCopyAndDispose) {
4730 CreateMemberType(Unit, FType,
"__copy_helper", &FieldOffset));
4732 CreateMemberType(Unit, FType,
"__destroy_helper", &FieldOffset));
4734 bool HasByrefExtendedLayout;
4737 HasByrefExtendedLayout) &&
4738 HasByrefExtendedLayout) {
4741 CreateMemberType(Unit, FType,
"__byref_variable_layout", &FieldOffset));
4750 CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;
4753 llvm::APInt pad(32, NumPaddingBytes.
getQuantity());
4756 EltTys.push_back(CreateMemberType(Unit, FType,
"", &FieldOffset));
4761 llvm::DIType *WrappedTy = getOrCreateType(FType, Unit);
4765 *XOffset = FieldOffset;
4766 llvm::DIType *FieldTy = DBuilder.createMemberType(
4767 Unit, VD->
getName(), Unit, 0, FieldSize, FieldAlign, FieldOffset,
4768 llvm::DINode::FlagZero, WrappedTy);
4769 EltTys.push_back(FieldTy);
4770 FieldOffset += FieldSize;
4772 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
4773 return {DBuilder.createStructType(Unit,
"", Unit, 0, FieldOffset, 0,
4774 llvm::DINode::FlagZero,
nullptr, Elements),
4778llvm::DILocalVariable *CGDebugInfo::EmitDeclare(
const VarDecl *VD,
4779 llvm::Value *Storage,
4780 std::optional<unsigned> ArgNo,
4782 const bool UsePointerValue) {
4784 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4785 if (VD->
hasAttr<NoDebugAttr>())
4790 llvm::DIFile *Unit =
nullptr;
4791 if (!VarIsArtificial)
4795 if (VD->
hasAttr<BlocksAttr>())
4796 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;
4798 Ty = getOrCreateType(VD->
getType(), Unit);
4808 if (!VarIsArtificial) {
4813 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
4814 if (VarIsArtificial)
4815 Flags |= llvm::DINode::FlagArtificial;
4820 AppendAddressSpaceXDeref(AddressSpace,
Expr);
4824 if (
const auto *IPD = dyn_cast<ImplicitParamDecl>(VD)) {
4827 Flags |= llvm::DINode::FlagObjectPointer;
4834 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
4835 StringRef Name = VD->
getName();
4836 if (!Name.empty()) {
4842 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4847 Expr.push_back(llvm::dwarf::DW_OP_deref);
4848 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4853 }
else if (
const auto *RT = dyn_cast<RecordType>(VD->
getType())) {
4865 for (
const auto *Field : RD->
fields()) {
4866 llvm::DIType *FieldTy = getOrCreateType(
Field->getType(), Unit);
4867 StringRef FieldName =
Field->getName();
4870 if (FieldName.empty() && !isa<RecordType>(
Field->getType()))
4875 auto *
D = DBuilder.createAutoVariable(
4877 Flags | llvm::DINode::FlagArtificial, FieldAlign);
4880 DBuilder.insertDeclare(Storage,
D, DBuilder.createExpression(
Expr),
4884 Builder.GetInsertBlock());
4892 if (UsePointerValue) {
4893 assert(!llvm::is_contained(
Expr, llvm::dwarf::DW_OP_deref) &&
4894 "Debug info already contains DW_OP_deref.");
4895 Expr.push_back(llvm::dwarf::DW_OP_deref);
4899 llvm::DILocalVariable *
D =
nullptr;
4901 llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(VD);
4902 D = DBuilder.createParameterVariable(
Scope, Name, *ArgNo, Unit,
Line, Ty,
4913 auto RemapCoroArgToLocalVar = [&]() -> llvm::DILocalVariable * {
4916 if (!isa<llvm::DISubprogram>(
Scope) || !
Scope->isDistinct())
4919 auto Iter = llvm::find_if(CoroutineParameterMappings, [&](
auto &Pair) {
4920 Stmt *StmtPtr =
const_cast<Stmt *
>(Pair.second);
4921 if (
DeclStmt *DeclStmtPtr = dyn_cast<DeclStmt>(StmtPtr)) {
4924 if (VD == dyn_cast_or_null<VarDecl>(
Decl))
4930 if (
Iter != CoroutineParameterMappings.end()) {
4932 auto Iter2 = llvm::find_if(ParamDbgMappings, [&](
auto &DbgPair) {
4933 return DbgPair.first == PD && DbgPair.second->getScope() ==
Scope;
4935 if (Iter2 != ParamDbgMappings.end())
4936 return const_cast<llvm::DILocalVariable *
>(Iter2->second);
4942 D = RemapCoroArgToLocalVar();
4945 D = DBuilder.createAutoVariable(
Scope, Name, Unit,
Line, Ty,
4949 DBuilder.insertDeclare(Storage,
D, DBuilder.createExpression(
Expr),
4952 Builder.GetInsertBlock());
4957llvm::DILocalVariable *CGDebugInfo::EmitDeclare(
const BindingDecl *BD,
4958 llvm::Value *Storage,
4959 std::optional<unsigned> ArgNo,
4961 const bool UsePointerValue) {
4963 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
4964 if (BD->
hasAttr<NoDebugAttr>())
4971 llvm::DIFile *Unit = getOrCreateFile(BD->
getLocation());
4972 llvm::DIType *Ty = getOrCreateType(BD->
getType(), Unit);
4983 AppendAddressSpaceXDeref(AddressSpace,
Expr);
4988 if (UsePointerValue) {
4989 assert(!llvm::is_contained(
Expr, llvm::dwarf::DW_OP_deref) &&
4990 "Debug info already contains DW_OP_deref.");
4991 Expr.push_back(llvm::dwarf::DW_OP_deref);
4996 StringRef Name = BD->
getName();
4997 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
4999 llvm::DILocalVariable *
D = DBuilder.createAutoVariable(
5001 llvm::DINode::FlagZero, Align);
5004 if (
const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
5005 const unsigned fieldIndex = FD->getFieldIndex();
5011 if (FD->isBitField()) {
5018 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
5024 ? llvm::dwarf::DW_OP_LLVM_extract_bits_sext
5025 : llvm::dwarf::DW_OP_LLVM_extract_bits_zext);
5030 Expr.push_back(std::min((uint64_t)Info.
Size, TypeSize));
5031 }
else if (fieldOffset != 0) {
5033 "Unexpected non-bitfield with non-byte-aligned offset");
5034 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
5040 dyn_cast<ArraySubscriptExpr>(BD->
getBinding())) {
5041 if (
const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(ASE->getIdx())) {
5042 const uint64_t value = IL->getValue().getZExtValue();
5046 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
5055 DBuilder.insertDeclare(Storage,
D, DBuilder.createExpression(
Expr),
5058 Builder.GetInsertBlock());
5063llvm::DILocalVariable *
5066 const bool UsePointerValue) {
5069 if (
auto *DD = dyn_cast<DecompositionDecl>(VD)) {
5070 for (
auto *B : DD->bindings()) {
5071 EmitDeclare(B, Storage, std::nullopt, Builder,
5079 return EmitDeclare(VD, Storage, std::nullopt, Builder, UsePointerValue);
5084 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
5089 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
5090 llvm::DIFile *Unit = getOrCreateFile(
D->
getLocation());
5096 StringRef Name =
D->getName();
5103 DBuilder.insertLabel(L,
5105 Scope, CurInlinedAt),
5106 Builder.GetInsertBlock());
5109llvm::DIType *CGDebugInfo::CreateSelfType(
const QualType &QualTy,
5111 llvm::DIType *CachedTy = getTypeOrNull(QualTy);
5114 return DBuilder.createObjectPointerType(Ty);
5119 const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) {
5121 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
5123 if (Builder.GetInsertBlock() ==
nullptr)
5125 if (VD->
hasAttr<NoDebugAttr>())
5128 bool isByRef = VD->
hasAttr<BlocksAttr>();
5130 uint64_t XOffset = 0;
5131 llvm::DIFile *Unit = getOrCreateFile(VD->
getLocation());
5134 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;
5136 Ty = getOrCreateType(VD->
getType(), Unit);
5140 if (
const auto *IPD = dyn_cast<ImplicitParamDecl>(VD))
5142 Ty = CreateSelfType(VD->
getType(), Ty);
5145 const unsigned Line =
5156 addr.push_back(llvm::dwarf::DW_OP_deref);
5157 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
5160 addr.push_back(llvm::dwarf::DW_OP_deref);
5161 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
5166 addr.push_back(llvm::dwarf::DW_OP_deref);
5167 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
5175 auto *
D = DBuilder.createAutoVariable(
5176 cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->
getName(), Unit,
5177 Line, Ty,
false, llvm::DINode::FlagZero, Align);
5181 LexicalBlockStack.back(), CurInlinedAt);
5182 auto *
Expr = DBuilder.createExpression(addr);
5184 DBuilder.insertDeclare(Storage,
D,
Expr, DL, InsertPoint);
5186 DBuilder.insertDeclare(Storage,
D,
Expr, DL, Builder.GetInsertBlock());
5189llvm::DILocalVariable *
5192 bool UsePointerValue) {
5194 return EmitDeclare(VD, AI, ArgNo, Builder, UsePointerValue);
5198struct BlockLayoutChunk {
5199 uint64_t OffsetInBits;
5202bool operator<(
const BlockLayoutChunk &l,
const BlockLayoutChunk &r) {
5203 return l.OffsetInBits < r.OffsetInBits;
5207void CGDebugInfo::collectDefaultFieldsForBlockLiteralDeclare(
5209 const llvm::StructLayout &BlockLayout, llvm::DIFile *Unit,
5216 BlockLayout.getElementOffsetInBits(0),