1 //===--- CGDebugInfo.cpp - Emit Debug Information for a Module ------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This coordinates the debug information generation while generating code.
12 //===----------------------------------------------------------------------===//
14 #include "CGDebugInfo.h"
17 #include "CGObjCRuntime.h"
18 #include "CodeGenFunction.h"
19 #include "CodeGenModule.h"
20 #include "clang/AST/ASTContext.h"
21 #include "clang/AST/DeclFriend.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/DeclTemplate.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/RecordLayout.h"
26 #include "clang/Basic/FileManager.h"
27 #include "clang/Basic/SourceManager.h"
28 #include "clang/Basic/Version.h"
29 #include "clang/Frontend/CodeGenOptions.h"
30 #include "clang/Lex/HeaderSearchOptions.h"
31 #include "clang/Lex/ModuleMap.h"
32 #include "clang/Lex/PreprocessorOptions.h"
33 #include "llvm/ADT/SmallVector.h"
34 #include "llvm/ADT/StringExtras.h"
35 #include "llvm/IR/Constants.h"
36 #include "llvm/IR/DataLayout.h"
37 #include "llvm/IR/DerivedTypes.h"
38 #include "llvm/IR/Instructions.h"
39 #include "llvm/IR/Intrinsics.h"
40 #include "llvm/IR/Module.h"
41 #include "llvm/Support/FileSystem.h"
42 #include "llvm/Support/Path.h"
43 using namespace clang;
44 using namespace clang::CodeGen;
46 CGDebugInfo::CGDebugInfo(CodeGenModule &CGM)
47 : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
48 DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),
49 DBuilder(CGM.getModule()) {
50 for (const auto &KV : CGM.getCodeGenOpts().DebugPrefixMap)
51 DebugPrefixMap[KV.first] = KV.second;
55 CGDebugInfo::~CGDebugInfo() {
56 assert(LexicalBlockStack.empty() &&
57 "Region stack mismatch, stack not empty!");
60 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
61 SourceLocation TemporaryLocation)
63 init(TemporaryLocation);
66 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
68 SourceLocation TemporaryLocation)
70 init(TemporaryLocation, DefaultToEmpty);
73 void ApplyDebugLocation::init(SourceLocation TemporaryLocation,
74 bool DefaultToEmpty) {
75 auto *DI = CGF->getDebugInfo();
81 OriginalLocation = CGF->Builder.getCurrentDebugLocation();
82 if (TemporaryLocation.isValid()) {
83 DI->EmitLocation(CGF->Builder, TemporaryLocation);
88 CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc());
92 // Construct a location that has a valid scope, but no line info.
93 assert(!DI->LexicalBlockStack.empty());
94 CGF->Builder.SetCurrentDebugLocation(
95 llvm::DebugLoc::get(0, 0, DI->LexicalBlockStack.back()));
98 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E)
100 init(E->getExprLoc());
103 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, llvm::DebugLoc Loc)
105 if (!CGF.getDebugInfo()) {
109 OriginalLocation = CGF.Builder.getCurrentDebugLocation();
111 CGF.Builder.SetCurrentDebugLocation(std::move(Loc));
114 ApplyDebugLocation::~ApplyDebugLocation() {
115 // Query CGF so the location isn't overwritten when location updates are
116 // temporarily disabled (for C++ default function arguments)
118 CGF->Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
121 void CGDebugInfo::setLocation(SourceLocation Loc) {
122 // If the new location isn't valid return.
126 CurLoc = CGM.getContext().getSourceManager().getExpansionLoc(Loc);
128 // If we've changed files in the middle of a lexical scope go ahead
129 // and create a new lexical scope with file node if it's different
130 // from the one in the scope.
131 if (LexicalBlockStack.empty())
134 SourceManager &SM = CGM.getContext().getSourceManager();
135 auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
136 PresumedLoc PCLoc = SM.getPresumedLoc(CurLoc);
138 if (PCLoc.isInvalid() || Scope->getFilename() == PCLoc.getFilename())
141 if (auto *LBF = dyn_cast<llvm::DILexicalBlockFile>(Scope)) {
142 LexicalBlockStack.pop_back();
143 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlockFile(
144 LBF->getScope(), getOrCreateFile(CurLoc)));
145 } else if (isa<llvm::DILexicalBlock>(Scope) ||
146 isa<llvm::DISubprogram>(Scope)) {
147 LexicalBlockStack.pop_back();
148 LexicalBlockStack.emplace_back(
149 DBuilder.createLexicalBlockFile(Scope, getOrCreateFile(CurLoc)));
153 llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(const Decl *D) {
154 llvm::DIScope *Mod = getParentModuleOrNull(D);
155 return getContextDescriptor(cast<Decl>(D->getDeclContext()),
159 llvm::DIScope *CGDebugInfo::getContextDescriptor(const Decl *Context,
160 llvm::DIScope *Default) {
164 auto I = RegionMap.find(Context);
165 if (I != RegionMap.end()) {
166 llvm::Metadata *V = I->second;
167 return dyn_cast_or_null<llvm::DIScope>(V);
171 if (const NamespaceDecl *NSDecl = dyn_cast<NamespaceDecl>(Context))
172 return getOrCreateNameSpace(NSDecl);
174 if (const RecordDecl *RDecl = dyn_cast<RecordDecl>(Context))
175 if (!RDecl->isDependentType())
176 return getOrCreateType(CGM.getContext().getTypeDeclType(RDecl),
177 getOrCreateMainFile());
181 StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) {
182 assert(FD && "Invalid FunctionDecl!");
183 IdentifierInfo *FII = FD->getIdentifier();
184 FunctionTemplateSpecializationInfo *Info =
185 FD->getTemplateSpecializationInfo();
187 if (!Info && FII && !CGM.getCodeGenOpts().EmitCodeView)
188 return FII->getName();
190 // Otherwise construct human readable name for debug info.
192 llvm::raw_svector_ostream OS(NS);
193 PrintingPolicy Policy(CGM.getLangOpts());
195 if (CGM.getCodeGenOpts().EmitCodeView) {
196 // Print a fully qualified name like MSVC would.
197 Policy.MSVCFormatting = true;
198 FD->printQualifiedName(OS, Policy);
200 // Print the unqualified name with some template arguments. This is what
201 // DWARF-based debuggers expect.
203 // Add any template specialization args.
205 const TemplateArgumentList *TArgs = Info->TemplateArguments;
206 const TemplateArgument *Args = TArgs->data();
207 unsigned NumArgs = TArgs->size();
208 TemplateSpecializationType::PrintTemplateArgumentList(OS, Args, NumArgs,
213 // Copy this name on the side and use its reference.
214 return internString(OS.str());
217 StringRef CGDebugInfo::getObjCMethodName(const ObjCMethodDecl *OMD) {
218 SmallString<256> MethodName;
219 llvm::raw_svector_ostream OS(MethodName);
220 OS << (OMD->isInstanceMethod() ? '-' : '+') << '[';
221 const DeclContext *DC = OMD->getDeclContext();
222 if (const ObjCImplementationDecl *OID =
223 dyn_cast<const ObjCImplementationDecl>(DC)) {
224 OS << OID->getName();
225 } else if (const ObjCInterfaceDecl *OID =
226 dyn_cast<const ObjCInterfaceDecl>(DC)) {
227 OS << OID->getName();
228 } else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(DC)) {
229 if (OC->IsClassExtension()) {
230 OS << OC->getClassInterface()->getName();
232 OS << ((const NamedDecl *)OC)->getIdentifier()->getNameStart() << '('
233 << OC->getIdentifier()->getNameStart() << ')';
235 } else if (const ObjCCategoryImplDecl *OCD =
236 dyn_cast<const ObjCCategoryImplDecl>(DC)) {
237 OS << ((const NamedDecl *)OCD)->getIdentifier()->getNameStart() << '('
238 << OCD->getIdentifier()->getNameStart() << ')';
239 } else if (isa<ObjCProtocolDecl>(DC)) {
240 // We can extract the type of the class from the self pointer.
241 if (ImplicitParamDecl *SelfDecl = OMD->getSelfDecl()) {
243 cast<ObjCObjectPointerType>(SelfDecl->getType())->getPointeeType();
244 ClassTy.print(OS, PrintingPolicy(LangOptions()));
247 OS << ' ' << OMD->getSelector().getAsString() << ']';
249 return internString(OS.str());
252 StringRef CGDebugInfo::getSelectorName(Selector S) {
253 return internString(S.getAsString());
256 StringRef CGDebugInfo::getClassName(const RecordDecl *RD) {
257 // quick optimization to avoid having to intern strings that are already
258 // stored reliably elsewhere
259 if (!isa<ClassTemplateSpecializationDecl>(RD))
260 return RD->getName();
262 SmallString<128> Name;
264 llvm::raw_svector_ostream OS(Name);
265 RD->getNameForDiagnostic(OS, CGM.getContext().getPrintingPolicy(),
266 /*Qualified*/ false);
269 // Copy this name on the side and use its reference.
270 return internString(Name);
273 llvm::DIFile *CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
275 // If Location is not valid then use main input file.
276 return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
277 remapDIPath(TheCU->getDirectory()));
279 SourceManager &SM = CGM.getContext().getSourceManager();
280 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
282 if (PLoc.isInvalid() || StringRef(PLoc.getFilename()).empty())
283 // If the location is not valid then use main input file.
284 return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
285 remapDIPath(TheCU->getDirectory()));
287 // Cache the results.
288 const char *fname = PLoc.getFilename();
289 auto it = DIFileCache.find(fname);
291 if (it != DIFileCache.end()) {
292 // Verify that the information still exists.
293 if (llvm::Metadata *V = it->second)
294 return cast<llvm::DIFile>(V);
297 llvm::DIFile *F = DBuilder.createFile(remapDIPath(PLoc.getFilename()),
298 remapDIPath(getCurrentDirname()));
300 DIFileCache[fname].reset(F);
304 llvm::DIFile *CGDebugInfo::getOrCreateMainFile() {
305 return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
306 remapDIPath(TheCU->getDirectory()));
309 std::string CGDebugInfo::remapDIPath(StringRef Path) const {
310 for (const auto &Entry : DebugPrefixMap)
311 if (Path.startswith(Entry.first))
312 return (Twine(Entry.second) + Path.substr(Entry.first.size())).str();
316 unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) {
317 if (Loc.isInvalid() && CurLoc.isInvalid())
319 SourceManager &SM = CGM.getContext().getSourceManager();
320 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
321 return PLoc.isValid() ? PLoc.getLine() : 0;
324 unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc, bool Force) {
325 // We may not want column information at all.
326 if (!Force && !CGM.getCodeGenOpts().DebugColumnInfo)
329 // If the location is invalid then use the current column.
330 if (Loc.isInvalid() && CurLoc.isInvalid())
332 SourceManager &SM = CGM.getContext().getSourceManager();
333 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
334 return PLoc.isValid() ? PLoc.getColumn() : 0;
337 StringRef CGDebugInfo::getCurrentDirname() {
338 if (!CGM.getCodeGenOpts().DebugCompilationDir.empty())
339 return CGM.getCodeGenOpts().DebugCompilationDir;
341 if (!CWDName.empty())
343 SmallString<256> CWD;
344 llvm::sys::fs::current_path(CWD);
345 return CWDName = internString(CWD);
348 void CGDebugInfo::CreateCompileUnit() {
350 // Should we be asking the SourceManager for the main file name, instead of
351 // accepting it as an argument? This just causes the main file name to
352 // mismatch with source locations and create extra lexical scopes or
353 // mismatched debug info (a CU with a DW_AT_file of "-", because that's what
354 // the driver passed, but functions/other things have DW_AT_file of "<stdin>"
355 // because that's what the SourceManager says)
357 // Get absolute path name.
358 SourceManager &SM = CGM.getContext().getSourceManager();
359 std::string MainFileName = CGM.getCodeGenOpts().MainFileName;
360 if (MainFileName.empty())
361 MainFileName = "<stdin>";
363 // The main file name provided via the "-main-file-name" option contains just
364 // the file name itself with no path information. This file name may have had
365 // a relative path, so we look into the actual file entry for the main
366 // file to determine the real absolute path for the file.
367 std::string MainFileDir;
368 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
369 MainFileDir = remapDIPath(MainFile->getDir()->getName());
370 if (MainFileDir != ".") {
371 llvm::SmallString<1024> MainFileDirSS(MainFileDir);
372 llvm::sys::path::append(MainFileDirSS, MainFileName);
373 MainFileName = MainFileDirSS.str();
377 llvm::dwarf::SourceLanguage LangTag;
378 const LangOptions &LO = CGM.getLangOpts();
381 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
383 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
384 } else if (LO.ObjC1) {
385 LangTag = llvm::dwarf::DW_LANG_ObjC;
387 LangTag = llvm::dwarf::DW_LANG_C99;
389 LangTag = llvm::dwarf::DW_LANG_C89;
392 std::string Producer = getClangFullVersion();
394 // Figure out which version of the ObjC runtime we have.
395 unsigned RuntimeVers = 0;
397 RuntimeVers = LO.ObjCRuntime.isNonFragile() ? 2 : 1;
399 // Create new compile unit.
400 // FIXME - Eliminate TheCU.
401 TheCU = DBuilder.createCompileUnit(
402 LangTag, remapDIPath(MainFileName), remapDIPath(getCurrentDirname()),
403 Producer, LO.Optimize, CGM.getCodeGenOpts().DwarfDebugFlags, RuntimeVers,
404 CGM.getCodeGenOpts().SplitDwarfFile,
405 DebugKind <= CodeGenOptions::DebugLineTablesOnly
406 ? llvm::DIBuilder::LineTablesOnly
407 : llvm::DIBuilder::FullDebug,
408 0 /* DWOid */, DebugKind != CodeGenOptions::LocTrackingOnly);
411 llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
412 llvm::dwarf::TypeKind Encoding;
414 switch (BT->getKind()) {
415 #define BUILTIN_TYPE(Id, SingletonId)
416 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
417 #include "clang/AST/BuiltinTypes.def"
418 case BuiltinType::Dependent:
419 llvm_unreachable("Unexpected builtin type");
420 case BuiltinType::NullPtr:
421 return DBuilder.createNullPtrType();
422 case BuiltinType::Void:
424 case BuiltinType::ObjCClass:
426 ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
428 getOrCreateMainFile(), 0);
430 case BuiltinType::ObjCId: {
431 // typedef struct objc_class *Class;
432 // typedef struct objc_object {
440 ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
442 getOrCreateMainFile(), 0);
444 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
446 auto *ISATy = DBuilder.createPointerType(ClassTy, Size);
449 DBuilder.createStructType(TheCU, "objc_object", getOrCreateMainFile(),
450 0, 0, 0, 0, nullptr, llvm::DINodeArray());
452 DBuilder.replaceArrays(
454 DBuilder.getOrCreateArray(&*DBuilder.createMemberType(
455 ObjTy, "isa", getOrCreateMainFile(), 0, Size, 0, 0, 0, ISATy)));
458 case BuiltinType::ObjCSel: {
460 SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
461 "objc_selector", TheCU,
462 getOrCreateMainFile(), 0);
466 case BuiltinType::OCLImage1d:
467 return getOrCreateStructPtrType("opencl_image1d_t", OCLImage1dDITy);
468 case BuiltinType::OCLImage1dArray:
469 return getOrCreateStructPtrType("opencl_image1d_array_t",
470 OCLImage1dArrayDITy);
471 case BuiltinType::OCLImage1dBuffer:
472 return getOrCreateStructPtrType("opencl_image1d_buffer_t",
473 OCLImage1dBufferDITy);
474 case BuiltinType::OCLImage2d:
475 return getOrCreateStructPtrType("opencl_image2d_t", OCLImage2dDITy);
476 case BuiltinType::OCLImage2dArray:
477 return getOrCreateStructPtrType("opencl_image2d_array_t",
478 OCLImage2dArrayDITy);
479 case BuiltinType::OCLImage2dDepth:
480 return getOrCreateStructPtrType("opencl_image2d_depth_t",
481 OCLImage2dDepthDITy);
482 case BuiltinType::OCLImage2dArrayDepth:
483 return getOrCreateStructPtrType("opencl_image2d_array_depth_t",
484 OCLImage2dArrayDepthDITy);
485 case BuiltinType::OCLImage2dMSAA:
486 return getOrCreateStructPtrType("opencl_image2d_msaa_t",
488 case BuiltinType::OCLImage2dArrayMSAA:
489 return getOrCreateStructPtrType("opencl_image2d_array_msaa_t",
490 OCLImage2dArrayMSAADITy);
491 case BuiltinType::OCLImage2dMSAADepth:
492 return getOrCreateStructPtrType("opencl_image2d_msaa_depth_t",
493 OCLImage2dMSAADepthDITy);
494 case BuiltinType::OCLImage2dArrayMSAADepth:
495 return getOrCreateStructPtrType("opencl_image2d_array_msaa_depth_t",
496 OCLImage2dArrayMSAADepthDITy);
497 case BuiltinType::OCLImage3d:
498 return getOrCreateStructPtrType("opencl_image3d_t", OCLImage3dDITy);
499 case BuiltinType::OCLSampler:
500 return DBuilder.createBasicType(
501 "opencl_sampler_t", CGM.getContext().getTypeSize(BT),
502 CGM.getContext().getTypeAlign(BT), llvm::dwarf::DW_ATE_unsigned);
503 case BuiltinType::OCLEvent:
504 return getOrCreateStructPtrType("opencl_event_t", OCLEventDITy);
505 case BuiltinType::OCLClkEvent:
506 return getOrCreateStructPtrType("opencl_clk_event_t", OCLClkEventDITy);
507 case BuiltinType::OCLQueue:
508 return getOrCreateStructPtrType("opencl_queue_t", OCLQueueDITy);
509 case BuiltinType::OCLNDRange:
510 return getOrCreateStructPtrType("opencl_ndrange_t", OCLNDRangeDITy);
511 case BuiltinType::OCLReserveID:
512 return getOrCreateStructPtrType("opencl_reserve_id_t", OCLReserveIDDITy);
514 case BuiltinType::UChar:
515 case BuiltinType::Char_U:
516 Encoding = llvm::dwarf::DW_ATE_unsigned_char;
518 case BuiltinType::Char_S:
519 case BuiltinType::SChar:
520 Encoding = llvm::dwarf::DW_ATE_signed_char;
522 case BuiltinType::Char16:
523 case BuiltinType::Char32:
524 Encoding = llvm::dwarf::DW_ATE_UTF;
526 case BuiltinType::UShort:
527 case BuiltinType::UInt:
528 case BuiltinType::UInt128:
529 case BuiltinType::ULong:
530 case BuiltinType::WChar_U:
531 case BuiltinType::ULongLong:
532 Encoding = llvm::dwarf::DW_ATE_unsigned;
534 case BuiltinType::Short:
535 case BuiltinType::Int:
536 case BuiltinType::Int128:
537 case BuiltinType::Long:
538 case BuiltinType::WChar_S:
539 case BuiltinType::LongLong:
540 Encoding = llvm::dwarf::DW_ATE_signed;
542 case BuiltinType::Bool:
543 Encoding = llvm::dwarf::DW_ATE_boolean;
545 case BuiltinType::Half:
546 case BuiltinType::Float:
547 case BuiltinType::LongDouble:
548 case BuiltinType::Double:
549 Encoding = llvm::dwarf::DW_ATE_float;
553 switch (BT->getKind()) {
554 case BuiltinType::Long:
557 case BuiltinType::LongLong:
558 BTName = "long long int";
560 case BuiltinType::ULong:
561 BTName = "long unsigned int";
563 case BuiltinType::ULongLong:
564 BTName = "long long unsigned int";
567 BTName = BT->getName(CGM.getLangOpts());
570 // Bit size, align and offset of the type.
571 uint64_t Size = CGM.getContext().getTypeSize(BT);
572 uint64_t Align = CGM.getContext().getTypeAlign(BT);
573 return DBuilder.createBasicType(BTName, Size, Align, Encoding);
576 llvm::DIType *CGDebugInfo::CreateType(const ComplexType *Ty) {
577 // Bit size, align and offset of the type.
578 llvm::dwarf::TypeKind Encoding = llvm::dwarf::DW_ATE_complex_float;
579 if (Ty->isComplexIntegerType())
580 Encoding = llvm::dwarf::DW_ATE_lo_user;
582 uint64_t Size = CGM.getContext().getTypeSize(Ty);
583 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
584 return DBuilder.createBasicType("complex", Size, Align, Encoding);
587 llvm::DIType *CGDebugInfo::CreateQualifiedType(QualType Ty,
588 llvm::DIFile *Unit) {
589 QualifierCollector Qc;
590 const Type *T = Qc.strip(Ty);
592 // Ignore these qualifiers for now.
593 Qc.removeObjCGCAttr();
594 Qc.removeAddressSpace();
595 Qc.removeObjCLifetime();
597 // We will create one Derived type for one qualifier and recurse to handle any
599 llvm::dwarf::Tag Tag;
601 Tag = llvm::dwarf::DW_TAG_const_type;
603 } else if (Qc.hasVolatile()) {
604 Tag = llvm::dwarf::DW_TAG_volatile_type;
606 } else if (Qc.hasRestrict()) {
607 Tag = llvm::dwarf::DW_TAG_restrict_type;
610 assert(Qc.empty() && "Unknown type qualifier for debug info");
611 return getOrCreateType(QualType(T, 0), Unit);
614 auto *FromTy = getOrCreateType(Qc.apply(CGM.getContext(), T), Unit);
616 // No need to fill in the Name, Line, Size, Alignment, Offset in case of
617 // CVR derived types.
618 return DBuilder.createQualifiedType(Tag, FromTy);
621 llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty,
622 llvm::DIFile *Unit) {
624 // The frontend treats 'id' as a typedef to an ObjCObjectType,
625 // whereas 'id<protocol>' is treated as an ObjCPointerType. For the
626 // debug info, we want to emit 'id' in both cases.
627 if (Ty->isObjCQualifiedIdType())
628 return getOrCreateType(CGM.getContext().getObjCIdType(), Unit);
630 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
631 Ty->getPointeeType(), Unit);
634 llvm::DIType *CGDebugInfo::CreateType(const PointerType *Ty,
635 llvm::DIFile *Unit) {
636 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
637 Ty->getPointeeType(), Unit);
640 /// \return whether a C++ mangling exists for the type defined by TD.
641 static bool hasCXXMangling(const TagDecl *TD, llvm::DICompileUnit *TheCU) {
642 switch (TheCU->getSourceLanguage()) {
643 case llvm::dwarf::DW_LANG_C_plus_plus:
645 case llvm::dwarf::DW_LANG_ObjC_plus_plus:
646 return isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD);
652 /// In C++ mode, types have linkage, so we can rely on the ODR and
653 /// on their mangled names, if they're external.
654 static SmallString<256> getUniqueTagTypeName(const TagType *Ty,
656 llvm::DICompileUnit *TheCU) {
657 SmallString<256> FullName;
658 const TagDecl *TD = Ty->getDecl();
660 if (!hasCXXMangling(TD, TheCU) || !TD->isExternallyVisible())
663 // Microsoft Mangler does not have support for mangleCXXRTTIName yet.
664 if (CGM.getTarget().getCXXABI().isMicrosoft())
667 // TODO: This is using the RTTI name. Is there a better way to get
668 // a unique string for a type?
669 llvm::raw_svector_ostream Out(FullName);
670 CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(QualType(Ty, 0), Out);
674 /// \return the approproate DWARF tag for a composite type.
675 static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD) {
676 llvm::dwarf::Tag Tag;
677 if (RD->isStruct() || RD->isInterface())
678 Tag = llvm::dwarf::DW_TAG_structure_type;
679 else if (RD->isUnion())
680 Tag = llvm::dwarf::DW_TAG_union_type;
682 // FIXME: This could be a struct type giving a default visibility different
683 // than C++ class type, but needs llvm metadata changes first.
684 assert(RD->isClass());
685 Tag = llvm::dwarf::DW_TAG_class_type;
690 llvm::DICompositeType *
691 CGDebugInfo::getOrCreateRecordFwdDecl(const RecordType *Ty,
692 llvm::DIScope *Ctx) {
693 const RecordDecl *RD = Ty->getDecl();
694 if (llvm::DIType *T = getTypeOrNull(CGM.getContext().getRecordType(RD)))
695 return cast<llvm::DICompositeType>(T);
696 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
697 unsigned Line = getLineNumber(RD->getLocation());
698 StringRef RDName = getClassName(RD);
703 const RecordDecl *D = RD->getDefinition();
704 if (D && D->isCompleteDefinition()) {
705 Size = CGM.getContext().getTypeSize(Ty);
706 Align = CGM.getContext().getTypeAlign(Ty);
710 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
711 llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
712 getTagForRecord(RD), RDName, Ctx, DefUnit, Line, 0, Size, Align,
713 llvm::DINode::FlagFwdDecl, FullName);
714 ReplaceMap.emplace_back(
715 std::piecewise_construct, std::make_tuple(Ty),
716 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
720 llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
723 llvm::DIFile *Unit) {
724 // Bit size, align and offset of the type.
725 // Size is always the size of a pointer. We can't use getTypeSize here
726 // because that does not return the correct value for references.
727 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
728 uint64_t Size = CGM.getTarget().getPointerWidth(AS);
729 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
731 if (Tag == llvm::dwarf::DW_TAG_reference_type ||
732 Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)
733 return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit),
736 return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
740 llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
741 llvm::DIType *&Cache) {
744 Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
745 TheCU, getOrCreateMainFile(), 0);
746 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
747 Cache = DBuilder.createPointerType(Cache, Size);
751 llvm::DIType *CGDebugInfo::CreateType(const BlockPointerType *Ty,
752 llvm::DIFile *Unit) {
753 SmallVector<llvm::Metadata *, 8> EltTys;
755 uint64_t FieldSize, FieldOffset;
757 llvm::DINodeArray Elements;
760 FType = CGM.getContext().UnsignedLongTy;
761 EltTys.push_back(CreateMemberType(Unit, FType, "reserved", &FieldOffset));
762 EltTys.push_back(CreateMemberType(Unit, FType, "Size", &FieldOffset));
764 Elements = DBuilder.getOrCreateArray(EltTys);
767 unsigned Flags = llvm::DINode::FlagAppleBlock;
771 DBuilder.createStructType(Unit, "__block_descriptor", nullptr, LineNo,
772 FieldOffset, 0, Flags, nullptr, Elements);
774 // Bit size, align and offset of the type.
775 uint64_t Size = CGM.getContext().getTypeSize(Ty);
777 auto *DescTy = DBuilder.createPointerType(EltTy, Size);
780 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
781 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
782 FType = CGM.getContext().IntTy;
783 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
784 EltTys.push_back(CreateMemberType(Unit, FType, "__reserved", &FieldOffset));
785 FType = CGM.getContext().getPointerType(Ty->getPointeeType());
786 EltTys.push_back(CreateMemberType(Unit, FType, "__FuncPtr", &FieldOffset));
788 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
789 FieldSize = CGM.getContext().getTypeSize(Ty);
790 FieldAlign = CGM.getContext().getTypeAlign(Ty);
791 EltTys.push_back(DBuilder.createMemberType(Unit, "__descriptor", nullptr, LineNo,
792 FieldSize, FieldAlign, FieldOffset,
795 FieldOffset += FieldSize;
796 Elements = DBuilder.getOrCreateArray(EltTys);
798 // The __block_literal_generic structs are marked with a special
799 // DW_AT_APPLE_BLOCK attribute and are an implementation detail only
800 // the debugger needs to know about. To allow type uniquing, emit
801 // them without a name or a location.
803 DBuilder.createStructType(Unit, "", nullptr, LineNo,
804 FieldOffset, 0, Flags, nullptr, Elements);
806 return DBuilder.createPointerType(EltTy, Size);
809 llvm::DIType *CGDebugInfo::CreateType(const TemplateSpecializationType *Ty,
810 llvm::DIFile *Unit) {
811 assert(Ty->isTypeAlias());
812 llvm::DIType *Src = getOrCreateType(Ty->getAliasedType(), Unit);
815 llvm::raw_svector_ostream OS(NS);
816 Ty->getTemplateName().print(OS, CGM.getContext().getPrintingPolicy(),
817 /*qualified*/ false);
819 TemplateSpecializationType::PrintTemplateArgumentList(
820 OS, Ty->getArgs(), Ty->getNumArgs(),
821 CGM.getContext().getPrintingPolicy());
823 TypeAliasDecl *AliasDecl = cast<TypeAliasTemplateDecl>(
824 Ty->getTemplateName().getAsTemplateDecl())->getTemplatedDecl();
826 SourceLocation Loc = AliasDecl->getLocation();
827 return DBuilder.createTypedef(Src, OS.str(), getOrCreateFile(Loc),
829 getDeclContextDescriptor(AliasDecl));
832 llvm::DIType *CGDebugInfo::CreateType(const TypedefType *Ty,
833 llvm::DIFile *Unit) {
834 // We don't set size information, but do specify where the typedef was
836 SourceLocation Loc = Ty->getDecl()->getLocation();
838 // Typedefs are derived from some other type.
839 return DBuilder.createTypedef(
840 getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit),
841 Ty->getDecl()->getName(), getOrCreateFile(Loc), getLineNumber(Loc),
842 getDeclContextDescriptor(Ty->getDecl()));
845 llvm::DIType *CGDebugInfo::CreateType(const FunctionType *Ty,
846 llvm::DIFile *Unit) {
847 SmallVector<llvm::Metadata *, 16> EltTys;
849 // Add the result type at least.
850 EltTys.push_back(getOrCreateType(Ty->getReturnType(), Unit));
852 // Set up remainder of arguments if there is a prototype.
853 // otherwise emit it as a variadic function.
854 if (isa<FunctionNoProtoType>(Ty))
855 EltTys.push_back(DBuilder.createUnspecifiedParameter());
856 else if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(Ty)) {
857 for (unsigned i = 0, e = FPT->getNumParams(); i != e; ++i)
858 EltTys.push_back(getOrCreateType(FPT->getParamType(i), Unit));
859 if (FPT->isVariadic())
860 EltTys.push_back(DBuilder.createUnspecifiedParameter());
863 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
864 return DBuilder.createSubroutineType(EltTypeArray);
867 /// Convert an AccessSpecifier into the corresponding DINode flag.
868 /// As an optimization, return 0 if the access specifier equals the
869 /// default for the containing type.
870 static unsigned getAccessFlag(AccessSpecifier Access, const RecordDecl *RD) {
871 AccessSpecifier Default = clang::AS_none;
872 if (RD && RD->isClass())
873 Default = clang::AS_private;
874 else if (RD && (RD->isStruct() || RD->isUnion()))
875 Default = clang::AS_public;
877 if (Access == Default)
881 case clang::AS_private:
882 return llvm::DINode::FlagPrivate;
883 case clang::AS_protected:
884 return llvm::DINode::FlagProtected;
885 case clang::AS_public:
886 return llvm::DINode::FlagPublic;
890 llvm_unreachable("unexpected access enumerator");
893 llvm::DIType *CGDebugInfo::createFieldType(
894 StringRef name, QualType type, uint64_t sizeInBitsOverride,
895 SourceLocation loc, AccessSpecifier AS, uint64_t offsetInBits,
896 llvm::DIFile *tunit, llvm::DIScope *scope, const RecordDecl *RD) {
897 llvm::DIType *debugType = getOrCreateType(type, tunit);
899 // Get the location for the field.
900 llvm::DIFile *file = getOrCreateFile(loc);
901 unsigned line = getLineNumber(loc);
903 uint64_t SizeInBits = 0;
904 unsigned AlignInBits = 0;
905 if (!type->isIncompleteArrayType()) {
906 TypeInfo TI = CGM.getContext().getTypeInfo(type);
907 SizeInBits = TI.Width;
908 AlignInBits = TI.Align;
910 if (sizeInBitsOverride)
911 SizeInBits = sizeInBitsOverride;
914 unsigned flags = getAccessFlag(AS, RD);
915 return DBuilder.createMemberType(scope, name, file, line, SizeInBits,
916 AlignInBits, offsetInBits, flags, debugType);
919 void CGDebugInfo::CollectRecordLambdaFields(
920 const CXXRecordDecl *CXXDecl, SmallVectorImpl<llvm::Metadata *> &elements,
921 llvm::DIType *RecordTy) {
922 // For C++11 Lambdas a Field will be the same as a Capture, but the Capture
923 // has the name and the location of the variable so we should iterate over
924 // both concurrently.
925 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(CXXDecl);
926 RecordDecl::field_iterator Field = CXXDecl->field_begin();
927 unsigned fieldno = 0;
928 for (CXXRecordDecl::capture_const_iterator I = CXXDecl->captures_begin(),
929 E = CXXDecl->captures_end();
930 I != E; ++I, ++Field, ++fieldno) {
931 const LambdaCapture &C = *I;
932 if (C.capturesVariable()) {
933 VarDecl *V = C.getCapturedVar();
934 llvm::DIFile *VUnit = getOrCreateFile(C.getLocation());
935 StringRef VName = V->getName();
936 uint64_t SizeInBitsOverride = 0;
937 if (Field->isBitField()) {
938 SizeInBitsOverride = Field->getBitWidthValue(CGM.getContext());
939 assert(SizeInBitsOverride && "found named 0-width bitfield");
941 llvm::DIType *fieldType = createFieldType(
942 VName, Field->getType(), SizeInBitsOverride, C.getLocation(),
943 Field->getAccess(), layout.getFieldOffset(fieldno), VUnit, RecordTy,
945 elements.push_back(fieldType);
946 } else if (C.capturesThis()) {
947 // TODO: Need to handle 'this' in some way by probably renaming the
948 // this of the lambda class and having a field member of 'this' or
949 // by using AT_object_pointer for the function and having that be
950 // used as 'this' for semantic references.
951 FieldDecl *f = *Field;
952 llvm::DIFile *VUnit = getOrCreateFile(f->getLocation());
953 QualType type = f->getType();
954 llvm::DIType *fieldType = createFieldType(
955 "this", type, 0, f->getLocation(), f->getAccess(),
956 layout.getFieldOffset(fieldno), VUnit, RecordTy, CXXDecl);
958 elements.push_back(fieldType);
963 llvm::DIDerivedType *
964 CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy,
965 const RecordDecl *RD) {
966 // Create the descriptor for the static variable, with or without
967 // constant initializers.
968 Var = Var->getCanonicalDecl();
969 llvm::DIFile *VUnit = getOrCreateFile(Var->getLocation());
970 llvm::DIType *VTy = getOrCreateType(Var->getType(), VUnit);
972 unsigned LineNumber = getLineNumber(Var->getLocation());
973 StringRef VName = Var->getName();
974 llvm::Constant *C = nullptr;
975 if (Var->getInit()) {
976 const APValue *Value = Var->evaluateValue();
979 C = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->getInt());
980 if (Value->isFloat())
981 C = llvm::ConstantFP::get(CGM.getLLVMContext(), Value->getFloat());
985 unsigned Flags = getAccessFlag(Var->getAccess(), RD);
986 llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
987 RecordTy, VName, VUnit, LineNumber, VTy, Flags, C);
988 StaticDataMemberCache[Var->getCanonicalDecl()].reset(GV);
992 void CGDebugInfo::CollectRecordNormalField(
993 const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit,
994 SmallVectorImpl<llvm::Metadata *> &elements, llvm::DIType *RecordTy,
995 const RecordDecl *RD) {
996 StringRef name = field->getName();
997 QualType type = field->getType();
999 // Ignore unnamed fields unless they're anonymous structs/unions.
1000 if (name.empty() && !type->isRecordType())
1003 uint64_t SizeInBitsOverride = 0;
1004 if (field->isBitField()) {
1005 SizeInBitsOverride = field->getBitWidthValue(CGM.getContext());
1006 assert(SizeInBitsOverride && "found named 0-width bitfield");
1009 llvm::DIType *fieldType =
1010 createFieldType(name, type, SizeInBitsOverride, field->getLocation(),
1011 field->getAccess(), OffsetInBits, tunit, RecordTy, RD);
1013 elements.push_back(fieldType);
1016 void CGDebugInfo::CollectRecordFields(
1017 const RecordDecl *record, llvm::DIFile *tunit,
1018 SmallVectorImpl<llvm::Metadata *> &elements,
1019 llvm::DICompositeType *RecordTy) {
1020 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(record);
1022 if (CXXDecl && CXXDecl->isLambda())
1023 CollectRecordLambdaFields(CXXDecl, elements, RecordTy);
1025 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(record);
1027 // Field number for non-static fields.
1028 unsigned fieldNo = 0;
1030 // Static and non-static members should appear in the same order as
1031 // the corresponding declarations in the source program.
1032 for (const auto *I : record->decls())
1033 if (const auto *V = dyn_cast<VarDecl>(I)) {
1034 // Reuse the existing static member declaration if one exists
1035 auto MI = StaticDataMemberCache.find(V->getCanonicalDecl());
1036 if (MI != StaticDataMemberCache.end()) {
1037 assert(MI->second &&
1038 "Static data member declaration should still exist");
1039 elements.push_back(MI->second);
1041 auto Field = CreateRecordStaticField(V, RecordTy, record);
1042 elements.push_back(Field);
1044 } else if (const auto *field = dyn_cast<FieldDecl>(I)) {
1045 CollectRecordNormalField(field, layout.getFieldOffset(fieldNo), tunit,
1046 elements, RecordTy, record);
1048 // Bump field number for next field.
1054 llvm::DISubroutineType *
1055 CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method,
1056 llvm::DIFile *Unit) {
1057 const FunctionProtoType *Func = Method->getType()->getAs<FunctionProtoType>();
1058 if (Method->isStatic())
1059 return cast_or_null<llvm::DISubroutineType>(
1060 getOrCreateType(QualType(Func, 0), Unit));
1061 return getOrCreateInstanceMethodType(Method->getThisType(CGM.getContext()),
1065 llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType(
1066 QualType ThisPtr, const FunctionProtoType *Func, llvm::DIFile *Unit) {
1067 // Add "this" pointer.
1068 llvm::DITypeRefArray Args(
1069 cast<llvm::DISubroutineType>(getOrCreateType(QualType(Func, 0), Unit))
1071 assert(Args.size() && "Invalid number of arguments!");
1073 SmallVector<llvm::Metadata *, 16> Elts;
1075 // First element is always return type. For 'void' functions it is NULL.
1076 Elts.push_back(Args[0]);
1078 // "this" pointer is always first argument.
1079 const CXXRecordDecl *RD = ThisPtr->getPointeeCXXRecordDecl();
1080 if (isa<ClassTemplateSpecializationDecl>(RD)) {
1081 // Create pointer type directly in this case.
1082 const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr);
1083 QualType PointeeTy = ThisPtrTy->getPointeeType();
1084 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
1085 uint64_t Size = CGM.getTarget().getPointerWidth(AS);
1086 uint64_t Align = CGM.getContext().getTypeAlign(ThisPtrTy);
1087 llvm::DIType *PointeeType = getOrCreateType(PointeeTy, Unit);
1088 llvm::DIType *ThisPtrType =
1089 DBuilder.createPointerType(PointeeType, Size, Align);
1090 TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
1091 // TODO: This and the artificial type below are misleading, the
1092 // types aren't artificial the argument is, but the current
1093 // metadata doesn't represent that.
1094 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1095 Elts.push_back(ThisPtrType);
1097 llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);
1098 TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
1099 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1100 Elts.push_back(ThisPtrType);
1103 // Copy rest of the arguments.
1104 for (unsigned i = 1, e = Args.size(); i != e; ++i)
1105 Elts.push_back(Args[i]);
1107 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
1110 if (Func->getExtProtoInfo().RefQualifier == RQ_LValue)
1111 Flags |= llvm::DINode::FlagLValueReference;
1112 if (Func->getExtProtoInfo().RefQualifier == RQ_RValue)
1113 Flags |= llvm::DINode::FlagRValueReference;
1115 return DBuilder.createSubroutineType(EltTypeArray, Flags);
1118 /// isFunctionLocalClass - Return true if CXXRecordDecl is defined
1119 /// inside a function.
1120 static bool isFunctionLocalClass(const CXXRecordDecl *RD) {
1121 if (const CXXRecordDecl *NRD = dyn_cast<CXXRecordDecl>(RD->getDeclContext()))
1122 return isFunctionLocalClass(NRD);
1123 if (isa<FunctionDecl>(RD->getDeclContext()))
1128 llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
1129 const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {
1131 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
1133 StringRef MethodName = getFunctionName(Method);
1134 llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit);
1136 // Since a single ctor/dtor corresponds to multiple functions, it doesn't
1137 // make sense to give a single ctor/dtor a linkage name.
1138 StringRef MethodLinkageName;
1139 if (!IsCtorOrDtor && !isFunctionLocalClass(Method->getParent()))
1140 MethodLinkageName = CGM.getMangledName(Method);
1142 // Get the location for the method.
1143 llvm::DIFile *MethodDefUnit = nullptr;
1144 unsigned MethodLine = 0;
1145 if (!Method->isImplicit()) {
1146 MethodDefUnit = getOrCreateFile(Method->getLocation());
1147 MethodLine = getLineNumber(Method->getLocation());
1150 // Collect virtual method info.
1151 llvm::DIType *ContainingType = nullptr;
1152 unsigned Virtuality = 0;
1153 unsigned VIndex = 0;
1155 if (Method->isVirtual()) {
1156 if (Method->isPure())
1157 Virtuality = llvm::dwarf::DW_VIRTUALITY_pure_virtual;
1159 Virtuality = llvm::dwarf::DW_VIRTUALITY_virtual;
1161 // It doesn't make sense to give a virtual destructor a vtable index,
1162 // since a single destructor has two entries in the vtable.
1163 // FIXME: Add proper support for debug info for virtual calls in
1164 // the Microsoft ABI, where we may use multiple vptrs to make a vftable
1165 // lookup if we have multiple or virtual inheritance.
1166 if (!isa<CXXDestructorDecl>(Method) &&
1167 !CGM.getTarget().getCXXABI().isMicrosoft())
1168 VIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(Method);
1169 ContainingType = RecordTy;
1173 if (Method->isImplicit())
1174 Flags |= llvm::DINode::FlagArtificial;
1175 Flags |= getAccessFlag(Method->getAccess(), Method->getParent());
1176 if (const CXXConstructorDecl *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
1177 if (CXXC->isExplicit())
1178 Flags |= llvm::DINode::FlagExplicit;
1179 } else if (const CXXConversionDecl *CXXC =
1180 dyn_cast<CXXConversionDecl>(Method)) {
1181 if (CXXC->isExplicit())
1182 Flags |= llvm::DINode::FlagExplicit;
1184 if (Method->hasPrototype())
1185 Flags |= llvm::DINode::FlagPrototyped;
1186 if (Method->getRefQualifier() == RQ_LValue)
1187 Flags |= llvm::DINode::FlagLValueReference;
1188 if (Method->getRefQualifier() == RQ_RValue)
1189 Flags |= llvm::DINode::FlagRValueReference;
1191 llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
1192 llvm::DISubprogram *SP = DBuilder.createMethod(
1193 RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
1194 MethodTy, /*isLocalToUnit=*/false,
1195 /* isDefinition=*/false, Virtuality, VIndex, ContainingType, Flags,
1196 CGM.getLangOpts().Optimize, TParamsArray.get());
1198 SPCache[Method->getCanonicalDecl()].reset(SP);
1203 void CGDebugInfo::CollectCXXMemberFunctions(
1204 const CXXRecordDecl *RD, llvm::DIFile *Unit,
1205 SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy) {
1207 // Since we want more than just the individual member decls if we
1208 // have templated functions iterate over every declaration to gather
1210 for (const auto *I : RD->decls()) {
1211 const auto *Method = dyn_cast<CXXMethodDecl>(I);
1212 // If the member is implicit, don't add it to the member list. This avoids
1213 // the member being added to type units by LLVM, while still allowing it
1214 // to be emitted into the type declaration/reference inside the compile
1216 // Ditto 'nodebug' methods, for consistency with CodeGenFunction.cpp.
1217 // FIXME: Handle Using(Shadow?)Decls here to create
1218 // DW_TAG_imported_declarations inside the class for base decls brought into
1219 // derived classes. GDB doesn't seem to notice/leverage these when I tried
1220 // it, so I'm not rushing to fix this. (GCC seems to produce them, if
1222 if (!Method || Method->isImplicit() || Method->hasAttr<NoDebugAttr>())
1225 if (Method->getType()->getAs<FunctionProtoType>()->getContainedAutoType())
1228 // Reuse the existing member function declaration if it exists.
1229 // It may be associated with the declaration of the type & should be
1230 // reused as we're building the definition.
1232 // This situation can arise in the vtable-based debug info reduction where
1233 // implicit members are emitted in a non-vtable TU.
1234 auto MI = SPCache.find(Method->getCanonicalDecl());
1235 EltTys.push_back(MI == SPCache.end()
1236 ? CreateCXXMemberFunction(Method, Unit, RecordTy)
1237 : static_cast<llvm::Metadata *>(MI->second));
1241 void CGDebugInfo::CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile *Unit,
1242 SmallVectorImpl<llvm::Metadata *> &EltTys,
1243 llvm::DIType *RecordTy) {
1244 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1245 for (const auto &BI : RD->bases()) {
1246 unsigned BFlags = 0;
1247 uint64_t BaseOffset;
1249 const CXXRecordDecl *Base =
1250 cast<CXXRecordDecl>(BI.getType()->getAs<RecordType>()->getDecl());
1252 if (BI.isVirtual()) {
1253 if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1254 // virtual base offset offset is -ve. The code generator emits dwarf
1255 // expression where it expects +ve number.
1256 BaseOffset = 0 - CGM.getItaniumVTableContext()
1257 .getVirtualBaseOffsetOffset(RD, Base)
1260 // In the MS ABI, store the vbtable offset, which is analogous to the
1261 // vbase offset offset in Itanium.
1263 4 * CGM.getMicrosoftVTableContext().getVBTableIndex(RD, Base);
1265 BFlags = llvm::DINode::FlagVirtual;
1267 BaseOffset = CGM.getContext().toBits(RL.getBaseClassOffset(Base));
1268 // FIXME: Inconsistent units for BaseOffset. It is in bytes when
1269 // BI->isVirtual() and bits when not.
1271 BFlags |= getAccessFlag(BI.getAccessSpecifier(), RD);
1272 llvm::DIType *DTy = DBuilder.createInheritance(
1273 RecordTy, getOrCreateType(BI.getType(), Unit), BaseOffset, BFlags);
1274 EltTys.push_back(DTy);
1279 CGDebugInfo::CollectTemplateParams(const TemplateParameterList *TPList,
1280 ArrayRef<TemplateArgument> TAList,
1281 llvm::DIFile *Unit) {
1282 SmallVector<llvm::Metadata *, 16> TemplateParams;
1283 for (unsigned i = 0, e = TAList.size(); i != e; ++i) {
1284 const TemplateArgument &TA = TAList[i];
1287 Name = TPList->getParam(i)->getName();
1288 switch (TA.getKind()) {
1289 case TemplateArgument::Type: {
1290 llvm::DIType *TTy = getOrCreateType(TA.getAsType(), Unit);
1291 TemplateParams.push_back(
1292 DBuilder.createTemplateTypeParameter(TheCU, Name, TTy));
1294 case TemplateArgument::Integral: {
1295 llvm::DIType *TTy = getOrCreateType(TA.getIntegralType(), Unit);
1296 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1298 llvm::ConstantInt::get(CGM.getLLVMContext(), TA.getAsIntegral())));
1300 case TemplateArgument::Declaration: {
1301 const ValueDecl *D = TA.getAsDecl();
1302 QualType T = TA.getParamTypeForDecl().getDesugaredType(CGM.getContext());
1303 llvm::DIType *TTy = getOrCreateType(T, Unit);
1304 llvm::Constant *V = nullptr;
1305 const CXXMethodDecl *MD;
1306 // Variable pointer template parameters have a value that is the address
1308 if (const auto *VD = dyn_cast<VarDecl>(D))
1309 V = CGM.GetAddrOfGlobalVar(VD);
1310 // Member function pointers have special support for building them, though
1311 // this is currently unsupported in LLVM CodeGen.
1312 else if ((MD = dyn_cast<CXXMethodDecl>(D)) && MD->isInstance())
1313 V = CGM.getCXXABI().EmitMemberFunctionPointer(MD);
1314 else if (const auto *FD = dyn_cast<FunctionDecl>(D))
1315 V = CGM.GetAddrOfFunction(FD);
1316 // Member data pointers have special handling too to compute the fixed
1317 // offset within the object.
1318 else if (const auto *MPT = dyn_cast<MemberPointerType>(T.getTypePtr())) {
1319 // These five lines (& possibly the above member function pointer
1320 // handling) might be able to be refactored to use similar code in
1321 // CodeGenModule::getMemberPointerConstant
1322 uint64_t fieldOffset = CGM.getContext().getFieldOffset(D);
1324 CGM.getContext().toCharUnitsFromBits((int64_t)fieldOffset);
1325 V = CGM.getCXXABI().EmitMemberDataPointer(MPT, chars);
1327 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1329 cast_or_null<llvm::Constant>(V->stripPointerCasts())));
1331 case TemplateArgument::NullPtr: {
1332 QualType T = TA.getNullPtrType();
1333 llvm::DIType *TTy = getOrCreateType(T, Unit);
1334 llvm::Constant *V = nullptr;
1335 // Special case member data pointer null values since they're actually -1
1337 if (const MemberPointerType *MPT =
1338 dyn_cast<MemberPointerType>(T.getTypePtr()))
1339 // But treat member function pointers as simple zero integers because
1340 // it's easier than having a special case in LLVM's CodeGen. If LLVM
1341 // CodeGen grows handling for values of non-null member function
1342 // pointers then perhaps we could remove this special case and rely on
1343 // EmitNullMemberPointer for member function pointers.
1344 if (MPT->isMemberDataPointer())
1345 V = CGM.getCXXABI().EmitNullMemberPointer(MPT);
1347 V = llvm::ConstantInt::get(CGM.Int8Ty, 0);
1348 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1349 TheCU, Name, TTy, cast<llvm::Constant>(V)));
1351 case TemplateArgument::Template:
1352 TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(
1353 TheCU, Name, nullptr,
1354 TA.getAsTemplate().getAsTemplateDecl()->getQualifiedNameAsString()));
1356 case TemplateArgument::Pack:
1357 TemplateParams.push_back(DBuilder.createTemplateParameterPack(
1358 TheCU, Name, nullptr,
1359 CollectTemplateParams(nullptr, TA.getPackAsArray(), Unit)));
1361 case TemplateArgument::Expression: {
1362 const Expr *E = TA.getAsExpr();
1363 QualType T = E->getType();
1365 T = CGM.getContext().getLValueReferenceType(T);
1366 llvm::Constant *V = CGM.EmitConstantExpr(E, T);
1367 assert(V && "Expression in template argument isn't constant");
1368 llvm::DIType *TTy = getOrCreateType(T, Unit);
1369 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1370 TheCU, Name, TTy, cast<llvm::Constant>(V->stripPointerCasts())));
1372 // And the following should never occur:
1373 case TemplateArgument::TemplateExpansion:
1374 case TemplateArgument::Null:
1376 "These argument types shouldn't exist in concrete types");
1379 return DBuilder.getOrCreateArray(TemplateParams);
1383 CGDebugInfo::CollectFunctionTemplateParams(const FunctionDecl *FD,
1384 llvm::DIFile *Unit) {
1385 if (FD->getTemplatedKind() ==
1386 FunctionDecl::TK_FunctionTemplateSpecialization) {
1387 const TemplateParameterList *TList = FD->getTemplateSpecializationInfo()
1389 ->getTemplateParameters();
1390 return CollectTemplateParams(
1391 TList, FD->getTemplateSpecializationArgs()->asArray(), Unit);
1393 return llvm::DINodeArray();
1396 llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(
1397 const ClassTemplateSpecializationDecl *TSpecial, llvm::DIFile *Unit) {
1398 // Always get the full list of parameters, not just the ones from
1399 // the specialization.
1400 TemplateParameterList *TPList =
1401 TSpecial->getSpecializedTemplate()->getTemplateParameters();
1402 const TemplateArgumentList &TAList = TSpecial->getTemplateArgs();
1403 return CollectTemplateParams(TPList, TAList.asArray(), Unit);
1406 llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
1408 return VTablePtrType;
1410 ASTContext &Context = CGM.getContext();
1413 llvm::Metadata *STy = getOrCreateType(Context.IntTy, Unit);
1414 llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);
1415 llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements);
1416 unsigned Size = Context.getTypeSize(Context.VoidPtrTy);
1417 llvm::DIType *vtbl_ptr_type =
1418 DBuilder.createPointerType(SubTy, Size, 0, "__vtbl_ptr_type");
1419 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
1420 return VTablePtrType;
1423 StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) {
1424 // Copy the gdb compatible name on the side and use its reference.
1425 return internString("_vptr$", RD->getNameAsString());
1428 void CGDebugInfo::CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile *Unit,
1429 SmallVectorImpl<llvm::Metadata *> &EltTys) {
1430 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1432 // If there is a primary base then it will hold vtable info.
1433 if (RL.getPrimaryBase())
1436 // If this class is not dynamic then there is not any vtable info to collect.
1437 if (!RD->isDynamicClass())
1440 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
1441 llvm::DIType *VPTR = DBuilder.createMemberType(
1442 Unit, getVTableName(RD), Unit, 0, Size, 0, 0,
1443 llvm::DINode::FlagArtificial, getOrCreateVTablePtrType(Unit));
1444 EltTys.push_back(VPTR);
1447 llvm::DIType *CGDebugInfo::getOrCreateRecordType(QualType RTy,
1448 SourceLocation Loc) {
1449 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
1450 llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
1454 llvm::DIType *CGDebugInfo::getOrCreateInterfaceType(QualType D,
1455 SourceLocation Loc) {
1456 return getOrCreateStandaloneType(D, Loc);
1459 llvm::DIType *CGDebugInfo::getOrCreateStandaloneType(QualType D,
1460 SourceLocation Loc) {
1461 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
1462 assert(!D.isNull() && "null type");
1463 llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc));
1464 assert(T && "could not create debug info for type");
1466 // Composite types with UIDs were already retained by DIBuilder
1467 // because they are only referenced by name in the IR.
1468 if (auto *CTy = dyn_cast<llvm::DICompositeType>(T))
1469 if (!CTy->getIdentifier().empty())
1471 RetainedTypes.push_back(D.getAsOpaquePtr());
1475 void CGDebugInfo::completeType(const EnumDecl *ED) {
1476 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
1478 QualType Ty = CGM.getContext().getEnumType(ED);
1479 void *TyPtr = Ty.getAsOpaquePtr();
1480 auto I = TypeCache.find(TyPtr);
1481 if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())
1483 llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<EnumType>());
1484 assert(!Res->isForwardDecl());
1485 TypeCache[TyPtr].reset(Res);
1488 void CGDebugInfo::completeType(const RecordDecl *RD) {
1489 if (DebugKind > CodeGenOptions::LimitedDebugInfo ||
1490 !CGM.getLangOpts().CPlusPlus)
1491 completeRequiredType(RD);
1494 void CGDebugInfo::completeRequiredType(const RecordDecl *RD) {
1495 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
1498 if (const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
1499 if (CXXDecl->isDynamicClass())
1502 if (DebugTypeExtRefs && RD->isFromASTFile())
1505 QualType Ty = CGM.getContext().getRecordType(RD);
1506 llvm::DIType *T = getTypeOrNull(Ty);
1507 if (T && T->isForwardDecl())
1508 completeClassData(RD);
1511 void CGDebugInfo::completeClassData(const RecordDecl *RD) {
1512 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
1514 QualType Ty = CGM.getContext().getRecordType(RD);
1515 void *TyPtr = Ty.getAsOpaquePtr();
1516 auto I = TypeCache.find(TyPtr);
1517 if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
1519 llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<RecordType>());
1520 assert(!Res->isForwardDecl());
1521 TypeCache[TyPtr].reset(Res);
1524 static bool hasExplicitMemberDefinition(CXXRecordDecl::method_iterator I,
1525 CXXRecordDecl::method_iterator End) {
1526 for (; I != End; ++I)
1527 if (FunctionDecl *Tmpl = I->getInstantiatedFromMemberFunction())
1528 if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&
1529 !I->getMemberSpecializationInfo()->isExplicitSpecialization())
1534 static bool shouldOmitDefinition(CodeGenOptions::DebugInfoKind DebugKind,
1535 bool DebugTypeExtRefs,
1536 const RecordDecl *RD,
1537 const LangOptions &LangOpts) {
1538 // Does the type exist in an imported clang module?
1539 if (DebugTypeExtRefs && RD->isFromASTFile() && RD->getDefinition())
1542 if (DebugKind > CodeGenOptions::LimitedDebugInfo)
1545 if (!LangOpts.CPlusPlus)
1548 if (!RD->isCompleteDefinitionRequired())
1551 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
1556 if (CXXDecl->hasDefinition() && CXXDecl->isDynamicClass())
1559 TemplateSpecializationKind Spec = TSK_Undeclared;
1560 if (const ClassTemplateSpecializationDecl *SD =
1561 dyn_cast<ClassTemplateSpecializationDecl>(RD))
1562 Spec = SD->getSpecializationKind();
1564 if (Spec == TSK_ExplicitInstantiationDeclaration &&
1565 hasExplicitMemberDefinition(CXXDecl->method_begin(),
1566 CXXDecl->method_end()))
1572 llvm::DIType *CGDebugInfo::CreateType(const RecordType *Ty) {
1573 RecordDecl *RD = Ty->getDecl();
1574 llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(QualType(Ty, 0)));
1575 if (T || shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD,
1576 CGM.getLangOpts())) {
1578 T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));
1582 return CreateTypeDefinition(Ty);
1585 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) {
1586 RecordDecl *RD = Ty->getDecl();
1588 // Get overall information about the record type for the debug info.
1589 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
1591 // Records and classes and unions can all be recursive. To handle them, we
1592 // first generate a debug descriptor for the struct as a forward declaration.
1593 // Then (if it is a definition) we go through and get debug info for all of
1594 // its members. Finally, we create a descriptor for the complete type (which
1595 // may refer to the forward decl if the struct is recursive) and replace all
1596 // uses of the forward declaration with the final definition.
1597 llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty, DefUnit);
1599 const RecordDecl *D = RD->getDefinition();
1600 if (!D || !D->isCompleteDefinition())
1603 if (const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
1604 CollectContainingType(CXXDecl, FwdDecl);
1606 // Push the struct on region stack.
1607 LexicalBlockStack.emplace_back(&*FwdDecl);
1608 RegionMap[Ty->getDecl()].reset(FwdDecl);
1610 // Convert all the elements.
1611 SmallVector<llvm::Metadata *, 16> EltTys;
1612 // what about nested types?
1614 // Note: The split of CXXDecl information here is intentional, the
1615 // gdb tests will depend on a certain ordering at printout. The debug
1616 // information offsets are still correct if we merge them all together
1618 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
1620 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
1621 CollectVTableInfo(CXXDecl, DefUnit, EltTys);
1624 // Collect data fields (including static variables and any initializers).
1625 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
1627 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
1629 LexicalBlockStack.pop_back();
1630 RegionMap.erase(Ty->getDecl());
1632 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
1633 DBuilder.replaceArrays(FwdDecl, Elements);
1635 if (FwdDecl->isTemporary())
1637 llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
1639 RegionMap[Ty->getDecl()].reset(FwdDecl);
1643 llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectType *Ty,
1644 llvm::DIFile *Unit) {
1645 // Ignore protocols.
1646 return getOrCreateType(Ty->getBaseType(), Unit);
1649 /// \return true if Getter has the default name for the property PD.
1650 static bool hasDefaultGetterName(const ObjCPropertyDecl *PD,
1651 const ObjCMethodDecl *Getter) {
1656 assert(Getter->getDeclName().isObjCZeroArgSelector());
1657 return PD->getName() ==
1658 Getter->getDeclName().getObjCSelector().getNameForSlot(0);
1661 /// \return true if Setter has the default name for the property PD.
1662 static bool hasDefaultSetterName(const ObjCPropertyDecl *PD,
1663 const ObjCMethodDecl *Setter) {
1668 assert(Setter->getDeclName().isObjCOneArgSelector());
1669 return SelectorTable::constructSetterName(PD->getName()) ==
1670 Setter->getDeclName().getObjCSelector().getNameForSlot(0);
1673 llvm::DIType *CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
1674 llvm::DIFile *Unit) {
1675 ObjCInterfaceDecl *ID = Ty->getDecl();
1679 // Return a forward declaration if this type was imported from a clang module.
1680 if (DebugTypeExtRefs && ID->isFromASTFile() && ID->getDefinition())
1681 return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
1683 getDeclContextDescriptor(ID), Unit, 0);
1685 // Get overall information about the record type for the debug info.
1686 llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation());
1687 unsigned Line = getLineNumber(ID->getLocation());
1689 static_cast<llvm::dwarf::SourceLanguage>(TheCU->getSourceLanguage());
1691 // If this is just a forward declaration return a special forward-declaration
1692 // debug type since we won't be able to lay out the entire type.
1693 ObjCInterfaceDecl *Def = ID->getDefinition();
1694 if (!Def || !Def->getImplementation()) {
1695 llvm::DIScope *Mod = getParentModuleOrNull(ID);
1696 llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(
1697 llvm::dwarf::DW_TAG_structure_type, ID->getName(), Mod ? Mod : TheCU,
1698 DefUnit, Line, RuntimeLang);
1699 ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit));
1703 return CreateTypeDefinition(Ty, Unit);
1707 CGDebugInfo::getOrCreateModuleRef(ExternalASTSource::ASTSourceDescriptor Mod,
1708 bool CreateSkeletonCU) {
1709 // Use the Module pointer as the key into the cache. This is a
1710 // nullptr if the "Module" is a PCH, which is safe because we don't
1711 // support chained PCH debug info, so there can only be a single PCH.
1712 const Module *M = Mod.getModuleOrNull();
1713 auto ModRef = ModuleCache.find(M);
1714 if (ModRef != ModuleCache.end())
1715 return cast<llvm::DIModule>(ModRef->second);
1717 // Macro definitions that were defined with "-D" on the command line.
1718 SmallString<128> ConfigMacros;
1720 llvm::raw_svector_ostream OS(ConfigMacros);
1721 const auto &PPOpts = CGM.getPreprocessorOpts();
1723 // Translate the macro definitions back into a commmand line.
1724 for (auto &M : PPOpts.Macros) {
1727 const std::string &Macro = M.first;
1728 bool Undef = M.second;
1729 OS << "\"-" << (Undef ? 'U' : 'D');
1730 for (char c : Macro)
1732 case '\\' : OS << "\\\\"; break;
1733 case '"' : OS << "\\\""; break;
1740 bool IsRootModule = M ? !M->Parent : true;
1741 if (CreateSkeletonCU && IsRootModule) {
1742 llvm::DIBuilder DIB(CGM.getModule());
1743 DIB.createCompileUnit(TheCU->getSourceLanguage(), Mod.getModuleName(),
1744 Mod.getPath(), TheCU->getProducer(), true,
1745 StringRef(), 0, Mod.getASTFile(),
1746 llvm::DIBuilder::FullDebug, Mod.getSignature());
1749 llvm::DIModule *Parent =
1750 IsRootModule ? nullptr
1751 : getOrCreateModuleRef(
1752 ExternalASTSource::ASTSourceDescriptor(*M->Parent),
1754 llvm::DIModule *DIMod =
1755 DBuilder.createModule(Parent, Mod.getModuleName(), ConfigMacros,
1756 Mod.getPath(), CGM.getHeaderSearchOpts().Sysroot);
1757 ModuleCache[M].reset(DIMod);
1761 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty,
1762 llvm::DIFile *Unit) {
1763 ObjCInterfaceDecl *ID = Ty->getDecl();
1764 llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation());
1765 unsigned Line = getLineNumber(ID->getLocation());
1766 unsigned RuntimeLang = TheCU->getSourceLanguage();
1768 // Bit size, align and offset of the type.
1769 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1770 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1773 if (ID->getImplementation())
1774 Flags |= llvm::DINode::FlagObjcClassComplete;
1776 llvm::DIScope *Mod = getParentModuleOrNull(ID);
1777 llvm::DICompositeType *RealDecl = DBuilder.createStructType(
1778 Mod ? Mod : Unit, ID->getName(), DefUnit, Line, Size, Align, Flags,
1779 nullptr, llvm::DINodeArray(), RuntimeLang);
1781 QualType QTy(Ty, 0);
1782 TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl);
1784 // Push the struct on region stack.
1785 LexicalBlockStack.emplace_back(RealDecl);
1786 RegionMap[Ty->getDecl()].reset(RealDecl);
1788 // Convert all the elements.
1789 SmallVector<llvm::Metadata *, 16> EltTys;
1791 ObjCInterfaceDecl *SClass = ID->getSuperClass();
1793 llvm::DIType *SClassTy =
1794 getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit);
1798 llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0, 0);
1799 EltTys.push_back(InhTag);
1802 // Create entries for all of the properties.
1803 auto AddProperty = [&](const ObjCPropertyDecl *PD) {
1804 SourceLocation Loc = PD->getLocation();
1805 llvm::DIFile *PUnit = getOrCreateFile(Loc);
1806 unsigned PLine = getLineNumber(Loc);
1807 ObjCMethodDecl *Getter = PD->getGetterMethodDecl();
1808 ObjCMethodDecl *Setter = PD->getSetterMethodDecl();
1809 llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(
1810 PD->getName(), PUnit, PLine,
1811 hasDefaultGetterName(PD, Getter) ? ""
1812 : getSelectorName(PD->getGetterName()),
1813 hasDefaultSetterName(PD, Setter) ? ""
1814 : getSelectorName(PD->getSetterName()),
1815 PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit));
1816 EltTys.push_back(PropertyNode);
1819 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
1820 for (const ObjCCategoryDecl *ClassExt : ID->known_extensions())
1821 for (auto *PD : ClassExt->properties()) {
1822 PropertySet.insert(PD->getIdentifier());
1825 for (const auto *PD : ID->properties()) {
1826 // Don't emit duplicate metadata for properties that were already in a
1828 if (!PropertySet.insert(PD->getIdentifier()).second)
1834 const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(ID);
1835 unsigned FieldNo = 0;
1836 for (ObjCIvarDecl *Field = ID->all_declared_ivar_begin(); Field;
1837 Field = Field->getNextIvar(), ++FieldNo) {
1838 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
1842 StringRef FieldName = Field->getName();
1844 // Ignore unnamed fields.
1845 if (FieldName.empty())
1848 // Get the location for the field.
1849 llvm::DIFile *FieldDefUnit = getOrCreateFile(Field->getLocation());
1850 unsigned FieldLine = getLineNumber(Field->getLocation());
1851 QualType FType = Field->getType();
1852 uint64_t FieldSize = 0;
1853 unsigned FieldAlign = 0;
1855 if (!FType->isIncompleteArrayType()) {
1857 // Bit size, align and offset of the type.
1858 FieldSize = Field->isBitField()
1859 ? Field->getBitWidthValue(CGM.getContext())
1860 : CGM.getContext().getTypeSize(FType);
1861 FieldAlign = CGM.getContext().getTypeAlign(FType);
1864 uint64_t FieldOffset;
1865 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
1866 // We don't know the runtime offset of an ivar if we're using the
1867 // non-fragile ABI. For bitfields, use the bit offset into the first
1868 // byte of storage of the bitfield. For other fields, use zero.
1869 if (Field->isBitField()) {
1871 CGM.getObjCRuntime().ComputeBitfieldBitOffset(CGM, ID, Field);
1872 FieldOffset %= CGM.getContext().getCharWidth();
1877 FieldOffset = RL.getFieldOffset(FieldNo);
1881 if (Field->getAccessControl() == ObjCIvarDecl::Protected)
1882 Flags = llvm::DINode::FlagProtected;
1883 else if (Field->getAccessControl() == ObjCIvarDecl::Private)
1884 Flags = llvm::DINode::FlagPrivate;
1885 else if (Field->getAccessControl() == ObjCIvarDecl::Public)
1886 Flags = llvm::DINode::FlagPublic;
1888 llvm::MDNode *PropertyNode = nullptr;
1889 if (ObjCImplementationDecl *ImpD = ID->getImplementation()) {
1890 if (ObjCPropertyImplDecl *PImpD =
1891 ImpD->FindPropertyImplIvarDecl(Field->getIdentifier())) {
1892 if (ObjCPropertyDecl *PD = PImpD->getPropertyDecl()) {
1893 SourceLocation Loc = PD->getLocation();
1894 llvm::DIFile *PUnit = getOrCreateFile(Loc);
1895 unsigned PLine = getLineNumber(Loc);
1896 ObjCMethodDecl *Getter = PD->getGetterMethodDecl();
1897 ObjCMethodDecl *Setter = PD->getSetterMethodDecl();
1898 PropertyNode = DBuilder.createObjCProperty(
1899 PD->getName(), PUnit, PLine,
1900 hasDefaultGetterName(PD, Getter) ? "" : getSelectorName(
1901 PD->getGetterName()),
1902 hasDefaultSetterName(PD, Setter) ? "" : getSelectorName(
1903 PD->getSetterName()),
1904 PD->getPropertyAttributes(),
1905 getOrCreateType(PD->getType(), PUnit));
1909 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine,
1910 FieldSize, FieldAlign, FieldOffset, Flags,
1911 FieldTy, PropertyNode);
1912 EltTys.push_back(FieldTy);
1915 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
1916 DBuilder.replaceArrays(RealDecl, Elements);
1918 LexicalBlockStack.pop_back();
1922 llvm::DIType *CGDebugInfo::CreateType(const VectorType *Ty,
1923 llvm::DIFile *Unit) {
1924 llvm::DIType *ElementTy = getOrCreateType(Ty->getElementType(), Unit);
1925 int64_t Count = Ty->getNumElements();
1927 // If number of elements are not known then this is an unbounded array.
1928 // Use Count == -1 to express such arrays.
1931 llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(0, Count);
1932 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
1934 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1935 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1937 return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
1940 llvm::DIType *CGDebugInfo::CreateType(const ArrayType *Ty, llvm::DIFile *Unit) {
1944 // FIXME: make getTypeAlign() aware of VLAs and incomplete array types
1945 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(Ty)) {
1948 CGM.getContext().getTypeAlign(CGM.getContext().getBaseElementType(VAT));
1949 } else if (Ty->isIncompleteArrayType()) {
1951 if (Ty->getElementType()->isIncompleteType())
1954 Align = CGM.getContext().getTypeAlign(Ty->getElementType());
1955 } else if (Ty->isIncompleteType()) {
1959 // Size and align of the whole array, not the element type.
1960 Size = CGM.getContext().getTypeSize(Ty);
1961 Align = CGM.getContext().getTypeAlign(Ty);
1964 // Add the dimensions of the array. FIXME: This loses CV qualifiers from
1965 // interior arrays, do we care? Why aren't nested arrays represented the
1966 // obvious/recursive way?
1967 SmallVector<llvm::Metadata *, 8> Subscripts;
1968 QualType EltTy(Ty, 0);
1969 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
1970 // If the number of elements is known, then count is that number. Otherwise,
1971 // it's -1. This allows us to represent a subrange with an array of 0
1972 // elements, like this:
1977 int64_t Count = -1; // Count == -1 is an unbounded array.
1978 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(Ty))
1979 Count = CAT->getSize().getZExtValue();
1981 // FIXME: Verify this is right for VLAs.
1982 Subscripts.push_back(DBuilder.getOrCreateSubrange(0, Count));
1983 EltTy = Ty->getElementType();
1986 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
1988 return DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
1992 llvm::DIType *CGDebugInfo::CreateType(const LValueReferenceType *Ty,
1993 llvm::DIFile *Unit) {
1994 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty,
1995 Ty->getPointeeType(), Unit);
1998 llvm::DIType *CGDebugInfo::CreateType(const RValueReferenceType *Ty,
1999 llvm::DIFile *Unit) {
2000 return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type, Ty,
2001 Ty->getPointeeType(), Unit);
2004 llvm::DIType *CGDebugInfo::CreateType(const MemberPointerType *Ty,
2007 !Ty->isIncompleteType() ? CGM.getContext().getTypeSize(Ty) : 0;
2008 llvm::DIType *ClassType = getOrCreateType(QualType(Ty->getClass(), 0), U);
2009 if (Ty->isMemberDataPointerType())
2010 return DBuilder.createMemberPointerType(
2011 getOrCreateType(Ty->getPointeeType(), U), ClassType, Size);
2013 const FunctionProtoType *FPT =
2014 Ty->getPointeeType()->getAs<FunctionProtoType>();
2015 return DBuilder.createMemberPointerType(
2016 getOrCreateInstanceMethodType(CGM.getContext().getPointerType(QualType(
2017 Ty->getClass(), FPT->getTypeQuals())),
2022 llvm::DIType *CGDebugInfo::CreateType(const AtomicType *Ty, llvm::DIFile *U) {
2023 // Ignore the atomic wrapping
2024 // FIXME: What is the correct representation?
2025 return getOrCreateType(Ty->getValueType(), U);
2028 llvm::DIType* CGDebugInfo::CreateType(const PipeType *Ty,
2030 return getOrCreateType(Ty->getElementType(), U);
2033 llvm::DIType *CGDebugInfo::CreateEnumType(const EnumType *Ty) {
2034 const EnumDecl *ED = Ty->getDecl();
2038 if (!ED->getTypeForDecl()->isIncompleteType()) {
2039 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
2040 Align = CGM.getContext().getTypeAlign(ED->getTypeForDecl());
2043 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
2045 bool isImportedFromModule =
2046 DebugTypeExtRefs && ED->isFromASTFile() && ED->getDefinition();
2048 // If this is just a forward declaration, construct an appropriately
2049 // marked node and just return it.
2050 if (isImportedFromModule || !ED->getDefinition()) {
2051 llvm::DIScope *EDContext = getDeclContextDescriptor(ED);
2052 llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
2053 unsigned Line = getLineNumber(ED->getLocation());
2054 StringRef EDName = ED->getName();
2055 llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType(
2056 llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit, Line,
2057 0, Size, Align, llvm::DINode::FlagFwdDecl, FullName);
2058 ReplaceMap.emplace_back(
2059 std::piecewise_construct, std::make_tuple(Ty),
2060 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
2064 return CreateTypeDefinition(Ty);
2067 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) {
2068 const EnumDecl *ED = Ty->getDecl();
2071 if (!ED->getTypeForDecl()->isIncompleteType()) {
2072 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
2073 Align = CGM.getContext().getTypeAlign(ED->getTypeForDecl());
2076 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
2078 // Create elements for each enumerator.
2079 SmallVector<llvm::Metadata *, 16> Enumerators;
2080 ED = ED->getDefinition();
2081 for (const auto *Enum : ED->enumerators()) {
2082 Enumerators.push_back(DBuilder.createEnumerator(
2083 Enum->getName(), Enum->getInitVal().getSExtValue()));
2086 // Return a CompositeType for the enum itself.
2087 llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
2089 llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
2090 unsigned Line = getLineNumber(ED->getLocation());
2091 llvm::DIScope *EnumContext = getDeclContextDescriptor(ED);
2092 llvm::DIType *ClassTy =
2093 ED->isFixed() ? getOrCreateType(ED->getIntegerType(), DefUnit) : nullptr;
2094 return DBuilder.createEnumerationType(EnumContext, ED->getName(), DefUnit,
2095 Line, Size, Align, EltArray, ClassTy,
2099 static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C) {
2102 Qualifiers InnerQuals = T.getLocalQualifiers();
2103 // Qualifiers::operator+() doesn't like it if you add a Qualifier
2104 // that is already there.
2105 Quals += Qualifiers::removeCommonQualifiers(Quals, InnerQuals);
2106 Quals += InnerQuals;
2108 switch (T->getTypeClass()) {
2110 return C.getQualifiedType(T.getTypePtr(), Quals);
2111 case Type::TemplateSpecialization: {
2112 const auto *Spec = cast<TemplateSpecializationType>(T);
2113 if (Spec->isTypeAlias())
2114 return C.getQualifiedType(T.getTypePtr(), Quals);
2115 T = Spec->desugar();
2118 case Type::TypeOfExpr:
2119 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
2122 T = cast<TypeOfType>(T)->getUnderlyingType();
2124 case Type::Decltype:
2125 T = cast<DecltypeType>(T)->getUnderlyingType();
2127 case Type::UnaryTransform:
2128 T = cast<UnaryTransformType>(T)->getUnderlyingType();
2130 case Type::Attributed:
2131 T = cast<AttributedType>(T)->getEquivalentType();
2133 case Type::Elaborated:
2134 T = cast<ElaboratedType>(T)->getNamedType();
2137 T = cast<ParenType>(T)->getInnerType();
2139 case Type::SubstTemplateTypeParm:
2140 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
2143 QualType DT = cast<AutoType>(T)->getDeducedType();
2144 assert(!DT.isNull() && "Undeduced types shouldn't reach here.");
2149 assert(T != LastT && "Type unwrapping failed to unwrap!");
2154 llvm::DIType *CGDebugInfo::getTypeOrNull(QualType Ty) {
2156 // Unwrap the type as needed for debug information.
2157 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
2159 auto it = TypeCache.find(Ty.getAsOpaquePtr());
2160 if (it != TypeCache.end()) {
2161 // Verify that the debug info still exists.
2162 if (llvm::Metadata *V = it->second)
2163 return cast<llvm::DIType>(V);
2169 void CGDebugInfo::completeTemplateDefinition(
2170 const ClassTemplateSpecializationDecl &SD) {
2171 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2174 completeClassData(&SD);
2175 // In case this type has no member function definitions being emitted, ensure
2177 RetainedTypes.push_back(CGM.getContext().getRecordType(&SD).getAsOpaquePtr());
2180 llvm::DIType *CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile *Unit) {
2184 // Unwrap the type as needed for debug information.
2185 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
2187 if (auto *T = getTypeOrNull(Ty))
2190 llvm::DIType *Res = CreateTypeNode(Ty, Unit);
2191 void* TyPtr = Ty.getAsOpaquePtr();
2193 // And update the type cache.
2194 TypeCache[TyPtr].reset(Res);
2199 llvm::DIModule *CGDebugInfo::getParentModuleOrNull(const Decl *D) {
2200 // A forward declaration inside a module header does not belong to the module.
2201 if (isa<RecordDecl>(D) && !cast<RecordDecl>(D)->getDefinition())
2203 if (DebugTypeExtRefs && D->isFromASTFile()) {
2204 // Record a reference to an imported clang module or precompiled header.
2205 auto *Reader = CGM.getContext().getExternalSource();
2206 auto Idx = D->getOwningModuleID();
2207 auto Info = Reader->getSourceDescriptor(Idx);
2209 return getOrCreateModuleRef(*Info, /*SkeletonCU=*/true);
2210 } else if (ClangModuleMap) {
2211 // We are building a clang module or a precompiled header.
2213 // TODO: When D is a CXXRecordDecl or a C++ Enum, the ODR applies
2214 // and it wouldn't be necessary to specify the parent scope
2215 // because the type is already unique by definition (it would look
2216 // like the output of -fno-standalone-debug). On the other hand,
2217 // the parent scope helps a consumer to quickly locate the object
2218 // file where the type's definition is located, so it might be
2219 // best to make this behavior a command line or debugger tuning
2221 FullSourceLoc Loc(D->getLocation(), CGM.getContext().getSourceManager());
2222 if (Module *M = ClangModuleMap->inferModuleFromLocation(Loc)) {
2223 auto Info = ExternalASTSource::ASTSourceDescriptor(*M);
2224 return getOrCreateModuleRef(Info, /*SkeletonCU=*/false);
2231 llvm::DIType *CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile *Unit) {
2232 // Handle qualifiers, which recursively handles what they refer to.
2233 if (Ty.hasLocalQualifiers())
2234 return CreateQualifiedType(Ty, Unit);
2236 // Work out details of type.
2237 switch (Ty->getTypeClass()) {
2238 #define TYPE(Class, Base)
2239 #define ABSTRACT_TYPE(Class, Base)
2240 #define NON_CANONICAL_TYPE(Class, Base)
2241 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
2242 #include "clang/AST/TypeNodes.def"
2243 llvm_unreachable("Dependent types cannot show up in debug information");
2245 case Type::ExtVector:
2247 return CreateType(cast<VectorType>(Ty), Unit);
2248 case Type::ObjCObjectPointer:
2249 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
2250 case Type::ObjCObject:
2251 return CreateType(cast<ObjCObjectType>(Ty), Unit);
2252 case Type::ObjCInterface:
2253 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
2255 return CreateType(cast<BuiltinType>(Ty));
2257 return CreateType(cast<ComplexType>(Ty));
2259 return CreateType(cast<PointerType>(Ty), Unit);
2260 case Type::Adjusted:
2262 // Decayed and adjusted types use the adjusted type in LLVM and DWARF.
2264 cast<PointerType>(cast<AdjustedType>(Ty)->getAdjustedType()), Unit);
2265 case Type::BlockPointer:
2266 return CreateType(cast<BlockPointerType>(Ty), Unit);
2268 return CreateType(cast<TypedefType>(Ty), Unit);
2270 return CreateType(cast<RecordType>(Ty));
2272 return CreateEnumType(cast<EnumType>(Ty));
2273 case Type::FunctionProto:
2274 case Type::FunctionNoProto:
2275 return CreateType(cast<FunctionType>(Ty), Unit);
2276 case Type::ConstantArray:
2277 case Type::VariableArray:
2278 case Type::IncompleteArray:
2279 return CreateType(cast<ArrayType>(Ty), Unit);
2281 case Type::LValueReference:
2282 return CreateType(cast<LValueReferenceType>(Ty), Unit);
2283 case Type::RValueReference:
2284 return CreateType(cast<RValueReferenceType>(Ty), Unit);
2286 case Type::MemberPointer:
2287 return CreateType(cast<MemberPointerType>(Ty), Unit);
2290 return CreateType(cast<AtomicType>(Ty), Unit);
2293 return CreateType(cast<PipeType>(Ty), Unit);
2295 case Type::TemplateSpecialization:
2296 return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
2299 case Type::Attributed:
2300 case Type::Elaborated:
2302 case Type::SubstTemplateTypeParm:
2303 case Type::TypeOfExpr:
2305 case Type::Decltype:
2306 case Type::UnaryTransform:
2307 case Type::PackExpansion:
2311 llvm_unreachable("type should have been unwrapped!");
2314 llvm::DICompositeType *CGDebugInfo::getOrCreateLimitedType(const RecordType *Ty,
2315 llvm::DIFile *Unit) {
2316 QualType QTy(Ty, 0);
2318 auto *T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));
2320 // We may have cached a forward decl when we could have created
2321 // a non-forward decl. Go ahead and create a non-forward decl
2323 if (T && !T->isForwardDecl())
2326 // Otherwise create the type.
2327 llvm::DICompositeType *Res = CreateLimitedType(Ty);
2329 // Propagate members from the declaration to the definition
2330 // CreateType(const RecordType*) will overwrite this with the members in the
2331 // correct order if the full type is needed.
2332 DBuilder.replaceArrays(Res, T ? T->getElements() : llvm::DINodeArray());
2334 // And update the type cache.
2335 TypeCache[QTy.getAsOpaquePtr()].reset(Res);
2339 // TODO: Currently used for context chains when limiting debug info.
2340 llvm::DICompositeType *CGDebugInfo::CreateLimitedType(const RecordType *Ty) {
2341 RecordDecl *RD = Ty->getDecl();
2343 // Get overall information about the record type for the debug info.
2344 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
2345 unsigned Line = getLineNumber(RD->getLocation());
2346 StringRef RDName = getClassName(RD);
2348 llvm::DIScope *RDContext = getDeclContextDescriptor(RD);
2350 // If we ended up creating the type during the context chain construction,
2351 // just return that.
2352 auto *T = cast_or_null<llvm::DICompositeType>(
2353 getTypeOrNull(CGM.getContext().getRecordType(RD)));
2354 if (T && (!T->isForwardDecl() || !RD->getDefinition()))
2357 // If this is just a forward or incomplete declaration, construct an
2358 // appropriately marked node and just return it.
2359 const RecordDecl *D = RD->getDefinition();
2360 if (!D || !D->isCompleteDefinition())
2361 return getOrCreateRecordFwdDecl(Ty, RDContext);
2363 uint64_t Size = CGM.getContext().getTypeSize(Ty);
2364 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
2366 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
2368 llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
2369 getTagForRecord(RD), RDName, RDContext, DefUnit, Line, 0, Size, Align, 0,
2372 RegionMap[Ty->getDecl()].reset(RealDecl);
2373 TypeCache[QualType(Ty, 0).getAsOpaquePtr()].reset(RealDecl);
2375 if (const ClassTemplateSpecializationDecl *TSpecial =
2376 dyn_cast<ClassTemplateSpecializationDecl>(RD))
2377 DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),
2378 CollectCXXTemplateParams(TSpecial, DefUnit));
2382 void CGDebugInfo::CollectContainingType(const CXXRecordDecl *RD,
2383 llvm::DICompositeType *RealDecl) {
2384 // A class's primary base or the class itself contains the vtable.
2385 llvm::DICompositeType *ContainingType = nullptr;
2386 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2387 if (const CXXRecordDecl *PBase = RL.getPrimaryBase()) {
2388 // Seek non-virtual primary base root.
2390 const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase);
2391 const CXXRecordDecl *PBT = BRL.getPrimaryBase();
2392 if (PBT && !BRL.isPrimaryBaseVirtual())
2397 ContainingType = cast<llvm::DICompositeType>(
2398 getOrCreateType(QualType(PBase->getTypeForDecl(), 0),
2399 getOrCreateFile(RD->getLocation())));
2400 } else if (RD->isDynamicClass())
2401 ContainingType = RealDecl;
2403 DBuilder.replaceVTableHolder(RealDecl, ContainingType);
2406 llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit, QualType FType,
2407 StringRef Name, uint64_t *Offset) {
2408 llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
2409 uint64_t FieldSize = CGM.getContext().getTypeSize(FType);
2410 unsigned FieldAlign = CGM.getContext().getTypeAlign(FType);
2411 llvm::DIType *Ty = DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize,
2412 FieldAlign, *Offset, 0, FieldTy);
2413 *Offset += FieldSize;
2417 void CGDebugInfo::collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit,
2419 StringRef &LinkageName,
2420 llvm::DIScope *&FDContext,
2421 llvm::DINodeArray &TParamsArray,
2423 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
2424 Name = getFunctionName(FD);
2425 // Use mangled name as linkage name for C/C++ functions.
2426 if (FD->hasPrototype()) {
2427 LinkageName = CGM.getMangledName(GD);
2428 Flags |= llvm::DINode::FlagPrototyped;
2430 // No need to replicate the linkage name if it isn't different from the
2431 // subprogram name, no need to have it at all unless coverage is enabled or
2432 // debug is set to more than just line tables.
2433 if (LinkageName == Name ||
2434 (!CGM.getCodeGenOpts().EmitGcovArcs &&
2435 !CGM.getCodeGenOpts().EmitGcovNotes &&
2436 DebugKind <= CodeGenOptions::DebugLineTablesOnly))
2437 LinkageName = StringRef();
2439 if (DebugKind >= CodeGenOptions::LimitedDebugInfo) {
2440 if (const NamespaceDecl *NSDecl =
2441 dyn_cast_or_null<NamespaceDecl>(FD->getDeclContext()))
2442 FDContext = getOrCreateNameSpace(NSDecl);
2443 else if (const RecordDecl *RDecl =
2444 dyn_cast_or_null<RecordDecl>(FD->getDeclContext())) {
2445 llvm::DIScope *Mod = getParentModuleOrNull(RDecl);
2446 FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU);
2448 // Collect template parameters.
2449 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
2453 void CGDebugInfo::collectVarDeclProps(const VarDecl *VD, llvm::DIFile *&Unit,
2454 unsigned &LineNo, QualType &T,
2455 StringRef &Name, StringRef &LinkageName,
2456 llvm::DIScope *&VDContext) {
2457 Unit = getOrCreateFile(VD->getLocation());
2458 LineNo = getLineNumber(VD->getLocation());
2460 setLocation(VD->getLocation());
2463 if (T->isIncompleteArrayType()) {
2464 // CodeGen turns int[] into int[1] so we'll do the same here.
2465 llvm::APInt ConstVal(32, 1);
2466 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
2468 T = CGM.getContext().getConstantArrayType(ET, ConstVal,
2469 ArrayType::Normal, 0);
2472 Name = VD->getName();
2473 if (VD->getDeclContext() && !isa<FunctionDecl>(VD->getDeclContext()) &&
2474 !isa<ObjCMethodDecl>(VD->getDeclContext()))
2475 LinkageName = CGM.getMangledName(VD);
2476 if (LinkageName == Name)
2477 LinkageName = StringRef();
2479 // Since we emit declarations (DW_AT_members) for static members, place the
2480 // definition of those static members in the namespace they were declared in
2481 // in the source code (the lexical decl context).
2482 // FIXME: Generalize this for even non-member global variables where the
2483 // declaration and definition may have different lexical decl contexts, once
2484 // we have support for emitting declarations of (non-member) global variables.
2485 const DeclContext *DC = VD->isStaticDataMember() ? VD->getLexicalDeclContext()
2486 : VD->getDeclContext();
2487 // When a record type contains an in-line initialization of a static data
2488 // member, and the record type is marked as __declspec(dllexport), an implicit
2489 // definition of the member will be created in the record context. DWARF
2490 // doesn't seem to have a nice way to describe this in a form that consumers
2491 // are likely to understand, so fake the "normal" situation of a definition
2492 // outside the class by putting it in the global scope.
2494 DC = CGM.getContext().getTranslationUnitDecl();
2496 llvm::DIScope *Mod = getParentModuleOrNull(VD);
2497 VDContext = getContextDescriptor(cast<Decl>(DC), Mod ? Mod : TheCU);
2500 llvm::DISubprogram *
2501 CGDebugInfo::getFunctionForwardDeclaration(const FunctionDecl *FD) {
2502 llvm::DINodeArray TParamsArray;
2503 StringRef Name, LinkageName;
2505 SourceLocation Loc = FD->getLocation();
2506 llvm::DIFile *Unit = getOrCreateFile(Loc);
2507 llvm::DIScope *DContext = Unit;
2508 unsigned Line = getLineNumber(Loc);
2510 collectFunctionDeclProps(FD, Unit, Name, LinkageName, DContext,
2511 TParamsArray, Flags);
2512 // Build function type.
2513 SmallVector<QualType, 16> ArgTypes;
2514 for (const ParmVarDecl *Parm: FD->parameters())
2515 ArgTypes.push_back(Parm->getType());
2517 CGM.getContext().getFunctionType(FD->getReturnType(), ArgTypes,
2518 FunctionProtoType::ExtProtoInfo());
2519 llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
2520 DContext, Name, LinkageName, Unit, Line,
2521 getOrCreateFunctionType(FD, FnType, Unit), !FD->isExternallyVisible(),
2522 /* isDefinition = */ false, 0, Flags, CGM.getLangOpts().Optimize,
2523 TParamsArray.get(), getFunctionDeclaration(FD));
2524 const FunctionDecl *CanonDecl = cast<FunctionDecl>(FD->getCanonicalDecl());
2525 FwdDeclReplaceMap.emplace_back(std::piecewise_construct,
2526 std::make_tuple(CanonDecl),
2527 std::make_tuple(SP));
2531 llvm::DIGlobalVariable *
2532 CGDebugInfo::getGlobalVariableForwardDeclaration(const VarDecl *VD) {
2534 StringRef Name, LinkageName;
2535 SourceLocation Loc = VD->getLocation();
2536 llvm::DIFile *Unit = getOrCreateFile(Loc);
2537 llvm::DIScope *DContext = Unit;
2538 unsigned Line = getLineNumber(Loc);
2540 collectVarDeclProps(VD, Unit, Line, T, Name, LinkageName, DContext);
2541 auto *GV = DBuilder.createTempGlobalVariableFwdDecl(
2542 DContext, Name, LinkageName, Unit, Line, getOrCreateType(T, Unit),
2543 !VD->isExternallyVisible(), nullptr, nullptr);
2544 FwdDeclReplaceMap.emplace_back(
2545 std::piecewise_construct,
2546 std::make_tuple(cast<VarDecl>(VD->getCanonicalDecl())),
2547 std::make_tuple(static_cast<llvm::Metadata *>(GV)));
2551 llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(const Decl *D) {
2552 // We only need a declaration (not a definition) of the type - so use whatever
2553 // we would otherwise do to get a type for a pointee. (forward declarations in
2554 // limited debug info, full definitions (if the type definition is available)
2555 // in unlimited debug info)
2556 if (const TypeDecl *TD = dyn_cast<TypeDecl>(D))
2557 return getOrCreateType(CGM.getContext().getTypeDeclType(TD),
2558 getOrCreateFile(TD->getLocation()));
2559 auto I = DeclCache.find(D->getCanonicalDecl());
2561 if (I != DeclCache.end())
2562 return dyn_cast_or_null<llvm::DINode>(I->second);
2564 // No definition for now. Emit a forward definition that might be
2565 // merged with a potential upcoming definition.
2566 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
2567 return getFunctionForwardDeclaration(FD);
2568 else if (const auto *VD = dyn_cast<VarDecl>(D))
2569 return getGlobalVariableForwardDeclaration(VD);
2574 llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(const Decl *D) {
2575 if (!D || DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2578 const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
2583 auto *S = getDeclContextDescriptor(D);
2585 auto MI = SPCache.find(FD->getCanonicalDecl());
2586 if (MI == SPCache.end()) {
2587 if (const CXXMethodDecl *MD =
2588 dyn_cast<CXXMethodDecl>(FD->getCanonicalDecl())) {
2589 return CreateCXXMemberFunction(MD, getOrCreateFile(MD->getLocation()),
2590 cast<llvm::DICompositeType>(S));
2593 if (MI != SPCache.end()) {
2594 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
2595 if (SP && !SP->isDefinition())
2599 for (auto NextFD : FD->redecls()) {
2600 auto MI = SPCache.find(NextFD->getCanonicalDecl());
2601 if (MI != SPCache.end()) {
2602 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
2603 if (SP && !SP->isDefinition())
2610 // getOrCreateFunctionType - Construct type. If it is a c++ method, include
2611 // implicit parameter "this".
2612 llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(const Decl *D,
2615 if (!D || DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2616 // Create fake but valid subroutine type. Otherwise -verify would fail, and
2617 // subprogram DIE will miss DW_AT_decl_file and DW_AT_decl_line fields.
2618 return DBuilder.createSubroutineType(DBuilder.getOrCreateTypeArray(None));
2620 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
2621 return getOrCreateMethodType(Method, F);
2622 if (const ObjCMethodDecl *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
2623 // Add "self" and "_cmd"
2624 SmallVector<llvm::Metadata *, 16> Elts;
2626 // First element is always return type. For 'void' functions it is NULL.
2627 QualType ResultTy = OMethod->getReturnType();
2629 // Replace the instancetype keyword with the actual type.
2630 if (ResultTy == CGM.getContext().getObjCInstanceType())
2631 ResultTy = CGM.getContext().getPointerType(
2632 QualType(OMethod->getClassInterface()->getTypeForDecl(), 0));
2634 Elts.push_back(getOrCreateType(ResultTy, F));
2635 // "self" pointer is always first argument.
2636 QualType SelfDeclTy;
2637 if (auto *SelfDecl = OMethod->getSelfDecl())
2638 SelfDeclTy = SelfDecl->getType();
2639 else if (auto *FPT = dyn_cast<FunctionProtoType>(FnType))
2640 if (FPT->getNumParams() > 1)
2641 SelfDeclTy = FPT->getParamType(0);
2642 if (!SelfDeclTy.isNull())
2643 Elts.push_back(CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F)));
2644 // "_cmd" pointer is always second argument.
2645 Elts.push_back(DBuilder.createArtificialType(
2646 getOrCreateType(CGM.getContext().getObjCSelType(), F)));
2647 // Get rest of the arguments.
2648 for (const auto *PI : OMethod->params())
2649 Elts.push_back(getOrCreateType(PI->getType(), F));
2650 // Variadic methods need a special marker at the end of the type list.
2651 if (OMethod->isVariadic())
2652 Elts.push_back(DBuilder.createUnspecifiedParameter());
2654 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
2655 return DBuilder.createSubroutineType(EltTypeArray);
2658 // Handle variadic function types; they need an additional
2659 // unspecified parameter.
2660 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
2661 if (FD->isVariadic()) {
2662 SmallVector<llvm::Metadata *, 16> EltTys;
2663 EltTys.push_back(getOrCreateType(FD->getReturnType(), F));
2664 if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FnType))
2665 for (unsigned i = 0, e = FPT->getNumParams(); i != e; ++i)
2666 EltTys.push_back(getOrCreateType(FPT->getParamType(i), F));
2667 EltTys.push_back(DBuilder.createUnspecifiedParameter());
2668 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
2669 return DBuilder.createSubroutineType(EltTypeArray);
2672 return cast<llvm::DISubroutineType>(getOrCreateType(FnType, F));
2675 void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, SourceLocation Loc,
2676 SourceLocation ScopeLoc, QualType FnType,
2677 llvm::Function *Fn, CGBuilderTy &Builder) {
2680 StringRef LinkageName;
2682 FnBeginRegionCount.push_back(LexicalBlockStack.size());
2684 const Decl *D = GD.getDecl();
2685 bool HasDecl = (D != nullptr);
2688 llvm::DIFile *Unit = getOrCreateFile(Loc);
2689 llvm::DIScope *FDContext = Unit;
2690 llvm::DINodeArray TParamsArray;
2692 // Use llvm function name.
2693 LinkageName = Fn->getName();
2694 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2695 // If there is a subprogram for this function available then use it.
2696 auto FI = SPCache.find(FD->getCanonicalDecl());
2697 if (FI != SPCache.end()) {
2698 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
2699 if (SP && SP->isDefinition()) {
2700 LexicalBlockStack.emplace_back(SP);
2701 RegionMap[D].reset(SP);
2705 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
2706 TParamsArray, Flags);
2707 } else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D)) {
2708 Name = getObjCMethodName(OMD);
2709 Flags |= llvm::DINode::FlagPrototyped;
2711 // Use llvm function name.
2712 Name = Fn->getName();
2713 Flags |= llvm::DINode::FlagPrototyped;
2715 if (!Name.empty() && Name[0] == '\01')
2716 Name = Name.substr(1);
2718 if (!HasDecl || D->isImplicit()) {
2719 Flags |= llvm::DINode::FlagArtificial;
2720 // Artificial functions without a location should not silently reuse CurLoc.
2721 if (Loc.isInvalid())
2722 CurLoc = SourceLocation();
2724 unsigned LineNo = getLineNumber(Loc);
2725 unsigned ScopeLine = getLineNumber(ScopeLoc);
2727 // FIXME: The function declaration we're constructing here is mostly reusing
2728 // declarations from CXXMethodDecl and not constructing new ones for arbitrary
2729 // FunctionDecls. When/if we fix this we can have FDContext be TheCU/null for
2730 // all subprograms instead of the actual context since subprogram definitions
2731 // are emitted as CU level entities by the backend.
2732 llvm::DISubprogram *SP = DBuilder.createFunction(
2733 FDContext, Name, LinkageName, Unit, LineNo,
2734 getOrCreateFunctionType(D, FnType, Unit), Fn->hasInternalLinkage(),
2735 true /*definition*/, ScopeLine, Flags, CGM.getLangOpts().Optimize,
2736 TParamsArray.get(), getFunctionDeclaration(D));
2737 Fn->setSubprogram(SP);
2738 // We might get here with a VarDecl in the case we're generating
2739 // code for the initialization of globals. Do not record these decls
2740 // as they will overwrite the actual VarDecl Decl in the cache.
2741 if (HasDecl && isa<FunctionDecl>(D))
2742 DeclCache[D->getCanonicalDecl()].reset(static_cast<llvm::Metadata *>(SP));
2744 // Push the function onto the lexical block stack.
2745 LexicalBlockStack.emplace_back(SP);
2748 RegionMap[D].reset(SP);
2751 void CGDebugInfo::EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc,
2754 StringRef LinkageName;
2756 const Decl *D = GD.getDecl();
2761 llvm::DIFile *Unit = getOrCreateFile(Loc);
2762 llvm::DIScope *FDContext = getDeclContextDescriptor(D);
2763 llvm::DINodeArray TParamsArray;
2764 if (isa<FunctionDecl>(D)) {
2765 // If there is a DISubprogram for this function available then use it.
2766 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
2767 TParamsArray, Flags);
2768 } else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D)) {
2769 Name = getObjCMethodName(OMD);
2770 Flags |= llvm::DINode::FlagPrototyped;
2772 llvm_unreachable("not a function or ObjC method");
2774 if (!Name.empty() && Name[0] == '\01')
2775 Name = Name.substr(1);
2777 if (D->isImplicit()) {
2778 Flags |= llvm::DINode::FlagArtificial;
2779 // Artificial functions without a location should not silently reuse CurLoc.
2780 if (Loc.isInvalid())
2781 CurLoc = SourceLocation();
2783 unsigned LineNo = getLineNumber(Loc);
2784 unsigned ScopeLine = 0;
2786 DBuilder.createFunction(FDContext, Name, LinkageName, Unit, LineNo,
2787 getOrCreateFunctionType(D, FnType, Unit),
2788 false /*internalLinkage*/, true /*definition*/,
2789 ScopeLine, Flags, CGM.getLangOpts().Optimize,
2790 TParamsArray.get(), getFunctionDeclaration(D));
2793 void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc) {
2794 // Update our current location
2797 if (CurLoc.isInvalid() || CurLoc.isMacroID())
2800 llvm::MDNode *Scope = LexicalBlockStack.back();
2801 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
2802 getLineNumber(CurLoc), getColumnNumber(CurLoc), Scope));
2805 void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) {
2806 llvm::MDNode *Back = nullptr;
2807 if (!LexicalBlockStack.empty())
2808 Back = LexicalBlockStack.back().get();
2809 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
2810 cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
2811 getColumnNumber(CurLoc)));
2814 void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder,
2815 SourceLocation Loc) {
2816 // Set our current location.
2819 // Emit a line table change for the current location inside the new scope.
2820 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
2821 getLineNumber(Loc), getColumnNumber(Loc), LexicalBlockStack.back()));
2823 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2826 // Create a new lexical block and push it on the stack.
2827 CreateLexicalBlock(Loc);
2830 void CGDebugInfo::EmitLexicalBlockEnd(CGBuilderTy &Builder,
2831 SourceLocation Loc) {
2832 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
2834 // Provide an entry in the line table for the end of the block.
2835 EmitLocation(Builder, Loc);
2837 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2840 LexicalBlockStack.pop_back();
2843 void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder) {
2844 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
2845 unsigned RCount = FnBeginRegionCount.back();
2846 assert(RCount <= LexicalBlockStack.size() && "Region stack mismatch");
2848 // Pop all regions for this function.
2849 while (LexicalBlockStack.size() != RCount) {
2850 // Provide an entry in the line table for the end of the block.
2851 EmitLocation(Builder, CurLoc);
2852 LexicalBlockStack.pop_back();
2854 FnBeginRegionCount.pop_back();
2857 llvm::DIType *CGDebugInfo::EmitTypeForVarWithBlocksAttr(const VarDecl *VD,
2858 uint64_t *XOffset) {
2860 SmallVector<llvm::Metadata *, 5> EltTys;
2862 uint64_t FieldSize, FieldOffset;
2863 unsigned FieldAlign;
2865 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
2866 QualType Type = VD->getType();
2869 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
2870 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
2871 EltTys.push_back(CreateMemberType(Unit, FType, "__forwarding", &FieldOffset));
2872 FType = CGM.getContext().IntTy;
2873 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
2874 EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset));
2876 bool HasCopyAndDispose = CGM.getContext().BlockRequiresCopying(Type, VD);
2877 if (HasCopyAndDispose) {
2878 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
2880 CreateMemberType(Unit, FType, "__copy_helper", &FieldOffset));
2882 CreateMemberType(Unit, FType, "__destroy_helper", &FieldOffset));
2884 bool HasByrefExtendedLayout;
2885 Qualifiers::ObjCLifetime Lifetime;
2886 if (CGM.getContext().getByrefLifetime(Type, Lifetime,
2887 HasByrefExtendedLayout) &&
2888 HasByrefExtendedLayout) {
2889 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
2891 CreateMemberType(Unit, FType, "__byref_variable_layout", &FieldOffset));
2894 CharUnits Align = CGM.getContext().getDeclAlign(VD);
2895 if (Align > CGM.getContext().toCharUnitsFromBits(
2896 CGM.getTarget().getPointerAlign(0))) {
2897 CharUnits FieldOffsetInBytes =
2898 CGM.getContext().toCharUnitsFromBits(FieldOffset);
2899 CharUnits AlignedOffsetInBytes =
2900 FieldOffsetInBytes.RoundUpToAlignment(Align);
2901 CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;
2903 if (NumPaddingBytes.isPositive()) {
2904 llvm::APInt pad(32, NumPaddingBytes.getQuantity());
2905 FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy,
2906 pad, ArrayType::Normal, 0);
2907 EltTys.push_back(CreateMemberType(Unit, FType, "", &FieldOffset));
2912 llvm::DIType *FieldTy = getOrCreateType(FType, Unit);
2913 FieldSize = CGM.getContext().getTypeSize(FType);
2914 FieldAlign = CGM.getContext().toBits(Align);
2916 *XOffset = FieldOffset;
2917 FieldTy = DBuilder.createMemberType(Unit, VD->getName(), Unit, 0, FieldSize,
2918 FieldAlign, FieldOffset, 0, FieldTy);
2919 EltTys.push_back(FieldTy);
2920 FieldOffset += FieldSize;
2922 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2924 unsigned Flags = llvm::DINode::FlagBlockByrefStruct;
2926 return DBuilder.createStructType(Unit, "", Unit, 0, FieldOffset, 0, Flags,
2930 void CGDebugInfo::EmitDeclare(const VarDecl *VD, llvm::Value *Storage,
2931 llvm::Optional<unsigned> ArgNo,
2932 CGBuilderTy &Builder) {
2933 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
2934 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
2937 VD->isImplicit() || (isa<Decl>(VD->getDeclContext()) &&
2938 cast<Decl>(VD->getDeclContext())->isImplicit());
2939 llvm::DIFile *Unit = nullptr;
2941 Unit = getOrCreateFile(VD->getLocation());
2943 uint64_t XOffset = 0;
2944 if (VD->hasAttr<BlocksAttr>())
2945 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
2947 Ty = getOrCreateType(VD->getType(), Unit);
2949 // If there is no debug info for this type then do not emit debug info
2950 // for this variable.
2954 // Get location information.
2956 unsigned Column = 0;
2958 Line = getLineNumber(VD->getLocation());
2959 Column = getColumnNumber(VD->getLocation());
2961 SmallVector<int64_t, 9> Expr;
2963 if (VD->isImplicit())
2964 Flags |= llvm::DINode::FlagArtificial;
2965 // If this is the first argument and it is implicit then
2966 // give it an object pointer flag.
2967 // FIXME: There has to be a better way to do this, but for static
2968 // functions there won't be an implicit param at arg1 and
2969 // otherwise it is 'self' or 'this'.
2970 if (isa<ImplicitParamDecl>(VD) && ArgNo && *ArgNo == 1)
2971 Flags |= llvm::DINode::FlagObjectPointer;
2972 if (llvm::Argument *Arg = dyn_cast<llvm::Argument>(Storage))
2973 if (Arg->getType()->isPointerTy() && !Arg->hasByValAttr() &&
2974 !VD->getType()->isPointerType())
2975 Expr.push_back(llvm::dwarf::DW_OP_deref);
2977 auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
2979 StringRef Name = VD->getName();
2980 if (!Name.empty()) {
2981 if (VD->hasAttr<BlocksAttr>()) {
2982 CharUnits offset = CharUnits::fromQuantity(32);
2983 Expr.push_back(llvm::dwarf::DW_OP_plus);
2984 // offset of __forwarding field
2985 offset = CGM.getContext().toCharUnitsFromBits(
2986 CGM.getTarget().getPointerWidth(0));
2987 Expr.push_back(offset.getQuantity());
2988 Expr.push_back(llvm::dwarf::DW_OP_deref);
2989 Expr.push_back(llvm::dwarf::DW_OP_plus);
2990 // offset of x field
2991 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
2992 Expr.push_back(offset.getQuantity());
2994 // Create the descriptor for the variable.
2996 ? DBuilder.createParameterVariable(Scope, VD->getName(),
2997 *ArgNo, Unit, Line, Ty)
2998 : DBuilder.createAutoVariable(Scope, VD->getName(), Unit,
3001 // Insert an llvm.dbg.declare into the current block.
3002 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
3003 llvm::DebugLoc::get(Line, Column, Scope),
3004 Builder.GetInsertBlock());
3006 } else if (isa<VariableArrayType>(VD->getType()))
3007 Expr.push_back(llvm::dwarf::DW_OP_deref);
3008 } else if (const RecordType *RT = dyn_cast<RecordType>(VD->getType())) {
3009 // If VD is an anonymous union then Storage represents value for
3010 // all union fields.
3011 const RecordDecl *RD = cast<RecordDecl>(RT->getDecl());
3012 if (RD->isUnion() && RD->isAnonymousStructOrUnion()) {
3013 // GDB has trouble finding local variables in anonymous unions, so we emit
3014 // artifical local variables for each of the members.
3016 // FIXME: Remove this code as soon as GDB supports this.
3017 // The debug info verifier in LLVM operates based on the assumption that a
3018 // variable has the same size as its storage and we had to disable the check
3019 // for artificial variables.
3020 for (const auto *Field : RD->fields()) {
3021 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
3022 StringRef FieldName = Field->getName();
3024 // Ignore unnamed fields. Do not ignore unnamed records.
3025 if (FieldName.empty() && !isa<RecordType>(Field->getType()))
3028 // Use VarDecl's Tag, Scope and Line number.
3029 auto *D = DBuilder.createAutoVariable(
3030 Scope, FieldName, Unit, Line, FieldTy, CGM.getLangOpts().Optimize,
3031 Flags | llvm::DINode::FlagArtificial);
3033 // Insert an llvm.dbg.declare into the current block.
3034 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
3035 llvm::DebugLoc::get(Line, Column, Scope),
3036 Builder.GetInsertBlock());
3041 // Create the descriptor for the variable.
3044 ? DBuilder.createParameterVariable(Scope, Name, *ArgNo, Unit, Line,
3045 Ty, CGM.getLangOpts().Optimize,
3047 : DBuilder.createAutoVariable(Scope, Name, Unit, Line, Ty,
3048 CGM.getLangOpts().Optimize, Flags);
3050 // Insert an llvm.dbg.declare into the current block.
3051 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
3052 llvm::DebugLoc::get(Line, Column, Scope),
3053 Builder.GetInsertBlock());
3056 void CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD,
3057 llvm::Value *Storage,
3058 CGBuilderTy &Builder) {
3059 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
3060 EmitDeclare(VD, Storage, llvm::None, Builder);
3063 llvm::DIType *CGDebugInfo::CreateSelfType(const QualType &QualTy,
3065 llvm::DIType *CachedTy = getTypeOrNull(QualTy);
3068 return DBuilder.createObjectPointerType(Ty);
3071 void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
3072 const VarDecl *VD, llvm::Value *Storage, CGBuilderTy &Builder,
3073 const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) {
3074 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
3075 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
3077 if (Builder.GetInsertBlock() == nullptr)
3080 bool isByRef = VD->hasAttr<BlocksAttr>();
3082 uint64_t XOffset = 0;
3083 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
3086 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
3088 Ty = getOrCreateType(VD->getType(), Unit);
3090 // Self is passed along as an implicit non-arg variable in a
3091 // block. Mark it as the object pointer.
3092 if (isa<ImplicitParamDecl>(VD) && VD->getName() == "self")
3093 Ty = CreateSelfType(VD->getType(), Ty);
3095 // Get location information.
3096 unsigned Line = getLineNumber(VD->getLocation());
3097 unsigned Column = getColumnNumber(VD->getLocation());
3099 const llvm::DataLayout &target = CGM.getDataLayout();
3101 CharUnits offset = CharUnits::fromQuantity(
3102 target.getStructLayout(blockInfo.StructureType)
3103 ->getElementOffset(blockInfo.getCapture(VD).getIndex()));
3105 SmallVector<int64_t, 9> addr;
3106 if (isa<llvm::AllocaInst>(Storage))
3107 addr.push_back(llvm::dwarf::DW_OP_deref);
3108 addr.push_back(llvm::dwarf::DW_OP_plus);
3109 addr.push_back(offset.getQuantity());
3111 addr.push_back(llvm::dwarf::DW_OP_deref);
3112 addr.push_back(llvm::dwarf::DW_OP_plus);
3113 // offset of __forwarding field
3115 CGM.getContext().toCharUnitsFromBits(target.getPointerSizeInBits(0));
3116 addr.push_back(offset.getQuantity());
3117 addr.push_back(llvm::dwarf::DW_OP_deref);
3118 addr.push_back(llvm::dwarf::DW_OP_plus);
3119 // offset of x field
3120 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
3121 addr.push_back(offset.getQuantity());
3124 // Create the descriptor for the variable.
3125 auto *D = DBuilder.createAutoVariable(
3126 cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->getName(), Unit,
3129 // Insert an llvm.dbg.declare into the current block.
3130 auto DL = llvm::DebugLoc::get(Line, Column, LexicalBlockStack.back());
3132 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(addr), DL,
3135 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(addr), DL,
3136 Builder.GetInsertBlock());
3139 void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI,
3141 CGBuilderTy &Builder) {
3142 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
3143 EmitDeclare(VD, AI, ArgNo, Builder);
3147 struct BlockLayoutChunk {
3148 uint64_t OffsetInBits;
3149 const BlockDecl::Capture *Capture;
3151 bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) {
3152 return l.OffsetInBits < r.OffsetInBits;
3156 void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
3159 llvm::Value *LocalAddr,
3160 CGBuilderTy &Builder) {
3161 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
3162 ASTContext &C = CGM.getContext();
3163 const BlockDecl *blockDecl = block.getBlockDecl();
3165 // Collect some general information about the block's location.
3166 SourceLocation loc = blockDecl->getCaretLocation();
3167 llvm::DIFile *tunit = getOrCreateFile(loc);
3168 unsigned line = getLineNumber(loc);
3169 unsigned column = getColumnNumber(loc);
3171 // Build the debug-info type for the block literal.
3172 getDeclContextDescriptor(blockDecl);
3174 const llvm::StructLayout *blockLayout =
3175 CGM.getDataLayout().getStructLayout(block.StructureType);
3177 SmallVector<llvm::Metadata *, 16> fields;
3178 fields.push_back(createFieldType("__isa", C.VoidPtrTy, 0, loc, AS_public,
3179 blockLayout->getElementOffsetInBits(0),
3181 fields.push_back(createFieldType("__flags", C.IntTy, 0, loc, AS_public,
3182 blockLayout->getElementOffsetInBits(1),
3184 fields.push_back(createFieldType("__reserved", C.IntTy, 0, loc, AS_public,
3185 blockLayout->getElementOffsetInBits(2),
3187 auto *FnTy = block.getBlockExpr()->getFunctionType();
3188 auto FnPtrType = CGM.getContext().getPointerType(FnTy->desugar());
3189 fields.push_back(createFieldType("__FuncPtr", FnPtrType, 0, loc, AS_public,
3190 blockLayout->getElementOffsetInBits(3),
3192 fields.push_back(createFieldType(
3193 "__descriptor", C.getPointerType(block.NeedsCopyDispose
3194 ? C.getBlockDescriptorExtendedType()
3195 : C.getBlockDescriptorType()),
3196 0, loc, AS_public, blockLayout->getElementOffsetInBits(4), tunit, tunit));
3198 // We want to sort the captures by offset, not because DWARF
3199 // requires this, but because we're paranoid about debuggers.
3200 SmallVector<BlockLayoutChunk, 8> chunks;
3203 if (blockDecl->capturesCXXThis()) {
3204 BlockLayoutChunk chunk;
3205 chunk.OffsetInBits =
3206 blockLayout->getElementOffsetInBits(block.CXXThisIndex);
3207 chunk.Capture = nullptr;
3208 chunks.push_back(chunk);
3211 // Variable captures.
3212 for (const auto &capture : blockDecl->captures()) {
3213 const VarDecl *variable = capture.getVariable();
3214 const CGBlockInfo::Capture &captureInfo = block.getCapture(variable);
3216 // Ignore constant captures.
3217 if (captureInfo.isConstant())
3220 BlockLayoutChunk chunk;
3221 chunk.OffsetInBits =
3222 blockLayout->getElementOffsetInBits(captureInfo.getIndex());
3223 chunk.Capture = &capture;
3224 chunks.push_back(chunk);
3228 llvm::array_pod_sort(chunks.begin(), chunks.end());
3230 for (SmallVectorImpl<BlockLayoutChunk>::iterator i = chunks.begin(),
3233 uint64_t offsetInBits = i->OffsetInBits;
3234 const BlockDecl::Capture *capture = i->Capture;
3236 // If we have a null capture, this must be the C++ 'this' capture.
3238 const CXXMethodDecl *method =
3239 cast<CXXMethodDecl>(blockDecl->getNonClosureContext());
3240 QualType type = method->getThisType(C);
3242 fields.push_back(createFieldType("this", type, 0, loc, AS_public,
3243 offsetInBits, tunit, tunit));
3247 const VarDecl *variable = capture->getVariable();
3248 StringRef name = variable->getName();
3250 llvm::DIType *fieldType;
3251 if (capture->isByRef()) {
3252 TypeInfo PtrInfo = C.getTypeInfo(C.VoidPtrTy);
3254 // FIXME: this creates a second copy of this type!
3256 fieldType = EmitTypeForVarWithBlocksAttr(variable, &xoffset);
3257 fieldType = DBuilder.createPointerType(fieldType, PtrInfo.Width);
3259 DBuilder.createMemberType(tunit, name, tunit, line, PtrInfo.Width,
3260 PtrInfo.Align, offsetInBits, 0, fieldType);
3262 fieldType = createFieldType(name, variable->getType(), 0, loc, AS_public,
3263 offsetInBits, tunit, tunit);
3265 fields.push_back(fieldType);
3268 SmallString<36> typeName;
3269 llvm::raw_svector_ostream(typeName) << "__block_literal_"
3270 << CGM.getUniqueBlockCount();
3272 llvm::DINodeArray fieldsArray = DBuilder.getOrCreateArray(fields);
3274 llvm::DIType *type = DBuilder.createStructType(
3275 tunit, typeName.str(), tunit, line,
3276 CGM.getContext().toBits(block.BlockSize),
3277 CGM.getContext().toBits(block.BlockAlign), 0, nullptr, fieldsArray);
3278 type = DBuilder.createPointerType(type, CGM.PointerWidthInBits);
3280 // Get overall information about the block.
3281 unsigned flags = llvm::DINode::FlagArtificial;
3282 auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back());
3284 // Create the descriptor for the parameter.
3285 auto *debugVar = DBuilder.createParameterVariable(
3286 scope, Arg->getName(), ArgNo, tunit, line, type,
3287 CGM.getLangOpts().Optimize, flags);
3290 // Insert an llvm.dbg.value into the current block.
3291 DBuilder.insertDbgValueIntrinsic(
3292 LocalAddr, 0, debugVar, DBuilder.createExpression(),
3293 llvm::DebugLoc::get(line, column, scope), Builder.GetInsertBlock());
3296 // Insert an llvm.dbg.declare into the current block.
3297 DBuilder.insertDeclare(Arg, debugVar, DBuilder.createExpression(),
3298 llvm::DebugLoc::get(line, column, scope),
3299 Builder.GetInsertBlock());
3302 llvm::DIDerivedType *
3303 CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(const VarDecl *D) {
3304 if (!D->isStaticDataMember())
3307 auto MI = StaticDataMemberCache.find(D->getCanonicalDecl());
3308 if (MI != StaticDataMemberCache.end()) {
3309 assert(MI->second && "Static data member declaration should still exist");
3313 // If the member wasn't found in the cache, lazily construct and add it to the
3314 // type (used when a limited form of the type is emitted).
3315 auto DC = D->getDeclContext();
3316 auto *Ctxt = cast<llvm::DICompositeType>(getDeclContextDescriptor(D));
3317 return CreateRecordStaticField(D, Ctxt, cast<RecordDecl>(DC));
3320 llvm::DIGlobalVariable *CGDebugInfo::CollectAnonRecordDecls(
3321 const RecordDecl *RD, llvm::DIFile *Unit, unsigned LineNo,
3322 StringRef LinkageName, llvm::GlobalVariable *Var, llvm::DIScope *DContext) {
3323 llvm::DIGlobalVariable *GV = nullptr;
3325 for (const auto *Field : RD->fields()) {
3326 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
3327 StringRef FieldName = Field->getName();
3329 // Ignore unnamed fields, but recurse into anonymous records.
3330 if (FieldName.empty()) {
3331 const RecordType *RT = dyn_cast<RecordType>(Field->getType());
3333 GV = CollectAnonRecordDecls(RT->getDecl(), Unit, LineNo, LinkageName,
3337 // Use VarDecl's Tag, Scope and Line number.
3338 GV = DBuilder.createGlobalVariable(DContext, FieldName, LinkageName, Unit,
3340 Var->hasInternalLinkage(), Var, nullptr);
3345 void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
3347 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
3348 // Create global variable debug descriptor.
3349 llvm::DIFile *Unit = nullptr;
3350 llvm::DIScope *DContext = nullptr;
3352 StringRef DeclName, LinkageName;
3354 collectVarDeclProps(D, Unit, LineNo, T, DeclName, LinkageName, DContext);
3356 // Attempt to store one global variable for the declaration - even if we
3357 // emit a lot of fields.
3358 llvm::DIGlobalVariable *GV = nullptr;
3360 // If this is an anonymous union then we'll want to emit a global
3361 // variable for each member of the anonymous union so that it's possible
3362 // to find the name of any field in the union.
3363 if (T->isUnionType() && DeclName.empty()) {
3364 const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
3365 assert(RD->isAnonymousStructOrUnion() &&
3366 "unnamed non-anonymous struct or union?");
3367 GV = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
3369 GV = DBuilder.createGlobalVariable(
3370 DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit),
3371 Var->hasInternalLinkage(), Var,
3372 getOrCreateStaticDataMemberDeclarationOrNull(D));
3374 DeclCache[D->getCanonicalDecl()].reset(static_cast<llvm::Metadata *>(GV));
3377 void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD,
3378 llvm::Constant *Init) {
3379 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
3380 // Create the descriptor for the variable.
3381 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
3382 StringRef Name = VD->getName();
3383 llvm::DIType *Ty = getOrCreateType(VD->getType(), Unit);
3384 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(VD)) {
3385 const EnumDecl *ED = cast<EnumDecl>(ECD->getDeclContext());
3386 assert(isa<EnumType>(ED->getTypeForDecl()) && "Enum without EnumType?");
3387 Ty = getOrCreateType(QualType(ED->getTypeForDecl(), 0), Unit);
3389 // Do not use global variables for enums.
3392 if (Ty->getTag() == llvm::dwarf::DW_TAG_enumeration_type)
3394 // Do not emit separate definitions for function local const/statics.
3395 if (isa<FunctionDecl>(VD->getDeclContext()))
3397 VD = cast<ValueDecl>(VD->getCanonicalDecl());
3398 auto *VarD = cast<VarDecl>(VD);
3399 if (VarD->isStaticDataMember()) {
3400 auto *RD = cast<RecordDecl>(VarD->getDeclContext());
3401 getDeclContextDescriptor(VarD);
3402 // Ensure that the type is retained even though it's otherwise unreferenced.
3403 RetainedTypes.push_back(
3404 CGM.getContext().getRecordType(RD).getAsOpaquePtr());
3408 llvm::DIScope *DContext = getDeclContextDescriptor(VD);
3410 auto &GV = DeclCache[VD];
3413 GV.reset(DBuilder.createGlobalVariable(
3414 DContext, Name, StringRef(), Unit, getLineNumber(VD->getLocation()), Ty,
3415 true, Init, getOrCreateStaticDataMemberDeclarationOrNull(VarD)));
3418 llvm::DIScope *CGDebugInfo::getCurrentContextDescriptor(const Decl *D) {
3419 if (!LexicalBlockStack.empty())
3420 return LexicalBlockStack.back();
3421 llvm::DIScope *Mod = getParentModuleOrNull(D);
3422 return getContextDescriptor(D, Mod ? Mod : TheCU);
3425 void CGDebugInfo::EmitUsingDirective(const UsingDirectiveDecl &UD) {
3426 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
3428 const NamespaceDecl *NSDecl = UD.getNominatedNamespace();
3429 if (!NSDecl->isAnonymousNamespace() ||
3430 CGM.getCodeGenOpts().DebugExplicitImport) {
3431 DBuilder.createImportedModule(
3432 getCurrentContextDescriptor(cast<Decl>(UD.getDeclContext())),
3433 getOrCreateNameSpace(NSDecl),
3434 getLineNumber(UD.getLocation()));
3438 void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) {
3439 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
3441 assert(UD.shadow_size() &&
3442 "We shouldn't be codegening an invalid UsingDecl containing no decls");
3443 // Emitting one decl is sufficient - debuggers can detect that this is an
3444 // overloaded name & provide lookup for all the overloads.
3445 const UsingShadowDecl &USD = **UD.shadow_begin();
3446 if (llvm::DINode *Target =
3447 getDeclarationOrDefinition(USD.getUnderlyingDecl()))
3448 DBuilder.createImportedDeclaration(
3449 getCurrentContextDescriptor(cast<Decl>(USD.getDeclContext())), Target,
3450 getLineNumber(USD.getLocation()));
3453 void CGDebugInfo::EmitImportDecl(const ImportDecl &ID) {
3454 if (Module *M = ID.getImportedModule()) {
3455 auto Info = ExternalASTSource::ASTSourceDescriptor(*M);
3456 DBuilder.createImportedDeclaration(
3457 getCurrentContextDescriptor(cast<Decl>(ID.getDeclContext())),
3458 getOrCreateModuleRef(Info, DebugTypeExtRefs),
3459 getLineNumber(ID.getLocation()));
3463 llvm::DIImportedEntity *
3464 CGDebugInfo::EmitNamespaceAlias(const NamespaceAliasDecl &NA) {
3465 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
3467 auto &VH = NamespaceAliasCache[&NA];
3469 return cast<llvm::DIImportedEntity>(VH);
3470 llvm::DIImportedEntity *R;
3471 if (const NamespaceAliasDecl *Underlying =
3472 dyn_cast<NamespaceAliasDecl>(NA.getAliasedNamespace()))
3473 // This could cache & dedup here rather than relying on metadata deduping.
3474 R = DBuilder.createImportedDeclaration(
3475 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
3476 EmitNamespaceAlias(*Underlying), getLineNumber(NA.getLocation()),
3479 R = DBuilder.createImportedDeclaration(
3480 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
3481 getOrCreateNameSpace(cast<NamespaceDecl>(NA.getAliasedNamespace())),
3482 getLineNumber(NA.getLocation()), NA.getName());
3488 CGDebugInfo::getOrCreateNameSpace(const NamespaceDecl *NSDecl) {
3489 NSDecl = NSDecl->getCanonicalDecl();
3490 auto I = NameSpaceCache.find(NSDecl);
3491 if (I != NameSpaceCache.end())
3492 return cast<llvm::DINamespace>(I->second);
3494 unsigned LineNo = getLineNumber(NSDecl->getLocation());
3495 llvm::DIFile *FileD = getOrCreateFile(NSDecl->getLocation());
3496 llvm::DIScope *Context = getDeclContextDescriptor(NSDecl);
3497 llvm::DINamespace *NS =
3498 DBuilder.createNameSpace(Context, NSDecl->getName(), FileD, LineNo);
3499 NameSpaceCache[NSDecl].reset(NS);
3503 void CGDebugInfo::setDwoId(uint64_t Signature) {
3504 assert(TheCU && "no main compile unit");
3505 TheCU->setDWOId(Signature);
3509 void CGDebugInfo::finalize() {
3510 // Creating types might create further types - invalidating the current
3511 // element and the size(), so don't cache/reference them.
3512 for (size_t i = 0; i != ObjCInterfaceCache.size(); ++i) {
3513 ObjCInterfaceCacheEntry E = ObjCInterfaceCache[i];
3514 llvm::DIType *Ty = E.Type->getDecl()->getDefinition()
3515 ? CreateTypeDefinition(E.Type, E.Unit)
3517 DBuilder.replaceTemporary(llvm::TempDIType(E.Decl), Ty);
3520 for (auto p : ReplaceMap) {
3522 auto *Ty = cast<llvm::DIType>(p.second);
3523 assert(Ty->isForwardDecl());
3525 auto it = TypeCache.find(p.first);
3526 assert(it != TypeCache.end());
3529 DBuilder.replaceTemporary(llvm::TempDIType(Ty),
3530 cast<llvm::DIType>(it->second));
3533 for (const auto &p : FwdDeclReplaceMap) {
3535 llvm::TempMDNode FwdDecl(cast<llvm::MDNode>(p.second));
3536 llvm::Metadata *Repl;
3538 auto it = DeclCache.find(p.first);
3539 // If there has been no definition for the declaration, call RAUW
3540 // with ourselves, that will destroy the temporary MDNode and
3541 // replace it with a standard one, avoiding leaking memory.
3542 if (it == DeclCache.end())
3547 DBuilder.replaceTemporary(std::move(FwdDecl), cast<llvm::MDNode>(Repl));
3550 // We keep our own list of retained types, because we need to look
3551 // up the final type in the type cache.
3552 for (auto &RT : RetainedTypes)
3553 if (auto MD = TypeCache[RT])
3554 DBuilder.retainType(cast<llvm::DIType>(MD));
3556 DBuilder.finalize();
3559 void CGDebugInfo::EmitExplicitCastType(QualType Ty) {
3560 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
3563 if (auto *DieTy = getOrCreateType(Ty, getOrCreateMainFile()))
3564 // Don't ignore in case of explicit cast where it is referenced indirectly.
3565 DBuilder.retainType(DieTy);