1 //===--- CGDebugInfo.cpp - Emit Debug Information for a Module ------------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This coordinates the debug information generation while generating code.
11 //===----------------------------------------------------------------------===//
13 #include "CGDebugInfo.h"
16 #include "CGObjCRuntime.h"
17 #include "CGRecordLayout.h"
18 #include "CodeGenFunction.h"
19 #include "CodeGenModule.h"
20 #include "ConstantEmitter.h"
21 #include "clang/AST/ASTContext.h"
22 #include "clang/AST/Attr.h"
23 #include "clang/AST/DeclFriend.h"
24 #include "clang/AST/DeclObjC.h"
25 #include "clang/AST/DeclTemplate.h"
26 #include "clang/AST/Expr.h"
27 #include "clang/AST/RecordLayout.h"
28 #include "clang/Basic/CodeGenOptions.h"
29 #include "clang/Basic/FileManager.h"
30 #include "clang/Basic/SourceManager.h"
31 #include "clang/Basic/Version.h"
32 #include "clang/Frontend/FrontendOptions.h"
33 #include "clang/Lex/HeaderSearchOptions.h"
34 #include "clang/Lex/ModuleMap.h"
35 #include "clang/Lex/PreprocessorOptions.h"
36 #include "llvm/ADT/DenseSet.h"
37 #include "llvm/ADT/SmallVector.h"
38 #include "llvm/ADT/StringExtras.h"
39 #include "llvm/IR/Constants.h"
40 #include "llvm/IR/DataLayout.h"
41 #include "llvm/IR/DerivedTypes.h"
42 #include "llvm/IR/Instructions.h"
43 #include "llvm/IR/Intrinsics.h"
44 #include "llvm/IR/Metadata.h"
45 #include "llvm/IR/Module.h"
46 #include "llvm/Support/FileSystem.h"
47 #include "llvm/Support/MD5.h"
48 #include "llvm/Support/Path.h"
49 #include "llvm/Support/TimeProfiler.h"
50 using namespace clang;
51 using namespace clang::CodeGen;
53 static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx) {
54 auto TI = Ctx.getTypeInfo(Ty);
55 return TI.AlignIsRequired ? TI.Align : 0;
58 static uint32_t getTypeAlignIfRequired(QualType Ty, const ASTContext &Ctx) {
59 return getTypeAlignIfRequired(Ty.getTypePtr(), Ctx);
62 static uint32_t getDeclAlignIfRequired(const Decl *D, const ASTContext &Ctx) {
63 return D->hasAttr<AlignedAttr>() ? D->getMaxAlignment() : 0;
66 CGDebugInfo::CGDebugInfo(CodeGenModule &CGM)
67 : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
68 DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),
69 DBuilder(CGM.getModule()) {
70 for (const auto &KV : CGM.getCodeGenOpts().DebugPrefixMap)
71 DebugPrefixMap[KV.first] = KV.second;
75 CGDebugInfo::~CGDebugInfo() {
76 assert(LexicalBlockStack.empty() &&
77 "Region stack mismatch, stack not empty!");
80 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
81 SourceLocation TemporaryLocation)
83 init(TemporaryLocation);
86 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
88 SourceLocation TemporaryLocation)
90 init(TemporaryLocation, DefaultToEmpty);
93 void ApplyDebugLocation::init(SourceLocation TemporaryLocation,
94 bool DefaultToEmpty) {
95 auto *DI = CGF->getDebugInfo();
101 OriginalLocation = CGF->Builder.getCurrentDebugLocation();
103 if (OriginalLocation && !DI->CGM.getExpressionLocationsEnabled())
106 if (TemporaryLocation.isValid()) {
107 DI->EmitLocation(CGF->Builder, TemporaryLocation);
111 if (DefaultToEmpty) {
112 CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc());
116 // Construct a location that has a valid scope, but no line info.
117 assert(!DI->LexicalBlockStack.empty());
118 CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
119 0, 0, DI->LexicalBlockStack.back(), DI->getInlinedAt()));
122 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E)
124 init(E->getExprLoc());
127 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, llvm::DebugLoc Loc)
129 if (!CGF.getDebugInfo()) {
133 OriginalLocation = CGF.Builder.getCurrentDebugLocation();
135 CGF.Builder.SetCurrentDebugLocation(std::move(Loc));
138 ApplyDebugLocation::~ApplyDebugLocation() {
139 // Query CGF so the location isn't overwritten when location updates are
140 // temporarily disabled (for C++ default function arguments)
142 CGF->Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
145 ApplyInlineDebugLocation::ApplyInlineDebugLocation(CodeGenFunction &CGF,
146 GlobalDecl InlinedFn)
148 if (!CGF.getDebugInfo()) {
152 auto &DI = *CGF.getDebugInfo();
153 SavedLocation = DI.getLocation();
154 assert((DI.getInlinedAt() ==
155 CGF.Builder.getCurrentDebugLocation()->getInlinedAt()) &&
156 "CGDebugInfo and IRBuilder are out of sync");
158 DI.EmitInlineFunctionStart(CGF.Builder, InlinedFn);
161 ApplyInlineDebugLocation::~ApplyInlineDebugLocation() {
164 auto &DI = *CGF->getDebugInfo();
165 DI.EmitInlineFunctionEnd(CGF->Builder);
166 DI.EmitLocation(CGF->Builder, SavedLocation);
169 void CGDebugInfo::setLocation(SourceLocation Loc) {
170 // If the new location isn't valid return.
174 CurLoc = CGM.getContext().getSourceManager().getExpansionLoc(Loc);
176 // If we've changed files in the middle of a lexical scope go ahead
177 // and create a new lexical scope with file node if it's different
178 // from the one in the scope.
179 if (LexicalBlockStack.empty())
182 SourceManager &SM = CGM.getContext().getSourceManager();
183 auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
184 PresumedLoc PCLoc = SM.getPresumedLoc(CurLoc);
185 if (PCLoc.isInvalid() || Scope->getFile() == getOrCreateFile(CurLoc))
188 if (auto *LBF = dyn_cast<llvm::DILexicalBlockFile>(Scope)) {
189 LexicalBlockStack.pop_back();
190 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlockFile(
191 LBF->getScope(), getOrCreateFile(CurLoc)));
192 } else if (isa<llvm::DILexicalBlock>(Scope) ||
193 isa<llvm::DISubprogram>(Scope)) {
194 LexicalBlockStack.pop_back();
195 LexicalBlockStack.emplace_back(
196 DBuilder.createLexicalBlockFile(Scope, getOrCreateFile(CurLoc)));
200 llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(const Decl *D) {
201 llvm::DIScope *Mod = getParentModuleOrNull(D);
202 return getContextDescriptor(cast<Decl>(D->getDeclContext()),
206 llvm::DIScope *CGDebugInfo::getContextDescriptor(const Decl *Context,
207 llvm::DIScope *Default) {
211 auto I = RegionMap.find(Context);
212 if (I != RegionMap.end()) {
213 llvm::Metadata *V = I->second;
214 return dyn_cast_or_null<llvm::DIScope>(V);
218 if (const auto *NSDecl = dyn_cast<NamespaceDecl>(Context))
219 return getOrCreateNamespace(NSDecl);
221 if (const auto *RDecl = dyn_cast<RecordDecl>(Context))
222 if (!RDecl->isDependentType())
223 return getOrCreateType(CGM.getContext().getTypeDeclType(RDecl),
228 PrintingPolicy CGDebugInfo::getPrintingPolicy() const {
229 PrintingPolicy PP = CGM.getContext().getPrintingPolicy();
231 // If we're emitting codeview, it's important to try to match MSVC's naming so
232 // that visualizers written for MSVC will trigger for our class names. In
233 // particular, we can't have spaces between arguments of standard templates
234 // like basic_string and vector, but we must have spaces between consecutive
235 // angle brackets that close nested template argument lists.
236 if (CGM.getCodeGenOpts().EmitCodeView) {
237 PP.MSVCFormatting = true;
238 PP.SplitTemplateClosers = true;
240 // For DWARF, printing rules are underspecified.
241 // SplitTemplateClosers yields better interop with GCC and GDB (PR46052).
242 PP.SplitTemplateClosers = true;
245 // Apply -fdebug-prefix-map.
246 PP.Callbacks = &PrintCB;
250 StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) {
251 assert(FD && "Invalid FunctionDecl!");
252 IdentifierInfo *FII = FD->getIdentifier();
253 FunctionTemplateSpecializationInfo *Info =
254 FD->getTemplateSpecializationInfo();
256 // Emit the unqualified name in normal operation. LLVM and the debugger can
257 // compute the fully qualified name from the scope chain. If we're only
258 // emitting line table info, there won't be any scope chains, so emit the
259 // fully qualified name here so that stack traces are more accurate.
260 // FIXME: Do this when emitting DWARF as well as when emitting CodeView after
261 // evaluating the size impact.
262 bool UseQualifiedName = DebugKind == codegenoptions::DebugLineTablesOnly &&
263 CGM.getCodeGenOpts().EmitCodeView;
265 if (!Info && FII && !UseQualifiedName)
266 return FII->getName();
269 llvm::raw_svector_ostream OS(NS);
270 if (!UseQualifiedName)
273 FD->printQualifiedName(OS, getPrintingPolicy());
275 // Add any template specialization args.
277 const TemplateArgumentList *TArgs = Info->TemplateArguments;
278 printTemplateArgumentList(OS, TArgs->asArray(), getPrintingPolicy());
281 // Copy this name on the side and use its reference.
282 return internString(OS.str());
285 StringRef CGDebugInfo::getObjCMethodName(const ObjCMethodDecl *OMD) {
286 SmallString<256> MethodName;
287 llvm::raw_svector_ostream OS(MethodName);
288 OS << (OMD->isInstanceMethod() ? '-' : '+') << '[';
289 const DeclContext *DC = OMD->getDeclContext();
290 if (const auto *OID = dyn_cast<ObjCImplementationDecl>(DC)) {
291 OS << OID->getName();
292 } else if (const auto *OID = dyn_cast<ObjCInterfaceDecl>(DC)) {
293 OS << OID->getName();
294 } else if (const auto *OC = dyn_cast<ObjCCategoryDecl>(DC)) {
295 if (OC->IsClassExtension()) {
296 OS << OC->getClassInterface()->getName();
298 OS << OC->getIdentifier()->getNameStart() << '('
299 << OC->getIdentifier()->getNameStart() << ')';
301 } else if (const auto *OCD = dyn_cast<ObjCCategoryImplDecl>(DC)) {
302 OS << OCD->getClassInterface()->getName() << '(' << OCD->getName() << ')';
304 OS << ' ' << OMD->getSelector().getAsString() << ']';
306 return internString(OS.str());
309 StringRef CGDebugInfo::getSelectorName(Selector S) {
310 return internString(S.getAsString());
313 StringRef CGDebugInfo::getClassName(const RecordDecl *RD) {
314 if (isa<ClassTemplateSpecializationDecl>(RD)) {
315 SmallString<128> Name;
316 llvm::raw_svector_ostream OS(Name);
317 PrintingPolicy PP = getPrintingPolicy();
318 PP.PrintCanonicalTypes = true;
319 RD->getNameForDiagnostic(OS, PP,
320 /*Qualified*/ false);
322 // Copy this name on the side and use its reference.
323 return internString(Name);
326 // quick optimization to avoid having to intern strings that are already
327 // stored reliably elsewhere
328 if (const IdentifierInfo *II = RD->getIdentifier())
329 return II->getName();
331 // The CodeView printer in LLVM wants to see the names of unnamed types: it is
332 // used to reconstruct the fully qualified type names.
333 if (CGM.getCodeGenOpts().EmitCodeView) {
334 if (const TypedefNameDecl *D = RD->getTypedefNameForAnonDecl()) {
335 assert(RD->getDeclContext() == D->getDeclContext() &&
336 "Typedef should not be in another decl context!");
337 assert(D->getDeclName().getAsIdentifierInfo() &&
338 "Typedef was not named!");
339 return D->getDeclName().getAsIdentifierInfo()->getName();
342 if (CGM.getLangOpts().CPlusPlus) {
345 ASTContext &Context = CGM.getContext();
346 if (const DeclaratorDecl *DD = Context.getDeclaratorForUnnamedTagDecl(RD))
347 // Anonymous types without a name for linkage purposes have their
348 // declarator mangled in if they have one.
349 Name = DD->getName();
350 else if (const TypedefNameDecl *TND =
351 Context.getTypedefNameForUnnamedTagDecl(RD))
352 // Anonymous types without a name for linkage purposes have their
353 // associate typedef mangled in if they have one.
354 Name = TND->getName();
357 SmallString<256> UnnamedType("<unnamed-type-");
360 return internString(UnnamedType);
368 Optional<llvm::DIFile::ChecksumKind>
369 CGDebugInfo::computeChecksum(FileID FID, SmallString<32> &Checksum) const {
372 if (!CGM.getCodeGenOpts().EmitCodeView &&
373 CGM.getCodeGenOpts().DwarfVersion < 5)
376 SourceManager &SM = CGM.getContext().getSourceManager();
378 const llvm::MemoryBuffer *MemBuffer = SM.getBuffer(FID, &Invalid);
383 llvm::MD5::MD5Result Result;
385 Hash.update(MemBuffer->getBuffer());
388 Hash.stringifyResult(Result, Checksum);
389 return llvm::DIFile::CSK_MD5;
392 Optional<StringRef> CGDebugInfo::getSource(const SourceManager &SM,
394 if (!CGM.getCodeGenOpts().EmbedSource)
397 bool SourceInvalid = false;
398 StringRef Source = SM.getBufferData(FID, &SourceInvalid);
406 llvm::DIFile *CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
408 // If Location is not valid then use main input file.
409 return TheCU->getFile();
411 SourceManager &SM = CGM.getContext().getSourceManager();
412 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
414 StringRef FileName = PLoc.getFilename();
415 if (PLoc.isInvalid() || FileName.empty())
416 // If the location is not valid then use main input file.
417 return TheCU->getFile();
419 // Cache the results.
420 auto It = DIFileCache.find(FileName.data());
421 if (It != DIFileCache.end()) {
422 // Verify that the information still exists.
423 if (llvm::Metadata *V = It->second)
424 return cast<llvm::DIFile>(V);
427 SmallString<32> Checksum;
429 // Compute the checksum if possible. If the location is affected by a #line
430 // directive that refers to a file, PLoc will have an invalid FileID, and we
431 // will correctly get no checksum.
432 Optional<llvm::DIFile::ChecksumKind> CSKind =
433 computeChecksum(PLoc.getFileID(), Checksum);
434 Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo;
436 CSInfo.emplace(*CSKind, Checksum);
437 return createFile(FileName, CSInfo, getSource(SM, SM.getFileID(Loc)));
441 CGDebugInfo::createFile(StringRef FileName,
442 Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo,
443 Optional<StringRef> Source) {
446 std::string RemappedFile = remapDIPath(FileName);
447 std::string CurDir = remapDIPath(getCurrentDirname());
448 SmallString<128> DirBuf;
449 SmallString<128> FileBuf;
450 if (llvm::sys::path::is_absolute(RemappedFile)) {
451 // Strip the common prefix (if it is more than just "/") from current
452 // directory and FileName for a more space-efficient encoding.
453 auto FileIt = llvm::sys::path::begin(RemappedFile);
454 auto FileE = llvm::sys::path::end(RemappedFile);
455 auto CurDirIt = llvm::sys::path::begin(CurDir);
456 auto CurDirE = llvm::sys::path::end(CurDir);
457 for (; CurDirIt != CurDirE && *CurDirIt == *FileIt; ++CurDirIt, ++FileIt)
458 llvm::sys::path::append(DirBuf, *CurDirIt);
459 if (std::distance(llvm::sys::path::begin(CurDir), CurDirIt) == 1) {
460 // Don't strip the common prefix if it is only the root "/"
461 // since that would make LLVM diagnostic locations confusing.
465 for (; FileIt != FileE; ++FileIt)
466 llvm::sys::path::append(FileBuf, *FileIt);
474 llvm::DIFile *F = DBuilder.createFile(File, Dir, CSInfo, Source);
475 DIFileCache[FileName.data()].reset(F);
479 std::string CGDebugInfo::remapDIPath(StringRef Path) const {
480 if (DebugPrefixMap.empty())
483 SmallString<256> P = Path;
484 for (const auto &Entry : DebugPrefixMap)
485 if (llvm::sys::path::replace_path_prefix(P, Entry.first, Entry.second))
487 return P.str().str();
490 unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) {
491 if (Loc.isInvalid() && CurLoc.isInvalid())
493 SourceManager &SM = CGM.getContext().getSourceManager();
494 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
495 return PLoc.isValid() ? PLoc.getLine() : 0;
498 unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc, bool Force) {
499 // We may not want column information at all.
500 if (!Force && !CGM.getCodeGenOpts().DebugColumnInfo)
503 // If the location is invalid then use the current column.
504 if (Loc.isInvalid() && CurLoc.isInvalid())
506 SourceManager &SM = CGM.getContext().getSourceManager();
507 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
508 return PLoc.isValid() ? PLoc.getColumn() : 0;
511 StringRef CGDebugInfo::getCurrentDirname() {
512 if (!CGM.getCodeGenOpts().DebugCompilationDir.empty())
513 return CGM.getCodeGenOpts().DebugCompilationDir;
515 if (!CWDName.empty())
517 SmallString<256> CWD;
518 llvm::sys::fs::current_path(CWD);
519 return CWDName = internString(CWD);
522 void CGDebugInfo::CreateCompileUnit() {
523 SmallString<32> Checksum;
524 Optional<llvm::DIFile::ChecksumKind> CSKind;
525 Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo;
527 // Should we be asking the SourceManager for the main file name, instead of
528 // accepting it as an argument? This just causes the main file name to
529 // mismatch with source locations and create extra lexical scopes or
530 // mismatched debug info (a CU with a DW_AT_file of "-", because that's what
531 // the driver passed, but functions/other things have DW_AT_file of "<stdin>"
532 // because that's what the SourceManager says)
534 // Get absolute path name.
535 SourceManager &SM = CGM.getContext().getSourceManager();
536 std::string MainFileName = CGM.getCodeGenOpts().MainFileName;
537 if (MainFileName.empty())
538 MainFileName = "<stdin>";
540 // The main file name provided via the "-main-file-name" option contains just
541 // the file name itself with no path information. This file name may have had
542 // a relative path, so we look into the actual file entry for the main
543 // file to determine the real absolute path for the file.
544 std::string MainFileDir;
545 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
546 MainFileDir = std::string(MainFile->getDir()->getName());
547 if (!llvm::sys::path::is_absolute(MainFileName)) {
548 llvm::SmallString<1024> MainFileDirSS(MainFileDir);
549 llvm::sys::path::append(MainFileDirSS, MainFileName);
551 std::string(llvm::sys::path::remove_leading_dotslash(MainFileDirSS));
553 // If the main file name provided is identical to the input file name, and
554 // if the input file is a preprocessed source, use the module name for
555 // debug info. The module name comes from the name specified in the first
556 // linemarker if the input is a preprocessed source.
557 if (MainFile->getName() == MainFileName &&
558 FrontendOptions::getInputKindForExtension(
559 MainFile->getName().rsplit('.').second)
561 MainFileName = CGM.getModule().getName().str();
563 CSKind = computeChecksum(SM.getMainFileID(), Checksum);
566 llvm::dwarf::SourceLanguage LangTag;
567 const LangOptions &LO = CGM.getLangOpts();
570 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
571 else if (LO.CPlusPlus14)
572 LangTag = llvm::dwarf::DW_LANG_C_plus_plus_14;
573 else if (LO.CPlusPlus11)
574 LangTag = llvm::dwarf::DW_LANG_C_plus_plus_11;
576 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
577 } else if (LO.ObjC) {
578 LangTag = llvm::dwarf::DW_LANG_ObjC;
579 } else if (LO.RenderScript) {
580 LangTag = llvm::dwarf::DW_LANG_GOOGLE_RenderScript;
582 LangTag = llvm::dwarf::DW_LANG_C99;
584 LangTag = llvm::dwarf::DW_LANG_C89;
587 std::string Producer = getClangFullVersion();
589 // Figure out which version of the ObjC runtime we have.
590 unsigned RuntimeVers = 0;
592 RuntimeVers = LO.ObjCRuntime.isNonFragile() ? 2 : 1;
594 llvm::DICompileUnit::DebugEmissionKind EmissionKind;
596 case codegenoptions::NoDebugInfo:
597 case codegenoptions::LocTrackingOnly:
598 EmissionKind = llvm::DICompileUnit::NoDebug;
600 case codegenoptions::DebugLineTablesOnly:
601 EmissionKind = llvm::DICompileUnit::LineTablesOnly;
603 case codegenoptions::DebugDirectivesOnly:
604 EmissionKind = llvm::DICompileUnit::DebugDirectivesOnly;
606 case codegenoptions::DebugInfoConstructor:
607 case codegenoptions::LimitedDebugInfo:
608 case codegenoptions::FullDebugInfo:
609 EmissionKind = llvm::DICompileUnit::FullDebug;
614 auto &CGOpts = CGM.getCodeGenOpts();
615 // The DIFile used by the CU is distinct from the main source
616 // file. Its directory part specifies what becomes the
617 // DW_AT_comp_dir (the compilation directory), even if the source
618 // file was specified with an absolute path.
620 CSInfo.emplace(*CSKind, Checksum);
621 llvm::DIFile *CUFile = DBuilder.createFile(
622 remapDIPath(MainFileName), remapDIPath(getCurrentDirname()), CSInfo,
623 getSource(SM, SM.getMainFileID()));
625 StringRef Sysroot, SDK;
626 if (CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB) {
627 Sysroot = CGM.getHeaderSearchOpts().Sysroot;
628 auto B = llvm::sys::path::rbegin(Sysroot);
629 auto E = llvm::sys::path::rend(Sysroot);
630 auto It = std::find_if(B, E, [](auto SDK) { return SDK.endswith(".sdk"); });
635 // Create new compile unit.
636 TheCU = DBuilder.createCompileUnit(
637 LangTag, CUFile, CGOpts.EmitVersionIdentMetadata ? Producer : "",
638 LO.Optimize || CGOpts.PrepareForLTO || CGOpts.PrepareForThinLTO,
639 CGOpts.DwarfDebugFlags, RuntimeVers, CGOpts.SplitDwarfFile, EmissionKind,
640 DwoId, CGOpts.SplitDwarfInlining, CGOpts.DebugInfoForProfiling,
641 CGM.getTarget().getTriple().isNVPTX()
642 ? llvm::DICompileUnit::DebugNameTableKind::None
643 : static_cast<llvm::DICompileUnit::DebugNameTableKind>(
644 CGOpts.DebugNameTable),
645 CGOpts.DebugRangesBaseAddress, remapDIPath(Sysroot), SDK);
648 llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
649 llvm::dwarf::TypeKind Encoding;
651 switch (BT->getKind()) {
652 #define BUILTIN_TYPE(Id, SingletonId)
653 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
654 #include "clang/AST/BuiltinTypes.def"
655 case BuiltinType::Dependent:
656 llvm_unreachable("Unexpected builtin type");
657 case BuiltinType::NullPtr:
658 return DBuilder.createNullPtrType();
659 case BuiltinType::Void:
661 case BuiltinType::ObjCClass:
664 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
665 "objc_class", TheCU, TheCU->getFile(), 0);
667 case BuiltinType::ObjCId: {
668 // typedef struct objc_class *Class;
669 // typedef struct objc_object {
678 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
679 "objc_class", TheCU, TheCU->getFile(), 0);
681 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
683 auto *ISATy = DBuilder.createPointerType(ClassTy, Size);
685 ObjTy = DBuilder.createStructType(TheCU, "objc_object", TheCU->getFile(), 0,
686 0, 0, llvm::DINode::FlagZero, nullptr,
687 llvm::DINodeArray());
689 DBuilder.replaceArrays(
690 ObjTy, DBuilder.getOrCreateArray(&*DBuilder.createMemberType(
691 ObjTy, "isa", TheCU->getFile(), 0, Size, 0, 0,
692 llvm::DINode::FlagZero, ISATy)));
695 case BuiltinType::ObjCSel: {
697 SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
698 "objc_selector", TheCU,
699 TheCU->getFile(), 0);
703 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
704 case BuiltinType::Id: \
705 return getOrCreateStructPtrType("opencl_" #ImgType "_" #Suffix "_t", \
707 #include "clang/Basic/OpenCLImageTypes.def"
708 case BuiltinType::OCLSampler:
709 return getOrCreateStructPtrType("opencl_sampler_t", OCLSamplerDITy);
710 case BuiltinType::OCLEvent:
711 return getOrCreateStructPtrType("opencl_event_t", OCLEventDITy);
712 case BuiltinType::OCLClkEvent:
713 return getOrCreateStructPtrType("opencl_clk_event_t", OCLClkEventDITy);
714 case BuiltinType::OCLQueue:
715 return getOrCreateStructPtrType("opencl_queue_t", OCLQueueDITy);
716 case BuiltinType::OCLReserveID:
717 return getOrCreateStructPtrType("opencl_reserve_id_t", OCLReserveIDDITy);
718 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
719 case BuiltinType::Id: \
720 return getOrCreateStructPtrType("opencl_" #ExtType, Id##Ty);
721 #include "clang/Basic/OpenCLExtensionTypes.def"
722 // TODO: real support for SVE types requires more infrastructure
723 // to be added first. The types have a variable length and are
724 // represented in debug info as types whose length depends on a
725 // target-specific pseudo register.
726 #define SVE_TYPE(Name, Id, SingletonId) \
727 case BuiltinType::Id:
728 #include "clang/Basic/AArch64SVEACLETypes.def"
730 unsigned DiagID = CGM.getDiags().getCustomDiagID(
731 DiagnosticsEngine::Error,
732 "cannot yet generate debug info for SVE type '%0'");
733 auto Name = BT->getName(CGM.getContext().getPrintingPolicy());
734 CGM.getDiags().Report(DiagID) << Name;
735 // Return something safe.
736 return CreateType(cast<const BuiltinType>(CGM.getContext().IntTy));
739 case BuiltinType::UChar:
740 case BuiltinType::Char_U:
741 Encoding = llvm::dwarf::DW_ATE_unsigned_char;
743 case BuiltinType::Char_S:
744 case BuiltinType::SChar:
745 Encoding = llvm::dwarf::DW_ATE_signed_char;
747 case BuiltinType::Char8:
748 case BuiltinType::Char16:
749 case BuiltinType::Char32:
750 Encoding = llvm::dwarf::DW_ATE_UTF;
752 case BuiltinType::UShort:
753 case BuiltinType::UInt:
754 case BuiltinType::UInt128:
755 case BuiltinType::ULong:
756 case BuiltinType::WChar_U:
757 case BuiltinType::ULongLong:
758 Encoding = llvm::dwarf::DW_ATE_unsigned;
760 case BuiltinType::Short:
761 case BuiltinType::Int:
762 case BuiltinType::Int128:
763 case BuiltinType::Long:
764 case BuiltinType::WChar_S:
765 case BuiltinType::LongLong:
766 Encoding = llvm::dwarf::DW_ATE_signed;
768 case BuiltinType::Bool:
769 Encoding = llvm::dwarf::DW_ATE_boolean;
771 case BuiltinType::Half:
772 case BuiltinType::Float:
773 case BuiltinType::LongDouble:
774 case BuiltinType::Float16:
775 case BuiltinType::BFloat16:
776 case BuiltinType::Float128:
777 case BuiltinType::Double:
778 // FIXME: For targets where long double and __float128 have the same size,
779 // they are currently indistinguishable in the debugger without some
780 // special treatment. However, there is currently no consensus on encoding
781 // and this should be updated once a DWARF encoding exists for distinct
782 // floating point types of the same size.
783 Encoding = llvm::dwarf::DW_ATE_float;
785 case BuiltinType::ShortAccum:
786 case BuiltinType::Accum:
787 case BuiltinType::LongAccum:
788 case BuiltinType::ShortFract:
789 case BuiltinType::Fract:
790 case BuiltinType::LongFract:
791 case BuiltinType::SatShortFract:
792 case BuiltinType::SatFract:
793 case BuiltinType::SatLongFract:
794 case BuiltinType::SatShortAccum:
795 case BuiltinType::SatAccum:
796 case BuiltinType::SatLongAccum:
797 Encoding = llvm::dwarf::DW_ATE_signed_fixed;
799 case BuiltinType::UShortAccum:
800 case BuiltinType::UAccum:
801 case BuiltinType::ULongAccum:
802 case BuiltinType::UShortFract:
803 case BuiltinType::UFract:
804 case BuiltinType::ULongFract:
805 case BuiltinType::SatUShortAccum:
806 case BuiltinType::SatUAccum:
807 case BuiltinType::SatULongAccum:
808 case BuiltinType::SatUShortFract:
809 case BuiltinType::SatUFract:
810 case BuiltinType::SatULongFract:
811 Encoding = llvm::dwarf::DW_ATE_unsigned_fixed;
815 switch (BT->getKind()) {
816 case BuiltinType::Long:
819 case BuiltinType::LongLong:
820 BTName = "long long int";
822 case BuiltinType::ULong:
823 BTName = "long unsigned int";
825 case BuiltinType::ULongLong:
826 BTName = "long long unsigned int";
829 BTName = BT->getName(CGM.getLangOpts());
832 // Bit size and offset of the type.
833 uint64_t Size = CGM.getContext().getTypeSize(BT);
834 return DBuilder.createBasicType(BTName, Size, Encoding);
837 llvm::DIType *CGDebugInfo::CreateType(const AutoType *Ty) {
838 return DBuilder.createUnspecifiedType("auto");
841 llvm::DIType *CGDebugInfo::CreateType(const ExtIntType *Ty) {
843 StringRef Name = Ty->isUnsigned() ? "unsigned _ExtInt" : "_ExtInt";
844 llvm::dwarf::TypeKind Encoding = Ty->isUnsigned()
845 ? llvm::dwarf::DW_ATE_unsigned
846 : llvm::dwarf::DW_ATE_signed;
848 return DBuilder.createBasicType(Name, CGM.getContext().getTypeSize(Ty),
852 llvm::DIType *CGDebugInfo::CreateType(const ComplexType *Ty) {
853 // Bit size and offset of the type.
854 llvm::dwarf::TypeKind Encoding = llvm::dwarf::DW_ATE_complex_float;
855 if (Ty->isComplexIntegerType())
856 Encoding = llvm::dwarf::DW_ATE_lo_user;
858 uint64_t Size = CGM.getContext().getTypeSize(Ty);
859 return DBuilder.createBasicType("complex", Size, Encoding);
862 llvm::DIType *CGDebugInfo::CreateQualifiedType(QualType Ty,
863 llvm::DIFile *Unit) {
864 QualifierCollector Qc;
865 const Type *T = Qc.strip(Ty);
867 // Ignore these qualifiers for now.
868 Qc.removeObjCGCAttr();
869 Qc.removeAddressSpace();
870 Qc.removeObjCLifetime();
872 // We will create one Derived type for one qualifier and recurse to handle any
874 llvm::dwarf::Tag Tag;
876 Tag = llvm::dwarf::DW_TAG_const_type;
878 } else if (Qc.hasVolatile()) {
879 Tag = llvm::dwarf::DW_TAG_volatile_type;
881 } else if (Qc.hasRestrict()) {
882 Tag = llvm::dwarf::DW_TAG_restrict_type;
885 assert(Qc.empty() && "Unknown type qualifier for debug info");
886 return getOrCreateType(QualType(T, 0), Unit);
889 auto *FromTy = getOrCreateType(Qc.apply(CGM.getContext(), T), Unit);
891 // No need to fill in the Name, Line, Size, Alignment, Offset in case of
892 // CVR derived types.
893 return DBuilder.createQualifiedType(Tag, FromTy);
896 llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty,
897 llvm::DIFile *Unit) {
899 // The frontend treats 'id' as a typedef to an ObjCObjectType,
900 // whereas 'id<protocol>' is treated as an ObjCPointerType. For the
901 // debug info, we want to emit 'id' in both cases.
902 if (Ty->isObjCQualifiedIdType())
903 return getOrCreateType(CGM.getContext().getObjCIdType(), Unit);
905 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
906 Ty->getPointeeType(), Unit);
909 llvm::DIType *CGDebugInfo::CreateType(const PointerType *Ty,
910 llvm::DIFile *Unit) {
911 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
912 Ty->getPointeeType(), Unit);
915 /// \return whether a C++ mangling exists for the type defined by TD.
916 static bool hasCXXMangling(const TagDecl *TD, llvm::DICompileUnit *TheCU) {
917 switch (TheCU->getSourceLanguage()) {
918 case llvm::dwarf::DW_LANG_C_plus_plus:
919 case llvm::dwarf::DW_LANG_C_plus_plus_11:
920 case llvm::dwarf::DW_LANG_C_plus_plus_14:
922 case llvm::dwarf::DW_LANG_ObjC_plus_plus:
923 return isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD);
929 // Determines if the debug info for this tag declaration needs a type
930 // identifier. The purpose of the unique identifier is to deduplicate type
931 // information for identical types across TUs. Because of the C++ one definition
932 // rule (ODR), it is valid to assume that the type is defined the same way in
933 // every TU and its debug info is equivalent.
935 // C does not have the ODR, and it is common for codebases to contain multiple
936 // different definitions of a struct with the same name in different TUs.
937 // Therefore, if the type doesn't have a C++ mangling, don't give it an
938 // identifer. Type information in C is smaller and simpler than C++ type
939 // information, so the increase in debug info size is negligible.
941 // If the type is not externally visible, it should be unique to the current TU,
942 // and should not need an identifier to participate in type deduplication.
943 // However, when emitting CodeView, the format internally uses these
944 // unique type name identifers for references between debug info. For example,
945 // the method of a class in an anonymous namespace uses the identifer to refer
946 // to its parent class. The Microsoft C++ ABI attempts to provide unique names
947 // for such types, so when emitting CodeView, always use identifiers for C++
948 // types. This may create problems when attempting to emit CodeView when the MS
949 // C++ ABI is not in use.
950 static bool needsTypeIdentifier(const TagDecl *TD, CodeGenModule &CGM,
951 llvm::DICompileUnit *TheCU) {
952 // We only add a type identifier for types with C++ name mangling.
953 if (!hasCXXMangling(TD, TheCU))
956 // Externally visible types with C++ mangling need a type identifier.
957 if (TD->isExternallyVisible())
960 // CodeView types with C++ mangling need a type identifier.
961 if (CGM.getCodeGenOpts().EmitCodeView)
967 // Returns a unique type identifier string if one exists, or an empty string.
968 static SmallString<256> getTypeIdentifier(const TagType *Ty, CodeGenModule &CGM,
969 llvm::DICompileUnit *TheCU) {
970 SmallString<256> Identifier;
971 const TagDecl *TD = Ty->getDecl();
973 if (!needsTypeIdentifier(TD, CGM, TheCU))
975 if (const auto *RD = dyn_cast<CXXRecordDecl>(TD))
976 if (RD->getDefinition())
977 if (RD->isDynamicClass() &&
978 CGM.getVTableLinkage(RD) == llvm::GlobalValue::ExternalLinkage)
981 // TODO: This is using the RTTI name. Is there a better way to get
982 // a unique string for a type?
983 llvm::raw_svector_ostream Out(Identifier);
984 CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(QualType(Ty, 0), Out);
988 /// \return the appropriate DWARF tag for a composite type.
989 static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD) {
990 llvm::dwarf::Tag Tag;
991 if (RD->isStruct() || RD->isInterface())
992 Tag = llvm::dwarf::DW_TAG_structure_type;
993 else if (RD->isUnion())
994 Tag = llvm::dwarf::DW_TAG_union_type;
996 // FIXME: This could be a struct type giving a default visibility different
997 // than C++ class type, but needs llvm metadata changes first.
998 assert(RD->isClass());
999 Tag = llvm::dwarf::DW_TAG_class_type;
1004 llvm::DICompositeType *
1005 CGDebugInfo::getOrCreateRecordFwdDecl(const RecordType *Ty,
1006 llvm::DIScope *Ctx) {
1007 const RecordDecl *RD = Ty->getDecl();
1008 if (llvm::DIType *T = getTypeOrNull(CGM.getContext().getRecordType(RD)))
1009 return cast<llvm::DICompositeType>(T);
1010 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
1011 unsigned Line = getLineNumber(RD->getLocation());
1012 StringRef RDName = getClassName(RD);
1017 llvm::DINode::DIFlags Flags = llvm::DINode::FlagFwdDecl;
1019 // Add flag to nontrivial forward declarations. To be consistent with MSVC,
1020 // add the flag if a record has no definition because we don't know whether
1021 // it will be trivial or not.
1022 if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1023 if (!CXXRD->hasDefinition() ||
1024 (CXXRD->hasDefinition() && !CXXRD->isTrivial()))
1025 Flags |= llvm::DINode::FlagNonTrivial;
1028 SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU);
1029 llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
1030 getTagForRecord(RD), RDName, Ctx, DefUnit, Line, 0, Size, Align, Flags,
1032 if (CGM.getCodeGenOpts().DebugFwdTemplateParams)
1033 if (auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
1034 DBuilder.replaceArrays(RetTy, llvm::DINodeArray(),
1035 CollectCXXTemplateParams(TSpecial, DefUnit));
1036 ReplaceMap.emplace_back(
1037 std::piecewise_construct, std::make_tuple(Ty),
1038 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
1042 llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
1045 llvm::DIFile *Unit) {
1046 // Bit size, align and offset of the type.
1047 // Size is always the size of a pointer. We can't use getTypeSize here
1048 // because that does not return the correct value for references.
1049 unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(PointeeTy);
1050 uint64_t Size = CGM.getTarget().getPointerWidth(AddressSpace);
1051 auto Align = getTypeAlignIfRequired(Ty, CGM.getContext());
1052 Optional<unsigned> DWARFAddressSpace =
1053 CGM.getTarget().getDWARFAddressSpace(AddressSpace);
1055 if (Tag == llvm::dwarf::DW_TAG_reference_type ||
1056 Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)
1057 return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit),
1058 Size, Align, DWARFAddressSpace);
1060 return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
1061 Align, DWARFAddressSpace);
1064 llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
1065 llvm::DIType *&Cache) {
1068 Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
1069 TheCU, TheCU->getFile(), 0);
1070 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
1071 Cache = DBuilder.createPointerType(Cache, Size);
1075 uint64_t CGDebugInfo::collectDefaultElementTypesForBlockPointer(
1076 const BlockPointerType *Ty, llvm::DIFile *Unit, llvm::DIDerivedType *DescTy,
1077 unsigned LineNo, SmallVectorImpl<llvm::Metadata *> &EltTys) {
1080 // Advanced by calls to CreateMemberType in increments of FType, then
1081 // returned as the overall size of the default elements.
1082 uint64_t FieldOffset = 0;
1084 // Blocks in OpenCL have unique constraints which make the standard fields
1085 // redundant while requiring size and align fields for enqueue_kernel. See
1086 // initializeForBlockHeader in CGBlocks.cpp
1087 if (CGM.getLangOpts().OpenCL) {
1088 FType = CGM.getContext().IntTy;
1089 EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset));
1090 EltTys.push_back(CreateMemberType(Unit, FType, "__align", &FieldOffset));
1092 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
1093 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
1094 FType = CGM.getContext().IntTy;
1095 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
1096 EltTys.push_back(CreateMemberType(Unit, FType, "__reserved", &FieldOffset));
1097 FType = CGM.getContext().getPointerType(Ty->getPointeeType());
1098 EltTys.push_back(CreateMemberType(Unit, FType, "__FuncPtr", &FieldOffset));
1099 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
1100 uint64_t FieldSize = CGM.getContext().getTypeSize(Ty);
1101 uint32_t FieldAlign = CGM.getContext().getTypeAlign(Ty);
1102 EltTys.push_back(DBuilder.createMemberType(
1103 Unit, "__descriptor", nullptr, LineNo, FieldSize, FieldAlign,
1104 FieldOffset, llvm::DINode::FlagZero, DescTy));
1105 FieldOffset += FieldSize;
1111 llvm::DIType *CGDebugInfo::CreateType(const BlockPointerType *Ty,
1112 llvm::DIFile *Unit) {
1113 SmallVector<llvm::Metadata *, 8> EltTys;
1115 uint64_t FieldOffset;
1116 llvm::DINodeArray Elements;
1119 FType = CGM.getContext().UnsignedLongTy;
1120 EltTys.push_back(CreateMemberType(Unit, FType, "reserved", &FieldOffset));
1121 EltTys.push_back(CreateMemberType(Unit, FType, "Size", &FieldOffset));
1123 Elements = DBuilder.getOrCreateArray(EltTys);
1126 llvm::DINode::DIFlags Flags = llvm::DINode::FlagAppleBlock;
1129 DBuilder.createStructType(Unit, "__block_descriptor", nullptr, 0,
1130 FieldOffset, 0, Flags, nullptr, Elements);
1132 // Bit size, align and offset of the type.
1133 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1135 auto *DescTy = DBuilder.createPointerType(EltTy, Size);
1137 FieldOffset = collectDefaultElementTypesForBlockPointer(Ty, Unit, DescTy,
1140 Elements = DBuilder.getOrCreateArray(EltTys);
1142 // The __block_literal_generic structs are marked with a special
1143 // DW_AT_APPLE_BLOCK attribute and are an implementation detail only
1144 // the debugger needs to know about. To allow type uniquing, emit
1145 // them without a name or a location.
1146 EltTy = DBuilder.createStructType(Unit, "", nullptr, 0, FieldOffset, 0,
1147 Flags, nullptr, Elements);
1149 return DBuilder.createPointerType(EltTy, Size);
1152 llvm::DIType *CGDebugInfo::CreateType(const TemplateSpecializationType *Ty,
1153 llvm::DIFile *Unit) {
1154 assert(Ty->isTypeAlias());
1155 llvm::DIType *Src = getOrCreateType(Ty->getAliasedType(), Unit);
1158 cast<TypeAliasTemplateDecl>(Ty->getTemplateName().getAsTemplateDecl())
1159 ->getTemplatedDecl();
1161 if (AliasDecl->hasAttr<NoDebugAttr>())
1164 SmallString<128> NS;
1165 llvm::raw_svector_ostream OS(NS);
1166 Ty->getTemplateName().print(OS, getPrintingPolicy(), /*qualified*/ false);
1167 printTemplateArgumentList(OS, Ty->template_arguments(), getPrintingPolicy());
1169 SourceLocation Loc = AliasDecl->getLocation();
1170 return DBuilder.createTypedef(Src, OS.str(), getOrCreateFile(Loc),
1172 getDeclContextDescriptor(AliasDecl));
1175 llvm::DIType *CGDebugInfo::CreateType(const TypedefType *Ty,
1176 llvm::DIFile *Unit) {
1177 llvm::DIType *Underlying =
1178 getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit);
1180 if (Ty->getDecl()->hasAttr<NoDebugAttr>())
1183 // We don't set size information, but do specify where the typedef was
1185 SourceLocation Loc = Ty->getDecl()->getLocation();
1187 uint32_t Align = getDeclAlignIfRequired(Ty->getDecl(), CGM.getContext());
1188 // Typedefs are derived from some other type.
1189 return DBuilder.createTypedef(Underlying, Ty->getDecl()->getName(),
1190 getOrCreateFile(Loc), getLineNumber(Loc),
1191 getDeclContextDescriptor(Ty->getDecl()), Align);
1194 static unsigned getDwarfCC(CallingConv CC) {
1197 // Avoid emitting DW_AT_calling_convention if the C convention was used.
1201 return llvm::dwarf::DW_CC_BORLAND_stdcall;
1202 case CC_X86FastCall:
1203 return llvm::dwarf::DW_CC_BORLAND_msfastcall;
1204 case CC_X86ThisCall:
1205 return llvm::dwarf::DW_CC_BORLAND_thiscall;
1206 case CC_X86VectorCall:
1207 return llvm::dwarf::DW_CC_LLVM_vectorcall;
1209 return llvm::dwarf::DW_CC_BORLAND_pascal;
1211 return llvm::dwarf::DW_CC_LLVM_Win64;
1213 return llvm::dwarf::DW_CC_LLVM_X86_64SysV;
1215 case CC_AArch64VectorCall:
1216 return llvm::dwarf::DW_CC_LLVM_AAPCS;
1218 return llvm::dwarf::DW_CC_LLVM_AAPCS_VFP;
1219 case CC_IntelOclBicc:
1220 return llvm::dwarf::DW_CC_LLVM_IntelOclBicc;
1221 case CC_SpirFunction:
1222 return llvm::dwarf::DW_CC_LLVM_SpirFunction;
1223 case CC_OpenCLKernel:
1224 return llvm::dwarf::DW_CC_LLVM_OpenCLKernel;
1226 return llvm::dwarf::DW_CC_LLVM_Swift;
1227 case CC_PreserveMost:
1228 return llvm::dwarf::DW_CC_LLVM_PreserveMost;
1229 case CC_PreserveAll:
1230 return llvm::dwarf::DW_CC_LLVM_PreserveAll;
1232 return llvm::dwarf::DW_CC_LLVM_X86RegCall;
1237 llvm::DIType *CGDebugInfo::CreateType(const FunctionType *Ty,
1238 llvm::DIFile *Unit) {
1239 SmallVector<llvm::Metadata *, 16> EltTys;
1241 // Add the result type at least.
1242 EltTys.push_back(getOrCreateType(Ty->getReturnType(), Unit));
1244 // Set up remainder of arguments if there is a prototype.
1245 // otherwise emit it as a variadic function.
1246 if (isa<FunctionNoProtoType>(Ty))
1247 EltTys.push_back(DBuilder.createUnspecifiedParameter());
1248 else if (const auto *FPT = dyn_cast<FunctionProtoType>(Ty)) {
1249 for (const QualType &ParamType : FPT->param_types())
1250 EltTys.push_back(getOrCreateType(ParamType, Unit));
1251 if (FPT->isVariadic())
1252 EltTys.push_back(DBuilder.createUnspecifiedParameter());
1255 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
1256 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
1257 getDwarfCC(Ty->getCallConv()));
1260 /// Convert an AccessSpecifier into the corresponding DINode flag.
1261 /// As an optimization, return 0 if the access specifier equals the
1262 /// default for the containing type.
1263 static llvm::DINode::DIFlags getAccessFlag(AccessSpecifier Access,
1264 const RecordDecl *RD) {
1265 AccessSpecifier Default = clang::AS_none;
1266 if (RD && RD->isClass())
1267 Default = clang::AS_private;
1268 else if (RD && (RD->isStruct() || RD->isUnion()))
1269 Default = clang::AS_public;
1271 if (Access == Default)
1272 return llvm::DINode::FlagZero;
1275 case clang::AS_private:
1276 return llvm::DINode::FlagPrivate;
1277 case clang::AS_protected:
1278 return llvm::DINode::FlagProtected;
1279 case clang::AS_public:
1280 return llvm::DINode::FlagPublic;
1281 case clang::AS_none:
1282 return llvm::DINode::FlagZero;
1284 llvm_unreachable("unexpected access enumerator");
1287 llvm::DIType *CGDebugInfo::createBitFieldType(const FieldDecl *BitFieldDecl,
1288 llvm::DIScope *RecordTy,
1289 const RecordDecl *RD) {
1290 StringRef Name = BitFieldDecl->getName();
1291 QualType Ty = BitFieldDecl->getType();
1292 SourceLocation Loc = BitFieldDecl->getLocation();
1293 llvm::DIFile *VUnit = getOrCreateFile(Loc);
1294 llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);
1296 // Get the location for the field.
1297 llvm::DIFile *File = getOrCreateFile(Loc);
1298 unsigned Line = getLineNumber(Loc);
1300 const CGBitFieldInfo &BitFieldInfo =
1301 CGM.getTypes().getCGRecordLayout(RD).getBitFieldInfo(BitFieldDecl);
1302 uint64_t SizeInBits = BitFieldInfo.Size;
1303 assert(SizeInBits > 0 && "found named 0-width bitfield");
1304 uint64_t StorageOffsetInBits =
1305 CGM.getContext().toBits(BitFieldInfo.StorageOffset);
1306 uint64_t Offset = BitFieldInfo.Offset;
1307 // The bit offsets for big endian machines are reversed for big
1308 // endian target, compensate for that as the DIDerivedType requires
1309 // un-reversed offsets.
1310 if (CGM.getDataLayout().isBigEndian())
1311 Offset = BitFieldInfo.StorageSize - BitFieldInfo.Size - Offset;
1312 uint64_t OffsetInBits = StorageOffsetInBits + Offset;
1313 llvm::DINode::DIFlags Flags = getAccessFlag(BitFieldDecl->getAccess(), RD);
1314 return DBuilder.createBitFieldMemberType(
1315 RecordTy, Name, File, Line, SizeInBits, OffsetInBits, StorageOffsetInBits,
1320 CGDebugInfo::createFieldType(StringRef name, QualType type, SourceLocation loc,
1321 AccessSpecifier AS, uint64_t offsetInBits,
1322 uint32_t AlignInBits, llvm::DIFile *tunit,
1323 llvm::DIScope *scope, const RecordDecl *RD) {
1324 llvm::DIType *debugType = getOrCreateType(type, tunit);
1326 // Get the location for the field.
1327 llvm::DIFile *file = getOrCreateFile(loc);
1328 unsigned line = getLineNumber(loc);
1330 uint64_t SizeInBits = 0;
1331 auto Align = AlignInBits;
1332 if (!type->isIncompleteArrayType()) {
1333 TypeInfo TI = CGM.getContext().getTypeInfo(type);
1334 SizeInBits = TI.Width;
1336 Align = getTypeAlignIfRequired(type, CGM.getContext());
1339 llvm::DINode::DIFlags flags = getAccessFlag(AS, RD);
1340 return DBuilder.createMemberType(scope, name, file, line, SizeInBits, Align,
1341 offsetInBits, flags, debugType);
1344 void CGDebugInfo::CollectRecordLambdaFields(
1345 const CXXRecordDecl *CXXDecl, SmallVectorImpl<llvm::Metadata *> &elements,
1346 llvm::DIType *RecordTy) {
1347 // For C++11 Lambdas a Field will be the same as a Capture, but the Capture
1348 // has the name and the location of the variable so we should iterate over
1349 // both concurrently.
1350 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(CXXDecl);
1351 RecordDecl::field_iterator Field = CXXDecl->field_begin();
1352 unsigned fieldno = 0;
1353 for (CXXRecordDecl::capture_const_iterator I = CXXDecl->captures_begin(),
1354 E = CXXDecl->captures_end();
1355 I != E; ++I, ++Field, ++fieldno) {
1356 const LambdaCapture &C = *I;
1357 if (C.capturesVariable()) {
1358 SourceLocation Loc = C.getLocation();
1359 assert(!Field->isBitField() && "lambdas don't have bitfield members!");
1360 VarDecl *V = C.getCapturedVar();
1361 StringRef VName = V->getName();
1362 llvm::DIFile *VUnit = getOrCreateFile(Loc);
1363 auto Align = getDeclAlignIfRequired(V, CGM.getContext());
1364 llvm::DIType *FieldType = createFieldType(
1365 VName, Field->getType(), Loc, Field->getAccess(),
1366 layout.getFieldOffset(fieldno), Align, VUnit, RecordTy, CXXDecl);
1367 elements.push_back(FieldType);
1368 } else if (C.capturesThis()) {
1369 // TODO: Need to handle 'this' in some way by probably renaming the
1370 // this of the lambda class and having a field member of 'this' or
1371 // by using AT_object_pointer for the function and having that be
1372 // used as 'this' for semantic references.
1373 FieldDecl *f = *Field;
1374 llvm::DIFile *VUnit = getOrCreateFile(f->getLocation());
1375 QualType type = f->getType();
1376 llvm::DIType *fieldType = createFieldType(
1377 "this", type, f->getLocation(), f->getAccess(),
1378 layout.getFieldOffset(fieldno), VUnit, RecordTy, CXXDecl);
1380 elements.push_back(fieldType);
1385 llvm::DIDerivedType *
1386 CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy,
1387 const RecordDecl *RD) {
1388 // Create the descriptor for the static variable, with or without
1389 // constant initializers.
1390 Var = Var->getCanonicalDecl();
1391 llvm::DIFile *VUnit = getOrCreateFile(Var->getLocation());
1392 llvm::DIType *VTy = getOrCreateType(Var->getType(), VUnit);
1394 unsigned LineNumber = getLineNumber(Var->getLocation());
1395 StringRef VName = Var->getName();
1396 llvm::Constant *C = nullptr;
1397 if (Var->getInit()) {
1398 const APValue *Value = Var->evaluateValue();
1401 C = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->getInt());
1402 if (Value->isFloat())
1403 C = llvm::ConstantFP::get(CGM.getLLVMContext(), Value->getFloat());
1407 llvm::DINode::DIFlags Flags = getAccessFlag(Var->getAccess(), RD);
1408 auto Align = getDeclAlignIfRequired(Var, CGM.getContext());
1409 llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
1410 RecordTy, VName, VUnit, LineNumber, VTy, Flags, C, Align);
1411 StaticDataMemberCache[Var->getCanonicalDecl()].reset(GV);
1415 void CGDebugInfo::CollectRecordNormalField(
1416 const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit,
1417 SmallVectorImpl<llvm::Metadata *> &elements, llvm::DIType *RecordTy,
1418 const RecordDecl *RD) {
1419 StringRef name = field->getName();
1420 QualType type = field->getType();
1422 // Ignore unnamed fields unless they're anonymous structs/unions.
1423 if (name.empty() && !type->isRecordType())
1426 llvm::DIType *FieldType;
1427 if (field->isBitField()) {
1428 FieldType = createBitFieldType(field, RecordTy, RD);
1430 auto Align = getDeclAlignIfRequired(field, CGM.getContext());
1432 createFieldType(name, type, field->getLocation(), field->getAccess(),
1433 OffsetInBits, Align, tunit, RecordTy, RD);
1436 elements.push_back(FieldType);
1439 void CGDebugInfo::CollectRecordNestedType(
1440 const TypeDecl *TD, SmallVectorImpl<llvm::Metadata *> &elements) {
1441 QualType Ty = CGM.getContext().getTypeDeclType(TD);
1442 // Injected class names are not considered nested records.
1443 if (isa<InjectedClassNameType>(Ty))
1445 SourceLocation Loc = TD->getLocation();
1446 llvm::DIType *nestedType = getOrCreateType(Ty, getOrCreateFile(Loc));
1447 elements.push_back(nestedType);
1450 void CGDebugInfo::CollectRecordFields(
1451 const RecordDecl *record, llvm::DIFile *tunit,
1452 SmallVectorImpl<llvm::Metadata *> &elements,
1453 llvm::DICompositeType *RecordTy) {
1454 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(record);
1456 if (CXXDecl && CXXDecl->isLambda())
1457 CollectRecordLambdaFields(CXXDecl, elements, RecordTy);
1459 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(record);
1461 // Field number for non-static fields.
1462 unsigned fieldNo = 0;
1464 // Static and non-static members should appear in the same order as
1465 // the corresponding declarations in the source program.
1466 for (const auto *I : record->decls())
1467 if (const auto *V = dyn_cast<VarDecl>(I)) {
1468 if (V->hasAttr<NoDebugAttr>())
1471 // Skip variable template specializations when emitting CodeView. MSVC
1472 // doesn't emit them.
1473 if (CGM.getCodeGenOpts().EmitCodeView &&
1474 isa<VarTemplateSpecializationDecl>(V))
1477 if (isa<VarTemplatePartialSpecializationDecl>(V))
1480 // Reuse the existing static member declaration if one exists
1481 auto MI = StaticDataMemberCache.find(V->getCanonicalDecl());
1482 if (MI != StaticDataMemberCache.end()) {
1483 assert(MI->second &&
1484 "Static data member declaration should still exist");
1485 elements.push_back(MI->second);
1487 auto Field = CreateRecordStaticField(V, RecordTy, record);
1488 elements.push_back(Field);
1490 } else if (const auto *field = dyn_cast<FieldDecl>(I)) {
1491 CollectRecordNormalField(field, layout.getFieldOffset(fieldNo), tunit,
1492 elements, RecordTy, record);
1494 // Bump field number for next field.
1496 } else if (CGM.getCodeGenOpts().EmitCodeView) {
1497 // Debug info for nested types is included in the member list only for
1499 if (const auto *nestedType = dyn_cast<TypeDecl>(I))
1500 if (!nestedType->isImplicit() &&
1501 nestedType->getDeclContext() == record)
1502 CollectRecordNestedType(nestedType, elements);
1507 llvm::DISubroutineType *
1508 CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method,
1509 llvm::DIFile *Unit, bool decl) {
1510 const FunctionProtoType *Func = Method->getType()->getAs<FunctionProtoType>();
1511 if (Method->isStatic())
1512 return cast_or_null<llvm::DISubroutineType>(
1513 getOrCreateType(QualType(Func, 0), Unit));
1514 return getOrCreateInstanceMethodType(Method->getThisType(), Func, Unit, decl);
1517 llvm::DISubroutineType *
1518 CGDebugInfo::getOrCreateInstanceMethodType(QualType ThisPtr,
1519 const FunctionProtoType *Func,
1520 llvm::DIFile *Unit, bool decl) {
1521 // Add "this" pointer.
1522 llvm::DITypeRefArray Args(
1523 cast<llvm::DISubroutineType>(getOrCreateType(QualType(Func, 0), Unit))
1525 assert(Args.size() && "Invalid number of arguments!");
1527 SmallVector<llvm::Metadata *, 16> Elts;
1528 // First element is always return type. For 'void' functions it is NULL.
1529 QualType temp = Func->getReturnType();
1530 if (temp->getTypeClass() == Type::Auto && decl)
1531 Elts.push_back(CreateType(cast<AutoType>(temp)));
1533 Elts.push_back(Args[0]);
1535 // "this" pointer is always first argument.
1536 const CXXRecordDecl *RD = ThisPtr->getPointeeCXXRecordDecl();
1537 if (isa<ClassTemplateSpecializationDecl>(RD)) {
1538 // Create pointer type directly in this case.
1539 const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr);
1540 QualType PointeeTy = ThisPtrTy->getPointeeType();
1541 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
1542 uint64_t Size = CGM.getTarget().getPointerWidth(AS);
1543 auto Align = getTypeAlignIfRequired(ThisPtrTy, CGM.getContext());
1544 llvm::DIType *PointeeType = getOrCreateType(PointeeTy, Unit);
1545 llvm::DIType *ThisPtrType =
1546 DBuilder.createPointerType(PointeeType, Size, Align);
1547 TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
1548 // TODO: This and the artificial type below are misleading, the
1549 // types aren't artificial the argument is, but the current
1550 // metadata doesn't represent that.
1551 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1552 Elts.push_back(ThisPtrType);
1554 llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);
1555 TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
1556 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1557 Elts.push_back(ThisPtrType);
1560 // Copy rest of the arguments.
1561 for (unsigned i = 1, e = Args.size(); i != e; ++i)
1562 Elts.push_back(Args[i]);
1564 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
1566 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1567 if (Func->getExtProtoInfo().RefQualifier == RQ_LValue)
1568 Flags |= llvm::DINode::FlagLValueReference;
1569 if (Func->getExtProtoInfo().RefQualifier == RQ_RValue)
1570 Flags |= llvm::DINode::FlagRValueReference;
1572 return DBuilder.createSubroutineType(EltTypeArray, Flags,
1573 getDwarfCC(Func->getCallConv()));
1576 /// isFunctionLocalClass - Return true if CXXRecordDecl is defined
1577 /// inside a function.
1578 static bool isFunctionLocalClass(const CXXRecordDecl *RD) {
1579 if (const auto *NRD = dyn_cast<CXXRecordDecl>(RD->getDeclContext()))
1580 return isFunctionLocalClass(NRD);
1581 if (isa<FunctionDecl>(RD->getDeclContext()))
1586 llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
1587 const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {
1589 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
1591 StringRef MethodName = getFunctionName(Method);
1592 llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit, true);
1594 // Since a single ctor/dtor corresponds to multiple functions, it doesn't
1595 // make sense to give a single ctor/dtor a linkage name.
1596 StringRef MethodLinkageName;
1597 // FIXME: 'isFunctionLocalClass' seems like an arbitrary/unintentional
1598 // property to use here. It may've been intended to model "is non-external
1599 // type" but misses cases of non-function-local but non-external classes such
1600 // as those in anonymous namespaces as well as the reverse - external types
1601 // that are function local, such as those in (non-local) inline functions.
1602 if (!IsCtorOrDtor && !isFunctionLocalClass(Method->getParent()))
1603 MethodLinkageName = CGM.getMangledName(Method);
1605 // Get the location for the method.
1606 llvm::DIFile *MethodDefUnit = nullptr;
1607 unsigned MethodLine = 0;
1608 if (!Method->isImplicit()) {
1609 MethodDefUnit = getOrCreateFile(Method->getLocation());
1610 MethodLine = getLineNumber(Method->getLocation());
1613 // Collect virtual method info.
1614 llvm::DIType *ContainingType = nullptr;
1615 unsigned VIndex = 0;
1616 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1617 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
1618 int ThisAdjustment = 0;
1620 if (Method->isVirtual()) {
1621 if (Method->isPure())
1622 SPFlags |= llvm::DISubprogram::SPFlagPureVirtual;
1624 SPFlags |= llvm::DISubprogram::SPFlagVirtual;
1626 if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1627 // It doesn't make sense to give a virtual destructor a vtable index,
1628 // since a single destructor has two entries in the vtable.
1629 if (!isa<CXXDestructorDecl>(Method))
1630 VIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(Method);
1632 // Emit MS ABI vftable information. There is only one entry for the
1634 const auto *DD = dyn_cast<CXXDestructorDecl>(Method);
1635 GlobalDecl GD = DD ? GlobalDecl(DD, Dtor_Deleting) : GlobalDecl(Method);
1636 MethodVFTableLocation ML =
1637 CGM.getMicrosoftVTableContext().getMethodVFTableLocation(GD);
1640 // CodeView only records the vftable offset in the class that introduces
1641 // the virtual method. This is possible because, unlike Itanium, the MS
1642 // C++ ABI does not include all virtual methods from non-primary bases in
1643 // the vtable for the most derived class. For example, if C inherits from
1644 // A and B, C's primary vftable will not include B's virtual methods.
1645 if (Method->size_overridden_methods() == 0)
1646 Flags |= llvm::DINode::FlagIntroducedVirtual;
1648 // The 'this' adjustment accounts for both the virtual and non-virtual
1649 // portions of the adjustment. Presumably the debugger only uses it when
1650 // it knows the dynamic type of an object.
1651 ThisAdjustment = CGM.getCXXABI()
1652 .getVirtualFunctionPrologueThisAdjustment(GD)
1655 ContainingType = RecordTy;
1658 // We're checking for deleted C++ special member functions
1659 // [Ctors,Dtors, Copy/Move]
1660 auto checkAttrDeleted = [&](const auto *Method) {
1661 if (Method->getCanonicalDecl()->isDeleted())
1662 SPFlags |= llvm::DISubprogram::SPFlagDeleted;
1665 switch (Method->getKind()) {
1667 case Decl::CXXConstructor:
1668 case Decl::CXXDestructor:
1669 checkAttrDeleted(Method);
1671 case Decl::CXXMethod:
1672 if (Method->isCopyAssignmentOperator() ||
1673 Method->isMoveAssignmentOperator())
1674 checkAttrDeleted(Method);
1680 if (Method->isNoReturn())
1681 Flags |= llvm::DINode::FlagNoReturn;
1683 if (Method->isStatic())
1684 Flags |= llvm::DINode::FlagStaticMember;
1685 if (Method->isImplicit())
1686 Flags |= llvm::DINode::FlagArtificial;
1687 Flags |= getAccessFlag(Method->getAccess(), Method->getParent());
1688 if (const auto *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
1689 if (CXXC->isExplicit())
1690 Flags |= llvm::DINode::FlagExplicit;
1691 } else if (const auto *CXXC = dyn_cast<CXXConversionDecl>(Method)) {
1692 if (CXXC->isExplicit())
1693 Flags |= llvm::DINode::FlagExplicit;
1695 if (Method->hasPrototype())
1696 Flags |= llvm::DINode::FlagPrototyped;
1697 if (Method->getRefQualifier() == RQ_LValue)
1698 Flags |= llvm::DINode::FlagLValueReference;
1699 if (Method->getRefQualifier() == RQ_RValue)
1700 Flags |= llvm::DINode::FlagRValueReference;
1701 if (CGM.getLangOpts().Optimize)
1702 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
1704 // In this debug mode, emit type info for a class when its constructor type
1706 if (DebugKind == codegenoptions::DebugInfoConstructor)
1707 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
1708 completeClass(CD->getParent());
1710 llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
1711 llvm::DISubprogram *SP = DBuilder.createMethod(
1712 RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
1713 MethodTy, VIndex, ThisAdjustment, ContainingType, Flags, SPFlags,
1714 TParamsArray.get());
1716 SPCache[Method->getCanonicalDecl()].reset(SP);
1721 void CGDebugInfo::CollectCXXMemberFunctions(
1722 const CXXRecordDecl *RD, llvm::DIFile *Unit,
1723 SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy) {
1725 // Since we want more than just the individual member decls if we
1726 // have templated functions iterate over every declaration to gather
1728 for (const auto *I : RD->decls()) {
1729 const auto *Method = dyn_cast<CXXMethodDecl>(I);
1730 // If the member is implicit, don't add it to the member list. This avoids
1731 // the member being added to type units by LLVM, while still allowing it
1732 // to be emitted into the type declaration/reference inside the compile
1734 // Ditto 'nodebug' methods, for consistency with CodeGenFunction.cpp.
1735 // FIXME: Handle Using(Shadow?)Decls here to create
1736 // DW_TAG_imported_declarations inside the class for base decls brought into
1737 // derived classes. GDB doesn't seem to notice/leverage these when I tried
1738 // it, so I'm not rushing to fix this. (GCC seems to produce them, if
1740 if (!Method || Method->isImplicit() || Method->hasAttr<NoDebugAttr>())
1743 if (Method->getType()->castAs<FunctionProtoType>()->getContainedAutoType())
1746 // Reuse the existing member function declaration if it exists.
1747 // It may be associated with the declaration of the type & should be
1748 // reused as we're building the definition.
1750 // This situation can arise in the vtable-based debug info reduction where
1751 // implicit members are emitted in a non-vtable TU.
1752 auto MI = SPCache.find(Method->getCanonicalDecl());
1753 EltTys.push_back(MI == SPCache.end()
1754 ? CreateCXXMemberFunction(Method, Unit, RecordTy)
1755 : static_cast<llvm::Metadata *>(MI->second));
1759 void CGDebugInfo::CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile *Unit,
1760 SmallVectorImpl<llvm::Metadata *> &EltTys,
1761 llvm::DIType *RecordTy) {
1762 llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> SeenTypes;
1763 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->bases(), SeenTypes,
1764 llvm::DINode::FlagZero);
1766 // If we are generating CodeView debug info, we also need to emit records for
1767 // indirect virtual base classes.
1768 if (CGM.getCodeGenOpts().EmitCodeView) {
1769 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->vbases(), SeenTypes,
1770 llvm::DINode::FlagIndirectVirtualBase);
1774 void CGDebugInfo::CollectCXXBasesAux(
1775 const CXXRecordDecl *RD, llvm::DIFile *Unit,
1776 SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy,
1777 const CXXRecordDecl::base_class_const_range &Bases,
1778 llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> &SeenTypes,
1779 llvm::DINode::DIFlags StartingFlags) {
1780 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1781 for (const auto &BI : Bases) {
1783 cast<CXXRecordDecl>(BI.getType()->castAs<RecordType>()->getDecl());
1784 if (!SeenTypes.insert(Base).second)
1786 auto *BaseTy = getOrCreateType(BI.getType(), Unit);
1787 llvm::DINode::DIFlags BFlags = StartingFlags;
1788 uint64_t BaseOffset;
1789 uint32_t VBPtrOffset = 0;
1791 if (BI.isVirtual()) {
1792 if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1793 // virtual base offset offset is -ve. The code generator emits dwarf
1794 // expression where it expects +ve number.
1795 BaseOffset = 0 - CGM.getItaniumVTableContext()
1796 .getVirtualBaseOffsetOffset(RD, Base)
1799 // In the MS ABI, store the vbtable offset, which is analogous to the
1800 // vbase offset offset in Itanium.
1802 4 * CGM.getMicrosoftVTableContext().getVBTableIndex(RD, Base);
1803 VBPtrOffset = CGM.getContext()
1804 .getASTRecordLayout(RD)
1808 BFlags |= llvm::DINode::FlagVirtual;
1810 BaseOffset = CGM.getContext().toBits(RL.getBaseClassOffset(Base));
1811 // FIXME: Inconsistent units for BaseOffset. It is in bytes when
1812 // BI->isVirtual() and bits when not.
1814 BFlags |= getAccessFlag(BI.getAccessSpecifier(), RD);
1815 llvm::DIType *DTy = DBuilder.createInheritance(RecordTy, BaseTy, BaseOffset,
1816 VBPtrOffset, BFlags);
1817 EltTys.push_back(DTy);
1822 CGDebugInfo::CollectTemplateParams(const TemplateParameterList *TPList,
1823 ArrayRef<TemplateArgument> TAList,
1824 llvm::DIFile *Unit) {
1825 SmallVector<llvm::Metadata *, 16> TemplateParams;
1826 for (unsigned i = 0, e = TAList.size(); i != e; ++i) {
1827 const TemplateArgument &TA = TAList[i];
1829 bool defaultParameter = false;
1831 Name = TPList->getParam(i)->getName();
1832 switch (TA.getKind()) {
1833 case TemplateArgument::Type: {
1834 llvm::DIType *TTy = getOrCreateType(TA.getAsType(), Unit);
1837 if (auto *templateType =
1838 dyn_cast_or_null<TemplateTypeParmDecl>(TPList->getParam(i)))
1839 if (templateType->hasDefaultArgument())
1841 templateType->getDefaultArgument() == TA.getAsType();
1843 TemplateParams.push_back(DBuilder.createTemplateTypeParameter(
1844 TheCU, Name, TTy, defaultParameter));
1847 case TemplateArgument::Integral: {
1848 llvm::DIType *TTy = getOrCreateType(TA.getIntegralType(), Unit);
1849 if (TPList && CGM.getCodeGenOpts().DwarfVersion >= 5)
1850 if (auto *templateType =
1851 dyn_cast_or_null<NonTypeTemplateParmDecl>(TPList->getParam(i)))
1852 if (templateType->hasDefaultArgument() &&
1853 !templateType->getDefaultArgument()->isValueDependent())
1854 defaultParameter = llvm::APSInt::isSameValue(
1855 templateType->getDefaultArgument()->EvaluateKnownConstInt(
1857 TA.getAsIntegral());
1859 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1860 TheCU, Name, TTy, defaultParameter,
1861 llvm::ConstantInt::get(CGM.getLLVMContext(), TA.getAsIntegral())));
1863 case TemplateArgument::Declaration: {
1864 const ValueDecl *D = TA.getAsDecl();
1865 QualType T = TA.getParamTypeForDecl().getDesugaredType(CGM.getContext());
1866 llvm::DIType *TTy = getOrCreateType(T, Unit);
1867 llvm::Constant *V = nullptr;
1868 // Skip retrieve the value if that template parameter has cuda device
1869 // attribute, i.e. that value is not available at the host side.
1870 if (!CGM.getLangOpts().CUDA || CGM.getLangOpts().CUDAIsDevice ||
1871 !D->hasAttr<CUDADeviceAttr>()) {
1872 const CXXMethodDecl *MD;
1873 // Variable pointer template parameters have a value that is the address
1875 if (const auto *VD = dyn_cast<VarDecl>(D))
1876 V = CGM.GetAddrOfGlobalVar(VD);
1877 // Member function pointers have special support for building them,
1878 // though this is currently unsupported in LLVM CodeGen.
1879 else if ((MD = dyn_cast<CXXMethodDecl>(D)) && MD->isInstance())
1880 V = CGM.getCXXABI().EmitMemberFunctionPointer(MD);
1881 else if (const auto *FD = dyn_cast<FunctionDecl>(D))
1882 V = CGM.GetAddrOfFunction(FD);
1883 // Member data pointers have special handling too to compute the fixed
1884 // offset within the object.
1885 else if (const auto *MPT =
1886 dyn_cast<MemberPointerType>(T.getTypePtr())) {
1887 // These five lines (& possibly the above member function pointer
1888 // handling) might be able to be refactored to use similar code in
1889 // CodeGenModule::getMemberPointerConstant
1890 uint64_t fieldOffset = CGM.getContext().getFieldOffset(D);
1892 CGM.getContext().toCharUnitsFromBits((int64_t)fieldOffset);
1893 V = CGM.getCXXABI().EmitMemberDataPointer(MPT, chars);
1894 } else if (const auto *GD = dyn_cast<MSGuidDecl>(D)) {
1895 V = CGM.GetAddrOfMSGuidDecl(GD).getPointer();
1897 assert(V && "Failed to find template parameter pointer");
1898 V = V->stripPointerCasts();
1900 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1901 TheCU, Name, TTy, defaultParameter, cast_or_null<llvm::Constant>(V)));
1903 case TemplateArgument::NullPtr: {
1904 QualType T = TA.getNullPtrType();
1905 llvm::DIType *TTy = getOrCreateType(T, Unit);
1906 llvm::Constant *V = nullptr;
1907 // Special case member data pointer null values since they're actually -1
1909 if (const auto *MPT = dyn_cast<MemberPointerType>(T.getTypePtr()))
1910 // But treat member function pointers as simple zero integers because
1911 // it's easier than having a special case in LLVM's CodeGen. If LLVM
1912 // CodeGen grows handling for values of non-null member function
1913 // pointers then perhaps we could remove this special case and rely on
1914 // EmitNullMemberPointer for member function pointers.
1915 if (MPT->isMemberDataPointer())
1916 V = CGM.getCXXABI().EmitNullMemberPointer(MPT);
1918 V = llvm::ConstantInt::get(CGM.Int8Ty, 0);
1919 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1920 TheCU, Name, TTy, defaultParameter, V));
1922 case TemplateArgument::Template:
1923 TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(
1924 TheCU, Name, nullptr,
1925 TA.getAsTemplate().getAsTemplateDecl()->getQualifiedNameAsString()));
1927 case TemplateArgument::Pack:
1928 TemplateParams.push_back(DBuilder.createTemplateParameterPack(
1929 TheCU, Name, nullptr,
1930 CollectTemplateParams(nullptr, TA.getPackAsArray(), Unit)));
1932 case TemplateArgument::Expression: {
1933 const Expr *E = TA.getAsExpr();
1934 QualType T = E->getType();
1936 T = CGM.getContext().getLValueReferenceType(T);
1937 llvm::Constant *V = ConstantEmitter(CGM).emitAbstract(E, T);
1938 assert(V && "Expression in template argument isn't constant");
1939 llvm::DIType *TTy = getOrCreateType(T, Unit);
1940 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1941 TheCU, Name, TTy, defaultParameter, V->stripPointerCasts()));
1943 // And the following should never occur:
1944 case TemplateArgument::TemplateExpansion:
1945 case TemplateArgument::Null:
1947 "These argument types shouldn't exist in concrete types");
1950 return DBuilder.getOrCreateArray(TemplateParams);
1954 CGDebugInfo::CollectFunctionTemplateParams(const FunctionDecl *FD,
1955 llvm::DIFile *Unit) {
1956 if (FD->getTemplatedKind() ==
1957 FunctionDecl::TK_FunctionTemplateSpecialization) {
1958 const TemplateParameterList *TList = FD->getTemplateSpecializationInfo()
1960 ->getTemplateParameters();
1961 return CollectTemplateParams(
1962 TList, FD->getTemplateSpecializationArgs()->asArray(), Unit);
1964 return llvm::DINodeArray();
1967 llvm::DINodeArray CGDebugInfo::CollectVarTemplateParams(const VarDecl *VL,
1968 llvm::DIFile *Unit) {
1969 // Always get the full list of parameters, not just the ones from the
1970 // specialization. A partial specialization may have fewer parameters than
1971 // there are arguments.
1972 auto *TS = dyn_cast<VarTemplateSpecializationDecl>(VL);
1974 return llvm::DINodeArray();
1975 VarTemplateDecl *T = TS->getSpecializedTemplate();
1976 const TemplateParameterList *TList = T->getTemplateParameters();
1977 auto TA = TS->getTemplateArgs().asArray();
1978 return CollectTemplateParams(TList, TA, Unit);
1981 llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(
1982 const ClassTemplateSpecializationDecl *TSpecial, llvm::DIFile *Unit) {
1983 // Always get the full list of parameters, not just the ones from the
1984 // specialization. A partial specialization may have fewer parameters than
1985 // there are arguments.
1986 TemplateParameterList *TPList =
1987 TSpecial->getSpecializedTemplate()->getTemplateParameters();
1988 const TemplateArgumentList &TAList = TSpecial->getTemplateArgs();
1989 return CollectTemplateParams(TPList, TAList.asArray(), Unit);
1992 llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
1994 return VTablePtrType;
1996 ASTContext &Context = CGM.getContext();
1999 llvm::Metadata *STy = getOrCreateType(Context.IntTy, Unit);
2000 llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);
2001 llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements);
2002 unsigned Size = Context.getTypeSize(Context.VoidPtrTy);
2003 unsigned VtblPtrAddressSpace = CGM.getTarget().getVtblPtrAddressSpace();
2004 Optional<unsigned> DWARFAddressSpace =
2005 CGM.getTarget().getDWARFAddressSpace(VtblPtrAddressSpace);
2007 llvm::DIType *vtbl_ptr_type = DBuilder.createPointerType(
2008 SubTy, Size, 0, DWARFAddressSpace, "__vtbl_ptr_type");
2009 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
2010 return VTablePtrType;
2013 StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) {
2014 // Copy the gdb compatible name on the side and use its reference.
2015 return internString("_vptr$", RD->getNameAsString());
2018 StringRef CGDebugInfo::getDynamicInitializerName(const VarDecl *VD,
2019 DynamicInitKind StubKind,
2020 llvm::Function *InitFn) {
2021 // If we're not emitting codeview, use the mangled name. For Itanium, this is
2023 if (!CGM.getCodeGenOpts().EmitCodeView)
2024 return InitFn->getName();
2026 // Print the normal qualified name for the variable, then break off the last
2027 // NNS, and add the appropriate other text. Clang always prints the global
2028 // variable name without template arguments, so we can use rsplit("::") and
2029 // then recombine the pieces.
2030 SmallString<128> QualifiedGV;
2034 llvm::raw_svector_ostream OS(QualifiedGV);
2035 VD->printQualifiedName(OS, getPrintingPolicy());
2036 std::tie(Quals, GVName) = OS.str().rsplit("::");
2038 std::swap(Quals, GVName);
2041 SmallString<128> InitName;
2042 llvm::raw_svector_ostream OS(InitName);
2044 OS << Quals << "::";
2047 case DynamicInitKind::NoStub:
2048 llvm_unreachable("not an initializer");
2049 case DynamicInitKind::Initializer:
2050 OS << "`dynamic initializer for '";
2052 case DynamicInitKind::AtExit:
2053 OS << "`dynamic atexit destructor for '";
2059 // Add any template specialization args.
2060 if (const auto *VTpl = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
2061 printTemplateArgumentList(OS, VTpl->getTemplateArgs().asArray(),
2062 getPrintingPolicy());
2067 return internString(OS.str());
2070 void CGDebugInfo::CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile *Unit,
2071 SmallVectorImpl<llvm::Metadata *> &EltTys,
2072 llvm::DICompositeType *RecordTy) {
2073 // If this class is not dynamic then there is not any vtable info to collect.
2074 if (!RD->isDynamicClass())
2077 // Don't emit any vtable shape or vptr info if this class doesn't have an
2078 // extendable vfptr. This can happen if the class doesn't have virtual
2079 // methods, or in the MS ABI if those virtual methods only come from virtually
2081 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2082 if (!RL.hasExtendableVFPtr())
2085 // CodeView needs to know how large the vtable of every dynamic class is, so
2086 // emit a special named pointer type into the element list. The vptr type
2087 // points to this type as well.
2088 llvm::DIType *VPtrTy = nullptr;
2089 bool NeedVTableShape = CGM.getCodeGenOpts().EmitCodeView &&
2090 CGM.getTarget().getCXXABI().isMicrosoft();
2091 if (NeedVTableShape) {
2093 CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
2094 const VTableLayout &VFTLayout =
2095 CGM.getMicrosoftVTableContext().getVFTableLayout(RD, CharUnits::Zero());
2096 unsigned VSlotCount =
2097 VFTLayout.vtable_components().size() - CGM.getLangOpts().RTTIData;
2098 unsigned VTableWidth = PtrWidth * VSlotCount;
2099 unsigned VtblPtrAddressSpace = CGM.getTarget().getVtblPtrAddressSpace();
2100 Optional<unsigned> DWARFAddressSpace =
2101 CGM.getTarget().getDWARFAddressSpace(VtblPtrAddressSpace);
2103 // Create a very wide void* type and insert it directly in the element list.
2104 llvm::DIType *VTableType = DBuilder.createPointerType(
2105 nullptr, VTableWidth, 0, DWARFAddressSpace, "__vtbl_ptr_type");
2106 EltTys.push_back(VTableType);
2108 // The vptr is a pointer to this special vtable type.
2109 VPtrTy = DBuilder.createPointerType(VTableType, PtrWidth);
2112 // If there is a primary base then the artificial vptr member lives there.
2113 if (RL.getPrimaryBase())
2117 VPtrTy = getOrCreateVTablePtrType(Unit);
2119 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
2120 llvm::DIType *VPtrMember =
2121 DBuilder.createMemberType(Unit, getVTableName(RD), Unit, 0, Size, 0, 0,
2122 llvm::DINode::FlagArtificial, VPtrTy);
2123 EltTys.push_back(VPtrMember);
2126 llvm::DIType *CGDebugInfo::getOrCreateRecordType(QualType RTy,
2127 SourceLocation Loc) {
2128 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
2129 llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
2133 llvm::DIType *CGDebugInfo::getOrCreateInterfaceType(QualType D,
2134 SourceLocation Loc) {
2135 return getOrCreateStandaloneType(D, Loc);
2138 llvm::DIType *CGDebugInfo::getOrCreateStandaloneType(QualType D,
2139 SourceLocation Loc) {
2140 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
2141 assert(!D.isNull() && "null type");
2142 llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc));
2143 assert(T && "could not create debug info for type");
2145 RetainedTypes.push_back(D.getAsOpaquePtr());
2149 void CGDebugInfo::addHeapAllocSiteMetadata(llvm::CallBase *CI,
2150 QualType AllocatedTy,
2151 SourceLocation Loc) {
2152 if (CGM.getCodeGenOpts().getDebugInfo() <=
2153 codegenoptions::DebugLineTablesOnly)
2156 if (AllocatedTy->isVoidType())
2157 node = llvm::MDNode::get(CGM.getLLVMContext(), None);
2159 node = getOrCreateType(AllocatedTy, getOrCreateFile(Loc));
2161 CI->setMetadata("heapallocsite", node);
2164 void CGDebugInfo::completeType(const EnumDecl *ED) {
2165 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
2167 QualType Ty = CGM.getContext().getEnumType(ED);
2168 void *TyPtr = Ty.getAsOpaquePtr();
2169 auto I = TypeCache.find(TyPtr);
2170 if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())
2172 llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<EnumType>());
2173 assert(!Res->isForwardDecl());
2174 TypeCache[TyPtr].reset(Res);
2177 void CGDebugInfo::completeType(const RecordDecl *RD) {
2178 if (DebugKind > codegenoptions::LimitedDebugInfo ||
2179 !CGM.getLangOpts().CPlusPlus)
2180 completeRequiredType(RD);
2183 /// Return true if the class or any of its methods are marked dllimport.
2184 static bool isClassOrMethodDLLImport(const CXXRecordDecl *RD) {
2185 if (RD->hasAttr<DLLImportAttr>())
2187 for (const CXXMethodDecl *MD : RD->methods())
2188 if (MD->hasAttr<DLLImportAttr>())
2193 /// Does a type definition exist in an imported clang module?
2194 static bool isDefinedInClangModule(const RecordDecl *RD) {
2195 // Only definitions that where imported from an AST file come from a module.
2196 if (!RD || !RD->isFromASTFile())
2198 // Anonymous entities cannot be addressed. Treat them as not from module.
2199 if (!RD->isExternallyVisible() && RD->getName().empty())
2201 if (auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) {
2202 if (!CXXDecl->isCompleteDefinition())
2204 // Check wether RD is a template.
2205 auto TemplateKind = CXXDecl->getTemplateSpecializationKind();
2206 if (TemplateKind != TSK_Undeclared) {
2207 // Unfortunately getOwningModule() isn't accurate enough to find the
2208 // owning module of a ClassTemplateSpecializationDecl that is inside a
2209 // namespace spanning multiple modules.
2210 bool Explicit = false;
2211 if (auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(CXXDecl))
2212 Explicit = TD->isExplicitInstantiationOrSpecialization();
2213 if (!Explicit && CXXDecl->getEnclosingNamespaceContext())
2215 // This is a template, check the origin of the first member.
2216 if (CXXDecl->field_begin() == CXXDecl->field_end())
2217 return TemplateKind == TSK_ExplicitInstantiationDeclaration;
2218 if (!CXXDecl->field_begin()->isFromASTFile())
2225 void CGDebugInfo::completeClassData(const RecordDecl *RD) {
2226 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
2227 if (CXXRD->isDynamicClass() &&
2228 CGM.getVTableLinkage(CXXRD) ==
2229 llvm::GlobalValue::AvailableExternallyLinkage &&
2230 !isClassOrMethodDLLImport(CXXRD))
2233 if (DebugTypeExtRefs && isDefinedInClangModule(RD->getDefinition()))
2239 void CGDebugInfo::completeClass(const RecordDecl *RD) {
2240 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
2242 QualType Ty = CGM.getContext().getRecordType(RD);
2243 void *TyPtr = Ty.getAsOpaquePtr();
2244 auto I = TypeCache.find(TyPtr);
2245 if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
2247 llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<RecordType>());
2248 assert(!Res->isForwardDecl());
2249 TypeCache[TyPtr].reset(Res);
2252 static bool hasExplicitMemberDefinition(CXXRecordDecl::method_iterator I,
2253 CXXRecordDecl::method_iterator End) {
2254 for (CXXMethodDecl *MD : llvm::make_range(I, End))
2255 if (FunctionDecl *Tmpl = MD->getInstantiatedFromMemberFunction())
2256 if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&
2257 !MD->getMemberSpecializationInfo()->isExplicitSpecialization())
2262 static bool shouldOmitDefinition(codegenoptions::DebugInfoKind DebugKind,
2263 bool DebugTypeExtRefs, const RecordDecl *RD,
2264 const LangOptions &LangOpts) {
2265 if (DebugTypeExtRefs && isDefinedInClangModule(RD->getDefinition()))
2268 if (auto *ES = RD->getASTContext().getExternalSource())
2269 if (ES->hasExternalDefinitions(RD) == ExternalASTSource::EK_Always)
2272 if (DebugKind > codegenoptions::LimitedDebugInfo)
2275 if (!LangOpts.CPlusPlus)
2278 if (!RD->isCompleteDefinitionRequired())
2281 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
2286 // Only emit complete debug info for a dynamic class when its vtable is
2287 // emitted. However, Microsoft debuggers don't resolve type information
2288 // across DLL boundaries, so skip this optimization if the class or any of its
2289 // methods are marked dllimport. This isn't a complete solution, since objects
2290 // without any dllimport methods can be used in one DLL and constructed in
2291 // another, but it is the current behavior of LimitedDebugInfo.
2292 if (CXXDecl->hasDefinition() && CXXDecl->isDynamicClass() &&
2293 !isClassOrMethodDLLImport(CXXDecl))
2296 // In constructor debug mode, only emit debug info for a class when its
2297 // constructor is emitted. Skip this optimization if the class or any of
2298 // its methods are marked dllimport.
2299 if (DebugKind == codegenoptions::DebugInfoConstructor &&
2300 !CXXDecl->isLambda() && !CXXDecl->hasConstexprNonCopyMoveConstructor() &&
2301 !isClassOrMethodDLLImport(CXXDecl))
2302 for (const auto *Ctor : CXXDecl->ctors())
2303 if (Ctor->isUserProvided())
2306 TemplateSpecializationKind Spec = TSK_Undeclared;
2307 if (const auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
2308 Spec = SD->getSpecializationKind();
2310 if (Spec == TSK_ExplicitInstantiationDeclaration &&
2311 hasExplicitMemberDefinition(CXXDecl->method_begin(),
2312 CXXDecl->method_end()))
2318 void CGDebugInfo::completeRequiredType(const RecordDecl *RD) {
2319 if (shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD, CGM.getLangOpts()))
2322 QualType Ty = CGM.getContext().getRecordType(RD);
2323 llvm::DIType *T = getTypeOrNull(Ty);
2324 if (T && T->isForwardDecl())
2325 completeClassData(RD);
2328 llvm::DIType *CGDebugInfo::CreateType(const RecordType *Ty) {
2329 RecordDecl *RD = Ty->getDecl();
2330 llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(QualType(Ty, 0)));
2331 if (T || shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD,
2332 CGM.getLangOpts())) {
2334 T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));
2338 return CreateTypeDefinition(Ty);
2341 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) {
2342 RecordDecl *RD = Ty->getDecl();
2344 // Get overall information about the record type for the debug info.
2345 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
2347 // Records and classes and unions can all be recursive. To handle them, we
2348 // first generate a debug descriptor for the struct as a forward declaration.
2349 // Then (if it is a definition) we go through and get debug info for all of
2350 // its members. Finally, we create a descriptor for the complete type (which
2351 // may refer to the forward decl if the struct is recursive) and replace all
2352 // uses of the forward declaration with the final definition.
2353 llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty, DefUnit);
2355 const RecordDecl *D = RD->getDefinition();
2356 if (!D || !D->isCompleteDefinition())
2359 if (const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
2360 CollectContainingType(CXXDecl, FwdDecl);
2362 // Push the struct on region stack.
2363 LexicalBlockStack.emplace_back(&*FwdDecl);
2364 RegionMap[Ty->getDecl()].reset(FwdDecl);
2366 // Convert all the elements.
2367 SmallVector<llvm::Metadata *, 16> EltTys;
2368 // what about nested types?
2370 // Note: The split of CXXDecl information here is intentional, the
2371 // gdb tests will depend on a certain ordering at printout. The debug
2372 // information offsets are still correct if we merge them all together
2374 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
2376 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
2377 CollectVTableInfo(CXXDecl, DefUnit, EltTys, FwdDecl);
2380 // Collect data fields (including static variables and any initializers).
2381 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
2383 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
2385 LexicalBlockStack.pop_back();
2386 RegionMap.erase(Ty->getDecl());
2388 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2389 DBuilder.replaceArrays(FwdDecl, Elements);
2391 if (FwdDecl->isTemporary())
2393 llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
2395 RegionMap[Ty->getDecl()].reset(FwdDecl);
2399 llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectType *Ty,
2400 llvm::DIFile *Unit) {
2401 // Ignore protocols.
2402 return getOrCreateType(Ty->getBaseType(), Unit);
2405 llvm::DIType *CGDebugInfo::CreateType(const ObjCTypeParamType *Ty,
2406 llvm::DIFile *Unit) {
2407 // Ignore protocols.
2408 SourceLocation Loc = Ty->getDecl()->getLocation();
2410 // Use Typedefs to represent ObjCTypeParamType.
2411 return DBuilder.createTypedef(
2412 getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit),
2413 Ty->getDecl()->getName(), getOrCreateFile(Loc), getLineNumber(Loc),
2414 getDeclContextDescriptor(Ty->getDecl()));
2417 /// \return true if Getter has the default name for the property PD.
2418 static bool hasDefaultGetterName(const ObjCPropertyDecl *PD,
2419 const ObjCMethodDecl *Getter) {
2424 assert(Getter->getDeclName().isObjCZeroArgSelector());
2425 return PD->getName() ==
2426 Getter->getDeclName().getObjCSelector().getNameForSlot(0);
2429 /// \return true if Setter has the default name for the property PD.
2430 static bool hasDefaultSetterName(const ObjCPropertyDecl *PD,
2431 const ObjCMethodDecl *Setter) {
2436 assert(Setter->getDeclName().isObjCOneArgSelector());
2437 return SelectorTable::constructSetterName(PD->getName()) ==
2438 Setter->getDeclName().getObjCSelector().getNameForSlot(0);
2441 llvm::DIType *CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
2442 llvm::DIFile *Unit) {
2443 ObjCInterfaceDecl *ID = Ty->getDecl();
2447 // Return a forward declaration if this type was imported from a clang module,
2448 // and this is not the compile unit with the implementation of the type (which
2449 // may contain hidden ivars).
2450 if (DebugTypeExtRefs && ID->isFromASTFile() && ID->getDefinition() &&
2451 !ID->getImplementation())
2452 return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
2454 getDeclContextDescriptor(ID), Unit, 0);
2456 // Get overall information about the record type for the debug info.
2457 llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation());
2458 unsigned Line = getLineNumber(ID->getLocation());
2460 static_cast<llvm::dwarf::SourceLanguage>(TheCU->getSourceLanguage());
2462 // If this is just a forward declaration return a special forward-declaration
2463 // debug type since we won't be able to lay out the entire type.
2464 ObjCInterfaceDecl *Def = ID->getDefinition();
2465 if (!Def || !Def->getImplementation()) {
2466 llvm::DIScope *Mod = getParentModuleOrNull(ID);
2467 llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(
2468 llvm::dwarf::DW_TAG_structure_type, ID->getName(), Mod ? Mod : TheCU,
2469 DefUnit, Line, RuntimeLang);
2470 ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit));
2474 return CreateTypeDefinition(Ty, Unit);
2477 llvm::DIModule *CGDebugInfo::getOrCreateModuleRef(ASTSourceDescriptor Mod,
2478 bool CreateSkeletonCU) {
2479 // Use the Module pointer as the key into the cache. This is a
2480 // nullptr if the "Module" is a PCH, which is safe because we don't
2481 // support chained PCH debug info, so there can only be a single PCH.
2482 const Module *M = Mod.getModuleOrNull();
2483 auto ModRef = ModuleCache.find(M);
2484 if (ModRef != ModuleCache.end())
2485 return cast<llvm::DIModule>(ModRef->second);
2487 // Macro definitions that were defined with "-D" on the command line.
2488 SmallString<128> ConfigMacros;
2490 llvm::raw_svector_ostream OS(ConfigMacros);
2491 const auto &PPOpts = CGM.getPreprocessorOpts();
2493 // Translate the macro definitions back into a command line.
2494 for (auto &M : PPOpts.Macros) {
2497 const std::string &Macro = M.first;
2498 bool Undef = M.second;
2499 OS << "\"-" << (Undef ? 'U' : 'D');
2500 for (char c : Macro)
2515 bool IsRootModule = M ? !M->Parent : true;
2516 // When a module name is specified as -fmodule-name, that module gets a
2517 // clang::Module object, but it won't actually be built or imported; it will
2519 if (CreateSkeletonCU && IsRootModule && Mod.getASTFile().empty() && M)
2520 assert(StringRef(M->Name).startswith(CGM.getLangOpts().ModuleName) &&
2521 "clang module without ASTFile must be specified by -fmodule-name");
2523 // Return a StringRef to the remapped Path.
2524 auto RemapPath = [this](StringRef Path) -> std::string {
2525 std::string Remapped = remapDIPath(Path);
2526 StringRef Relative(Remapped);
2527 StringRef CompDir = TheCU->getDirectory();
2528 if (Relative.consume_front(CompDir))
2529 Relative.consume_front(llvm::sys::path::get_separator());
2531 return Relative.str();
2534 if (CreateSkeletonCU && IsRootModule && !Mod.getASTFile().empty()) {
2535 // PCH files don't have a signature field in the control block,
2536 // but LLVM detects skeleton CUs by looking for a non-zero DWO id.
2537 // We use the lower 64 bits for debug info.
2539 uint64_t Signature = 0;
2540 if (const auto &ModSig = Mod.getSignature()) {
2541 for (unsigned I = 0; I != sizeof(Signature); ++I)
2542 Signature |= (uint64_t)ModSig[I] << (I * 8);
2546 llvm::DIBuilder DIB(CGM.getModule());
2548 if (!llvm::sys::path::is_absolute(Mod.getASTFile()))
2549 PCM = Mod.getPath();
2550 llvm::sys::path::append(PCM, Mod.getASTFile());
2551 DIB.createCompileUnit(
2552 TheCU->getSourceLanguage(),
2553 // TODO: Support "Source" from external AST providers?
2554 DIB.createFile(Mod.getModuleName(), TheCU->getDirectory()),
2555 TheCU->getProducer(), false, StringRef(), 0, RemapPath(PCM),
2556 llvm::DICompileUnit::FullDebug, Signature);
2560 llvm::DIModule *Parent =
2561 IsRootModule ? nullptr
2562 : getOrCreateModuleRef(ASTSourceDescriptor(*M->Parent),
2564 std::string IncludePath = Mod.getPath().str();
2565 llvm::DIModule *DIMod =
2566 DBuilder.createModule(Parent, Mod.getModuleName(), ConfigMacros,
2567 RemapPath(IncludePath));
2568 ModuleCache[M].reset(DIMod);
2572 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty,
2573 llvm::DIFile *Unit) {
2574 ObjCInterfaceDecl *ID = Ty->getDecl();
2575 llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation());
2576 unsigned Line = getLineNumber(ID->getLocation());
2577 unsigned RuntimeLang = TheCU->getSourceLanguage();
2579 // Bit size, align and offset of the type.
2580 uint64_t Size = CGM.getContext().getTypeSize(Ty);
2581 auto Align = getTypeAlignIfRequired(Ty, CGM.getContext());
2583 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2584 if (ID->getImplementation())
2585 Flags |= llvm::DINode::FlagObjcClassComplete;
2587 llvm::DIScope *Mod = getParentModuleOrNull(ID);
2588 llvm::DICompositeType *RealDecl = DBuilder.createStructType(
2589 Mod ? Mod : Unit, ID->getName(), DefUnit, Line, Size, Align, Flags,
2590 nullptr, llvm::DINodeArray(), RuntimeLang);
2592 QualType QTy(Ty, 0);
2593 TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl);
2595 // Push the struct on region stack.
2596 LexicalBlockStack.emplace_back(RealDecl);
2597 RegionMap[Ty->getDecl()].reset(RealDecl);
2599 // Convert all the elements.
2600 SmallVector<llvm::Metadata *, 16> EltTys;
2602 ObjCInterfaceDecl *SClass = ID->getSuperClass();
2604 llvm::DIType *SClassTy =
2605 getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit);
2609 llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0, 0,
2610 llvm::DINode::FlagZero);
2611 EltTys.push_back(InhTag);
2614 // Create entries for all of the properties.
2615 auto AddProperty = [&](const ObjCPropertyDecl *PD) {
2616 SourceLocation Loc = PD->getLocation();
2617 llvm::DIFile *PUnit = getOrCreateFile(Loc);
2618 unsigned PLine = getLineNumber(Loc);
2619 ObjCMethodDecl *Getter = PD->getGetterMethodDecl();
2620 ObjCMethodDecl *Setter = PD->getSetterMethodDecl();
2621 llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(
2622 PD->getName(), PUnit, PLine,
2623 hasDefaultGetterName(PD, Getter) ? ""
2624 : getSelectorName(PD->getGetterName()),
2625 hasDefaultSetterName(PD, Setter) ? ""
2626 : getSelectorName(PD->getSetterName()),
2627 PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit));
2628 EltTys.push_back(PropertyNode);
2631 llvm::SmallPtrSet<const IdentifierInfo *, 16> PropertySet;
2632 for (const ObjCCategoryDecl *ClassExt : ID->known_extensions())
2633 for (auto *PD : ClassExt->properties()) {
2634 PropertySet.insert(PD->getIdentifier());
2637 for (const auto *PD : ID->properties()) {
2638 // Don't emit duplicate metadata for properties that were already in a
2640 if (!PropertySet.insert(PD->getIdentifier()).second)
2646 const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(ID);
2647 unsigned FieldNo = 0;
2648 for (ObjCIvarDecl *Field = ID->all_declared_ivar_begin(); Field;
2649 Field = Field->getNextIvar(), ++FieldNo) {
2650 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
2654 StringRef FieldName = Field->getName();
2656 // Ignore unnamed fields.
2657 if (FieldName.empty())
2660 // Get the location for the field.
2661 llvm::DIFile *FieldDefUnit = getOrCreateFile(Field->getLocation());
2662 unsigned FieldLine = getLineNumber(Field->getLocation());
2663 QualType FType = Field->getType();
2664 uint64_t FieldSize = 0;
2665 uint32_t FieldAlign = 0;
2667 if (!FType->isIncompleteArrayType()) {
2669 // Bit size, align and offset of the type.
2670 FieldSize = Field->isBitField()
2671 ? Field->getBitWidthValue(CGM.getContext())
2672 : CGM.getContext().getTypeSize(FType);
2673 FieldAlign = getTypeAlignIfRequired(FType, CGM.getContext());
2676 uint64_t FieldOffset;
2677 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
2678 // We don't know the runtime offset of an ivar if we're using the
2679 // non-fragile ABI. For bitfields, use the bit offset into the first
2680 // byte of storage of the bitfield. For other fields, use zero.
2681 if (Field->isBitField()) {
2683 CGM.getObjCRuntime().ComputeBitfieldBitOffset(CGM, ID, Field);
2684 FieldOffset %= CGM.getContext().getCharWidth();
2689 FieldOffset = RL.getFieldOffset(FieldNo);
2692 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2693 if (Field->getAccessControl() == ObjCIvarDecl::Protected)
2694 Flags = llvm::DINode::FlagProtected;
2695 else if (Field->getAccessControl() == ObjCIvarDecl::Private)
2696 Flags = llvm::DINode::FlagPrivate;
2697 else if (Field->getAccessControl() == ObjCIvarDecl::Public)
2698 Flags = llvm::DINode::FlagPublic;
2700 llvm::MDNode *PropertyNode = nullptr;
2701 if (ObjCImplementationDecl *ImpD = ID->getImplementation()) {
2702 if (ObjCPropertyImplDecl *PImpD =
2703 ImpD->FindPropertyImplIvarDecl(Field->getIdentifier())) {
2704 if (ObjCPropertyDecl *PD = PImpD->getPropertyDecl()) {
2705 SourceLocation Loc = PD->getLocation();
2706 llvm::DIFile *PUnit = getOrCreateFile(Loc);
2707 unsigned PLine = getLineNumber(Loc);
2708 ObjCMethodDecl *Getter = PImpD->getGetterMethodDecl();
2709 ObjCMethodDecl *Setter = PImpD->getSetterMethodDecl();
2710 PropertyNode = DBuilder.createObjCProperty(
2711 PD->getName(), PUnit, PLine,
2712 hasDefaultGetterName(PD, Getter)
2714 : getSelectorName(PD->getGetterName()),
2715 hasDefaultSetterName(PD, Setter)
2717 : getSelectorName(PD->getSetterName()),
2718 PD->getPropertyAttributes(),
2719 getOrCreateType(PD->getType(), PUnit));
2723 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine,
2724 FieldSize, FieldAlign, FieldOffset, Flags,
2725 FieldTy, PropertyNode);
2726 EltTys.push_back(FieldTy);
2729 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2730 DBuilder.replaceArrays(RealDecl, Elements);
2732 LexicalBlockStack.pop_back();
2736 llvm::DIType *CGDebugInfo::CreateType(const VectorType *Ty,
2737 llvm::DIFile *Unit) {
2738 llvm::DIType *ElementTy = getOrCreateType(Ty->getElementType(), Unit);
2739 int64_t Count = Ty->getNumElements();
2741 llvm::Metadata *Subscript;
2742 QualType QTy(Ty, 0);
2743 auto SizeExpr = SizeExprCache.find(QTy);
2744 if (SizeExpr != SizeExprCache.end())
2745 Subscript = DBuilder.getOrCreateSubrange(
2746 SizeExpr->getSecond() /*count*/, nullptr /*lowerBound*/,
2747 nullptr /*upperBound*/, nullptr /*stride*/);
2750 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
2751 llvm::Type::getInt64Ty(CGM.getLLVMContext()), Count ? Count : -1));
2752 Subscript = DBuilder.getOrCreateSubrange(
2753 CountNode /*count*/, nullptr /*lowerBound*/, nullptr /*upperBound*/,
2754 nullptr /*stride*/);
2756 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
2758 uint64_t Size = CGM.getContext().getTypeSize(Ty);
2759 auto Align = getTypeAlignIfRequired(Ty, CGM.getContext());
2761 return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
2764 llvm::DIType *CGDebugInfo::CreateType(const ConstantMatrixType *Ty,
2765 llvm::DIFile *Unit) {
2766 // FIXME: Create another debug type for matrices
2767 // For the time being, it treats it like a nested ArrayType.
2769 llvm::DIType *ElementTy = getOrCreateType(Ty->getElementType(), Unit);
2770 uint64_t Size = CGM.getContext().getTypeSize(Ty);
2771 uint32_t Align = getTypeAlignIfRequired(Ty, CGM.getContext());
2773 // Create ranges for both dimensions.
2774 llvm::SmallVector<llvm::Metadata *, 2> Subscripts;
2775 auto *ColumnCountNode =
2776 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
2777 llvm::Type::getInt64Ty(CGM.getLLVMContext()), Ty->getNumColumns()));
2778 auto *RowCountNode =
2779 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
2780 llvm::Type::getInt64Ty(CGM.getLLVMContext()), Ty->getNumRows()));
2781 Subscripts.push_back(DBuilder.getOrCreateSubrange(
2782 ColumnCountNode /*count*/, nullptr /*lowerBound*/, nullptr /*upperBound*/,
2783 nullptr /*stride*/));
2784 Subscripts.push_back(DBuilder.getOrCreateSubrange(
2785 RowCountNode /*count*/, nullptr /*lowerBound*/, nullptr /*upperBound*/,
2786 nullptr /*stride*/));
2787 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
2788 return DBuilder.createArrayType(Size, Align, ElementTy, SubscriptArray);
2791 llvm::DIType *CGDebugInfo::CreateType(const ArrayType *Ty, llvm::DIFile *Unit) {
2795 // FIXME: make getTypeAlign() aware of VLAs and incomplete array types
2796 if (const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
2798 Align = getTypeAlignIfRequired(CGM.getContext().getBaseElementType(VAT),
2800 } else if (Ty->isIncompleteArrayType()) {
2802 if (Ty->getElementType()->isIncompleteType())
2805 Align = getTypeAlignIfRequired(Ty->getElementType(), CGM.getContext());
2806 } else if (Ty->isIncompleteType()) {
2810 // Size and align of the whole array, not the element type.
2811 Size = CGM.getContext().getTypeSize(Ty);
2812 Align = getTypeAlignIfRequired(Ty, CGM.getContext());
2815 // Add the dimensions of the array. FIXME: This loses CV qualifiers from
2816 // interior arrays, do we care? Why aren't nested arrays represented the
2817 // obvious/recursive way?
2818 SmallVector<llvm::Metadata *, 8> Subscripts;
2819 QualType EltTy(Ty, 0);
2820 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
2821 // If the number of elements is known, then count is that number. Otherwise,
2822 // it's -1. This allows us to represent a subrange with an array of 0
2823 // elements, like this:
2828 int64_t Count = -1; // Count == -1 is an unbounded array.
2829 if (const auto *CAT = dyn_cast<ConstantArrayType>(Ty))
2830 Count = CAT->getSize().getZExtValue();
2831 else if (const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
2832 if (Expr *Size = VAT->getSizeExpr()) {
2833 Expr::EvalResult Result;
2834 if (Size->EvaluateAsInt(Result, CGM.getContext()))
2835 Count = Result.Val.getInt().getExtValue();
2839 auto SizeNode = SizeExprCache.find(EltTy);
2840 if (SizeNode != SizeExprCache.end())
2841 Subscripts.push_back(DBuilder.getOrCreateSubrange(
2842 SizeNode->getSecond() /*count*/, nullptr /*lowerBound*/,
2843 nullptr /*upperBound*/, nullptr /*stride*/));
2846 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
2847 llvm::Type::getInt64Ty(CGM.getLLVMContext()), Count));
2848 Subscripts.push_back(DBuilder.getOrCreateSubrange(
2849 CountNode /*count*/, nullptr /*lowerBound*/, nullptr /*upperBound*/,
2850 nullptr /*stride*/));
2852 EltTy = Ty->getElementType();
2855 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
2857 return DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
2861 llvm::DIType *CGDebugInfo::CreateType(const LValueReferenceType *Ty,
2862 llvm::DIFile *Unit) {
2863 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty,
2864 Ty->getPointeeType(), Unit);
2867 llvm::DIType *CGDebugInfo::CreateType(const RValueReferenceType *Ty,
2868 llvm::DIFile *Unit) {
2869 return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type, Ty,
2870 Ty->getPointeeType(), Unit);
2873 llvm::DIType *CGDebugInfo::CreateType(const MemberPointerType *Ty,
2875 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2878 if (!Ty->isIncompleteType()) {
2879 Size = CGM.getContext().getTypeSize(Ty);
2881 // Set the MS inheritance model. There is no flag for the unspecified model.
2882 if (CGM.getTarget().getCXXABI().isMicrosoft()) {
2883 switch (Ty->getMostRecentCXXRecordDecl()->getMSInheritanceModel()) {
2884 case MSInheritanceModel::Single:
2885 Flags |= llvm::DINode::FlagSingleInheritance;
2887 case MSInheritanceModel::Multiple:
2888 Flags |= llvm::DINode::FlagMultipleInheritance;
2890 case MSInheritanceModel::Virtual:
2891 Flags |= llvm::DINode::FlagVirtualInheritance;
2893 case MSInheritanceModel::Unspecified:
2899 llvm::DIType *ClassType = getOrCreateType(QualType(Ty->getClass(), 0), U);
2900 if (Ty->isMemberDataPointerType())
2901 return DBuilder.createMemberPointerType(
2902 getOrCreateType(Ty->getPointeeType(), U), ClassType, Size, /*Align=*/0,
2905 const FunctionProtoType *FPT =
2906 Ty->getPointeeType()->getAs<FunctionProtoType>();
2907 return DBuilder.createMemberPointerType(
2908 getOrCreateInstanceMethodType(
2909 CXXMethodDecl::getThisType(FPT, Ty->getMostRecentCXXRecordDecl()),
2911 ClassType, Size, /*Align=*/0, Flags);
2914 llvm::DIType *CGDebugInfo::CreateType(const AtomicType *Ty, llvm::DIFile *U) {
2915 auto *FromTy = getOrCreateType(Ty->getValueType(), U);
2916 return DBuilder.createQualifiedType(llvm::dwarf::DW_TAG_atomic_type, FromTy);
2919 llvm::DIType *CGDebugInfo::CreateType(const PipeType *Ty, llvm::DIFile *U) {
2920 return getOrCreateType(Ty->getElementType(), U);
2923 llvm::DIType *CGDebugInfo::CreateEnumType(const EnumType *Ty) {
2924 const EnumDecl *ED = Ty->getDecl();
2928 if (!ED->getTypeForDecl()->isIncompleteType()) {
2929 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
2930 Align = getDeclAlignIfRequired(ED, CGM.getContext());
2933 SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU);
2935 bool isImportedFromModule =
2936 DebugTypeExtRefs && ED->isFromASTFile() && ED->getDefinition();
2938 // If this is just a forward declaration, construct an appropriately
2939 // marked node and just return it.
2940 if (isImportedFromModule || !ED->getDefinition()) {
2941 // Note that it is possible for enums to be created as part of
2942 // their own declcontext. In this case a FwdDecl will be created
2943 // twice. This doesn't cause a problem because both FwdDecls are
2944 // entered into the ReplaceMap: finalize() will replace the first
2945 // FwdDecl with the second and then replace the second with
2947 llvm::DIScope *EDContext = getDeclContextDescriptor(ED);
2948 llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
2949 llvm::TempDIScope TmpContext(DBuilder.createReplaceableCompositeType(
2950 llvm::dwarf::DW_TAG_enumeration_type, "", TheCU, DefUnit, 0));
2952 unsigned Line = getLineNumber(ED->getLocation());
2953 StringRef EDName = ED->getName();
2954 llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType(
2955 llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit, Line,
2956 0, Size, Align, llvm::DINode::FlagFwdDecl, Identifier);
2958 ReplaceMap.emplace_back(
2959 std::piecewise_construct, std::make_tuple(Ty),
2960 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
2964 return CreateTypeDefinition(Ty);
2967 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) {
2968 const EnumDecl *ED = Ty->getDecl();
2971 if (!ED->getTypeForDecl()->isIncompleteType()) {
2972 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
2973 Align = getDeclAlignIfRequired(ED, CGM.getContext());
2976 SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU);
2978 // Create elements for each enumerator.
2979 SmallVector<llvm::Metadata *, 16> Enumerators;
2980 ED = ED->getDefinition();
2981 bool IsSigned = ED->getIntegerType()->isSignedIntegerType();
2982 for (const auto *Enum : ED->enumerators()) {
2983 const auto &InitVal = Enum->getInitVal();
2984 auto Value = IsSigned ? InitVal.getSExtValue() : InitVal.getZExtValue();
2985 Enumerators.push_back(
2986 DBuilder.createEnumerator(Enum->getName(), Value, !IsSigned));
2989 // Return a CompositeType for the enum itself.
2990 llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
2992 llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
2993 unsigned Line = getLineNumber(ED->getLocation());
2994 llvm::DIScope *EnumContext = getDeclContextDescriptor(ED);
2995 llvm::DIType *ClassTy = getOrCreateType(ED->getIntegerType(), DefUnit);
2996 return DBuilder.createEnumerationType(EnumContext, ED->getName(), DefUnit,
2997 Line, Size, Align, EltArray, ClassTy,
2998 Identifier, ED->isScoped());
3001 llvm::DIMacro *CGDebugInfo::CreateMacro(llvm::DIMacroFile *Parent,
3002 unsigned MType, SourceLocation LineLoc,
3003 StringRef Name, StringRef Value) {
3004 unsigned Line = LineLoc.isInvalid() ? 0 : getLineNumber(LineLoc);
3005 return DBuilder.createMacro(Parent, Line, MType, Name, Value);
3008 llvm::DIMacroFile *CGDebugInfo::CreateTempMacroFile(llvm::DIMacroFile *Parent,
3009 SourceLocation LineLoc,
3010 SourceLocation FileLoc) {
3011 llvm::DIFile *FName = getOrCreateFile(FileLoc);
3012 unsigned Line = LineLoc.isInvalid() ? 0 : getLineNumber(LineLoc);
3013 return DBuilder.createTempMacroFile(Parent, Line, FName);
3016 static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C) {
3019 Qualifiers InnerQuals = T.getLocalQualifiers();
3020 // Qualifiers::operator+() doesn't like it if you add a Qualifier
3021 // that is already there.
3022 Quals += Qualifiers::removeCommonQualifiers(Quals, InnerQuals);
3023 Quals += InnerQuals;
3025 switch (T->getTypeClass()) {
3027 return C.getQualifiedType(T.getTypePtr(), Quals);
3028 case Type::TemplateSpecialization: {
3029 const auto *Spec = cast<TemplateSpecializationType>(T);
3030 if (Spec->isTypeAlias())
3031 return C.getQualifiedType(T.getTypePtr(), Quals);
3032 T = Spec->desugar();
3035 case Type::TypeOfExpr:
3036 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
3039 T = cast<TypeOfType>(T)->getUnderlyingType();
3041 case Type::Decltype:
3042 T = cast<DecltypeType>(T)->getUnderlyingType();
3044 case Type::UnaryTransform:
3045 T = cast<UnaryTransformType>(T)->getUnderlyingType();
3047 case Type::Attributed:
3048 T = cast<AttributedType>(T)->getEquivalentType();
3050 case Type::Elaborated:
3051 T = cast<ElaboratedType>(T)->getNamedType();
3054 T = cast<ParenType>(T)->getInnerType();
3056 case Type::MacroQualified:
3057 T = cast<MacroQualifiedType>(T)->getUnderlyingType();
3059 case Type::SubstTemplateTypeParm:
3060 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
3063 case Type::DeducedTemplateSpecialization: {
3064 QualType DT = cast<DeducedType>(T)->getDeducedType();
3065 assert(!DT.isNull() && "Undeduced types shouldn't reach here.");
3069 case Type::Adjusted:
3071 // Decayed and adjusted types use the adjusted type in LLVM and DWARF.
3072 T = cast<AdjustedType>(T)->getAdjustedType();
3076 assert(T != LastT && "Type unwrapping failed to unwrap!");
3081 llvm::DIType *CGDebugInfo::getTypeOrNull(QualType Ty) {
3083 // Unwrap the type as needed for debug information.
3084 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
3086 auto It = TypeCache.find(Ty.getAsOpaquePtr());
3087 if (It != TypeCache.end()) {
3088 // Verify that the debug info still exists.
3089 if (llvm::Metadata *V = It->second)
3090 return cast<llvm::DIType>(V);
3096 void CGDebugInfo::completeTemplateDefinition(
3097 const ClassTemplateSpecializationDecl &SD) {
3098 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
3100 completeUnusedClass(SD);
3103 void CGDebugInfo::completeUnusedClass(const CXXRecordDecl &D) {
3104 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
3107 completeClassData(&D);
3108 // In case this type has no member function definitions being emitted, ensure
3110 RetainedTypes.push_back(CGM.getContext().getRecordType(&D).getAsOpaquePtr());
3113 llvm::DIType *CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile *Unit) {
3117 llvm::TimeTraceScope TimeScope("DebugType", [&]() {
3119 llvm::raw_string_ostream OS(Name);
3120 Ty.print(OS, getPrintingPolicy());
3124 // Unwrap the type as needed for debug information.
3125 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
3127 if (auto *T = getTypeOrNull(Ty))
3130 llvm::DIType *Res = CreateTypeNode(Ty, Unit);
3131 void *TyPtr = Ty.getAsOpaquePtr();
3133 // And update the type cache.
3134 TypeCache[TyPtr].reset(Res);
3139 llvm::DIModule *CGDebugInfo::getParentModuleOrNull(const Decl *D) {
3140 // A forward declaration inside a module header does not belong to the module.
3141 if (isa<RecordDecl>(D) && !cast<RecordDecl>(D)->getDefinition())
3143 if (DebugTypeExtRefs && D->isFromASTFile()) {
3144 // Record a reference to an imported clang module or precompiled header.
3145 auto *Reader = CGM.getContext().getExternalSource();
3146 auto Idx = D->getOwningModuleID();
3147 auto Info = Reader->getSourceDescriptor(Idx);
3149 return getOrCreateModuleRef(*Info, /*SkeletonCU=*/true);
3150 } else if (ClangModuleMap) {
3151 // We are building a clang module or a precompiled header.
3153 // TODO: When D is a CXXRecordDecl or a C++ Enum, the ODR applies
3154 // and it wouldn't be necessary to specify the parent scope
3155 // because the type is already unique by definition (it would look
3156 // like the output of -fno-standalone-debug). On the other hand,
3157 // the parent scope helps a consumer to quickly locate the object
3158 // file where the type's definition is located, so it might be
3159 // best to make this behavior a command line or debugger tuning
3161 if (Module *M = D->getOwningModule()) {
3162 // This is a (sub-)module.
3163 auto Info = ASTSourceDescriptor(*M);
3164 return getOrCreateModuleRef(Info, /*SkeletonCU=*/false);
3166 // This the precompiled header being built.
3167 return getOrCreateModuleRef(PCHDescriptor, /*SkeletonCU=*/false);
3174 llvm::DIType *CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile *Unit) {
3175 // Handle qualifiers, which recursively handles what they refer to.
3176 if (Ty.hasLocalQualifiers())
3177 return CreateQualifiedType(Ty, Unit);
3179 // Work out details of type.
3180 switch (Ty->getTypeClass()) {
3181 #define TYPE(Class, Base)
3182 #define ABSTRACT_TYPE(Class, Base)
3183 #define NON_CANONICAL_TYPE(Class, Base)
3184 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
3185 #include "clang/AST/TypeNodes.inc"
3186 llvm_unreachable("Dependent types cannot show up in debug information");
3188 case Type::ExtVector:
3190 return CreateType(cast<VectorType>(Ty), Unit);
3191 case Type::ConstantMatrix:
3192 return CreateType(cast<ConstantMatrixType>(Ty), Unit);
3193 case Type::ObjCObjectPointer:
3194 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
3195 case Type::ObjCObject:
3196 return CreateType(cast<ObjCObjectType>(Ty), Unit);
3197 case Type::ObjCTypeParam:
3198 return CreateType(cast<ObjCTypeParamType>(Ty), Unit);
3199 case Type::ObjCInterface:
3200 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
3202 return CreateType(cast<BuiltinType>(Ty));
3204 return CreateType(cast<ComplexType>(Ty));
3206 return CreateType(cast<PointerType>(Ty), Unit);
3207 case Type::BlockPointer:
3208 return CreateType(cast<BlockPointerType>(Ty), Unit);
3210 return CreateType(cast<TypedefType>(Ty), Unit);
3212 return CreateType(cast<RecordType>(Ty));
3214 return CreateEnumType(cast<EnumType>(Ty));
3215 case Type::FunctionProto:
3216 case Type::FunctionNoProto:
3217 return CreateType(cast<FunctionType>(Ty), Unit);
3218 case Type::ConstantArray:
3219 case Type::VariableArray:
3220 case Type::IncompleteArray:
3221 return CreateType(cast<ArrayType>(Ty), Unit);
3223 case Type::LValueReference:
3224 return CreateType(cast<LValueReferenceType>(Ty), Unit);
3225 case Type::RValueReference:
3226 return CreateType(cast<RValueReferenceType>(Ty), Unit);
3228 case Type::MemberPointer:
3229 return CreateType(cast<MemberPointerType>(Ty), Unit);
3232 return CreateType(cast<AtomicType>(Ty), Unit);
3235 return CreateType(cast<ExtIntType>(Ty));
3237 return CreateType(cast<PipeType>(Ty), Unit);
3239 case Type::TemplateSpecialization:
3240 return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
3243 case Type::Attributed:
3244 case Type::Adjusted:
3246 case Type::DeducedTemplateSpecialization:
3247 case Type::Elaborated:
3249 case Type::MacroQualified:
3250 case Type::SubstTemplateTypeParm:
3251 case Type::TypeOfExpr:
3253 case Type::Decltype:
3254 case Type::UnaryTransform:
3255 case Type::PackExpansion:
3259 llvm_unreachable("type should have been unwrapped!");
3262 llvm::DICompositeType *CGDebugInfo::getOrCreateLimitedType(const RecordType *Ty,
3263 llvm::DIFile *Unit) {
3264 QualType QTy(Ty, 0);
3266 auto *T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));
3268 // We may have cached a forward decl when we could have created
3269 // a non-forward decl. Go ahead and create a non-forward decl
3271 if (T && !T->isForwardDecl())
3274 // Otherwise create the type.
3275 llvm::DICompositeType *Res = CreateLimitedType(Ty);
3277 // Propagate members from the declaration to the definition
3278 // CreateType(const RecordType*) will overwrite this with the members in the
3279 // correct order if the full type is needed.
3280 DBuilder.replaceArrays(Res, T ? T->getElements() : llvm::DINodeArray());
3282 // And update the type cache.
3283 TypeCache[QTy.getAsOpaquePtr()].reset(Res);
3287 // TODO: Currently used for context chains when limiting debug info.
3288 llvm::DICompositeType *CGDebugInfo::CreateLimitedType(const RecordType *Ty) {
3289 RecordDecl *RD = Ty->getDecl();
3291 // Get overall information about the record type for the debug info.
3292 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
3293 unsigned Line = getLineNumber(RD->getLocation());
3294 StringRef RDName = getClassName(RD);
3296 llvm::DIScope *RDContext = getDeclContextDescriptor(RD);
3298 // If we ended up creating the type during the context chain construction,
3299 // just return that.
3300 auto *T = cast_or_null<llvm::DICompositeType>(
3301 getTypeOrNull(CGM.getContext().getRecordType(RD)));
3302 if (T && (!T->isForwardDecl() || !RD->getDefinition()))
3305 // If this is just a forward or incomplete declaration, construct an
3306 // appropriately marked node and just return it.
3307 const RecordDecl *D = RD->getDefinition();
3308 if (!D || !D->isCompleteDefinition())
3309 return getOrCreateRecordFwdDecl(Ty, RDContext);
3311 uint64_t Size = CGM.getContext().getTypeSize(Ty);
3312 auto Align = getDeclAlignIfRequired(D, CGM.getContext());
3314 SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU);
3316 // Explicitly record the calling convention and export symbols for C++
3318 auto Flags = llvm::DINode::FlagZero;
3319 if (auto CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3320 if (CGM.getCXXABI().getRecordArgABI(CXXRD) == CGCXXABI::RAA_Indirect)
3321 Flags |= llvm::DINode::FlagTypePassByReference;
3323 Flags |= llvm::DINode::FlagTypePassByValue;
3325 // Record if a C++ record is non-trivial type.
3326 if (!CXXRD->isTrivial())
3327 Flags |= llvm::DINode::FlagNonTrivial;
3329 // Record exports it symbols to the containing structure.
3330 if (CXXRD->isAnonymousStructOrUnion())
3331 Flags |= llvm::DINode::FlagExportSymbols;
3334 llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
3335 getTagForRecord(RD), RDName, RDContext, DefUnit, Line, 0, Size, Align,
3338 // Elements of composite types usually have back to the type, creating
3339 // uniquing cycles. Distinct nodes are more efficient.
3340 switch (RealDecl->getTag()) {
3342 llvm_unreachable("invalid composite type tag");
3344 case llvm::dwarf::DW_TAG_array_type:
3345 case llvm::dwarf::DW_TAG_enumeration_type:
3346 // Array elements and most enumeration elements don't have back references,
3347 // so they don't tend to be involved in uniquing cycles and there is some
3348 // chance of merging them when linking together two modules. Only make
3349 // them distinct if they are ODR-uniqued.
3350 if (Identifier.empty())
3354 case llvm::dwarf::DW_TAG_structure_type:
3355 case llvm::dwarf::DW_TAG_union_type:
3356 case llvm::dwarf::DW_TAG_class_type:
3357 // Immediately resolve to a distinct node.
3359 llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
3363 RegionMap[Ty->getDecl()].reset(RealDecl);
3364 TypeCache[QualType(Ty, 0).getAsOpaquePtr()].reset(RealDecl);
3366 if (const auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
3367 DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),
3368 CollectCXXTemplateParams(TSpecial, DefUnit));
3372 void CGDebugInfo::CollectContainingType(const CXXRecordDecl *RD,
3373 llvm::DICompositeType *RealDecl) {
3374 // A class's primary base or the class itself contains the vtable.
3375 llvm::DICompositeType *ContainingType = nullptr;
3376 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
3377 if (const CXXRecordDecl *PBase = RL.getPrimaryBase()) {
3378 // Seek non-virtual primary base root.
3380 const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase);
3381 const CXXRecordDecl *PBT = BRL.getPrimaryBase();
3382 if (PBT && !BRL.isPrimaryBaseVirtual())
3387 ContainingType = cast<llvm::DICompositeType>(
3388 getOrCreateType(QualType(PBase->getTypeForDecl(), 0),
3389 getOrCreateFile(RD->getLocation())));
3390 } else if (RD->isDynamicClass())
3391 ContainingType = RealDecl;
3393 DBuilder.replaceVTableHolder(RealDecl, ContainingType);
3396 llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit, QualType FType,
3397 StringRef Name, uint64_t *Offset) {
3398 llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
3399 uint64_t FieldSize = CGM.getContext().getTypeSize(FType);
3400 auto FieldAlign = getTypeAlignIfRequired(FType, CGM.getContext());
3402 DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize, FieldAlign,
3403 *Offset, llvm::DINode::FlagZero, FieldTy);
3404 *Offset += FieldSize;
3408 void CGDebugInfo::collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit,
3410 StringRef &LinkageName,
3411 llvm::DIScope *&FDContext,
3412 llvm::DINodeArray &TParamsArray,
3413 llvm::DINode::DIFlags &Flags) {
3414 const auto *FD = cast<FunctionDecl>(GD.getDecl());
3415 Name = getFunctionName(FD);
3416 // Use mangled name as linkage name for C/C++ functions.
3417 if (FD->hasPrototype()) {
3418 LinkageName = CGM.getMangledName(GD);
3419 Flags |= llvm::DINode::FlagPrototyped;
3421 // No need to replicate the linkage name if it isn't different from the
3422 // subprogram name, no need to have it at all unless coverage is enabled or
3423 // debug is set to more than just line tables or extra debug info is needed.
3424 if (LinkageName == Name || (!CGM.getCodeGenOpts().EmitGcovArcs &&
3425 !CGM.getCodeGenOpts().EmitGcovNotes &&
3426 !CGM.getCodeGenOpts().DebugInfoForProfiling &&
3427 DebugKind <= codegenoptions::DebugLineTablesOnly))
3428 LinkageName = StringRef();
3430 if (CGM.getCodeGenOpts().hasReducedDebugInfo()) {
3431 if (const NamespaceDecl *NSDecl =
3432 dyn_cast_or_null<NamespaceDecl>(FD->getDeclContext()))
3433 FDContext = getOrCreateNamespace(NSDecl);
3434 else if (const RecordDecl *RDecl =
3435 dyn_cast_or_null<RecordDecl>(FD->getDeclContext())) {
3436 llvm::DIScope *Mod = getParentModuleOrNull(RDecl);
3437 FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU);
3439 // Check if it is a noreturn-marked function
3440 if (FD->isNoReturn())
3441 Flags |= llvm::DINode::FlagNoReturn;
3442 // Collect template parameters.
3443 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
3447 void CGDebugInfo::collectVarDeclProps(const VarDecl *VD, llvm::DIFile *&Unit,
3448 unsigned &LineNo, QualType &T,
3449 StringRef &Name, StringRef &LinkageName,
3450 llvm::MDTuple *&TemplateParameters,
3451 llvm::DIScope *&VDContext) {
3452 Unit = getOrCreateFile(VD->getLocation());
3453 LineNo = getLineNumber(VD->getLocation());
3455 setLocation(VD->getLocation());
3458 if (T->isIncompleteArrayType()) {
3459 // CodeGen turns int[] into int[1] so we'll do the same here.
3460 llvm::APInt ConstVal(32, 1);
3461 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
3463 T = CGM.getContext().getConstantArrayType(ET, ConstVal, nullptr,
3464 ArrayType::Normal, 0);
3467 Name = VD->getName();
3468 if (VD->getDeclContext() && !isa<FunctionDecl>(VD->getDeclContext()) &&
3469 !isa<ObjCMethodDecl>(VD->getDeclContext()))
3470 LinkageName = CGM.getMangledName(VD);
3471 if (LinkageName == Name)
3472 LinkageName = StringRef();
3474 if (isa<VarTemplateSpecializationDecl>(VD)) {
3475 llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VD, &*Unit);
3476 TemplateParameters = parameterNodes.get();
3478 TemplateParameters = nullptr;
3481 // Since we emit declarations (DW_AT_members) for static members, place the
3482 // definition of those static members in the namespace they were declared in
3483 // in the source code (the lexical decl context).
3484 // FIXME: Generalize this for even non-member global variables where the
3485 // declaration and definition may have different lexical decl contexts, once
3486 // we have support for emitting declarations of (non-member) global variables.
3487 const DeclContext *DC = VD->isStaticDataMember() ? VD->getLexicalDeclContext()
3488 : VD->getDeclContext();
3489 // When a record type contains an in-line initialization of a static data
3490 // member, and the record type is marked as __declspec(dllexport), an implicit
3491 // definition of the member will be created in the record context. DWARF
3492 // doesn't seem to have a nice way to describe this in a form that consumers
3493 // are likely to understand, so fake the "normal" situation of a definition
3494 // outside the class by putting it in the global scope.
3496 DC = CGM.getContext().getTranslationUnitDecl();
3498 llvm::DIScope *Mod = getParentModuleOrNull(VD);
3499 VDContext = getContextDescriptor(cast<Decl>(DC), Mod ? Mod : TheCU);
3502 llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(GlobalDecl GD,
3504 llvm::DINodeArray TParamsArray;
3505 StringRef Name, LinkageName;
3506 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3507 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
3508 SourceLocation Loc = GD.getDecl()->getLocation();
3509 llvm::DIFile *Unit = getOrCreateFile(Loc);
3510 llvm::DIScope *DContext = Unit;
3511 unsigned Line = getLineNumber(Loc);
3512 collectFunctionDeclProps(GD, Unit, Name, LinkageName, DContext, TParamsArray,
3514 auto *FD = cast<FunctionDecl>(GD.getDecl());
3516 // Build function type.
3517 SmallVector<QualType, 16> ArgTypes;
3518 for (const ParmVarDecl *Parm : FD->parameters())
3519 ArgTypes.push_back(Parm->getType());
3521 CallingConv CC = FD->getType()->castAs<FunctionType>()->getCallConv();
3522 QualType FnType = CGM.getContext().getFunctionType(
3523 FD->getReturnType(), ArgTypes, FunctionProtoType::ExtProtoInfo(CC));
3524 if (!FD->isExternallyVisible())
3525 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
3526 if (CGM.getLangOpts().Optimize)
3527 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
3530 Flags |= getCallSiteRelatedAttrs();
3531 SPFlags |= llvm::DISubprogram::SPFlagDefinition;
3532 return DBuilder.createFunction(
3533 DContext, Name, LinkageName, Unit, Line,
3534 getOrCreateFunctionType(GD.getDecl(), FnType, Unit), 0, Flags, SPFlags,
3535 TParamsArray.get(), getFunctionDeclaration(FD));
3538 llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
3539 DContext, Name, LinkageName, Unit, Line,
3540 getOrCreateFunctionType(GD.getDecl(), FnType, Unit), 0, Flags, SPFlags,
3541 TParamsArray.get(), getFunctionDeclaration(FD));
3542 const FunctionDecl *CanonDecl = FD->getCanonicalDecl();
3543 FwdDeclReplaceMap.emplace_back(std::piecewise_construct,
3544 std::make_tuple(CanonDecl),
3545 std::make_tuple(SP));
3549 llvm::DISubprogram *CGDebugInfo::getFunctionForwardDeclaration(GlobalDecl GD) {
3550 return getFunctionFwdDeclOrStub(GD, /* Stub = */ false);
3553 llvm::DISubprogram *CGDebugInfo::getFunctionStub(GlobalDecl GD) {
3554 return getFunctionFwdDeclOrStub(GD, /* Stub = */ true);
3557 llvm::DIGlobalVariable *
3558 CGDebugInfo::getGlobalVariableForwardDeclaration(const VarDecl *VD) {
3560 StringRef Name, LinkageName;
3561 SourceLocation Loc = VD->getLocation();
3562 llvm::DIFile *Unit = getOrCreateFile(Loc);
3563 llvm::DIScope *DContext = Unit;
3564 unsigned Line = getLineNumber(Loc);
3565 llvm::MDTuple *TemplateParameters = nullptr;
3567 collectVarDeclProps(VD, Unit, Line, T, Name, LinkageName, TemplateParameters,
3569 auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
3570 auto *GV = DBuilder.createTempGlobalVariableFwdDecl(
3571 DContext, Name, LinkageName, Unit, Line, getOrCreateType(T, Unit),
3572 !VD->isExternallyVisible(), nullptr, TemplateParameters, Align);
3573 FwdDeclReplaceMap.emplace_back(
3574 std::piecewise_construct,
3575 std::make_tuple(cast<VarDecl>(VD->getCanonicalDecl())),
3576 std::make_tuple(static_cast<llvm::Metadata *>(GV)));
3580 llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(const Decl *D) {
3581 // We only need a declaration (not a definition) of the type - so use whatever
3582 // we would otherwise do to get a type for a pointee. (forward declarations in
3583 // limited debug info, full definitions (if the type definition is available)
3584 // in unlimited debug info)
3585 if (const auto *TD = dyn_cast<TypeDecl>(D))
3586 return getOrCreateType(CGM.getContext().getTypeDeclType(TD),
3587 getOrCreateFile(TD->getLocation()));
3588 auto I = DeclCache.find(D->getCanonicalDecl());
3590 if (I != DeclCache.end()) {
3592 if (auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(N))
3593 return GVE->getVariable();
3594 return dyn_cast_or_null<llvm::DINode>(N);
3597 // No definition for now. Emit a forward definition that might be
3598 // merged with a potential upcoming definition.
3599 if (const auto *FD = dyn_cast<FunctionDecl>(D))
3600 return getFunctionForwardDeclaration(FD);
3601 else if (const auto *VD = dyn_cast<VarDecl>(D))
3602 return getGlobalVariableForwardDeclaration(VD);
3607 llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(const Decl *D) {
3608 if (!D || DebugKind <= codegenoptions::DebugLineTablesOnly)
3611 const auto *FD = dyn_cast<FunctionDecl>(D);
3616 auto *S = getDeclContextDescriptor(D);
3618 auto MI = SPCache.find(FD->getCanonicalDecl());
3619 if (MI == SPCache.end()) {
3620 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD->getCanonicalDecl())) {
3621 return CreateCXXMemberFunction(MD, getOrCreateFile(MD->getLocation()),
3622 cast<llvm::DICompositeType>(S));
3625 if (MI != SPCache.end()) {
3626 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3627 if (SP && !SP->isDefinition())
3631 for (auto NextFD : FD->redecls()) {
3632 auto MI = SPCache.find(NextFD->getCanonicalDecl());
3633 if (MI != SPCache.end()) {
3634 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3635 if (SP && !SP->isDefinition())
3642 llvm::DISubprogram *CGDebugInfo::getObjCMethodDeclaration(
3643 const Decl *D, llvm::DISubroutineType *FnType, unsigned LineNo,
3644 llvm::DINode::DIFlags Flags, llvm::DISubprogram::DISPFlags SPFlags) {
3645 if (!D || DebugKind <= codegenoptions::DebugLineTablesOnly)
3648 const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
3652 if (CGM.getCodeGenOpts().DwarfVersion < 5 && !OMD->isDirectMethod())
3655 if (OMD->isDirectMethod())
3656 SPFlags |= llvm::DISubprogram::SPFlagObjCDirect;
3658 // Starting with DWARF V5 method declarations are emitted as children of
3659 // the interface type.
3660 auto *ID = dyn_cast_or_null<ObjCInterfaceDecl>(D->getDeclContext());
3662 ID = OMD->getClassInterface();
3665 QualType QTy(ID->getTypeForDecl(), 0);
3666 auto It = TypeCache.find(QTy.getAsOpaquePtr());
3667 if (It == TypeCache.end())
3669 auto *InterfaceType = cast<llvm::DICompositeType>(It->second);
3670 llvm::DISubprogram *FD = DBuilder.createFunction(
3671 InterfaceType, getObjCMethodName(OMD), StringRef(),
3672 InterfaceType->getFile(), LineNo, FnType, LineNo, Flags, SPFlags);
3673 DBuilder.finalizeSubprogram(FD);
3674 ObjCMethodCache[ID].push_back({FD, OMD->isDirectMethod()});
3678 // getOrCreateFunctionType - Construct type. If it is a c++ method, include
3679 // implicit parameter "this".
3680 llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(const Decl *D,
3683 if (!D || DebugKind <= codegenoptions::DebugLineTablesOnly)
3684 // Create fake but valid subroutine type. Otherwise -verify would fail, and
3685 // subprogram DIE will miss DW_AT_decl_file and DW_AT_decl_line fields.
3686 return DBuilder.createSubroutineType(DBuilder.getOrCreateTypeArray(None));
3688 if (const auto *Method = dyn_cast<CXXMethodDecl>(D))
3689 return getOrCreateMethodType(Method, F, false);
3691 const auto *FTy = FnType->getAs<FunctionType>();
3692 CallingConv CC = FTy ? FTy->getCallConv() : CallingConv::CC_C;
3694 if (const auto *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
3695 // Add "self" and "_cmd"
3696 SmallVector<llvm::Metadata *, 16> Elts;
3698 // First element is always return type. For 'void' functions it is NULL.
3699 QualType ResultTy = OMethod->getReturnType();
3701 // Replace the instancetype keyword with the actual type.
3702 if (ResultTy == CGM.getContext().getObjCInstanceType())
3703 ResultTy = CGM.getContext().getPointerType(
3704 QualType(OMethod->getClassInterface()->getTypeForDecl(), 0));
3706 Elts.push_back(getOrCreateType(ResultTy, F));
3707 // "self" pointer is always first argument.
3708 QualType SelfDeclTy;
3709 if (auto *SelfDecl = OMethod->getSelfDecl())
3710 SelfDeclTy = SelfDecl->getType();
3711 else if (auto *FPT = dyn_cast<FunctionProtoType>(FnType))
3712 if (FPT->getNumParams() > 1)
3713 SelfDeclTy = FPT->getParamType(0);
3714 if (!SelfDeclTy.isNull())
3716 CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F)));
3717 // "_cmd" pointer is always second argument.
3718 Elts.push_back(DBuilder.createArtificialType(
3719 getOrCreateType(CGM.getContext().getObjCSelType(), F)));
3720 // Get rest of the arguments.
3721 for (const auto *PI : OMethod->parameters())
3722 Elts.push_back(getOrCreateType(PI->getType(), F));
3723 // Variadic methods need a special marker at the end of the type list.
3724 if (OMethod->isVariadic())
3725 Elts.push_back(DBuilder.createUnspecifiedParameter());
3727 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
3728 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
3732 // Handle variadic function types; they need an additional
3733 // unspecified parameter.
3734 if (const auto *FD = dyn_cast<FunctionDecl>(D))
3735 if (FD->isVariadic()) {
3736 SmallVector<llvm::Metadata *, 16> EltTys;
3737 EltTys.push_back(getOrCreateType(FD->getReturnType(), F));
3738 if (const auto *FPT = dyn_cast<FunctionProtoType>(FnType))
3739 for (QualType ParamType : FPT->param_types())
3740 EltTys.push_back(getOrCreateType(ParamType, F));
3741 EltTys.push_back(DBuilder.createUnspecifiedParameter());
3742 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
3743 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
3747 return cast<llvm::DISubroutineType>(getOrCreateType(FnType, F));
3750 void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, SourceLocation Loc,
3751 SourceLocation ScopeLoc, QualType FnType,
3752 llvm::Function *Fn, bool CurFuncIsThunk,
3753 CGBuilderTy &Builder) {
3756 StringRef LinkageName;
3758 FnBeginRegionCount.push_back(LexicalBlockStack.size());
3760 const Decl *D = GD.getDecl();
3761 bool HasDecl = (D != nullptr);
3763 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3764 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
3765 llvm::DIFile *Unit = getOrCreateFile(Loc);
3766 llvm::DIScope *FDContext = Unit;
3767 llvm::DINodeArray TParamsArray;
3769 // Use llvm function name.
3770 LinkageName = Fn->getName();
3771 } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
3772 // If there is a subprogram for this function available then use it.
3773 auto FI = SPCache.find(FD->getCanonicalDecl());
3774 if (FI != SPCache.end()) {
3775 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
3776 if (SP && SP->isDefinition()) {
3777 LexicalBlockStack.emplace_back(SP);
3778 RegionMap[D].reset(SP);
3782 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
3783 TParamsArray, Flags);
3784 } else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
3785 Name = getObjCMethodName(OMD);
3786 Flags |= llvm::DINode::FlagPrototyped;
3787 } else if (isa<VarDecl>(D) &&
3788 GD.getDynamicInitKind() != DynamicInitKind::NoStub) {
3789 // This is a global initializer or atexit destructor for a global variable.
3790 Name = getDynamicInitializerName(cast<VarDecl>(D), GD.getDynamicInitKind(),
3793 Name = Fn->getName();
3795 if (isa<BlockDecl>(D))
3798 Flags |= llvm::DINode::FlagPrototyped;
3800 if (Name.startswith("\01"))
3801 Name = Name.substr(1);
3803 if (!HasDecl || D->isImplicit() || D->hasAttr<ArtificialAttr>()) {
3804 Flags |= llvm::DINode::FlagArtificial;
3805 // Artificial functions should not silently reuse CurLoc.
3806 CurLoc = SourceLocation();
3810 Flags |= llvm::DINode::FlagThunk;
3812 if (Fn->hasLocalLinkage())
3813 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
3814 if (CGM.getLangOpts().Optimize)
3815 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
3817 llvm::DINode::DIFlags FlagsForDef = Flags | getCallSiteRelatedAttrs();
3818 llvm::DISubprogram::DISPFlags SPFlagsForDef =
3819 SPFlags | llvm::DISubprogram::SPFlagDefinition;
3821 unsigned LineNo = getLineNumber(Loc);
3822 unsigned ScopeLine = getLineNumber(ScopeLoc);
3823 llvm::DISubroutineType *DIFnType = getOrCreateFunctionType(D, FnType, Unit);
3824 llvm::DISubprogram *Decl = nullptr;
3826 Decl = isa<ObjCMethodDecl>(D)
3827 ? getObjCMethodDeclaration(D, DIFnType, LineNo, Flags, SPFlags)
3828 : getFunctionDeclaration(D);
3830 // FIXME: The function declaration we're constructing here is mostly reusing
3831 // declarations from CXXMethodDecl and not constructing new ones for arbitrary
3832 // FunctionDecls. When/if we fix this we can have FDContext be TheCU/null for
3833 // all subprograms instead of the actual context since subprogram definitions
3834 // are emitted as CU level entities by the backend.
3835 llvm::DISubprogram *SP = DBuilder.createFunction(
3836 FDContext, Name, LinkageName, Unit, LineNo, DIFnType, ScopeLine,
3837 FlagsForDef, SPFlagsForDef, TParamsArray.get(), Decl);
3838 Fn->setSubprogram(SP);
3839 // We might get here with a VarDecl in the case we're generating
3840 // code for the initialization of globals. Do not record these decls
3841 // as they will overwrite the actual VarDecl Decl in the cache.
3842 if (HasDecl && isa<FunctionDecl>(D))
3843 DeclCache[D->getCanonicalDecl()].reset(SP);
3845 // Push the function onto the lexical block stack.
3846 LexicalBlockStack.emplace_back(SP);
3849 RegionMap[D].reset(SP);
3852 void CGDebugInfo::EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc,
3853 QualType FnType, llvm::Function *Fn) {
3855 StringRef LinkageName;
3857 const Decl *D = GD.getDecl();
3861 llvm::TimeTraceScope TimeScope("DebugFunction", [&]() {
3863 llvm::raw_string_ostream OS(Name);
3864 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
3865 ND->getNameForDiagnostic(OS, getPrintingPolicy(),
3866 /*Qualified=*/true);
3870 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3871 llvm::DIFile *Unit = getOrCreateFile(Loc);
3872 bool IsDeclForCallSite = Fn ? true : false;
3873 llvm::DIScope *FDContext =
3874 IsDeclForCallSite ? Unit : getDeclContextDescriptor(D);
3875 llvm::DINodeArray TParamsArray;
3876 if (isa<FunctionDecl>(D)) {
3877 // If there is a DISubprogram for this function available then use it.
3878 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
3879 TParamsArray, Flags);
3880 } else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
3881 Name = getObjCMethodName(OMD);
3882 Flags |= llvm::DINode::FlagPrototyped;
3884 llvm_unreachable("not a function or ObjC method");
3886 if (!Name.empty() && Name[0] == '\01')
3887 Name = Name.substr(1);
3889 if (D->isImplicit()) {
3890 Flags |= llvm::DINode::FlagArtificial;
3891 // Artificial functions without a location should not silently reuse CurLoc.
3892 if (Loc.isInvalid())
3893 CurLoc = SourceLocation();
3895 unsigned LineNo = getLineNumber(Loc);
3896 unsigned ScopeLine = 0;
3897 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
3898 if (CGM.getLangOpts().Optimize)
3899 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
3901 llvm::DISubprogram *SP = DBuilder.createFunction(
3902 FDContext, Name, LinkageName, Unit, LineNo,
3903 getOrCreateFunctionType(D, FnType, Unit), ScopeLine, Flags, SPFlags,
3904 TParamsArray.get(), getFunctionDeclaration(D));
3906 if (IsDeclForCallSite)
3907 Fn->setSubprogram(SP);
3909 DBuilder.finalizeSubprogram(SP);
3912 void CGDebugInfo::EmitFuncDeclForCallSite(llvm::CallBase *CallOrInvoke,
3913 QualType CalleeType,
3914 const FunctionDecl *CalleeDecl) {
3917 auto *Func = CallOrInvoke->getCalledFunction();
3920 if (Func->getSubprogram())
3923 // Do not emit a declaration subprogram for a builtin, a function with nodebug
3924 // attribute, or if call site info isn't required. Also, elide declarations
3925 // for functions with reserved names, as call site-related features aren't
3926 // interesting in this case (& also, the compiler may emit calls to these
3927 // functions without debug locations, which makes the verifier complain).
3928 if (CalleeDecl->getBuiltinID() != 0 || CalleeDecl->hasAttr<NoDebugAttr>() ||
3929 getCallSiteRelatedAttrs() == llvm::DINode::FlagZero)
3931 if (const auto *Id = CalleeDecl->getIdentifier())
3932 if (Id->isReservedName())
3935 // If there is no DISubprogram attached to the function being called,
3936 // create the one describing the function in order to have complete
3937 // call site debug info.
3938 if (!CalleeDecl->isStatic() && !CalleeDecl->isInlined())
3939 EmitFunctionDecl(CalleeDecl, CalleeDecl->getLocation(), CalleeType, Func);
3942 void CGDebugInfo::EmitInlineFunctionStart(CGBuilderTy &Builder, GlobalDecl GD) {
3943 const auto *FD = cast<FunctionDecl>(GD.getDecl());
3944 // If there is a subprogram for this function available then use it.
3945 auto FI = SPCache.find(FD->getCanonicalDecl());
3946 llvm::DISubprogram *SP = nullptr;
3947 if (FI != SPCache.end())
3948 SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
3949 if (!SP || !SP->isDefinition())
3950 SP = getFunctionStub(GD);
3951 FnBeginRegionCount.push_back(LexicalBlockStack.size());
3952 LexicalBlockStack.emplace_back(SP);
3953 setInlinedAt(Builder.getCurrentDebugLocation());
3954 EmitLocation(Builder, FD->getLocation());
3957 void CGDebugInfo::EmitInlineFunctionEnd(CGBuilderTy &Builder) {
3958 assert(CurInlinedAt && "unbalanced inline scope stack");
3959 EmitFunctionEnd(Builder, nullptr);
3960 setInlinedAt(llvm::DebugLoc(CurInlinedAt).getInlinedAt());
3963 void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc) {
3964 // Update our current location
3967 if (CurLoc.isInvalid() || CurLoc.isMacroID() || LexicalBlockStack.empty())
3970 llvm::MDNode *Scope = LexicalBlockStack.back();
3971 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
3972 getLineNumber(CurLoc), getColumnNumber(CurLoc), Scope, CurInlinedAt));
3975 void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) {
3976 llvm::MDNode *Back = nullptr;
3977 if (!LexicalBlockStack.empty())
3978 Back = LexicalBlockStack.back().get();
3979 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
3980 cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
3981 getColumnNumber(CurLoc)));
3984 void CGDebugInfo::AppendAddressSpaceXDeref(
3985 unsigned AddressSpace, SmallVectorImpl<int64_t> &Expr) const {
3986 Optional<unsigned> DWARFAddressSpace =
3987 CGM.getTarget().getDWARFAddressSpace(AddressSpace);
3988 if (!DWARFAddressSpace)
3991 Expr.push_back(llvm::dwarf::DW_OP_constu);
3992 Expr.push_back(DWARFAddressSpace.getValue());
3993 Expr.push_back(llvm::dwarf::DW_OP_swap);
3994 Expr.push_back(llvm::dwarf::DW_OP_xderef);
3997 void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder,
3998 SourceLocation Loc) {
3999 // Set our current location.
4002 // Emit a line table change for the current location inside the new scope.
4003 Builder.SetCurrentDebugLocation(
4004 llvm::DebugLoc::get(getLineNumber(Loc), getColumnNumber(Loc),
4005 LexicalBlockStack.back(), CurInlinedAt));
4007 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
4010 // Create a new lexical block and push it on the stack.
4011 CreateLexicalBlock(Loc);
4014 void CGDebugInfo::EmitLexicalBlockEnd(CGBuilderTy &Builder,
4015 SourceLocation Loc) {
4016 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
4018 // Provide an entry in the line table for the end of the block.
4019 EmitLocation(Builder, Loc);
4021 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
4024 LexicalBlockStack.pop_back();
4027 void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder, llvm::Function *Fn) {
4028 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
4029 unsigned RCount = FnBeginRegionCount.back();
4030 assert(RCount <= LexicalBlockStack.size() && "Region stack mismatch");
4032 // Pop all regions for this function.
4033 while (LexicalBlockStack.size() != RCount) {
4034 // Provide an entry in the line table for the end of the block.
4035 EmitLocation(Builder, CurLoc);
4036 LexicalBlockStack.pop_back();
4038 FnBeginRegionCount.pop_back();
4040 if (Fn && Fn->getSubprogram())
4041 DBuilder.finalizeSubprogram(Fn->getSubprogram());
4044 CGDebugInfo::BlockByRefType
4045 CGDebugInfo::EmitTypeForVarWithBlocksAttr(const VarDecl *VD,
4046 uint64_t *XOffset) {
4047 SmallVector<llvm::Metadata *, 5> EltTys;
4049 uint64_t FieldSize, FieldOffset;
4050 uint32_t FieldAlign;
4052 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
4053 QualType Type = VD->getType();
4056 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
4057 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
4058 EltTys.push_back(CreateMemberType(Unit, FType, "__forwarding", &FieldOffset));
4059 FType = CGM.getContext().IntTy;
4060 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
4061 EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset));
4063 bool HasCopyAndDispose = CGM.getContext().BlockRequiresCopying(Type, VD);
4064 if (HasCopyAndDispose) {
4065 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
4067 CreateMemberType(Unit, FType, "__copy_helper", &FieldOffset));
4069 CreateMemberType(Unit, FType, "__destroy_helper", &FieldOffset));
4071 bool HasByrefExtendedLayout;
4072 Qualifiers::ObjCLifetime Lifetime;
4073 if (CGM.getContext().getByrefLifetime(Type, Lifetime,
4074 HasByrefExtendedLayout) &&
4075 HasByrefExtendedLayout) {
4076 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
4078 CreateMemberType(Unit, FType, "__byref_variable_layout", &FieldOffset));
4081 CharUnits Align = CGM.getContext().getDeclAlign(VD);
4082 if (Align > CGM.getContext().toCharUnitsFromBits(
4083 CGM.getTarget().getPointerAlign(0))) {
4084 CharUnits FieldOffsetInBytes =
4085 CGM.getContext().toCharUnitsFromBits(FieldOffset);
4086 CharUnits AlignedOffsetInBytes = FieldOffsetInBytes.alignTo(Align);
4087 CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;
4089 if (NumPaddingBytes.isPositive()) {
4090 llvm::APInt pad(32, NumPaddingBytes.getQuantity());
4091 FType = CGM.getContext().getConstantArrayType(
4092 CGM.getContext().CharTy, pad, nullptr, ArrayType::Normal, 0);
4093 EltTys.push_back(CreateMemberType(Unit, FType, "", &FieldOffset));
4098 llvm::DIType *WrappedTy = getOrCreateType(FType, Unit);
4099 FieldSize = CGM.getContext().getTypeSize(FType);
4100 FieldAlign = CGM.getContext().toBits(Align);
4102 *XOffset = FieldOffset;
4103 llvm::DIType *FieldTy = DBuilder.createMemberType(
4104 Unit, VD->getName(), Unit, 0, FieldSize, FieldAlign, FieldOffset,
4105 llvm::DINode::FlagZero, WrappedTy);
4106 EltTys.push_back(FieldTy);
4107 FieldOffset += FieldSize;
4109 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
4110 return {DBuilder.createStructType(Unit, "", Unit, 0, FieldOffset, 0,
4111 llvm::DINode::FlagZero, nullptr, Elements),
4115 llvm::DILocalVariable *CGDebugInfo::EmitDeclare(const VarDecl *VD,
4116 llvm::Value *Storage,
4117 llvm::Optional<unsigned> ArgNo,
4118 CGBuilderTy &Builder,
4119 const bool UsePointerValue) {
4120 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
4121 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
4122 if (VD->hasAttr<NoDebugAttr>())
4126 VD->isImplicit() || (isa<Decl>(VD->getDeclContext()) &&
4127 cast<Decl>(VD->getDeclContext())->isImplicit());
4128 llvm::DIFile *Unit = nullptr;
4130 Unit = getOrCreateFile(VD->getLocation());
4132 uint64_t XOffset = 0;
4133 if (VD->hasAttr<BlocksAttr>())
4134 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;
4136 Ty = getOrCreateType(VD->getType(), Unit);
4138 // If there is no debug info for this type then do not emit debug info
4139 // for this variable.
4143 // Get location information.
4145 unsigned Column = 0;
4147 Line = getLineNumber(VD->getLocation());
4148 Column = getColumnNumber(VD->getLocation());
4150 SmallVector<int64_t, 13> Expr;
4151 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
4152 if (VD->isImplicit())
4153 Flags |= llvm::DINode::FlagArtificial;
4155 auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
4157 unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(VD->getType());
4158 AppendAddressSpaceXDeref(AddressSpace, Expr);
4160 // If this is implicit parameter of CXXThis or ObjCSelf kind, then give it an
4161 // object pointer flag.
4162 if (const auto *IPD = dyn_cast<ImplicitParamDecl>(VD)) {
4163 if (IPD->getParameterKind() == ImplicitParamDecl::CXXThis ||
4164 IPD->getParameterKind() == ImplicitParamDecl::ObjCSelf)
4165 Flags |= llvm::DINode::FlagObjectPointer;
4168 // Note: Older versions of clang used to emit byval references with an extra
4169 // DW_OP_deref, because they referenced the IR arg directly instead of
4170 // referencing an alloca. Newer versions of LLVM don't treat allocas
4171 // differently from other function arguments when used in a dbg.declare.
4172 auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
4173 StringRef Name = VD->getName();
4174 if (!Name.empty()) {
4175 if (VD->hasAttr<BlocksAttr>()) {
4176 // Here, we need an offset *into* the alloca.
4177 CharUnits offset = CharUnits::fromQuantity(32);
4178 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4179 // offset of __forwarding field
4180 offset = CGM.getContext().toCharUnitsFromBits(
4181 CGM.getTarget().getPointerWidth(0));
4182 Expr.push_back(offset.getQuantity());
4183 Expr.push_back(llvm::dwarf::DW_OP_deref);
4184 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4185 // offset of x field
4186 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
4187 Expr.push_back(offset.getQuantity());
4189 } else if (const auto *RT = dyn_cast<RecordType>(VD->getType())) {
4190 // If VD is an anonymous union then Storage represents value for
4191 // all union fields.
4192 const RecordDecl *RD = RT->getDecl();
4193 if (RD->isUnion() && RD->isAnonymousStructOrUnion()) {
4194 // GDB has trouble finding local variables in anonymous unions, so we emit
4195 // artificial local variables for each of the members.
4197 // FIXME: Remove this code as soon as GDB supports this.
4198 // The debug info verifier in LLVM operates based on the assumption that a
4199 // variable has the same size as its storage and we had to disable the
4200 // check for artificial variables.
4201 for (const auto *Field : RD->fields()) {
4202 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
4203 StringRef FieldName = Field->getName();
4205 // Ignore unnamed fields. Do not ignore unnamed records.
4206 if (FieldName.empty() && !isa<RecordType>(Field->getType()))
4209 // Use VarDecl's Tag, Scope and Line number.
4210 auto FieldAlign = getDeclAlignIfRequired(Field, CGM.getContext());
4211 auto *D = DBuilder.createAutoVariable(
4212 Scope, FieldName, Unit, Line, FieldTy, CGM.getLangOpts().Optimize,
4213 Flags | llvm::DINode::FlagArtificial, FieldAlign);
4215 // Insert an llvm.dbg.declare into the current block.
4216 DBuilder.insertDeclare(
4217 Storage, D, DBuilder.createExpression(Expr),
4218 llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
4219 Builder.GetInsertBlock());
4224 // Clang stores the sret pointer provided by the caller in a static alloca.
4225 // Use DW_OP_deref to tell the debugger to load the pointer and treat it as
4226 // the address of the variable.
4227 if (UsePointerValue) {
4228 assert(std::find(Expr.begin(), Expr.end(), llvm::dwarf::DW_OP_deref) ==
4230 "Debug info already contains DW_OP_deref.");
4231 Expr.push_back(llvm::dwarf::DW_OP_deref);
4234 // Create the descriptor for the variable.
4235 auto *D = ArgNo ? DBuilder.createParameterVariable(
4236 Scope, Name, *ArgNo, Unit, Line, Ty,
4237 CGM.getLangOpts().Optimize, Flags)
4238 : DBuilder.createAutoVariable(Scope, Name, Unit, Line, Ty,
4239 CGM.getLangOpts().Optimize,
4242 // Insert an llvm.dbg.declare into the current block.
4243 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
4244 llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
4245 Builder.GetInsertBlock());
4250 llvm::DILocalVariable *
4251 CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD, llvm::Value *Storage,
4252 CGBuilderTy &Builder,
4253 const bool UsePointerValue) {
4254 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
4255 return EmitDeclare(VD, Storage, llvm::None, Builder, UsePointerValue);
4258 void CGDebugInfo::EmitLabel(const LabelDecl *D, CGBuilderTy &Builder) {
4259 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
4260 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
4262 if (D->hasAttr<NoDebugAttr>())
4265 auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
4266 llvm::DIFile *Unit = getOrCreateFile(D->getLocation());
4268 // Get location information.
4269 unsigned Line = getLineNumber(D->getLocation());
4270 unsigned Column = getColumnNumber(D->getLocation());
4272 StringRef Name = D->getName();
4274 // Create the descriptor for the label.
4276 DBuilder.createLabel(Scope, Name, Unit, Line, CGM.getLangOpts().Optimize);
4278 // Insert an llvm.dbg.label into the current block.
4279 DBuilder.insertLabel(L,
4280 llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
4281 Builder.GetInsertBlock());
4284 llvm::DIType *CGDebugInfo::CreateSelfType(const QualType &QualTy,
4286 llvm::DIType *CachedTy = getTypeOrNull(QualTy);
4289 return DBuilder.createObjectPointerType(Ty);
4292 void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
4293 const VarDecl *VD, llvm::Value *Storage, CGBuilderTy &Builder,
4294 const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) {
4295 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
4296 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
4298 if (Builder.GetInsertBlock() == nullptr)
4300 if (VD->hasAttr<NoDebugAttr>())
4303 bool isByRef = VD->hasAttr<BlocksAttr>();
4305 uint64_t XOffset = 0;
4306 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
4309 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;
4311 Ty = getOrCreateType(VD->getType(), Unit);
4313 // Self is passed along as an implicit non-arg variable in a
4314 // block. Mark it as the object pointer.
4315 if (const auto *IPD = dyn_cast<ImplicitParamDecl>(VD))
4316 if (IPD->getParameterKind() == ImplicitParamDecl::ObjCSelf)
4317 Ty = CreateSelfType(VD->getType(), Ty);
4319 // Get location information.
4320 unsigned Line = getLineNumber(VD->getLocation());
4321 unsigned Column = getColumnNumber(VD->getLocation());
4323 const llvm::DataLayout &target = CGM.getDataLayout();
4325 CharUnits offset = CharUnits::fromQuantity(
4326 target.getStructLayout(blockInfo.StructureType)
4327 ->getElementOffset(blockInfo.getCapture(VD).getIndex()));
4329 SmallVector<int64_t, 9> addr;
4330 addr.push_back(llvm::dwarf::DW_OP_deref);
4331 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4332 addr.push_back(offset.getQuantity());
4334 addr.push_back(llvm::dwarf::DW_OP_deref);
4335 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4336 // offset of __forwarding field
4338 CGM.getContext().toCharUnitsFromBits(target.getPointerSizeInBits(0));
4339 addr.push_back(offset.getQuantity());
4340 addr.push_back(llvm::dwarf::DW_OP_deref);
4341 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
4342 // offset of x field
4343 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
4344 addr.push_back(offset.getQuantity());
4347 // Create the descriptor for the variable.
4348 auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
4349 auto *D = DBuilder.createAutoVariable(
4350 cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->getName(), Unit,
4351 Line, Ty, false, llvm::DINode::FlagZero, Align);
4353 // Insert an llvm.dbg.declare into the current block.
4355 llvm::DebugLoc::get(Line, Column, LexicalBlockStack.back(), CurInlinedAt);
4356 auto *Expr = DBuilder.createExpression(addr);
4358 DBuilder.insertDeclare(Storage, D, Expr, DL, InsertPoint);
4360 DBuilder.insertDeclare(Storage, D, Expr, DL, Builder.GetInsertBlock());
4363 void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI,
4365 CGBuilderTy &Builder) {
4366 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
4367 EmitDeclare(VD, AI, ArgNo, Builder);
4371 struct BlockLayoutChunk {
4372 uint64_t OffsetInBits;
4373 const BlockDecl::Capture *Capture;
4375 bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) {
4376 return l.OffsetInBits < r.OffsetInBits;
4380 void CGDebugInfo::collectDefaultFieldsForBlockLiteralDeclare(
4381 const CGBlockInfo &Block, const ASTContext &Context, SourceLocation Loc,
4382 const llvm::StructLayout &BlockLayout, llvm::DIFile *Unit,
4383 SmallVectorImpl<llvm::Metadata *> &Fields) {
4384 // Blocks in OpenCL have unique constraints which make the standard fields
4385 // redundant while requiring size and align fields for enqueue_kernel. See
4386 // initializeForBlockHeader in CGBlocks.cpp
4387 if (CGM.getLangOpts().OpenCL) {
4388 Fields.push_back(createFieldType("__size", Context.IntTy, Loc, AS_public,
4389 BlockLayout.getElementOffsetInBits(0),
4391 Fields.push_back(createFieldType("__align", Context.IntTy, Loc, AS_public,
4392 BlockLayout.getElementOffsetInBits(1),
4395 Fields.push_back(createFieldType("__isa", Context.VoidPtrTy, Loc, AS_public,
4396 BlockLayout.getElementOffsetInBits(0),
4398 Fields.push_back(createFieldType("__flags", Context.IntTy, Loc, AS_public,
4399 BlockLayout.getElementOffsetInBits(1),
4402 createFieldType("__reserved", Context.IntTy, Loc, AS_public,
4403 BlockLayout.getElementOffsetInBits(2), Unit, Unit));
4404 auto *FnTy = Block.getBlockExpr()->getFunctionType();
4405 auto FnPtrType = CGM.getContext().getPointerType(FnTy->desugar());
4406 Fields.push_back(createFieldType("__FuncPtr", FnPtrType, Loc, AS_public,
4407 BlockLayout.getElementOffsetInBits(3),
4409 Fields.push_back(createFieldType(
4411 Context.getPointerType(Block.NeedsCopyDispose
4412 ? Context.getBlockDescriptorExtendedType()
4413 : Context.getBlockDescriptorType()),
4414 Loc, AS_public, BlockLayout.getElementOffsetInBits(4), Unit, Unit));
4418 void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
4421 llvm::AllocaInst *Alloca,
4422 CGBuilderTy &Builder) {
4423 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
4424 ASTContext &C = CGM.getContext();
4425 const BlockDecl *blockDecl = block.getBlockDecl();
4427 // Collect some general information about the block's location.
4428 SourceLocation loc = blockDecl->getCaretLocation();
4429 llvm::DIFile *tunit = getOrCreateFile(loc);
4430 unsigned line = getLineNumber(loc);
4431 unsigned column = getColumnNumber(loc);
4433 // Build the debug-info type for the block literal.
4434 getDeclContextDescriptor(blockDecl);
4436 const llvm::StructLayout *blockLayout =
4437 CGM.getDataLayout().getStructLayout(block.StructureType);
4439 SmallVector<llvm::Metadata *, 16> fields;
4440 collectDefaultFieldsForBlockLiteralDeclare(block, C, loc, *blockLayout, tunit,
4443 // We want to sort the captures by offset, not because DWARF
4444 // requires this, but because we're paranoid about debuggers.
4445 SmallVector<BlockLayoutChunk, 8> chunks;
4448 if (blockDecl->capturesCXXThis()) {
4449 BlockLayoutChunk chunk;
4450 chunk.OffsetInBits =
4451 blockLayout->getElementOffsetInBits(block.CXXThisIndex);
4452 chunk.Capture = nullptr;
4453 chunks.push_back(chunk);
4456 // Variable captures.
4457 for (const auto &capture : blockDecl->captures()) {
4458 const VarDecl *variable = capture.getVariable();
4459 const CGBlockInfo::Capture &captureInfo = block.getCapture(variable);
4461 // Ignore constant captures.
4462 if (captureInfo.isConstant())
4465 BlockLayoutChunk chunk;
4466 chunk.OffsetInBits =
4467 blockLayout->getElementOffsetInBits(captureInfo.getIndex());
4468 chunk.Capture = &capture;
4469 chunks.push_back(chunk);
4473 llvm::array_pod_sort(chunks.begin(), chunks.end());
4475 for (const BlockLayoutChunk &Chunk : chunks) {
4476 uint64_t offsetInBits = Chunk.OffsetInBits;
4477 const BlockDecl::Capture *capture = Chunk.Capture;
4479 // If we have a null capture, this must be the C++ 'this' capture.
4483 cast_or_null<CXXMethodDecl>(blockDecl->getNonClosureContext()))
4484 type = Method->getThisType();
4485 else if (auto *RDecl = dyn_cast<CXXRecordDecl>(blockDecl->getParent()))
4486 type = QualType(RDecl->getTypeForDecl(), 0);
4488 llvm_unreachable("unexpected block declcontext");
4490 fields.push_back(createFieldType("this", type, loc, AS_public,
4491 offsetInBits, tunit, tunit));
4495 const VarDecl *variable = capture->getVariable();
4496 StringRef name = variable->getName();
4498 llvm::DIType *fieldType;
4499 if (capture->isByRef()) {
4500 TypeInfo PtrInfo = C.getTypeInfo(C.VoidPtrTy);
4501 auto Align = PtrInfo.AlignIsRequired ? PtrInfo.Align : 0;
4502 // FIXME: This recomputes the layout of the BlockByRefWrapper.
4505 EmitTypeForVarWithBlocksAttr(variable, &xoffset).BlockByRefWrapper;
4506 fieldType = DBuilder.createPointerType(fieldType, PtrInfo.Width);
4507 fieldType = DBuilder.createMemberType(tunit, name, tunit, line,
4508 PtrInfo.Width, Align, offsetInBits,
4509 llvm::DINode::FlagZero, fieldType);
4511 auto Align = getDeclAlignIfRequired(variable, CGM.getContext());
4512 fieldType = createFieldType(name, variable->getType(), loc, AS_public,
4513 offsetInBits, Align, tunit, tunit);
4515 fields.push_back(fieldType);
4518 SmallString<36> typeName;
4519 llvm::raw_svector_ostream(typeName)
4520 << "__block_literal_" << CGM.getUniqueBlockCount();
4522 llvm::DINodeArray fieldsArray = DBuilder.getOrCreateArray(fields);
4524 llvm::DIType *type =
4525 DBuilder.createStructType(tunit, typeName.str(), tunit, line,
4526 CGM.getContext().toBits(block.BlockSize), 0,
4527 llvm::DINode::FlagZero, nullptr, fieldsArray);
4528 type = DBuilder.createPointerType(type, CGM.PointerWidthInBits);
4530 // Get overall information about the block.
4531 llvm::DINode::DIFlags flags = llvm::DINode::FlagArtificial;
4532 auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back());
4534 // Create the descriptor for the parameter.
4535 auto *debugVar = DBuilder.createParameterVariable(
4536 scope, Name, ArgNo, tunit, line, type, CGM.getLangOpts().Optimize, flags);
4538 // Insert an llvm.dbg.declare into the current block.
4539 DBuilder.insertDeclare(Alloca, debugVar, DBuilder.createExpression(),
4540 llvm::DebugLoc::get(line, column, scope, CurInlinedAt),
4541 Builder.GetInsertBlock());
4544 llvm::DIDerivedType *
4545 CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(const VarDecl *D) {
4546 if (!D || !D->isStaticDataMember())
4549 auto MI = StaticDataMemberCache.find(D->getCanonicalDecl());
4550 if (MI != StaticDataMemberCache.end()) {
4551 assert(MI->second && "Static data member declaration should still exist");
4555 // If the member wasn't found in the cache, lazily construct and add it to the
4556 // type (used when a limited form of the type is emitted).
4557 auto DC = D->getDeclContext();
4558 auto *Ctxt = cast<llvm::DICompositeType>(getDeclContextDescriptor(D));
4559 return CreateRecordStaticField(D, Ctxt, cast<RecordDecl>(DC));
4562 llvm::DIGlobalVariableExpression *CGDebugInfo::CollectAnonRecordDecls(
4563 const RecordDecl *RD, llvm::DIFile *Unit, unsigned LineNo,
4564 StringRef LinkageName, llvm::GlobalVariable *Var, llvm::DIScope *DContext) {
4565 llvm::DIGlobalVariableExpression *GVE = nullptr;
4567 for (const auto *Field : RD->fields()) {
4568 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
4569 StringRef FieldName = Field->getName();
4571 // Ignore unnamed fields, but recurse into anonymous records.
4572 if (FieldName.empty()) {
4573 if (const auto *RT = dyn_cast<RecordType>(Field->getType()))
4574 GVE = CollectAnonRecordDecls(RT->getDecl(), Unit, LineNo, LinkageName,
4578 // Use VarDecl's Tag, Scope and Line number.
4579 GVE = DBuilder.createGlobalVariableExpression(
4580 DContext, FieldName, LinkageName, Unit, LineNo, FieldTy,
4581 Var->hasLocalLinkage());
4582 Var->addDebugInfo(GVE);
4587 void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
4589 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
4590 if (D->hasAttr<NoDebugAttr>())
4593 llvm::TimeTraceScope TimeScope("DebugGlobalVariable", [&]() {
4595 llvm::raw_string_ostream OS(Name);
4596 D->getNameForDiagnostic(OS, getPrintingPolicy(),
4597 /*Qualified=*/true);
4601 // If we already created a DIGlobalVariable for this declaration, just attach
4602 // it to the llvm::GlobalVariable.
4603 auto Cached = DeclCache.find(D->getCanonicalDecl());
4604 if (Cached != DeclCache.end())
4605 return Var->addDebugInfo(
4606 cast<llvm::DIGlobalVariableExpression>(Cached->second));
4608 // Create global variable debug descriptor.
4609 llvm::DIFile *Unit = nullptr;
4610 llvm::DIScope *DContext = nullptr;
4612 StringRef DeclName, LinkageName;
4614 llvm::MDTuple *TemplateParameters = nullptr;
4615 collectVarDeclProps(D, Unit, LineNo, T, DeclName, LinkageName,
4616 TemplateParameters, DContext);
4618 // Attempt to store one global variable for the declaration - even if we
4619 // emit a lot of fields.
4620 llvm::DIGlobalVariableExpression *GVE = nullptr;
4622 // If this is an anonymous union then we'll want to emit a global
4623 // variable for each member of the anonymous union so that it's possible
4624 // to find the name of any field in the union.
4625 if (T->isUnionType() && DeclName.empty()) {
4626 const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
4627 assert(RD->isAnonymousStructOrUnion() &&
4628 "unnamed non-anonymous struct or union?");
4629 GVE = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
4631 auto Align = getDeclAlignIfRequired(D, CGM.getContext());
4633 SmallVector<int64_t, 4> Expr;
4634 unsigned AddressSpace =
4635 CGM.getContext().getTargetAddressSpace(D->getType());
4636 if (CGM.getLangOpts().CUDA && CGM.getLangOpts().CUDAIsDevice) {
4637 if (D->hasAttr<CUDASharedAttr>())
4639 CGM.getContext().getTargetAddressSpace(LangAS::cuda_shared);
4640 else if (D->hasAttr<CUDAConstantAttr>())
4642 CGM.getContext().getTargetAddressSpace(LangAS::cuda_constant);
4644 AppendAddressSpaceXDeref(AddressSpace, Expr);
4646 GVE = DBuilder.createGlobalVariableExpression(
4647 DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit),
4648 Var->hasLocalLinkage(), true,
4649 Expr.empty() ? nullptr : DBuilder.createExpression(Expr),
4650 getOrCreateStaticDataMemberDeclarationOrNull(D), TemplateParameters,
4652 Var->addDebugInfo(GVE);
4654 DeclCache[D->getCanonicalDecl()].reset(GVE);
4657 void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) {
4658 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
4659 if (VD->hasAttr<NoDebugAttr>())
4661 llvm::TimeTraceScope TimeScope("DebugConstGlobalVariable", [&]() {
4663 llvm::raw_string_ostream OS(Name);
4664 VD->getNameForDiagnostic(OS, getPrintingPolicy(),
4665 /*Qualified=*/true);
4669 auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
4670 // Create the descriptor for the variable.
4671 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
4672 StringRef Name = VD->getName();
4673 llvm::DIType *Ty = getOrCreateType(VD->getType(), Unit);
4675 if (const auto *ECD = dyn_cast<EnumConstantDecl>(VD)) {
4676 const auto *ED = cast<EnumDecl>(ECD->getDeclContext());
4677 assert(isa<EnumType>(ED->getTypeForDecl()) && "Enum without EnumType?");
4679 if (CGM.getCodeGenOpts().EmitCodeView) {
4680 // If CodeView, emit enums as global variables, unless they are defined
4681 // inside a class. We do this because MSVC doesn't emit S_CONSTANTs for
4682 // enums in classes, and because it is difficult to attach this scope
4683 // information to the global variable.
4684 if (isa<RecordDecl>(ED->getDeclContext()))
4687 // If not CodeView, emit DW_TAG_enumeration_type if necessary. For
4688 // example: for "enum { ZERO };", a DW_TAG_enumeration_type is created the
4689 // first time `ZERO` is referenced in a function.
4690 llvm::DIType *EDTy =
4691 getOrCreateType(QualType(ED->getTypeForDecl(), 0), Unit);
4692 assert (EDTy->getTag() == llvm::dwarf::DW_TAG_enumeration_type);
4698 llvm::DIScope *DContext = nullptr;
4700 // Do not emit separate definitions for function local consts.
4701 if (isa<FunctionDecl>(VD->getDeclContext()))
4704 // Emit definition for static members in CodeView.
4705 VD = cast<ValueDecl>(VD->getCanonicalDecl());
4706 auto *VarD = dyn_cast<VarDecl>(VD);
4707 if (VarD && VarD->isStaticDataMember()) {
4708 auto *RD = cast<RecordDecl>(VarD->getDeclContext());
4709 getDeclContextDescriptor(VarD);
4710 // Ensure that the type is retained even though it's otherwise unreferenced.
4712 // FIXME: This is probably unnecessary, since Ty should reference RD
4713 // through its scope.
4714 RetainedTypes.push_back(
4715 CGM.getContext().getRecordType(RD).getAsOpaquePtr());
4717 if (!CGM.getCodeGenOpts().EmitCodeView)
4720 // Use the global scope for static members.
4721 DContext = getContextDescriptor(
4722 cast<Decl>(CGM.getContext().getTranslationUnitDecl()), TheCU);
4724 DContext = getDeclContextDescriptor(VD);
4727 auto &GV = DeclCache[VD];
4730 llvm::DIExpression *InitExpr = nullptr;
4731 if (CGM.getContext().getTypeSize(VD->getType()) <= 64) {
4732 // FIXME: Add a representation for integer constants wider than 64 bits.
4735 DBuilder.createConstantValueExpression(Init.getInt().getExtValue());
4736 else if (Init.isFloat())
4737 InitExpr = DBuilder.createConstantValueExpression(
4738 Init.getFloat().bitcastToAPInt().getZExtValue());
4741 llvm::MDTuple *TemplateParameters = nullptr;
4743 if (isa<VarTemplateSpecializationDecl>(VD))
4745 llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VarD, &*Unit);
4746 TemplateParameters = parameterNodes.get();
4749 GV.reset(DBuilder.createGlobalVariableExpression(
4750 DContext, Name, StringRef(), Unit, getLineNumber(VD->getLocation()), Ty,
4751 true, true, InitExpr, getOrCreateStaticDataMemberDeclarationOrNull(VarD),
4752 TemplateParameters, Align));
4755 void CGDebugInfo::EmitExternalVariable(llvm::GlobalVariable *Var,
4757 assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
4758 if (D->hasAttr<NoDebugAttr>())
4761 auto Align = getDeclAlignIfRequired(D, CGM.getContext());
4762 llvm::DIFile *Unit = getOrCreateFile(D->getLocation());
4763 StringRef Name = D->getName();
4764 llvm::DIType *Ty = getOrCreateType(D->getType(), Unit);
4766 llvm::DIScope *DContext = getDeclContextDescriptor(D);
4767 llvm::DIGlobalVariableExpression *GVE =
4768 DBuilder.createGlobalVariableExpression(
4769 DContext, Name, StringRef(), Unit, getLineNumber(D->getLocation()),
4770 Ty, false, false, nullptr, nullptr, nullptr, Align);
4771 Var->addDebugInfo(GVE);
4774 llvm::DIScope *CGDebugInfo::getCurrentContextDescriptor(const Decl *D) {
4775 if (!LexicalBlockStack.empty())
4776 return LexicalBlockStack.back();
4777 llvm::DIScope *Mod = getParentModuleOrNull(D);
4778 return getContextDescriptor(D, Mod ? Mod : TheCU);
4781 void CGDebugInfo::EmitUsingDirective(const UsingDirectiveDecl &UD) {
4782 if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
4784 const NamespaceDecl *NSDecl = UD.getNominatedNamespace();
4785 if (!NSDecl->isAnonymousNamespace() ||
4786 CGM.getCodeGenOpts().DebugExplicitImport) {
4787 auto Loc = UD.getLocation();
4788 DBuilder.createImportedModule(
4789 getCurrentContextDescriptor(cast<Decl>(UD.getDeclContext())),
4790 getOrCreateNamespace(NSDecl), getOrCreateFile(Loc), getLineNumber(Loc));
4794 void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) {
4795 if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
4797 assert(UD.shadow_size() &&
4798 "We shouldn't be codegening an invalid UsingDecl containing no decls");
4799 // Emitting one decl is sufficient - debuggers can detect that this is an
4800 // overloaded name & provide lookup for all the overloads.
4801 const UsingShadowDecl &USD = **UD.shadow_begin();
4803 // FIXME: Skip functions with undeduced auto return type for now since we
4804 // don't currently have the plumbing for separate declarations & definitions
4805 // of free functions and mismatched types (auto in the declaration, concrete
4806 // return type in the definition)
4807 if (const auto *FD = dyn_cast<FunctionDecl>(USD.getUnderlyingDecl()))
4808 if (const auto *AT =
4809 FD->getType()->castAs<FunctionProtoType>()->getContainedAutoType())
4810 if (AT->getDeducedType().isNull())
4812 if (llvm::DINode *Target =
4813 getDeclarationOrDefinition(USD.getUnderlyingDecl())) {
4814 auto Loc = USD.getLocation();
4815 DBuilder.createImportedDeclaration(
4816 getCurrentContextDescriptor(cast<Decl>(USD.getDeclContext())), Target,
4817 getOrCreateFile(Loc), getLineNumber(Loc));
4821 void CGDebugInfo::EmitImportDecl(const ImportDecl &ID) {
4822 if (CGM.getCodeGenOpts().getDebuggerTuning() != llvm::DebuggerKind::LLDB)
4824 if (Module *M = ID.getImportedModule()) {
4825 auto Info = ASTSourceDescriptor(*M);
4826 auto Loc = ID.getLocation();
4827 DBuilder.createImportedDeclaration(
4828 getCurrentContextDescriptor(cast<Decl>(ID.getDeclContext())),
4829 getOrCreateModuleRef(Info, DebugTypeExtRefs), getOrCreateFile(Loc),
4830 getLineNumber(Loc));
4834 llvm::DIImportedEntity *
4835 CGDebugInfo::EmitNamespaceAlias(const NamespaceAliasDecl &NA) {
4836 if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
4838 auto &VH = NamespaceAliasCache[&NA];
4840 return cast<llvm::DIImportedEntity>(VH);
4841 llvm::DIImportedEntity *R;
4842 auto Loc = NA.getLocation();
4843 if (const auto *Underlying =
4844 dyn_cast<NamespaceAliasDecl>(NA.getAliasedNamespace()))
4845 // This could cache & dedup here rather than relying on metadata deduping.
4846 R = DBuilder.createImportedDeclaration(
4847 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
4848 EmitNamespaceAlias(*Underlying), getOrCreateFile(Loc),
4849 getLineNumber(Loc), NA.getName());
4851 R = DBuilder.createImportedDeclaration(
4852 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
4853 getOrCreateNamespace(cast<NamespaceDecl>(NA.getAliasedNamespace())),
4854 getOrCreateFile(Loc), getLineNumber(Loc), NA.getName());
4860 CGDebugInfo::getOrCreateNamespace(const NamespaceDecl *NSDecl) {
4861 // Don't canonicalize the NamespaceDecl here: The DINamespace will be uniqued
4862 // if necessary, and this way multiple declarations of the same namespace in
4863 // different parent modules stay distinct.
4864 auto I = NamespaceCache.find(NSDecl);
4865 if (I != NamespaceCache.end())
4866 return cast<llvm::DINamespace>(I->second);
4868 llvm::DIScope *Context = getDeclContextDescriptor(NSDecl);
4869 // Don't trust the context if it is a DIModule (see comment above).
4870 llvm::DINamespace *NS =
4871 DBuilder.createNameSpace(Context, NSDecl->getName(), NSDecl->isInline());
4872 NamespaceCache[NSDecl].reset(NS);
4876 void CGDebugInfo::setDwoId(uint64_t Signature) {
4877 assert(TheCU && "no main compile unit");
4878 TheCU->setDWOId(Signature);
4881 void CGDebugInfo::finalize() {
4882 // Creating types might create further types - invalidating the current
4883 // element and the size(), so don't cache/reference them.
4884 for (size_t i = 0; i != ObjCInterfaceCache.size(); ++i) {
4885 ObjCInterfaceCacheEntry E = ObjCInterfaceCache[i];
4886 llvm::DIType *Ty = E.Type->getDecl()->getDefinition()
4887 ? CreateTypeDefinition(E.Type, E.Unit)
4889 DBuilder.replaceTemporary(llvm::TempDIType(E.Decl), Ty);
4892 // Add methods to interface.
4893 for (const auto &P : ObjCMethodCache) {
4894 if (P.second.empty())
4897 QualType QTy(P.first->getTypeForDecl(), 0);
4898 auto It = TypeCache.find(QTy.getAsOpaquePtr());
4899 assert(It != TypeCache.end());
4901 llvm::DICompositeType *InterfaceDecl =
4902 cast<llvm::DICompositeType>(It->second);
4904 auto CurElts = InterfaceDecl->getElements();
4905 SmallVector<llvm::Metadata *, 16> EltTys(CurElts.begin(), CurElts.end());
4907 // For DWARF v4 or earlier, only add objc_direct methods.
4908 for (auto &SubprogramDirect : P.second)
4909 if (CGM.getCodeGenOpts().DwarfVersion >= 5 || SubprogramDirect.getInt())
4910 EltTys.push_back(SubprogramDirect.getPointer());
4912 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
4913 DBuilder.replaceArrays(InterfaceDecl, Elements);
4916 for (const auto &P : ReplaceMap) {
4918 auto *Ty = cast<llvm::DIType>(P.second);
4919 assert(Ty->isForwardDecl());
4921 auto It = TypeCache.find(P.first);
4922 assert(It != TypeCache.end());
4925 DBuilder.replaceTemporary(llvm::TempDIType(Ty),
4926 cast<llvm::DIType>(It->second));
4929 for (const auto &P : FwdDeclReplaceMap) {
4931 llvm::TempMDNode FwdDecl(cast<llvm::MDNode>(P.second));
4932 llvm::Metadata *Repl;
4934 auto It = DeclCache.find(P.first);
4935 // If there has been no definition for the declaration, call RAUW
4936 // with ourselves, that will destroy the temporary MDNode and
4937 // replace it with a standard one, avoiding leaking memory.
4938 if (It == DeclCache.end())
4943 if (auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(Repl))
4944 Repl = GVE->getVariable();
4945 DBuilder.replaceTemporary(std::move(FwdDecl), cast<llvm::MDNode>(Repl));
4948 // We keep our own list of retained types, because we need to look
4949 // up the final type in the type cache.
4950 for (auto &RT : RetainedTypes)
4951 if (auto MD = TypeCache[RT])
4952 DBuilder.retainType(cast<llvm::DIType>(MD));
4954 DBuilder.finalize();
4957 void CGDebugInfo::EmitExplicitCastType(QualType Ty) {
4958 if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
4961 if (auto *DieTy = getOrCreateType(Ty, TheCU->getFile()))
4962 // Don't ignore in case of explicit cast where it is referenced indirectly.
4963 DBuilder.retainType(DieTy);
4966 llvm::DebugLoc CGDebugInfo::SourceLocToDebugLoc(SourceLocation Loc) {
4967 if (LexicalBlockStack.empty())
4968 return llvm::DebugLoc();
4970 llvm::MDNode *Scope = LexicalBlockStack.back();
4971 return llvm::DebugLoc::get(getLineNumber(Loc), getColumnNumber(Loc), Scope);
4974 llvm::DINode::DIFlags CGDebugInfo::getCallSiteRelatedAttrs() const {
4975 // Call site-related attributes are only useful in optimized programs, and
4976 // when there's a possibility of debugging backtraces.
4977 if (!CGM.getLangOpts().Optimize || DebugKind == codegenoptions::NoDebugInfo ||
4978 DebugKind == codegenoptions::LocTrackingOnly)
4979 return llvm::DINode::FlagZero;
4981 // Call site-related attributes are available in DWARF v5. Some debuggers,
4982 // while not fully DWARF v5-compliant, may accept these attributes as if they
4983 // were part of DWARF v4.
4984 bool SupportsDWARFv4Ext =
4985 CGM.getCodeGenOpts().DwarfVersion == 4 &&
4986 (CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB ||
4987 CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::GDB);
4989 if (!SupportsDWARFv4Ext && CGM.getCodeGenOpts().DwarfVersion < 5)
4990 return llvm::DINode::FlagZero;
4992 return llvm::DINode::FlagAllCallsDescribed;