Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/CGDebugInfo_8cpp_source.html below:

clang: lib/CodeGen/CGDebugInfo.cpp Source File

;

(TI.isAlignRequired())

llvm::dyn_cast_or_null<DeclRefExpr>(

->IgnoreUnlessSpelledInSource());

llvm::dyn_cast_or_null<DecompositionDecl>(RefExpr->getDecl());

: CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),

DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),

DBuilder(CGM.getModule()) {

assert(LexicalBlockStack.empty() &&

);

init(TemporaryLocation);

init(TemporaryLocation, DefaultToEmpty);

DefaultToEmpty) {

OriginalLocation = CGF->

.getCurrentDebugLocation();

(OriginalLocation && !DI->CGM.getExpressionLocationsEnabled())

(TemporaryLocation.

()) {

DI->EmitLocation(CGF->

, TemporaryLocation);

(DefaultToEmpty) {

CGF->

.SetCurrentDebugLocation(llvm::DebugLoc());

assert(!DI->LexicalBlockStack.empty());

CGF->

.SetCurrentDebugLocation(

llvm::DILocation::get(DI->LexicalBlockStack.back()->getContext(), 0, 0,

DI->LexicalBlockStack.back(), DI->getInlinedAt()));

this->CGF =

;

OriginalLocation = CGF.

.getCurrentDebugLocation();

CGF.

.SetCurrentDebugLocation(std::move(

));

CGF->

.SetCurrentDebugLocation(std::move(OriginalLocation));

this->CGF =

;

SavedLocation = DI.getLocation();

assert((DI.getInlinedAt() ==

CGF.

.getCurrentDebugLocation()->getInlinedAt()) &&

);

DI.EmitInlineFunctionStart(CGF.

, InlinedFn);

DI.EmitLocation(CGF->

, SavedLocation);

(LexicalBlockStack.empty())

*

= cast<llvm::DIScope>(LexicalBlockStack.back());

(PCLoc.

() ||

->getFile() == getOrCreateFile(CurLoc))

(

*LBF = dyn_cast<llvm::DILexicalBlockFile>(

)) {

LexicalBlockStack.pop_back();

LexicalBlockStack.emplace_back(DBuilder.createLexicalBlockFile(

LBF->getScope(), getOrCreateFile(CurLoc)));

}

(isa<llvm::DILexicalBlock>(

) ||

isa<llvm::DISubprogram>(

)) {

LexicalBlockStack.pop_back();

LexicalBlockStack.emplace_back(

DBuilder.createLexicalBlockFile(

, getOrCreateFile(CurLoc)));

llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(

*

) {

llvm::DIScope *Mod = getParentModuleOrNull(

);

llvm::DIScope *CGDebugInfo::getContextDescriptor(

*Context,

I = RegionMap.find(Context);

(I != RegionMap.end()) {

llvm::Metadata *

= I->second;

dyn_cast_or_null<llvm::DIScope>(

);

(

*NSDecl = dyn_cast<NamespaceDecl>(Context))

getOrCreateNamespace(NSDecl);

(

*RDecl = dyn_cast<RecordDecl>(Context))

(!RDecl->isDependentType())

StringRef CGDebugInfo::getFunctionName(

*FD) {

internString(GetName(FD));

StringRef CGDebugInfo::getObjCMethodName(

*OMD) {

llvm::raw_svector_ostream OS(MethodName);

(

*OID = dyn_cast<ObjCImplementationDecl>(DC)) {

OS << OID->getName();

}

(

*OID = dyn_cast<ObjCInterfaceDecl>(DC)) {

OS << OID->getName();

}

(

*OC = dyn_cast<ObjCCategoryDecl>(DC)) {

(OC->IsClassExtension()) {

OS << OC->getClassInterface()->getName();

OS << OC->getIdentifier()->getNameStart() <<

<< OC->getIdentifier()->getNameStart() <<

;

}

(

*OCD = dyn_cast<ObjCCategoryImplDecl>(DC)) {

OS << OCD->getClassInterface()->getName() <<

<< OCD->getName() <<

;

internString(OS.str());

StringRef CGDebugInfo::getSelectorName(

S) {

internString(S.getAsString());

StringRef CGDebugInfo::getClassName(

*RD) {

(isa<ClassTemplateSpecializationDecl>(RD)) {

internString(GetName(RD));

II->getName();

);

assert(

->getDeclName().getAsIdentifierInfo() &&

);

->getDeclName().getAsIdentifierInfo()->getName();

Name = DD->getName();

Name = TND->getName();

(

*CXXRD = dyn_cast<CXXRecordDecl>(RD))

(CXXRD->isLambda())

internString(UnnamedType);

std::optional<llvm::DIFile::ChecksumKind>

std::optional<llvm::MemoryBufferRef> MemBuffer =

.getBufferOrNone(FID);

= llvm::arrayRefFromStringRef(MemBuffer->getBuffer());

llvm::toHex(llvm::MD5::hash(

),

, Checksum);

llvm::DIFile::CSK_MD5;

llvm::toHex(llvm::SHA1::hash(

),

, Checksum);

llvm::DIFile::CSK_SHA1;

llvm::toHex(llvm::SHA256::hash(

),

, Checksum);

llvm::DIFile::CSK_SHA256;

llvm_unreachable(

);

std::optional<StringRef> CGDebugInfo::getSource(

&

,

SourceInvalid =

;

StringRef Source =

.getBufferData(FID, &SourceInvalid);

std::optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo;

= TheCU->getFile()->getFilename();

CSInfo = TheCU->getFile()->getChecksum();

= TheCU->getFile()->getFilename();

It = DIFileCache.find(

.data());

(It != DIFileCache.end()) {

(llvm::Metadata *

= It->second)

cast<llvm::DIFile>(

);

std::optional<llvm::DIFile::ChecksumKind> CSKind =

computeChecksum(FID, Checksum);

CSInfo.emplace(*CSKind, Checksum);

createFile(

, CSInfo, getSource(

,

.getFileID(

)));

llvm::DIFile *CGDebugInfo::createFile(

std::optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo,

std::optional<StringRef> Source) {

std::string CurDir =

(getCurrentDirname());

(llvm::sys::path::is_absolute(RemappedFile)) {

FileIt = llvm::sys::path::begin(RemappedFile);

FileE = llvm::sys::path::end(RemappedFile);

CurDirIt = llvm::sys::path::begin(CurDir);

CurDirE = llvm::sys::path::end(CurDir);

(; CurDirIt != CurDirE && *CurDirIt == *FileIt; ++CurDirIt, ++FileIt)

llvm::sys::path::append(DirBuf, *CurDirIt);

(llvm::sys::path::root_path(DirBuf) == DirBuf) {

(; FileIt != FileE; ++FileIt)

llvm::sys::path::append(FileBuf, *FileIt);

(!llvm::sys::path::is_absolute(

))

llvm::DIFile *F = DBuilder.createFile(

, Dir, CSInfo, Source);

DIFileCache[

.data()].reset(F);

(llvm::sys::path::replace_path_prefix(

, From, To))

.str().str();

.getPresumedLoc(

).getLine();

StringRef CGDebugInfo::getCurrentDirname() {

(!CWDName.empty())

llvm::ErrorOr<std::string> CWD =

CWDName = internString(*CWD);

CGDebugInfo::CreateCompileUnit() {

std::optional<llvm::DIFile::ChecksumKind> CSKind;

std::optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo;

std::string MainFileName = CGO.MainFileName;

(MainFileName.empty())

MainFileName =

;

std::string MainFileDir;

.getFileEntryRefForID(

.getMainFileID())) {

MainFileDir = std::string(MainFile->getDir().getName());

(!llvm::sys::path::is_absolute(MainFileName)) {

llvm::sys::path::Style Style =

? llvm::sys::path::Style::windows_backslash

: llvm::sys::path::Style::posix)

: llvm::sys::path::Style::native;

llvm::sys::path::append(MainFileDirSS, Style, MainFileName);

MainFileName = std::string(

llvm::sys::path::remove_leading_dotslash(MainFileDirSS, Style));

(MainFile->getName() == MainFileName &&

MainFile->getName().rsplit(

).second)

MainFileName = CGM.

().getName().str();

CSKind = computeChecksum(

.getMainFileID(), Checksum);

llvm::dwarf::SourceLanguage LangTag;

LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;

(CGO.DebugStrictDwarf && CGO.DwarfVersion < 5)

LangTag = llvm::dwarf::DW_LANG_C_plus_plus;

(LO.CPlusPlus14)

LangTag = llvm::dwarf::DW_LANG_C_plus_plus_14;

(LO.CPlusPlus11)

LangTag = llvm::dwarf::DW_LANG_C_plus_plus_11;

LangTag = llvm::dwarf::DW_LANG_C_plus_plus;

}

(LO.ObjC) {

LangTag = llvm::dwarf::DW_LANG_ObjC;

}

(LO.OpenCL && (!CGM.

().DebugStrictDwarf ||

LangTag = llvm::dwarf::DW_LANG_OpenCL;

}

(LO.C11 && !(CGO.DebugStrictDwarf && CGO.DwarfVersion < 5)) {

LangTag = llvm::dwarf::DW_LANG_C11;

LangTag = llvm::dwarf::DW_LANG_C99;

LangTag = llvm::dwarf::DW_LANG_C89;

RuntimeVers = 0;

llvm::DICompileUnit::DebugEmissionKind EmissionKind;

llvm::codegenoptions::NoDebugInfo:

llvm::codegenoptions::LocTrackingOnly:

EmissionKind = llvm::DICompileUnit::NoDebug;

llvm::codegenoptions::DebugLineTablesOnly:

EmissionKind = llvm::DICompileUnit::LineTablesOnly;

llvm::codegenoptions::DebugDirectivesOnly:

EmissionKind = llvm::DICompileUnit::DebugDirectivesOnly;

llvm::codegenoptions::DebugInfoConstructor:

llvm::codegenoptions::LimitedDebugInfo:

llvm::codegenoptions::FullDebugInfo:

llvm::codegenoptions::UnusedTypeInfo:

EmissionKind = llvm::DICompileUnit::FullDebug;

CSInfo.emplace(*CSKind, Checksum);

llvm::DIFile *CUFile = DBuilder.createFile(

getSource(

,

.getMainFileID()));

StringRef Sysroot, SDK;

(CGM.

().getDebuggerTuning() == llvm::DebuggerKind::LLDB) {

B = llvm::sys::path::rbegin(Sysroot);

= llvm::sys::path::rend(Sysroot);

std::find_if(B,

, [](

SDK) {

SDK.ends_with(

); });

llvm::DICompileUnit::DebugNameTableKind NameTableKind =

llvm::DICompileUnit::DebugNameTableKind

(

CGOpts.DebugNameTable);

NameTableKind = llvm::DICompileUnit::DebugNameTableKind::None;

NameTableKind = llvm::DICompileUnit::DebugNameTableKind::Apple;

TheCU = DBuilder.createCompileUnit(

LangTag, CUFile, CGOpts.EmitVersionIdentMetadata ? Producer :

,

LO.Optimize || CGOpts.PrepareForLTO || CGOpts.PrepareForThinLTO,

CGOpts.DwarfDebugFlags, RuntimeVers, CGOpts.SplitDwarfFile, EmissionKind,

DwoId, CGOpts.SplitDwarfInlining, CGOpts.DebugInfoForProfiling,

NameTableKind, CGOpts.DebugRangesBaseAddress,

(Sysroot), SDK);

llvm::DIType *CGDebugInfo::CreateType(

*BT) {

BuiltinType::Dependent:

llvm_unreachable(

);

BuiltinType::NullPtr:

DBuilder.createNullPtrType();

BuiltinType::Void:

BuiltinType::ObjCClass:

DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,

, TheCU, TheCU->getFile(), 0);

BuiltinType::ObjCId: {

DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,

, TheCU, TheCU->getFile(), 0);

*ISATy = DBuilder.createPointerType(ClassTy, Size);

ObjTy = DBuilder.createStructType(TheCU,

, TheCU->getFile(), 0,

0, 0, llvm::DINode::FlagZero,

,

llvm::DINodeArray());

DBuilder.replaceArrays(

ObjTy, DBuilder.getOrCreateArray(&*DBuilder.createMemberType(

ObjTy,

, TheCU->getFile(), 0, Size, 0, 0,

llvm::DINode::FlagZero, ISATy)));

BuiltinType::ObjCSel: {

SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,

, TheCU,

TheCU->getFile(), 0);

#ImgType "_" #Suffix "_t", \

BuiltinType::OCLSampler:

getOrCreateStructPtrType(

, OCLSamplerDITy);

BuiltinType::OCLEvent:

getOrCreateStructPtrType(

, OCLEventDITy);

BuiltinType::OCLClkEvent:

getOrCreateStructPtrType(

, OCLClkEventDITy);

BuiltinType::OCLQueue:

getOrCreateStructPtrType(

, OCLQueueDITy);

BuiltinType::OCLReserveID:

getOrCreateStructPtrType(

, OCLReserveIDDITy);

#ExtType, Id##Ty);

(BT->

() == BuiltinType::MFloat8) {

= llvm::dwarf::DW_ATE_unsigned_char;

DBuilder.createBasicType(BTName, Size, Encoding);

BT->

() == BuiltinType::SveCount

: CGM.getContext().getBuiltinVectorTypeInfo(BT);

);

NumElems = Info.

.getKnownMinValue() * Info.

;

llvm::Metadata *LowerBound, *UpperBound;

LowerBound = llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(

(Info.

.isScalable()) {

NumElemsPerVG = NumElems / 2;

{llvm::dwarf::DW_OP_constu, NumElemsPerVG, llvm::dwarf::DW_OP_bregx,

46, 0, llvm::dwarf::DW_OP_mul,

llvm::dwarf::DW_OP_constu, 1, llvm::dwarf::DW_OP_minus});

UpperBound = DBuilder.createExpression(

);

UpperBound = llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(

llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(

, LowerBound, UpperBound,

);

llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);

llvm::DIType *ElemTy =

getOrCreateType(Info.

, TheCU->getFile());

DBuilder.createVectorType(

0, Align, ElemTy,

CreateType(cast<const BuiltinType>(CGM.

().

));

ElementCount = Info.

.getKnownMinValue();

Fractional =

;

FixedSize = ElementCount * SEW;

}

(FixedSize < 64) {

LMUL = 64 / FixedSize;

LMUL = FixedSize / 64;

{llvm::dwarf::DW_OP_bregx,

llvm::dwarf::DW_OP_constu,

llvm::dwarf::DW_OP_div, llvm::dwarf::DW_OP_constu, LMUL});

.push_back(llvm::dwarf::DW_OP_div);

.push_back(llvm::dwarf::DW_OP_mul);

.append({llvm::dwarf::DW_OP_constu, 1, llvm::dwarf::DW_OP_minus});

llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(

*UpperBound = DBuilder.createExpression(

);

llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(

, LowerBound, UpperBound,

);

llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);

llvm::DIType *ElemTy =

getOrCreateType(Info.

, TheCU->getFile());

DBuilder.createVectorType(

0, Align, ElemTy,

BuiltinType::UChar:

BuiltinType::Char_U:

= llvm::dwarf::DW_ATE_unsigned_char;

BuiltinType::Char_S:

BuiltinType::SChar:

= llvm::dwarf::DW_ATE_signed_char;

BuiltinType::Char8:

BuiltinType::Char16:

BuiltinType::Char32:

BuiltinType::UShort:

BuiltinType::UInt:

BuiltinType::UInt128:

BuiltinType::ULong:

BuiltinType::WChar_U:

BuiltinType::ULongLong:

= llvm::dwarf::DW_ATE_unsigned;

BuiltinType::Short:

BuiltinType::Int:

BuiltinType::Int128:

BuiltinType::Long:

BuiltinType::WChar_S:

BuiltinType::LongLong:

= llvm::dwarf::DW_ATE_signed;

BuiltinType::Bool:

= llvm::dwarf::DW_ATE_boolean;

BuiltinType::Half:

BuiltinType::Float:

BuiltinType::LongDouble:

BuiltinType::Float16:

BuiltinType::BFloat16:

BuiltinType::Float128:

BuiltinType::Double:

BuiltinType::Ibm128:

= llvm::dwarf::DW_ATE_float;

BuiltinType::ShortAccum:

BuiltinType::Accum:

BuiltinType::LongAccum:

BuiltinType::ShortFract:

BuiltinType::Fract:

BuiltinType::LongFract:

BuiltinType::SatShortFract:

BuiltinType::SatFract:

BuiltinType::SatLongFract:

BuiltinType::SatShortAccum:

BuiltinType::SatAccum:

BuiltinType::SatLongAccum:

= llvm::dwarf::DW_ATE_signed_fixed;

BuiltinType::UShortAccum:

BuiltinType::UAccum:

BuiltinType::ULongAccum:

BuiltinType::UShortFract:

BuiltinType::UFract:

BuiltinType::ULongFract:

BuiltinType::SatUShortAccum:

BuiltinType::SatUAccum:

BuiltinType::SatULongAccum:

BuiltinType::SatUShortFract:

BuiltinType::SatUFract:

BuiltinType::SatULongFract:

= llvm::dwarf::DW_ATE_unsigned_fixed;

DBuilder.createBasicType(BTName, Size, Encoding);

llvm::DIType *CGDebugInfo::CreateType(

*Ty) {

StringRef Name = Ty->

() ?

:

;

? llvm::dwarf::DW_ATE_unsigned

: llvm::dwarf::DW_ATE_signed;

llvm::DIType *CGDebugInfo::CreateType(

*Ty) {

llvm::dwarf::TypeKind

= llvm::dwarf::DW_ATE_complex_float;

= llvm::dwarf::DW_ATE_lo_user;

DBuilder.createBasicType(

, Size, Encoding);

llvm::dwarf::DW_TAG_const_type;

llvm::dwarf::DW_TAG_volatile_type;

llvm::dwarf::DW_TAG_restrict_type;

(llvm::dwarf::Tag)0;

llvm::DIType *CGDebugInfo::CreateQualifiedType(

Ty,

llvm::DIFile *Unit) {

assert(Qc.

() &&

);

getOrCreateType(

(

, 0), Unit);

DBuilder.createQualifiedType(Tag, FromTy);

llvm::DIFile *Unit) {

assert(Q.

() &&

);

DBuilder.createQualifiedType(Tag, FromTy);

llvm::DIFile *Unit) {

CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,

llvm::DIType *CGDebugInfo::CreateType(

*Ty,

llvm::DIFile *Unit) {

CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,

(TheCU->getSourceLanguage()) {

llvm::dwarf::DW_LANG_C_plus_plus:

llvm::dwarf::DW_LANG_C_plus_plus_11:

llvm::dwarf::DW_LANG_C_plus_plus_14:

llvm::dwarf::DW_LANG_ObjC_plus_plus:

isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD);

llvm::DICompileUnit *TheCU) {

llvm::DICompileUnit *TheCU) {

(

*RD = dyn_cast<CXXRecordDecl>(TD))

(RD->isDynamicClass() &&

llvm::dwarf::Tag Tag;

Tag = llvm::dwarf::DW_TAG_structure_type;

Tag = llvm::dwarf::DW_TAG_union_type;

Tag = llvm::dwarf::DW_TAG_class_type;

llvm::DICompositeType *

CGDebugInfo::getOrCreateRecordFwdDecl(

*Ty,

llvm::DIScope *Ctx) {

cast<llvm::DICompositeType>(

);

llvm::DIFile *DefUnit = getOrCreateFile(RD->

());

=

StringRef RDName = getClassName(RD);

(

&&

->isCompleteDefinition())

llvm::DINode::DIFlags Flags = llvm::DINode::FlagFwdDecl;

(

*CXXRD = dyn_cast<CXXRecordDecl>(RD))

(!CXXRD->hasDefinition() ||

(CXXRD->hasDefinition() && !CXXRD->isTrivial()))

Flags |= llvm::DINode::FlagNonTrivial;

llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(

(

*TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))

DBuilder.replaceArrays(RetTy, llvm::DINodeArray(),

CollectCXXTemplateParams(TSpecial, DefUnit));

ReplaceMap.emplace_back(

std::piecewise_construct, std::make_tuple(Ty),

std::make_tuple(

llvm::Metadata *

(RetTy)));

llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,

llvm::DIFile *Unit) {

std::optional<unsigned> DWARFAddressSpace =

BTFAttrTy = dyn_cast<BTFTagAttributedType>(

->getValueType());

BTFAttrTy = dyn_cast<BTFTagAttributedType>(PointeeTy);

StringRef

= BTFAttrTy->

()->getBTFTypeTag();

(!

.empty()) {

llvm::Metadata *Ops[2] = {

llvm::MDString::get(CGM.

(), StringRef(

)),

Annots.insert(Annots.begin(),

BTFAttrTy = dyn_cast<BTFTagAttributedType>(BTFAttrTy->

());

llvm::DINodeArray Annotations =

;

(Annots.size() > 0)

Annotations = DBuilder.getOrCreateArray(Annots);

(Tag == llvm::dwarf::DW_TAG_reference_type ||

Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)

DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit),

Size, Align, DWARFAddressSpace);

DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,

Align, DWARFAddressSpace, StringRef(),

llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,

llvm::DIType *&

) {

= DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,

TheCU, TheCU->getFile(), 0);

= DBuilder.createPointerType(

, Size);

CGDebugInfo::collectDefaultElementTypesForBlockPointer(

*Ty, llvm::DIFile *Unit, llvm::DIDerivedType *DescTy,

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

EltTys.push_back(DBuilder.createMemberType(

Unit,

,

, LineNo, FieldSize, FieldAlign,

FieldOffset, llvm::DINode::FlagZero, DescTy));

FieldOffset += FieldSize;

llvm::DIFile *Unit) {

llvm::DINodeArray Elements;

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

Elements = DBuilder.getOrCreateArray(EltTys);

llvm::DINode::DIFlags Flags = llvm::DINode::FlagAppleBlock;

DBuilder.createStructType(Unit,

,

, 0,

FieldOffset, 0, Flags,

, Elements);

*DescTy = DBuilder.createPointerType(EltTy, Size);

FieldOffset = collectDefaultElementTypesForBlockPointer(Ty, Unit, DescTy,

Elements = DBuilder.getOrCreateArray(EltTys);

EltTy = DBuilder.createStructType(Unit,

,

, 0, FieldOffset, 0,

Flags,

, Elements);

DBuilder.createPointerType(EltTy, Size);

(Param->isParameterPack()) {

(SubstArgs.empty()) {

SpecArgs.push_back(SubstArgs.front());

SubstArgs = SubstArgs.drop_front();

llvm::DIFile *Unit) {

llvm::DIType *Src = getOrCreateType(Ty->

(), Unit);

(isa<BuiltinTemplateDecl>(TD))

*

= cast<TypeAliasTemplateDecl>(TD)->getTemplatedDecl();

(

->hasAttr<NoDebugAttr>())

llvm::raw_svector_ostream OS(NS);

PP = getPrintingPolicy();

ArgVector = ::GetTemplateArgs(TD, Ty);

llvm::raw_string_ostream OS(Name);

llvm::codegenoptions::DebugTemplateNamesKind::Simple ||

!HasReconstitutableArgs(Args.Args))

llvm::DIDerivedType *AliasTy = DBuilder.createTemplateAlias(

Src, Name, getOrCreateFile(

), getLineNumber(

),

getDeclContextDescriptor(

), CollectTemplateParams(Args, Unit));

DBuilder.createTypedef(Src, OS.str(), getOrCreateFile(

),

getLineNumber(

),

llvm::DINode::FlagZero;

llvm::DINode::FlagPrivate;

llvm::DINode::FlagProtected;

llvm::DINode::FlagPublic;

llvm::DINode::FlagZero;

llvm_unreachable(

);

llvm::DIType *CGDebugInfo::CreateType(

*Ty,

llvm::DIFile *Unit) {

llvm::DIType *Underlying =

llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(Ty->

());

llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;

(isa<RecordDecl>(DC))

DBuilder.createTypedef(Underlying, Ty->

()->

(),

getOrCreateFile(

), getLineNumber(

),

getDeclContextDescriptor(Ty->

()), Align,

Flags, Annotations);

llvm::dwarf::DW_CC_BORLAND_stdcall;

llvm::dwarf::DW_CC_BORLAND_msfastcall;

llvm::dwarf::DW_CC_BORLAND_thiscall;

llvm::dwarf::DW_CC_LLVM_vectorcall;

llvm::dwarf::DW_CC_BORLAND_pascal;

llvm::dwarf::DW_CC_LLVM_Win64;

llvm::dwarf::DW_CC_LLVM_X86_64SysV;

llvm::dwarf::DW_CC_LLVM_AAPCS;

llvm::dwarf::DW_CC_LLVM_AAPCS_VFP;

llvm::dwarf::DW_CC_LLVM_IntelOclBicc;

llvm::dwarf::DW_CC_LLVM_SpirFunction;

llvm::dwarf::DW_CC_LLVM_OpenCLKernel;

llvm::dwarf::DW_CC_LLVM_Swift;

llvm::dwarf::DW_CC_LLVM_SwiftTail;

llvm::dwarf::DW_CC_LLVM_PreserveMost;

llvm::dwarf::DW_CC_LLVM_PreserveAll;

llvm::dwarf::DW_CC_LLVM_X86RegCall;

llvm::dwarf::DW_CC_LLVM_M68kRTD;

llvm::dwarf::DW_CC_LLVM_PreserveNone;

llvm::dwarf::DW_CC_LLVM_RISCVVectorCall;

llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;

Flags |= llvm::DINode::FlagLValueReference;

Flags |= llvm::DINode::FlagRValueReference;

llvm::DIType *CGDebugInfo::CreateType(

*Ty,

llvm::DIFile *Unit) {

*FPT = dyn_cast<FunctionProtoType>(Ty);

(llvm::DIType *QTy = CreateQualifiedType(FPT, Unit))

EltTys.push_back(getOrCreateType(Ty->

(), Unit));

llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;

EltTys.push_back(DBuilder.createUnspecifiedParameter());

(

&ParamType : FPT->param_types())

EltTys.push_back(getOrCreateType(ParamType, Unit));

(FPT->isVariadic())

EltTys.push_back(DBuilder.createUnspecifiedParameter());

llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);

llvm::DIType *F = DBuilder.createSubroutineType(

llvm::DIDerivedType *

CGDebugInfo::createBitFieldType(

*BitFieldDecl,

llvm::DIScope *RecordTy,

*RD) {

StringRef Name = BitFieldDecl->

();

(BitFieldDecl->

<PreferredTypeAttr>())

Ty = BitFieldDecl->

<PreferredTypeAttr>()->getType();

llvm::DIFile *VUnit = getOrCreateFile(

);

llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);

llvm::DIFile *

= getOrCreateFile(

);

= getLineNumber(

);

assert(SizeInBits > 0 &&

);

OffsetInBits = StorageOffsetInBits + Offset;

llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(BitFieldDecl);

DBuilder.createBitFieldMemberType(

RecordTy, Name,

,

, SizeInBits, OffsetInBits, StorageOffsetInBits,

Flags, DebugType, Annotations);

llvm::DIDerivedType *CGDebugInfo::createBitFieldSeparatorIfNeeded(

*BitFieldDecl,

llvm::DIDerivedType *BitFieldDI,

(PreviousFieldsDI.empty())

*PreviousMDEntry =

PreviousFieldsDI.empty() ? nullptr : PreviousFieldsDI.back();

*PreviousMDField =

dyn_cast_or_null<llvm::DIDerivedType>(PreviousMDEntry);

(!PreviousMDField || !PreviousMDField->isBitField() ||

PreviousMDField->getSizeInBits() == 0)

std::advance(PreviousBitfield, BitFieldDecl->

() - 1);

assert(PreviousBitfield->isBitField());

(!PreviousBitfield->isZeroLengthBitField())

Ty = PreviousBitfield->getType();

llvm::DIFile *VUnit = getOrCreateFile(

);

llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);

llvm::DIScope *RecordTy = BitFieldDI->getScope();

llvm::DIFile *

= getOrCreateFile(

);

= getLineNumber(

);

cast<llvm::ConstantInt>(BitFieldDI->getStorageOffsetInBits())

llvm::DINode::DIFlags Flags =

llvm::DINodeArray Annotations =

CollectBTFDeclTagAnnotations(*PreviousBitfield);

DBuilder.createBitFieldMemberType(

RecordTy,

,

,

, 0, StorageOffsetInBits, StorageOffsetInBits,

Flags, DebugType, Annotations);

llvm::DIType *CGDebugInfo::createFieldType(

uint64_t offsetInBits, uint32_t AlignInBits, llvm::DIFile *tunit,

llvm::DIScope *scope,

*RD, llvm::DINodeArray Annotations) {

llvm::DIType *debugType = getOrCreateType(

, tunit);

llvm::DIFile *file = getOrCreateFile(loc);

line = getLineNumber(loc.

() ? loc : CurLoc);

Align = AlignInBits;

(!

->isIncompleteArrayType()) {

SizeInBits = TI.

;

DBuilder.createMemberType(scope, name, file, line, SizeInBits, Align,

offsetInBits, flags, debugType, Annotations);

llvm::DISubprogram *

CGDebugInfo::createInlinedTrapSubprogram(StringRef FuncName,

llvm::DIFile *FileScope) {

llvm::DISubprogram *&SP = InlinedTrapFuncMap[FuncName];

llvm::DISubroutineType *DIFnTy = DBuilder.createSubroutineType(

);

SP = DBuilder.createFunction(

FileScope,

FuncName,

StringRef(),

FileScope,

0,

DIFnTy,

llvm::DINode::FlagArtificial,

llvm::DISubprogram::SPFlagDefinition,

,

,

);

CGDebugInfo::CollectRecordLambdaFields(

llvm::DIType *RecordTy) {

fieldno = 0;

I !=

; ++I, ++Field, ++fieldno) {

(

.capturesVariable()) {

assert(!

->isBitField() &&

);

StringRef VName =

->getName();

llvm::DIFile *VUnit = getOrCreateFile(

);

llvm::DIType *FieldType = createFieldType(

layout.

(fieldno), Align, VUnit, RecordTy, CXXDecl);

elements.push_back(FieldType);

}

(

.capturesThis()) {

llvm::DIFile *VUnit = getOrCreateFile(f->

());

StringRef ThisName =

llvm::DIType *fieldType = createFieldType(

elements.push_back(fieldType);

llvm::DIDerivedType *

CGDebugInfo::CreateRecordStaticField(

*Var, llvm::DIType *RecordTy,

llvm::DIFile *VUnit = getOrCreateFile(Var->

());

llvm::DIType *VTy = getOrCreateType(Var->

(), VUnit);

LineNumber = getLineNumber(Var->

());

StringRef VName = Var->

();

llvm::Constant *

=

;

(

->isInt())

(

->isFloat())

? llvm::dwarf::DW_TAG_variable

: llvm::dwarf::DW_TAG_member;

llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(

RecordTy, VName, VUnit, LineNumber, VTy, Flags,

, Tag, Align);

CGDebugInfo::CollectRecordNormalField(

*field, uint64_t OffsetInBits, llvm::DIFile *tunit,

(

.empty() && !

->isRecordType())

llvm::DIType *FieldType;

llvm::DIDerivedType *BitFieldType;

FieldType = BitFieldType = createBitFieldType(field, RecordTy, RD);

(llvm::DIType *Separator =

createBitFieldSeparatorIfNeeded(field, BitFieldType, elements, RD))

elements.push_back(Separator);

llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(field);

OffsetInBits, Align, tunit, RecordTy, RD, Annotations);

elements.push_back(FieldType);

CGDebugInfo::CollectRecordNestedType(

(isa<InjectedClassNameType>(Ty))

(llvm::DIType *nestedType = getOrCreateType(Ty, getOrCreateFile(

)))

elements.push_back(nestedType);

CGDebugInfo::CollectRecordFields(

*record, llvm::DIFile *tunit,

llvm::DICompositeType *RecordTy) {

*CXXDecl = dyn_cast<CXXRecordDecl>(record);

(CXXDecl && CXXDecl->

())

CollectRecordLambdaFields(CXXDecl, elements, RecordTy);

fieldNo = 0;

(

*I : record->

())

(

*

= dyn_cast<VarDecl>(I)) {

(

->hasAttr<NoDebugAttr>())

isa<VarTemplateSpecializationDecl>(

))

(isa<VarTemplatePartialSpecializationDecl>(

))

MI = StaticDataMemberCache.find(

->getCanonicalDecl());

(MI != StaticDataMemberCache.end()) {

assert(MI->second &&

);

elements.push_back(MI->second);

= CreateRecordStaticField(

, RecordTy, record);

elements.push_back(Field);

}

(

*field = dyn_cast<FieldDecl>(I)) {

CollectRecordNormalField(field, layout.

(fieldNo), tunit,

elements, RecordTy, record);

(

*nestedType = dyn_cast<TypeDecl>(I)) {

(isa<RecordDecl>(I) &&

cast<RecordDecl>(I)->isAnonymousStructOrUnion())

(!nestedType->isImplicit() &&

nestedType->getDeclContext() == record)

CollectRecordNestedType(nestedType, elements);

llvm::DISubroutineType *

CGDebugInfo::getOrCreateMethodType(

*Method,

llvm::DIFile *Unit) {

cast_or_null<llvm::DISubroutineType>(

getOrCreateInstanceMethodType(ThisType,

, Unit);

llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType(

*OriginalFunc = cast<llvm::DISubroutineType>(

->getReturnType(),

->getParamTypes(), EPI),

llvm::DITypeRefArray Args = OriginalFunc->getTypeArray();

assert(Args.size() &&

);

Elts.push_back(Args[0]);

HasExplicitObjectParameter = ThisPtr.

();

(!HasExplicitObjectParameter) {

llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);

DBuilder.createObjectPointerType(ThisPtrType,

);

Elts.push_back(ThisPtrType);

(

i = 1, e = Args.size(); i != e; ++i)

Elts.push_back(Args[i]);

(HasExplicitObjectParameter) {

assert(Elts.size() >= 2 && Args.size() >= 2 &&

);

Elts[1] = DBuilder.createObjectPointerType(Args[1],

);

llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);

DBuilder.createSubroutineType(EltTypeArray, OriginalFunc->getFlags(),

(

*NRD = dyn_cast<CXXRecordDecl>(RD->

()))

llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(

*Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {

isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);

StringRef MethodName = getFunctionName(Method);

llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit);

StringRef MethodLinkageName;

llvm::DIFile *MethodDefUnit =

;

MethodLine = 0;

MethodDefUnit = getOrCreateFile(Method->

());

MethodLine = getLineNumber(Method->

());

llvm::DIType *ContainingType =

;

VIndex = 0;

llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;

llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;

SPFlags |= llvm::DISubprogram::SPFlagPureVirtual;

SPFlags |= llvm::DISubprogram::SPFlagVirtual;

(!isa<CXXDestructorDecl>(Method))

*DD = dyn_cast<CXXDestructorDecl>(Method);

VIndex = ML.

;

Flags |= llvm::DINode::FlagIntroducedVirtual;

ContainingType = RecordTy;

SPFlags |= llvm::DISubprogram::SPFlagDeleted;

Flags |= llvm::DINode::FlagNoReturn;

Flags |= llvm::DINode::FlagStaticMember;

Flags |= llvm::DINode::FlagArtificial;

(

*CXXC = dyn_cast<CXXConstructorDecl>(Method)) {

(CXXC->isExplicit())

Flags |= llvm::DINode::FlagExplicit;

}

(

*CXXC = dyn_cast<CXXConversionDecl>(Method)) {

(CXXC->isExplicit())

Flags |= llvm::DINode::FlagExplicit;

Flags |= llvm::DINode::FlagPrototyped;

Flags |= llvm::DINode::FlagLValueReference;

Flags |= llvm::DINode::FlagRValueReference;

SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;

SPFlags |= llvm::DISubprogram::SPFlagOptimized;

(DebugKind == llvm::codegenoptions::DebugInfoConstructor)

llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);

llvm::DISubprogram *SP = DBuilder.createMethod(

RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,

MethodTy, VIndex,

, ContainingType, Flags, SPFlags,

TParamsArray.get());

CGDebugInfo::CollectCXXMemberFunctions(

(

*I : RD->

()) {

*Method = dyn_cast<CXXMethodDecl>(I);

EltTys.push_back(MI == SPCache.end()

? CreateCXXMemberFunction(Method, Unit, RecordTy)

:

llvm::Metadata *

(MI->second));

CGDebugInfo::CollectCXXBases(

*RD, llvm::DIFile *Unit,

llvm::DIType *RecordTy) {

llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> SeenTypes;

CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->

(), SeenTypes,

llvm::DINode::FlagZero);

CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->

(), SeenTypes,

llvm::DINode::FlagIndirectVirtualBase);

CGDebugInfo::CollectCXXBasesAux(

llvm::DINode::DIFlags StartingFlags) {

(

&BI : Bases) {

(!SeenTypes.insert(

).second)

*BaseTy = getOrCreateType(BI.getType(), Unit);

llvm::DINode::DIFlags BFlags = StartingFlags;

(BI.isVirtual()) {

BFlags |= llvm::DINode::FlagVirtual;

llvm::DIType *DTy = DBuilder.createInheritance(RecordTy, BaseTy, BaseOffset,

VBPtrOffset, BFlags);

EltTys.push_back(DTy);

CGDebugInfo::CollectTemplateParams(std::optional<TemplateArgs> OArgs,

llvm::DIFile *Unit) {

llvm::DINodeArray();

TemplateArgs &Args = *OArgs;

(

i = 0, e = Args.Args.size(); i != e; ++i) {

Name = Args.TList->getParam(i)->getName();

llvm::DIType *TTy = getOrCreateType(TA.

(), Unit);

TemplateParams.push_back(DBuilder.createTemplateTypeParameter(

TheCU, Name, TTy, defaultParameter));

TemplateParams.push_back(DBuilder.createTemplateValueParameter(

TheCU, Name, TTy, defaultParameter,

llvm::DIType *TTy = getOrCreateType(

, Unit);

llvm::Constant *

=

;

!

->

<CUDADeviceAttr>()) {

(

*VD = dyn_cast<VarDecl>(

))

(

*MD = dyn_cast<CXXMethodDecl>(

);

MD && MD->isImplicitObjectMemberFunction())

(

*FD = dyn_cast<FunctionDecl>(

))

(

*MPT =

dyn_cast<MemberPointerType>(

.getTypePtr())) {

}

(

*GD = dyn_cast<MSGuidDecl>(

)) {

}

(

*TPO = dyn_cast<TemplateParamObjectDecl>(

)) {

assert(

&&

);

=

->stripPointerCasts();

TemplateParams.push_back(DBuilder.createTemplateValueParameter(

TheCU, Name, TTy, defaultParameter, cast_or_null<llvm::Constant>(

)));

llvm::DIType *TTy = getOrCreateType(

, Unit);

llvm::Constant *

=

;

(

*MPT = dyn_cast<MemberPointerType>(

.getTypePtr()))

(MPT->isMemberDataPointer())

= llvm::ConstantInt::get(CGM.

, 0);

TemplateParams.push_back(DBuilder.createTemplateValueParameter(

TheCU, Name, TTy, defaultParameter,

));

llvm::DIType *TTy = getOrCreateType(

, Unit);

TemplateParams.push_back(DBuilder.createTemplateValueParameter(

TheCU, Name, TTy, defaultParameter,

));

std::string QualName;

llvm::raw_string_ostream OS(QualName);

OS, getPrintingPolicy());

TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(

TheCU, Name,

, QualName, defaultParameter));

TemplateParams.push_back(DBuilder.createTemplateParameterPack(

TheCU, Name,

,

CollectTemplateParams({{

, TA.

()}}, Unit)));

assert(

&&

);

llvm::DIType *TTy = getOrCreateType(

, Unit);

TemplateParams.push_back(DBuilder.createTemplateValueParameter(

TheCU, Name, TTy, defaultParameter,

->stripPointerCasts()));

);

DBuilder.getOrCreateArray(TemplateParams);

std::optional<CGDebugInfo::TemplateArgs>

CGDebugInfo::GetTemplateArgs(

*FD)

{

std::nullopt;

std::optional<CGDebugInfo::TemplateArgs>

CGDebugInfo::GetTemplateArgs(

*VD)

{

*TS = dyn_cast<VarTemplateSpecializationDecl>(VD);

std::nullopt;

TA = TS->getTemplateArgs().asArray();

{{TList, TA}};

std::optional<CGDebugInfo::TemplateArgs>

CGDebugInfo::GetTemplateArgs(

*RD)

{

(

*TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {

TSpecial->getSpecializedTemplate()->getTemplateParameters();

{{TPList, TAList.

()}};

std::nullopt;

CGDebugInfo::CollectFunctionTemplateParams(

*FD,

llvm::DIFile *Unit) {

CollectTemplateParams(GetTemplateArgs(FD), Unit);

llvm::DINodeArray CGDebugInfo::CollectVarTemplateParams(

*VL,

llvm::DIFile *Unit) {

CollectTemplateParams(GetTemplateArgs(VL), Unit);

llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(

*RD,

llvm::DIFile *Unit) {

CollectTemplateParams(GetTemplateArgs(RD), Unit);

llvm::DINodeArray CGDebugInfo::CollectBTFDeclTagAnnotations(

*

) {

(!

->

<BTFDeclTagAttr>())

llvm::Metadata *Ops[2] = {

llvm::MDString::get(CGM.

(), StringRef(

)),

llvm::MDString::get(CGM.

(), I->getBTFDeclTag())};

Annotations.push_back(llvm::MDNode::get(CGM.

(), Ops));

DBuilder.getOrCreateArray(Annotations);

llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {

VTablePtrType;

llvm::Metadata *STy = getOrCreateType(Context.

, Unit);

llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);

llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements);

std::optional<unsigned> DWARFAddressSpace =

llvm::DIType *vtbl_ptr_type = DBuilder.createPointerType(

SubTy, Size, 0, DWARFAddressSpace,

);

VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);

VTablePtrType;

StringRef CGDebugInfo::getVTableName(

*RD) {

StringRef CGDebugInfo::getDynamicInitializerName(

*VD,

llvm::Function *InitFn) {

InitFn->getName();

llvm::raw_svector_ostream OS(QualifiedGV);

std::tie(Quals, GVName) = OS.str().rsplit(

);

std::swap(Quals, GVName);

llvm::raw_svector_ostream OS(InitName);

OS << Quals <<

;

llvm_unreachable(

);

OS <<

;

OS <<

;

(

*VTpl = dyn_cast<VarTemplateSpecializationDecl>(VD)) {

getPrintingPolicy());

internString(OS.str());

CGDebugInfo::CollectVTableInfo(

*RD, llvm::DIFile *Unit,

llvm::DIType *VPtrTy =

;

(NeedVTableShape) {

VSlotCount =

VTableWidth = PtrWidth * VSlotCount;

std::optional<unsigned> DWARFAddressSpace =

llvm::DIType *VTableType = DBuilder.createPointerType(

, VTableWidth, 0, DWARFAddressSpace,

);

EltTys.push_back(VTableType);

VPtrTy = DBuilder.createPointerType(VTableType, PtrWidth);

VPtrTy = getOrCreateVTablePtrType(Unit);

llvm::DIType *VPtrMember =

DBuilder.createMemberType(Unit, getVTableName(RD), Unit, 0, Size, 0, 0,

llvm::DINode::FlagArtificial, VPtrTy);

EltTys.push_back(VPtrMember);

llvm::DIType *

= getOrCreateType(RTy, getOrCreateFile(

));

assert(!

.isNull() &&

);

llvm::DIType *

= getOrCreateType(

, getOrCreateFile(

));

assert(

&&

);

RetainedTypes.push_back(

.getAsOpaquePtr());

llvm::codegenoptions::DebugLineTablesOnly)

node = getOrCreateType(AllocatedTy, getOrCreateFile(

));

CI->setMetadata(

, node);

(DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)

I = TypeCache.find(TyPtr);

(I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())

llvm::DIType *Res = CreateTypeDefinition(Ty->

<

>());

assert(!Res->isForwardDecl());

TypeCache[TyPtr].reset(Res);

(DebugKind > llvm::codegenoptions::LimitedDebugInfo ||

(RD->

<DLLImportAttr>())

(MD->hasAttr<DLLImportAttr>())

(

*CXXDecl = dyn_cast<CXXRecordDecl>(RD)) {

(

*TD = dyn_cast<ClassTemplateSpecializationDecl>(CXXDecl))

= TD->isExplicitInstantiationOrSpecialization();

(

*CXXRD = dyn_cast<CXXRecordDecl>(RD))

(CXXRD->isDynamicClass() &&

llvm::GlobalValue::AvailableExternallyLinkage &&

(DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)

I = TypeCache.find(TyPtr);

(I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())

assert(!Res->isForwardDecl());

TypeCache[TyPtr].reset(Res);

(!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&

!MD->getMemberSpecializationInfo()->isExplicitSpecialization())

(Ctor->isCopyOrMoveConstructor())

(!Ctor->isDeleted())

(DebugKind == llvm::codegenoptions::DebugLineTablesOnly)

(DebugKind > llvm::codegenoptions::LimitedDebugInfo ||

RD->

<StandaloneDebugAttr>())

(!LangOpts.CPlusPlus)

*CXXDecl = dyn_cast<CXXRecordDecl>(RD);

(

*SD = dyn_cast<ClassTemplateSpecializationDecl>(RD))

Spec = SD->getSpecializationKind();

((DebugKind == llvm::codegenoptions::DebugInfoConstructor) &&

llvm::DIType *

= getTypeOrNull(Ty);

(

&&

->isForwardDecl())

llvm::DIType *CGDebugInfo::CreateType(

*Ty) {

llvm::DIType *

= cast_or_null<llvm::DIType>(getTypeOrNull(

(Ty, 0)));

= getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));

[Def, Pref] = CreateTypeDefinition(Ty);

Pref ? Pref : Def;

llvm::DIType *CGDebugInfo::GetPreferredNameType(

*RD,

llvm::DIFile *Unit) {

*PNA = RD->

<PreferredNameAttr>();

getOrCreateType(PNA->getTypedefType(), Unit);

std::pair<llvm::DIType *, llvm::DIType *>

CGDebugInfo::CreateTypeDefinition(

*Ty) {

llvm::DIFile *DefUnit = getOrCreateFile(RD->

());

llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty);

(!

|| !

->isCompleteDefinition())

{FwdDecl,

};

(

*CXXDecl = dyn_cast<CXXRecordDecl>(RD))

CollectContainingType(CXXDecl, FwdDecl);

LexicalBlockStack.emplace_back(&*FwdDecl);

RegionMap[Ty->

()].reset(FwdDecl);

*CXXDecl = dyn_cast<CXXRecordDecl>(RD);

CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);

CollectVTableInfo(CXXDecl, DefUnit, EltTys);

CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);

(CXXDecl && !CGM.

().DebugOmitUnreferencedMethods)

CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);

LexicalBlockStack.pop_back();

RegionMap.erase(Ty->

());

llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);

DBuilder.replaceArrays(FwdDecl, Elements);

(FwdDecl->isTemporary())

llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));

RegionMap[Ty->

()].reset(FwdDecl);

(CGM.

().getDebuggerTuning() == llvm::DebuggerKind::LLDB)

(

*PrefDI = GetPreferredNameType(CXXDecl, DefUnit))

{FwdDecl, PrefDI};

{FwdDecl,

};

llvm::DIFile *Unit) {

getOrCreateType(Ty->

(), Unit);

llvm::DIFile *Unit) {

DBuilder.createTypedef(

getDeclContextDescriptor(Ty->

()));

llvm::DIFile *Unit) {

llvm::dwarf::SourceLanguage

(TheCU->getSourceLanguage());

(DebugTypeExtRefs &&

->isFromASTFile() &&

->getDefinition() &&

!

->getImplementation())

DBuilder.createForwardDecl(

llvm::dwarf::DW_TAG_structure_type,

->getName(),

getDeclContextDescriptor(ID), Unit, 0, RuntimeLang);

llvm::DIFile *DefUnit = getOrCreateFile(

->getLocation());

= getLineNumber(

->getLocation());

llvm::DIScope *Mod = getParentModuleOrNull(ID);

llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(

llvm::dwarf::DW_TAG_structure_type,

->getName(), Mod ? Mod : TheCU,

DefUnit,

, RuntimeLang);

ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit));

CreateTypeDefinition(Ty, Unit);

CreateSkeletonCU) {

ModRef = ModuleCache.find(M);

(ModRef != ModuleCache.end())

cast<llvm::DIModule>(ModRef->second);

llvm::raw_svector_ostream OS(ConfigMacros);

(

&M : PPOpts.Macros) {

std::string &

= M.first;

Undef = M.second;

OS <<

<< (Undef ?

:

);

(

: Macro)

IsRootModule = M ? !M->

:

;

(CreateSkeletonCU && IsRootModule && Mod.

().empty() && M)

);

RemapPath = [

](StringRef

) -> std::string {

StringRef Relative(Remapped);

StringRef CompDir = TheCU->getDirectory();

(Relative.consume_front(CompDir))

Relative.consume_front(llvm::sys::path::get_separator());

Relative.str();

(CreateSkeletonCU && IsRootModule && !Mod.

().empty()) {

Signature = ModSig.truncatedValue();

(!llvm::sys::path::is_absolute(Mod.

())) {

PCM = getCurrentDirname();

llvm::sys::path::append(PCM, Mod.

());

DIB.createCompileUnit(

TheCU->getSourceLanguage(),

DIB.createFile(Mod.

(), TheCU->getDirectory()),

TheCU->getProducer(),

, StringRef(), 0, RemapPath(PCM),

llvm::DICompileUnit::FullDebug, Signature);

llvm::DIModule *

=

IsRootModule ? nullptr

std::string IncludePath = Mod.

().str();

llvm::DIModule *DIMod =

RemapPath(IncludePath));

ModuleCache[M].reset(DIMod);

llvm::DIFile *Unit) {

llvm::DIFile *DefUnit = getOrCreateFile(

->getLocation());

= getLineNumber(

->getLocation());

RuntimeLang = TheCU->getSourceLanguage();

llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;

(

->getImplementation())

Flags |= llvm::DINode::FlagObjcClassComplete;

llvm::DIScope *Mod = getParentModuleOrNull(ID);

llvm::DICompositeType *RealDecl = DBuilder.createStructType(

Mod ? Mod : Unit,

->getName(), DefUnit,

, Size, Align, Flags,

, llvm::DINodeArray(), RuntimeLang);

TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl);

LexicalBlockStack.emplace_back(RealDecl);

RegionMap[Ty->

()].reset(RealDecl);

llvm::DIType *SClassTy =

llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0, 0,

llvm::DINode::FlagZero);

EltTys.push_back(InhTag);

llvm::DIFile *PUnit = getOrCreateFile(

);

PLine = getLineNumber(

);

llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(

PD->getName(), PUnit, PLine,

: getSelectorName(PD->getGetterName()),

: getSelectorName(PD->getSetterName()),

PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit));

EltTys.push_back(PropertyNode);

std::pair<char, const IdentifierInfo *> IsClassAndIdent;

llvm::DenseSet<IsClassAndIdent> PropertySet;

std::make_pair(PD->isClassProperty(), PD->getIdentifier());

(

*PD : ClassExt->properties()) {

PropertySet.insert(GetIsClassAndIdent(PD));

(

*PD :

->properties()) {

(!PropertySet.insert(GetIsClassAndIdent(PD)).second)

FieldNo = 0;

(

*Field =

->all_declared_ivar_begin(); Field;

Field =

->getNextIvar(), ++FieldNo) {

llvm::DIType *FieldTy = getOrCreateType(

->getType(), Unit);

StringRef FieldName =

->getName();

(FieldName.empty())

llvm::DIFile *FieldDefUnit = getOrCreateFile(

->getLocation());

FieldLine = getLineNumber(

->getLocation());

FieldSize =

->isBitField() ?

->getBitWidthValue()

(

->isBitField()) {

llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;

Flags = llvm::DINode::FlagProtected;

Flags = llvm::DINode::FlagPrivate;

Flags = llvm::DINode::FlagPublic;

(

->isBitField())

Flags |= llvm::DINode::FlagBitField;

llvm::MDNode *PropertyNode =

;

ImpD->FindPropertyImplIvarDecl(

->getIdentifier())) {

llvm::DIFile *PUnit = getOrCreateFile(

);

PLine = getLineNumber(

);

PropertyNode = DBuilder.createObjCProperty(

PD->getName(), PUnit, PLine,

: getSelectorName(PD->getGetterName()),

: getSelectorName(PD->getSetterName()),

PD->getPropertyAttributes(),

getOrCreateType(PD->getType(), PUnit));

FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine,

FieldSize, FieldAlign, FieldOffset, Flags,

FieldTy, PropertyNode);

EltTys.push_back(FieldTy);

llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);

DBuilder.replaceArrays(RealDecl, Elements);

LexicalBlockStack.pop_back();

llvm::DIType *CGDebugInfo::CreateType(

*Ty,

llvm::DIFile *Unit) {

llvm::DIType *ElementTy = getOrCreateType(Ty->

(), Unit);

llvm::Metadata *Subscript;

SizeExpr = SizeExprCache.find(QTy);

(SizeExpr != SizeExprCache.end())

Subscript = DBuilder.getOrCreateSubrange(

SizeExpr->getSecond()

,

,

,

);

llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(

llvm::Type::getInt64Ty(CGM.

()), Count ? Count : -1));

Subscript = DBuilder.getOrCreateSubrange(

CountNode

,

,

,

llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);

DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);

llvm::DIFile *Unit) {

llvm::DIType *ElementTy = getOrCreateType(Ty->

(), Unit);

*ColumnCountNode =

llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(

*RowCountNode =

llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(

Subscripts.push_back(DBuilder.getOrCreateSubrange(

ColumnCountNode

,

,

,

Subscripts.push_back(DBuilder.getOrCreateSubrange(

RowCountNode

,

,

,

llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);

DBuilder.createArrayType(Size, Align, ElementTy, SubscriptArray);

llvm::DIType *CGDebugInfo::CreateType(

*Ty, llvm::DIFile *Unit) {

(

*VAT = dyn_cast<VariableArrayType>(Ty)) {

((Ty = dyn_cast<ArrayType>(EltTy))) {

(

*CAT = dyn_cast<ConstantArrayType>(Ty))

Count = CAT->getZExtSize();

(

*VAT = dyn_cast<VariableArrayType>(Ty)) {

(

*Size = VAT->getSizeExpr()) {

Count =

.Val.getInt().getExtValue();

SizeNode = SizeExprCache.find(EltTy);

(SizeNode != SizeExprCache.end())

Subscripts.push_back(DBuilder.getOrCreateSubrange(

SizeNode->getSecond()

,

,

,

));

llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(

Subscripts.push_back(DBuilder.getOrCreateSubrange(

CountNode

,

,

,

llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);

DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),

llvm::DIFile *Unit) {

CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty,

llvm::DIFile *Unit) {

llvm::dwarf::Tag

= llvm::dwarf::DW_TAG_rvalue_reference_type;

= llvm::dwarf::DW_TAG_reference_type;

CreatePointerLikeType(Tag, Ty, Ty->

(), Unit);

llvm::DIFile *

) {

llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;

Flags |= llvm::DINode::FlagSingleInheritance;

Flags |= llvm::DINode::FlagMultipleInheritance;

Flags |= llvm::DINode::FlagVirtualInheritance;

DBuilder.createMemberPointerType(

DBuilder.createMemberPointerType(

getOrCreateInstanceMethodType(

ClassType,

,

0, Flags);

llvm::DIType *CGDebugInfo::CreateType(

*Ty, llvm::DIFile *

) {

DBuilder.createQualifiedType(llvm::dwarf::DW_TAG_atomic_type, FromTy);

llvm::DIType *CGDebugInfo::CreateType(

*Ty, llvm::DIFile *

) {

llvm::DIFile *

) {

llvm::DIType *CGDebugInfo::CreateEnumType(

*Ty) {

isImportedFromModule =

llvm::DIScope *EDContext = getDeclContextDescriptor(ED);

llvm::DIFile *DefUnit = getOrCreateFile(ED->

());

llvm::TempDIScope TmpContext(DBuilder.createReplaceableCompositeType(

llvm::dwarf::DW_TAG_enumeration_type,

, TheCU, DefUnit, 0));

StringRef EDName = ED->

();

llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType(

llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit,

,

0, Size, Align, llvm::DINode::FlagFwdDecl,

);

ReplaceMap.emplace_back(

std::piecewise_construct, std::make_tuple(Ty),

std::make_tuple(

llvm::Metadata *

(RetTy)));

CreateTypeDefinition(Ty);

llvm::DIType *CGDebugInfo::CreateTypeDefinition(

*Ty) {

assert(ED &&

);

Enumerators.push_back(

DBuilder.createEnumerator(

->getName(),

->getInitVal()));

llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);

llvm::DIFile *DefUnit = getOrCreateFile(ED->

());

llvm::DIScope *EnumContext = getDeclContextDescriptor(ED);

llvm::DIType *ClassTy = getOrCreateType(ED->

(), DefUnit);

DBuilder.createEnumerationType(

EnumContext, ED->

(), DefUnit,

, Size, Align, EltArray, ClassTy,

StringRef Name, StringRef

) {

= LineLoc.

() ? 0 : getLineNumber(LineLoc);

llvm::DIFile *FName = getOrCreateFile(FileLoc);

= LineLoc.

() ? 0 : getLineNumber(LineLoc);

DBuilder.createTempMacroFile(

,

, FName);

llvm::DebugLoc TrapLocation, StringRef

, StringRef FailureMsg) {

FuncName += FailureMsg;

llvm::DISubprogram *TrapSP =

createInlinedTrapSubprogram(FuncName, TrapLocation->getFile());

TrapSP,

TrapLocation);

Quals += InnerQuals;

.getQualifiedType(

.getTypePtr(), Quals);

Type::TemplateSpecialization: {

*Spec = cast<TemplateSpecializationType>(

);

(Spec->isTypeAlias())

.getQualifiedType(

.getTypePtr(), Quals);

Type::TypeOfExpr:

= cast<TypeOfExprType>(

)->getUnderlyingExpr()->getType();

= cast<TypeOfType>(

)->getUnmodifiedType();

Type::Decltype:

= cast<DecltypeType>(

)->getUnderlyingType();

Type::UnaryTransform:

= cast<UnaryTransformType>(

)->getUnderlyingType();

Type::Attributed:

= cast<AttributedType>(

)->getEquivalentType();

Type::BTFTagAttributed:

= cast<BTFTagAttributedType>(

)->getWrappedType();

Type::CountAttributed:

= cast<CountAttributedType>(

)->

();

Type::Elaborated:

= cast<ElaboratedType>(

)->getNamedType();

= cast<UsingType>(

)->getUnderlyingType();

= cast<ParenType>(

)->getInnerType();

Type::MacroQualified:

= cast<MacroQualifiedType>(

)->getUnderlyingType();

Type::SubstTemplateTypeParm:

= cast<SubstTemplateTypeParmType>(

)->getReplacementType();

Type::DeducedTemplateSpecialization: {

DT = cast<DeducedType>(

)->getDeducedType();

assert(!DT.

() &&

);

Type::PackIndexing: {

= cast<PackIndexingType>(

)->getSelectedType();

Type::Adjusted:

= cast<AdjustedType>(

)->getAdjustedType();

assert(

!= LastT &&

);

llvm::DIType *CGDebugInfo::getTypeOrNull(

Ty) {

(It != TypeCache.end()) {

(llvm::Metadata *

= It->second)

cast<llvm::DIType>(

);

(DebugKind <= llvm::codegenoptions::DebugLineTablesOnly ||

.isDynamicClass())

llvm::DIType *CGDebugInfo::getOrCreateType(

Ty, llvm::DIFile *Unit) {

llvm::TimeTraceScope TimeScope(

, [&]() {

llvm::raw_string_ostream OS(Name);

Ty.

(OS, getPrintingPolicy());

(

*

= getTypeOrNull(Ty))

llvm::DIType *Res = CreateTypeNode(Ty, Unit);

*TyPtr = Ty.getAsOpaquePtr();

TypeCache[TyPtr].reset(Res);

llvm::DIModule *CGDebugInfo::getParentModuleOrNull(

*

) {

(isa<RecordDecl>(

) && !cast<RecordDecl>(

)->

())

Info = Reader->getSourceDescriptor(Idx);

getOrCreateModuleRef(*Info,

);

}

(ClangModuleMap) {

getOrCreateModuleRef(Info,

);

getOrCreateModuleRef(PCHDescriptor,

);

llvm::DIType *CGDebugInfo::CreateTypeNode(

Ty, llvm::DIFile *Unit) {

CreateQualifiedType(Ty, Unit);

llvm_unreachable(

);

Type::ExtVector:

CreateType(cast<VectorType>(Ty), Unit);

Type::ConstantMatrix:

CreateType(cast<ConstantMatrixType>(Ty), Unit);

Type::ObjCObjectPointer:

CreateType(cast<ObjCObjectPointerType>(Ty), Unit);

Type::ObjCObject:

CreateType(cast<ObjCObjectType>(Ty), Unit);

Type::ObjCTypeParam:

CreateType(cast<ObjCTypeParamType>(Ty), Unit);

Type::ObjCInterface:

CreateType(cast<ObjCInterfaceType>(Ty), Unit);

CreateType(cast<BuiltinType>(Ty));

CreateType(cast<ComplexType>(Ty));

CreateType(cast<PointerType>(Ty), Unit);

Type::BlockPointer:

CreateType(cast<BlockPointerType>(Ty), Unit);

CreateType(cast<TypedefType>(Ty), Unit);

CreateType(cast<RecordType>(Ty));

CreateEnumType(cast<EnumType>(Ty));

Type::FunctionProto:

Type::FunctionNoProto:

CreateType(cast<FunctionType>(Ty), Unit);

Type::ConstantArray:

Type::VariableArray:

Type::IncompleteArray:

Type::ArrayParameter:

CreateType(cast<ArrayType>(Ty), Unit);

Type::LValueReference:

CreateType(cast<LValueReferenceType>(Ty), Unit);

Type::RValueReference:

CreateType(cast<RValueReferenceType>(Ty), Unit);

Type::MemberPointer:

CreateType(cast<MemberPointerType>(Ty), Unit);

CreateType(cast<AtomicType>(Ty), Unit);

CreateType(cast<BitIntType>(Ty));

CreateType(cast<PipeType>(Ty), Unit);

Type::TemplateSpecialization:

CreateType(cast<TemplateSpecializationType>(Ty), Unit);

Type::HLSLAttributedResource:

CreateType(cast<HLSLAttributedResourceType>(Ty), Unit);

Type::CountAttributed:

Type::Attributed:

Type::BTFTagAttributed:

Type::Adjusted:

Type::DeducedTemplateSpecialization:

Type::Elaborated:

Type::MacroQualified:

Type::SubstTemplateTypeParm:

Type::TypeOfExpr:

Type::Decltype:

Type::PackIndexing:

Type::UnaryTransform:

llvm_unreachable(

);

llvm::DICompositeType *

CGDebugInfo::getOrCreateLimitedType(

*Ty) {

*

= cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));

(

&& !

->isForwardDecl())

llvm::DICompositeType *Res = CreateLimitedType(Ty);

DBuilder.replaceArrays(Res,

?

->getElements() : llvm::DINodeArray());

TypeCache[QTy.getAsOpaquePtr()].reset(Res);

llvm::DICompositeType *CGDebugInfo::CreateLimitedType(

*Ty) {

StringRef RDName = getClassName(RD);

llvm::DIFile *DefUnit =

;

DefUnit = getOrCreateFile(

);

llvm::DIScope *RDContext = getDeclContextDescriptor(RD);

*

= cast_or_null<llvm::DICompositeType>(

(!

|| !

->isCompleteDefinition())

getOrCreateRecordFwdDecl(Ty, RDContext);

Flags = llvm::DINode::FlagZero;

(

CXXRD = dyn_cast<CXXRecordDecl>(RD)) {

Flags |= llvm::DINode::FlagTypePassByReference;

Flags |= llvm::DINode::FlagTypePassByValue;

(!CXXRD->isTrivial())

Flags |= llvm::DINode::FlagNonTrivial;

(CXXRD->isAnonymousStructOrUnion())

Flags |= llvm::DINode::FlagExportSymbols;

dyn_cast<CXXRecordDecl>(CXXRD->getDeclContext()));

llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(

);

llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(

(RealDecl->getTag()) {

llvm_unreachable(

);

llvm::dwarf::DW_TAG_array_type:

llvm::dwarf::DW_TAG_enumeration_type:

llvm::dwarf::DW_TAG_structure_type:

llvm::dwarf::DW_TAG_union_type:

llvm::dwarf::DW_TAG_class_type:

llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));

RegionMap[Ty->

()].reset(RealDecl);

(

*TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))

DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),

CollectCXXTemplateParams(TSpecial, DefUnit));

CGDebugInfo::CollectContainingType(

*RD,

llvm::DICompositeType *RealDecl) {

llvm::DIType *ContainingType =

;

ContainingType = getOrCreateType(

(PBase->getTypeForDecl(), 0),

ContainingType = RealDecl;

DBuilder.replaceVTableHolder(RealDecl, ContainingType);

llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit,

FType,

StringRef Name, uint64_t *Offset) {

llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);

DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize, FieldAlign,

*Offset, llvm::DINode::FlagZero, FieldTy);

*Offset += FieldSize;

CGDebugInfo::collectFunctionDeclProps(

GD, llvm::DIFile *Unit,

StringRef &LinkageName,

llvm::DIScope *&FDContext,

llvm::DINodeArray &TParamsArray,

llvm::DINode::DIFlags &Flags) {

Name = getFunctionName(FD);

Flags |= llvm::DINode::FlagPrototyped;

(LinkageName == Name ||

DebugKind <= llvm::codegenoptions::DebugLineTablesOnly))

LinkageName = StringRef();

(DebugKind == llvm::codegenoptions::DebugLineTablesOnly &&

FDContext = getOrCreateNamespace(NSDecl);

llvm::DIScope *Mod = getParentModuleOrNull(RDecl);

FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU);

Flags |= llvm::DINode::FlagNoReturn;

TParamsArray = CollectFunctionTemplateParams(FD, Unit);

CGDebugInfo::collectVarDeclProps(

*VD, llvm::DIFile *&Unit,

StringRef &Name, StringRef &LinkageName,

llvm::MDTuple *&TemplateParameters,

llvm::DIScope *&VDContext) {

llvm::APInt ConstVal(32, 1);

(LinkageName == Name)

LinkageName = StringRef();

(isa<VarTemplateSpecializationDecl>(VD)) {

llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VD, &*Unit);

TemplateParameters = parameterNodes.get();

TemplateParameters =

;

llvm::DIScope *Mod = getParentModuleOrNull(VD);

VDContext = getContextDescriptor(cast<Decl>(DC), Mod ? Mod : TheCU);

llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(

GD,

llvm::DINodeArray TParamsArray;

StringRef Name, LinkageName;

llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;

llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;

llvm::DIFile *Unit = getOrCreateFile(

);

llvm::DIScope *DContext = Unit;

= getLineNumber(

);

collectFunctionDeclProps(GD, Unit, Name, LinkageName, DContext, TParamsArray,

*FD = cast<FunctionDecl>(GD.

());

ArgTypes.push_back(Parm->getType());

SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;

SPFlags |= llvm::DISubprogram::SPFlagOptimized;

Flags |= getCallSiteRelatedAttrs();

SPFlags |= llvm::DISubprogram::SPFlagDefinition;

DBuilder.createFunction(

DContext, Name, LinkageName, Unit,

,

getOrCreateFunctionType(GD.

(), FnType, Unit), 0, Flags, SPFlags,

TParamsArray.get(), getFunctionDeclaration(FD));

llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(

DContext, Name, LinkageName, Unit,

,

getOrCreateFunctionType(GD.

(), FnType, Unit), 0, Flags, SPFlags,

TParamsArray.get(), getFunctionDeclaration(FD));

FwdDeclReplaceMap.emplace_back(std::piecewise_construct,

std::make_tuple(CanonDecl),

std::make_tuple(SP));

llvm::DISubprogram *CGDebugInfo::getFunctionForwardDeclaration(

GD) {

getFunctionFwdDeclOrStub(GD,

);

llvm::DISubprogram *CGDebugInfo::getFunctionStub(

GD) {

getFunctionFwdDeclOrStub(GD,

);

llvm::DIGlobalVariable *

CGDebugInfo::getGlobalVariableForwardDeclaration(

*VD) {

StringRef Name, LinkageName;

llvm::DIFile *Unit = getOrCreateFile(

);

llvm::DIScope *DContext = Unit;

= getLineNumber(

);

llvm::MDTuple *TemplateParameters =

;

collectVarDeclProps(VD, Unit,

,

, Name, LinkageName, TemplateParameters,

*GV = DBuilder.createTempGlobalVariableFwdDecl(

DContext, Name, LinkageName, Unit,

, getOrCreateType(

, Unit),

FwdDeclReplaceMap.emplace_back(

std::piecewise_construct,

std::make_tuple(

llvm::Metadata *

(GV)));

llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(

*

) {

(

*TD = dyn_cast<TypeDecl>(

))

(I != DeclCache.end()) {

(

*GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(N))

GVE->getVariable();

cast<llvm::DINode>(N);

(IE != ImportedDeclCache.end()) {

N = IE->second;

(

*GVE = dyn_cast_or_null<llvm::DIImportedEntity>(N))

cast<llvm::DINode>(GVE);

dyn_cast_or_null<llvm::DINode>(N);

(

*FD = dyn_cast<FunctionDecl>(

))

getFunctionForwardDeclaration(FD);

(

*VD = dyn_cast<VarDecl>(

))

getGlobalVariableForwardDeclaration(VD);

llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(

*

) {

(!

|| DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)

*FD = dyn_cast<FunctionDecl>(

);

*S = getDeclContextDescriptor(

);

(MI == SPCache.end()) {

CreateCXXMemberFunction(MD, getOrCreateFile(MD->getLocation()),

cast<llvm::DICompositeType>(S));

(MI != SPCache.end()) {

*SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);

(SP && !SP->isDefinition())

(

*NextFD : FD->

()) {

MI = SPCache.find(NextFD->getCanonicalDecl());

(MI != SPCache.end()) {

*SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);

(SP && !SP->isDefinition())

llvm::DISubprogram *CGDebugInfo::getObjCMethodDeclaration(

*

, llvm::DISubroutineType *FnType,

LineNo,

llvm::DINode::DIFlags Flags, llvm::DISubprogram::DISPFlags SPFlags) {

(!

|| DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)

*OMD = dyn_cast<ObjCMethodDecl>(

);

SPFlags |= llvm::DISubprogram::SPFlagObjCDirect;

It = TypeCache.find(QTy.getAsOpaquePtr());

(It == TypeCache.end())

*InterfaceType = cast<llvm::DICompositeType>(It->second);

llvm::DISubprogram *FD = DBuilder.createFunction(

InterfaceType, getObjCMethodName(OMD), StringRef(),

InterfaceType->getFile(), LineNo, FnType, LineNo, Flags, SPFlags);

DBuilder.finalizeSubprogram(FD);

llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(

*

,

(!

|| (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly &&

DBuilder.createSubroutineType(DBuilder.getOrCreateTypeArray({}));

(

*Method = dyn_cast<CXXMethodDecl>(

))

getOrCreateMethodType(Method, F);

(

*OMethod = dyn_cast<ObjCMethodDecl>(

)) {

ResultTy = OMethod->getReturnType();

(OMethod->getClassInterface()->getTypeForDecl(), 0));

Elts.push_back(getOrCreateType(ResultTy, F));

(

*SelfDecl = OMethod->getSelfDecl())

SelfDeclTy = SelfDecl->getType();

(

*FPT = dyn_cast<FunctionProtoType>(FnType))

(!SelfDeclTy.

())

CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F)));

Elts.push_back(DBuilder.createArtificialType(

(

*PI : OMethod->parameters())

Elts.push_back(getOrCreateType(PI->getType(), F));

(OMethod->isVariadic())

Elts.push_back(DBuilder.createUnspecifiedParameter());

llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);

DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,

(

*FD = dyn_cast<FunctionDecl>(

))

(FD->isVariadic()) {

EltTys.push_back(getOrCreateType(FD->getReturnType(), F));

(

*FPT = dyn_cast<FunctionProtoType>(FnType))

EltTys.push_back(getOrCreateType(ParamType, F));

EltTys.push_back(DBuilder.createUnspecifiedParameter());

llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);

DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,

cast<llvm::DISubroutineType>(getOrCreateType(FnType, F));

CC = SrcFnTy->getCallConv();

(

*VD : Args)

ArgTypes.push_back(VD->

());

llvm::Function *Fn,

CurFuncIsThunk) {

StringRef LinkageName;

FnBeginRegionCount.push_back(LexicalBlockStack.size());

HasDecl = (

!=

);

llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;

llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;

llvm::DIFile *Unit = getOrCreateFile(

);

llvm::DIScope *FDContext = Unit;

llvm::DINodeArray TParamsArray;

LinkageName = Fn->getName();

}

(

*FD = dyn_cast<FunctionDecl>(

)) {

FI = SPCache.find(FD->getCanonicalDecl());

(FI != SPCache.end()) {

*SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);

(SP && SP->isDefinition()) {

LexicalBlockStack.emplace_back(SP);

RegionMap[

].reset(SP);

collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,

TParamsArray, Flags);

}

(

*OMD = dyn_cast<ObjCMethodDecl>(

)) {

Name = getObjCMethodName(OMD);

Flags |= llvm::DINode::FlagPrototyped;

}

(isa<VarDecl>(

) &&

Name = Fn->getName();

(isa<BlockDecl>(

))

Flags |= llvm::DINode::FlagPrototyped;

(Name.starts_with(

))

Name = Name.substr(1);

assert((!

|| !isa<VarDecl>(

) ||

);

isa<VarDecl>(

) || isa<CapturedDecl>(

)) {

Flags |= llvm::DINode::FlagArtificial;

Flags |= llvm::DINode::FlagThunk;

(Fn->hasLocalLinkage())

SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;

SPFlags |= llvm::DISubprogram::SPFlagOptimized;

llvm::DINode::DIFlags FlagsForDef = Flags | getCallSiteRelatedAttrs();

llvm::DISubprogram::DISPFlags SPFlagsForDef =

SPFlags | llvm::DISubprogram::SPFlagDefinition;

LineNo = getLineNumber(

.

() ?

: CurLoc);

ScopeLine = getLineNumber(ScopeLoc);

llvm::DISubroutineType *DIFnType = getOrCreateFunctionType(

, FnType, Unit);

llvm::DISubprogram *

=

;

llvm::DINodeArray Annotations =

;

= isa<ObjCMethodDecl>(

)

? getObjCMethodDeclaration(

, DIFnType, LineNo, Flags, SPFlags)

: getFunctionDeclaration(

);

Annotations = CollectBTFDeclTagAnnotations(

);

llvm::DISubprogram *SP = DBuilder.createFunction(

FDContext, Name, LinkageName, Unit, LineNo, DIFnType, ScopeLine,

FlagsForDef, SPFlagsForDef, TParamsArray.get(),

,

,

Fn->setSubprogram(SP);

(HasDecl && isa<FunctionDecl>(

))

LexicalBlockStack.emplace_back(SP);

RegionMap[

].reset(SP);

FnType, llvm::Function *Fn) {

StringRef LinkageName;

llvm::TimeTraceScope TimeScope(

, [&]() {

GetName(

,

);

llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;

llvm::DIFile *Unit = getOrCreateFile(

);

IsDeclForCallSite = Fn ?

:

;

llvm::DIScope *FDContext =

IsDeclForCallSite ? Unit : getDeclContextDescriptor(

);

llvm::DINodeArray TParamsArray;

(isa<FunctionDecl>(

)) {

collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,

TParamsArray, Flags);

}

(

*OMD = dyn_cast<ObjCMethodDecl>(

)) {

Name = getObjCMethodName(OMD);

Flags |= llvm::DINode::FlagPrototyped;

llvm_unreachable(

);

(!Name.empty() && Name[0] ==

)

Name = Name.substr(1);

Flags |= llvm::DINode::FlagArtificial;

LineNo = getLineNumber(

);

ScopeLine = 0;

llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;

SPFlags |= llvm::DISubprogram::SPFlagOptimized;

llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(

);

llvm::DISubroutineType *STy = getOrCreateFunctionType(

, FnType, Unit);

llvm::DISubprogram *SP = DBuilder.createFunction(

FDContext, Name, LinkageName, Unit, LineNo, STy, ScopeLine, Flags,

SPFlags, TParamsArray.get(),

,

, Annotations);

(

*FD = dyn_cast<FunctionDecl>(

)) {

llvm::DITypeRefArray ParamTypes = STy->getTypeArray();

llvm::DINodeArray ParamAnnotations = CollectBTFDeclTagAnnotations(PD);

DBuilder.createParameterVariable(

SP, PD->getName(), ArgNo, Unit, LineNo, ParamTypes[ArgNo],

,

llvm::DINode::FlagZero, ParamAnnotations);

(IsDeclForCallSite)

Fn->setSubprogram(SP);

DBuilder.finalizeSubprogram(SP);

*

= CallOrInvoke->getCalledFunction();

(

->getSubprogram())

(CalleeDecl->

<NoDebugAttr>() ||

getCallSiteRelatedAttrs() == llvm::DINode::FlagZero)

*FD = cast<FunctionDecl>(GD.

());

FI = SPCache.find(FD->getCanonicalDecl());

llvm::DISubprogram *SP =

;

(FI != SPCache.end())

SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);

(!SP || !SP->isDefinition())

SP = getFunctionStub(GD);

FnBeginRegionCount.push_back(LexicalBlockStack.size());

LexicalBlockStack.emplace_back(SP);

assert(CurInlinedAt &&

);

(CurLoc.isInvalid() || CurLoc.isMacroID() || LexicalBlockStack.empty())

llvm::MDNode *

= LexicalBlockStack.back();

Builder.SetCurrentDebugLocation(

llvm::DILocation::get(CGM.

(), getLineNumber(CurLoc),

getColumnNumber(CurLoc),

, CurInlinedAt));

llvm::MDNode *Back =

;

(!LexicalBlockStack.empty())

Back = LexicalBlockStack.back().get();

LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(

cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),

getColumnNumber(CurLoc)));

CGDebugInfo::AppendAddressSpaceXDeref(

std::optional<unsigned> DWARFAddressSpace =

(!DWARFAddressSpace)

.push_back(llvm::dwarf::DW_OP_constu);

.push_back(*DWARFAddressSpace);

.push_back(llvm::dwarf::DW_OP_swap);

.push_back(llvm::dwarf::DW_OP_xderef);

Builder.SetCurrentDebugLocation(llvm::DILocation::get(

LexicalBlockStack.back(), CurInlinedAt));

(DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)

CreateLexicalBlock(

);

assert(!LexicalBlockStack.empty() &&

);

(DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)

LexicalBlockStack.pop_back();

assert(!LexicalBlockStack.empty() &&

);

RCount = FnBeginRegionCount.back();

assert(RCount <= LexicalBlockStack.size() &&

);

(LexicalBlockStack.size() != RCount) {

LexicalBlockStack.pop_back();

FnBeginRegionCount.pop_back();

(Fn && Fn->getSubprogram())

DBuilder.finalizeSubprogram(Fn->getSubprogram());

CGDebugInfo::BlockByRefType

CGDebugInfo::EmitTypeForVarWithBlocksAttr(

*VD,

uint64_t *XOffset) {

uint64_t FieldSize, FieldOffset;

uint32_t FieldAlign;

llvm::DIFile *Unit = getOrCreateFile(VD->

());

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

(HasCopyAndDispose) {

CreateMemberType(Unit, FType,

, &FieldOffset));

CreateMemberType(Unit, FType,

, &FieldOffset));

HasByrefExtendedLayout;

HasByrefExtendedLayout) &&

HasByrefExtendedLayout) {

CreateMemberType(Unit, FType,

, &FieldOffset));

NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;

llvm::APInt pad(32, NumPaddingBytes.

());

EltTys.push_back(CreateMemberType(Unit, FType,

, &FieldOffset));

llvm::DIType *WrappedTy = getOrCreateType(FType, Unit);

*XOffset = FieldOffset;

llvm::DIType *FieldTy = DBuilder.createMemberType(

Unit, VD->

(), Unit, 0, FieldSize, FieldAlign, FieldOffset,

llvm::DINode::FlagZero, WrappedTy);

EltTys.push_back(FieldTy);

FieldOffset += FieldSize;

llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);

{DBuilder.createStructType(Unit,

, Unit, 0, FieldOffset, 0,

llvm::DINode::FlagZero,

, Elements),

llvm::DILocalVariable *CGDebugInfo::EmitDeclare(

*VD,

llvm::Value *Storage,

std::optional<unsigned> ArgNo,

UsePointerValue) {

assert(!LexicalBlockStack.empty() &&

);

(VD->

<NoDebugAttr>())

llvm::DIFile *Unit =

;

(!VarIsArtificial)

(VD->

<BlocksAttr>())

Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;

Ty = getOrCreateType(VD->

(), Unit);

(!VarIsArtificial) {

llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;

(VarIsArtificial)

Flags |= llvm::DINode::FlagArtificial;

AppendAddressSpaceXDeref(AddressSpace,

);

(

*IPD = dyn_cast<ImplicitParamDecl>(VD)) {

Flags |= llvm::DINode::FlagObjectPointer;

}

(

*PVD = dyn_cast<ParmVarDecl>(VD)) {

(PVD->isExplicitObjectParameter())

Flags |= llvm::DINode::FlagObjectPointer;

*

= cast<llvm::DIScope>(LexicalBlockStack.back());

StringRef Name = VD->

();

(!Name.empty()) {

.push_back(llvm::dwarf::DW_OP_plus_uconst);

.push_back(llvm::dwarf::DW_OP_deref);

.push_back(llvm::dwarf::DW_OP_plus_uconst);

}

(

*RT = dyn_cast<RecordType>(VD->

())) {

(

*Field : RD->

()) {

llvm::DIType *FieldTy = getOrCreateType(

->getType(), Unit);

StringRef FieldName =

->getName();

(FieldName.empty() && !isa<RecordType>(

->getType()))

*

= DBuilder.createAutoVariable(

Flags | llvm::DINode::FlagArtificial, FieldAlign);

DBuilder.insertDeclare(Storage,

, DBuilder.createExpression(

),

Builder.GetInsertBlock());

(UsePointerValue) {

assert(!llvm::is_contained(

, llvm::dwarf::DW_OP_deref) &&

);

.push_back(llvm::dwarf::DW_OP_deref);

llvm::DILocalVariable *

=

;

llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(VD);

= DBuilder.createParameterVariable(

, Name, *ArgNo, Unit,

, Ty,

RemapCoroArgToLocalVar = [&]() -> llvm::DILocalVariable * {

(!isa<llvm::DISubprogram>(

) || !

->isDistinct())

= llvm::find_if(CoroutineParameterMappings, [&](

&Pair) {

*StmtPtr =

*

(Pair.second);

(

*DeclStmtPtr = dyn_cast<DeclStmt>(StmtPtr)) {

(VD == dyn_cast_or_null<VarDecl>(

))

(

!= CoroutineParameterMappings.end()) {

Iter2 = llvm::find_if(ParamDbgMappings, [&](

&DbgPair) {

DbgPair.first == PD && DbgPair.second->getScope() ==

;

(Iter2 != ParamDbgMappings.end())

llvm::DILocalVariable *

(Iter2->second);

= RemapCoroArgToLocalVar();

= DBuilder.createAutoVariable(

, Name, Unit,

, Ty,

DBuilder.insertDeclare(Storage,

, DBuilder.createExpression(

),

Builder.GetInsertBlock());

llvm::DILocalVariable *CGDebugInfo::EmitDeclare(

*BD,

llvm::Value *Storage,

std::optional<unsigned> ArgNo,

UsePointerValue) {

assert(!LexicalBlockStack.empty() &&

);

(BD->

<NoDebugAttr>())

llvm::DIFile *Unit = getOrCreateFile(BD->

());

llvm::DIType *Ty = getOrCreateType(BD->

(), Unit);

AppendAddressSpaceXDeref(AddressSpace,

);

(UsePointerValue) {

assert(!llvm::is_contained(

, llvm::dwarf::DW_OP_deref) &&

);

.push_back(llvm::dwarf::DW_OP_deref);

StringRef Name = BD->

();

*

= cast<llvm::DIScope>(LexicalBlockStack.back());

llvm::DILocalVariable *

= DBuilder.createAutoVariable(

llvm::DINode::FlagZero, Align);

(

*FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {

fieldIndex = FD->getFieldIndex();

(FD->isBitField()) {

.push_back(llvm::dwarf::DW_OP_plus_uconst);

? llvm::dwarf::DW_OP_LLVM_extract_bits_sext

: llvm::dwarf::DW_OP_LLVM_extract_bits_zext);

.push_back(std::min((uint64_t)Info.

, TypeSize));

}

(fieldOffset != 0) {

);

.push_back(llvm::dwarf::DW_OP_plus_uconst);

dyn_cast<ArraySubscriptExpr>(BD->

())) {

(

*IL = dyn_cast<IntegerLiteral>(ASE->getIdx())) {

value = IL->getValue().getZExtValue();

.push_back(llvm::dwarf::DW_OP_plus_uconst);

DBuilder.insertDeclare(Storage,

, DBuilder.createExpression(

),

Builder.GetInsertBlock());

llvm::DILocalVariable *

UsePointerValue) {

(

*DD = dyn_cast<DecompositionDecl>(VD)) {

EmitDeclare(B, Storage, std::nullopt, Builder,

EmitDeclare(VD, Storage, std::nullopt, Builder, UsePointerValue);

assert(!LexicalBlockStack.empty() &&

);

*

= cast<llvm::DIScope>(LexicalBlockStack.back());

llvm::DIFile *Unit = getOrCreateFile(

->

());

StringRef Name =

->getName();

DBuilder.insertLabel(L,

, CurInlinedAt),

Builder.GetInsertBlock());

llvm::DIType *CGDebugInfo::CreateSelfType(

&QualTy,

llvm::DIType *CachedTy = getTypeOrNull(QualTy);

DBuilder.createObjectPointerType(Ty,

);

&blockInfo, llvm::Instruction *InsertPoint) {