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 "llvm/ADT/SmallVector.h"
31 #include "llvm/ADT/StringExtras.h"
32 #include "llvm/IR/Constants.h"
33 #include "llvm/IR/DataLayout.h"
34 #include "llvm/IR/DerivedTypes.h"
35 #include "llvm/IR/Instructions.h"
36 #include "llvm/IR/Intrinsics.h"
37 #include "llvm/IR/Module.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/FileSystem.h"
40 #include "llvm/Support/Path.h"
41 using namespace clang;
42 using namespace clang::CodeGen;
44 CGDebugInfo::CGDebugInfo(CodeGenModule &CGM)
45 : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
46 DBuilder(CGM.getModule()) {
50 CGDebugInfo::~CGDebugInfo() {
51 assert(LexicalBlockStack.empty() &&
52 "Region stack mismatch, stack not empty!");
55 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
56 SourceLocation TemporaryLocation)
58 init(TemporaryLocation);
61 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
63 SourceLocation TemporaryLocation)
65 init(TemporaryLocation, DefaultToEmpty);
68 void ApplyDebugLocation::init(SourceLocation TemporaryLocation,
69 bool DefaultToEmpty) {
70 if (auto *DI = CGF.getDebugInfo()) {
71 OriginalLocation = CGF.Builder.getCurrentDebugLocation();
72 if (TemporaryLocation.isInvalid()) {
74 CGF.Builder.SetCurrentDebugLocation(llvm::DebugLoc());
76 // Construct a location that has a valid scope, but no line info.
77 assert(!DI->LexicalBlockStack.empty());
78 CGF.Builder.SetCurrentDebugLocation(
79 llvm::DebugLoc::get(0, 0, DI->LexicalBlockStack.back()));
82 DI->EmitLocation(CGF.Builder, TemporaryLocation);
86 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E)
88 init(E->getExprLoc());
91 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, llvm::DebugLoc Loc)
93 if (CGF.getDebugInfo()) {
94 OriginalLocation = CGF.Builder.getCurrentDebugLocation();
96 CGF.Builder.SetCurrentDebugLocation(std::move(Loc));
100 ApplyDebugLocation::~ApplyDebugLocation() {
101 // Query CGF so the location isn't overwritten when location updates are
102 // temporarily disabled (for C++ default function arguments)
103 if (CGF.getDebugInfo())
104 CGF.Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
107 /// ArtificialLocation - An RAII object that temporarily switches to
108 /// an artificial debug location that has a valid scope, but no line
109 void CGDebugInfo::setLocation(SourceLocation Loc) {
110 // If the new location isn't valid return.
114 CurLoc = CGM.getContext().getSourceManager().getExpansionLoc(Loc);
116 // If we've changed files in the middle of a lexical scope go ahead
117 // and create a new lexical scope with file node if it's different
118 // from the one in the scope.
119 if (LexicalBlockStack.empty())
122 SourceManager &SM = CGM.getContext().getSourceManager();
123 auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
124 PresumedLoc PCLoc = SM.getPresumedLoc(CurLoc);
126 if (PCLoc.isInvalid() || Scope->getFilename() == PCLoc.getFilename())
129 if (auto *LBF = dyn_cast<llvm::DILexicalBlockFile>(Scope)) {
130 LexicalBlockStack.pop_back();
131 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlockFile(
132 LBF->getScope(), getOrCreateFile(CurLoc)));
133 } else if (isa<llvm::DILexicalBlock>(Scope) ||
134 isa<llvm::DISubprogram>(Scope)) {
135 LexicalBlockStack.pop_back();
136 LexicalBlockStack.emplace_back(
137 DBuilder.createLexicalBlockFile(Scope, getOrCreateFile(CurLoc)));
141 /// getContextDescriptor - Get context info for the decl.
142 llvm::DIScope *CGDebugInfo::getContextDescriptor(const Decl *Context) {
146 auto I = RegionMap.find(Context);
147 if (I != RegionMap.end()) {
148 llvm::Metadata *V = I->second;
149 return dyn_cast_or_null<llvm::DIScope>(V);
153 if (const NamespaceDecl *NSDecl = dyn_cast<NamespaceDecl>(Context))
154 return getOrCreateNameSpace(NSDecl);
156 if (const RecordDecl *RDecl = dyn_cast<RecordDecl>(Context))
157 if (!RDecl->isDependentType())
158 return getOrCreateType(CGM.getContext().getTypeDeclType(RDecl),
159 getOrCreateMainFile());
163 /// getFunctionName - Get function name for the given FunctionDecl. If the
164 /// name is constructed on demand (e.g. C++ destructor) then the name
165 /// is stored on the side.
166 StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) {
167 assert(FD && "Invalid FunctionDecl!");
168 IdentifierInfo *FII = FD->getIdentifier();
169 FunctionTemplateSpecializationInfo *Info =
170 FD->getTemplateSpecializationInfo();
172 return FII->getName();
174 // Otherwise construct human readable name for debug info.
176 llvm::raw_svector_ostream OS(NS);
179 // Add any template specialization args.
181 const TemplateArgumentList *TArgs = Info->TemplateArguments;
182 const TemplateArgument *Args = TArgs->data();
183 unsigned NumArgs = TArgs->size();
184 PrintingPolicy Policy(CGM.getLangOpts());
185 TemplateSpecializationType::PrintTemplateArgumentList(OS, Args, NumArgs,
189 // Copy this name on the side and use its reference.
190 return internString(OS.str());
193 StringRef CGDebugInfo::getObjCMethodName(const ObjCMethodDecl *OMD) {
194 SmallString<256> MethodName;
195 llvm::raw_svector_ostream OS(MethodName);
196 OS << (OMD->isInstanceMethod() ? '-' : '+') << '[';
197 const DeclContext *DC = OMD->getDeclContext();
198 if (const ObjCImplementationDecl *OID =
199 dyn_cast<const ObjCImplementationDecl>(DC)) {
200 OS << OID->getName();
201 } else if (const ObjCInterfaceDecl *OID =
202 dyn_cast<const ObjCInterfaceDecl>(DC)) {
203 OS << OID->getName();
204 } else if (const ObjCCategoryImplDecl *OCD =
205 dyn_cast<const ObjCCategoryImplDecl>(DC)) {
206 OS << ((const NamedDecl *)OCD)->getIdentifier()->getNameStart() << '('
207 << OCD->getIdentifier()->getNameStart() << ')';
208 } else if (isa<ObjCProtocolDecl>(DC)) {
209 // We can extract the type of the class from the self pointer.
210 if (ImplicitParamDecl *SelfDecl = OMD->getSelfDecl()) {
212 cast<ObjCObjectPointerType>(SelfDecl->getType())->getPointeeType();
213 ClassTy.print(OS, PrintingPolicy(LangOptions()));
216 OS << ' ' << OMD->getSelector().getAsString() << ']';
218 return internString(OS.str());
221 /// getSelectorName - Return selector name. This is used for debugging
223 StringRef CGDebugInfo::getSelectorName(Selector S) {
224 return internString(S.getAsString());
227 /// getClassName - Get class name including template argument list.
228 StringRef CGDebugInfo::getClassName(const RecordDecl *RD) {
229 // quick optimization to avoid having to intern strings that are already
230 // stored reliably elsewhere
231 if (!isa<ClassTemplateSpecializationDecl>(RD))
232 return RD->getName();
234 SmallString<128> Name;
236 llvm::raw_svector_ostream OS(Name);
237 RD->getNameForDiagnostic(OS, CGM.getContext().getPrintingPolicy(),
238 /*Qualified*/ false);
241 // Copy this name on the side and use its reference.
242 return internString(Name);
245 /// getOrCreateFile - Get the file debug info descriptor for the input location.
246 llvm::DIFile *CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
248 // If Location is not valid then use main input file.
249 return DBuilder.createFile(TheCU->getFilename(), TheCU->getDirectory());
251 SourceManager &SM = CGM.getContext().getSourceManager();
252 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
254 if (PLoc.isInvalid() || StringRef(PLoc.getFilename()).empty())
255 // If the location is not valid then use main input file.
256 return DBuilder.createFile(TheCU->getFilename(), TheCU->getDirectory());
258 // Cache the results.
259 const char *fname = PLoc.getFilename();
260 auto it = DIFileCache.find(fname);
262 if (it != DIFileCache.end()) {
263 // Verify that the information still exists.
264 if (llvm::Metadata *V = it->second)
265 return cast<llvm::DIFile>(V);
269 DBuilder.createFile(PLoc.getFilename(), getCurrentDirname());
271 DIFileCache[fname].reset(F);
275 /// getOrCreateMainFile - Get the file info for main compile unit.
276 llvm::DIFile *CGDebugInfo::getOrCreateMainFile() {
277 return DBuilder.createFile(TheCU->getFilename(), TheCU->getDirectory());
280 /// getLineNumber - Get line number for the location. If location is invalid
281 /// then use current location.
282 unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) {
283 if (Loc.isInvalid() && CurLoc.isInvalid())
285 SourceManager &SM = CGM.getContext().getSourceManager();
286 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
287 return PLoc.isValid() ? PLoc.getLine() : 0;
290 /// getColumnNumber - Get column number for the location.
291 unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc, bool Force) {
292 // We may not want column information at all.
293 if (!Force && !CGM.getCodeGenOpts().DebugColumnInfo)
296 // If the location is invalid then use the current column.
297 if (Loc.isInvalid() && CurLoc.isInvalid())
299 SourceManager &SM = CGM.getContext().getSourceManager();
300 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
301 return PLoc.isValid() ? PLoc.getColumn() : 0;
304 StringRef CGDebugInfo::getCurrentDirname() {
305 if (!CGM.getCodeGenOpts().DebugCompilationDir.empty())
306 return CGM.getCodeGenOpts().DebugCompilationDir;
308 if (!CWDName.empty())
310 SmallString<256> CWD;
311 llvm::sys::fs::current_path(CWD);
312 return CWDName = internString(CWD);
315 /// CreateCompileUnit - Create new compile unit.
316 void CGDebugInfo::CreateCompileUnit() {
318 // Should we be asking the SourceManager for the main file name, instead of
319 // accepting it as an argument? This just causes the main file name to
320 // mismatch with source locations and create extra lexical scopes or
321 // mismatched debug info (a CU with a DW_AT_file of "-", because that's what
322 // the driver passed, but functions/other things have DW_AT_file of "<stdin>"
323 // because that's what the SourceManager says)
325 // Get absolute path name.
326 SourceManager &SM = CGM.getContext().getSourceManager();
327 std::string MainFileName = CGM.getCodeGenOpts().MainFileName;
328 if (MainFileName.empty())
329 MainFileName = "<stdin>";
331 // The main file name provided via the "-main-file-name" option contains just
332 // the file name itself with no path information. This file name may have had
333 // a relative path, so we look into the actual file entry for the main
334 // file to determine the real absolute path for the file.
335 std::string MainFileDir;
336 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
337 MainFileDir = MainFile->getDir()->getName();
338 if (MainFileDir != ".") {
339 llvm::SmallString<1024> MainFileDirSS(MainFileDir);
340 llvm::sys::path::append(MainFileDirSS, MainFileName);
341 MainFileName = MainFileDirSS.str();
345 // Save filename string.
346 StringRef Filename = internString(MainFileName);
348 // Save split dwarf file string.
349 std::string SplitDwarfFile = CGM.getCodeGenOpts().SplitDwarfFile;
350 StringRef SplitDwarfFilename = internString(SplitDwarfFile);
352 llvm::dwarf::SourceLanguage LangTag;
353 const LangOptions &LO = CGM.getLangOpts();
356 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
358 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
359 } else if (LO.ObjC1) {
360 LangTag = llvm::dwarf::DW_LANG_ObjC;
362 LangTag = llvm::dwarf::DW_LANG_C99;
364 LangTag = llvm::dwarf::DW_LANG_C89;
367 std::string Producer = getClangFullVersion();
369 // Figure out which version of the ObjC runtime we have.
370 unsigned RuntimeVers = 0;
372 RuntimeVers = LO.ObjCRuntime.isNonFragile() ? 2 : 1;
374 // Create new compile unit.
375 // FIXME - Eliminate TheCU.
376 TheCU = DBuilder.createCompileUnit(
377 LangTag, Filename, getCurrentDirname(), Producer, LO.Optimize,
378 CGM.getCodeGenOpts().DwarfDebugFlags, RuntimeVers, SplitDwarfFilename,
379 DebugKind <= CodeGenOptions::DebugLineTablesOnly
380 ? llvm::DIBuilder::LineTablesOnly
381 : llvm::DIBuilder::FullDebug,
383 DebugKind != CodeGenOptions::LocTrackingOnly);
386 /// CreateType - Get the Basic type from the cache or create a new
387 /// one if necessary.
388 llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
389 llvm::dwarf::TypeKind Encoding;
391 switch (BT->getKind()) {
392 #define BUILTIN_TYPE(Id, SingletonId)
393 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
394 #include "clang/AST/BuiltinTypes.def"
395 case BuiltinType::Dependent:
396 llvm_unreachable("Unexpected builtin type");
397 case BuiltinType::NullPtr:
398 return DBuilder.createNullPtrType();
399 case BuiltinType::Void:
401 case BuiltinType::ObjCClass:
403 ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
405 getOrCreateMainFile(), 0);
407 case BuiltinType::ObjCId: {
408 // typedef struct objc_class *Class;
409 // typedef struct objc_object {
417 ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
419 getOrCreateMainFile(), 0);
421 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
423 auto *ISATy = DBuilder.createPointerType(ClassTy, Size);
426 DBuilder.createStructType(TheCU, "objc_object", getOrCreateMainFile(),
427 0, 0, 0, 0, nullptr, llvm::DINodeArray());
429 DBuilder.replaceArrays(
431 DBuilder.getOrCreateArray(&*DBuilder.createMemberType(
432 ObjTy, "isa", getOrCreateMainFile(), 0, Size, 0, 0, 0, ISATy)));
435 case BuiltinType::ObjCSel: {
437 SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
438 "objc_selector", TheCU,
439 getOrCreateMainFile(), 0);
443 case BuiltinType::OCLImage1d:
444 return getOrCreateStructPtrType("opencl_image1d_t", OCLImage1dDITy);
445 case BuiltinType::OCLImage1dArray:
446 return getOrCreateStructPtrType("opencl_image1d_array_t",
447 OCLImage1dArrayDITy);
448 case BuiltinType::OCLImage1dBuffer:
449 return getOrCreateStructPtrType("opencl_image1d_buffer_t",
450 OCLImage1dBufferDITy);
451 case BuiltinType::OCLImage2d:
452 return getOrCreateStructPtrType("opencl_image2d_t", OCLImage2dDITy);
453 case BuiltinType::OCLImage2dArray:
454 return getOrCreateStructPtrType("opencl_image2d_array_t",
455 OCLImage2dArrayDITy);
456 case BuiltinType::OCLImage3d:
457 return getOrCreateStructPtrType("opencl_image3d_t", OCLImage3dDITy);
458 case BuiltinType::OCLSampler:
459 return DBuilder.createBasicType(
460 "opencl_sampler_t", CGM.getContext().getTypeSize(BT),
461 CGM.getContext().getTypeAlign(BT), llvm::dwarf::DW_ATE_unsigned);
462 case BuiltinType::OCLEvent:
463 return getOrCreateStructPtrType("opencl_event_t", OCLEventDITy);
465 case BuiltinType::UChar:
466 case BuiltinType::Char_U:
467 Encoding = llvm::dwarf::DW_ATE_unsigned_char;
469 case BuiltinType::Char_S:
470 case BuiltinType::SChar:
471 Encoding = llvm::dwarf::DW_ATE_signed_char;
473 case BuiltinType::Char16:
474 case BuiltinType::Char32:
475 Encoding = llvm::dwarf::DW_ATE_UTF;
477 case BuiltinType::UShort:
478 case BuiltinType::UInt:
479 case BuiltinType::UInt128:
480 case BuiltinType::ULong:
481 case BuiltinType::WChar_U:
482 case BuiltinType::ULongLong:
483 Encoding = llvm::dwarf::DW_ATE_unsigned;
485 case BuiltinType::Short:
486 case BuiltinType::Int:
487 case BuiltinType::Int128:
488 case BuiltinType::Long:
489 case BuiltinType::WChar_S:
490 case BuiltinType::LongLong:
491 Encoding = llvm::dwarf::DW_ATE_signed;
493 case BuiltinType::Bool:
494 Encoding = llvm::dwarf::DW_ATE_boolean;
496 case BuiltinType::Half:
497 case BuiltinType::Float:
498 case BuiltinType::LongDouble:
499 case BuiltinType::Double:
500 Encoding = llvm::dwarf::DW_ATE_float;
504 switch (BT->getKind()) {
505 case BuiltinType::Long:
508 case BuiltinType::LongLong:
509 BTName = "long long int";
511 case BuiltinType::ULong:
512 BTName = "long unsigned int";
514 case BuiltinType::ULongLong:
515 BTName = "long long unsigned int";
518 BTName = BT->getName(CGM.getLangOpts());
521 // Bit size, align and offset of the type.
522 uint64_t Size = CGM.getContext().getTypeSize(BT);
523 uint64_t Align = CGM.getContext().getTypeAlign(BT);
524 return DBuilder.createBasicType(BTName, Size, Align, Encoding);
527 llvm::DIType *CGDebugInfo::CreateType(const ComplexType *Ty) {
528 // Bit size, align and offset of the type.
529 llvm::dwarf::TypeKind Encoding = llvm::dwarf::DW_ATE_complex_float;
530 if (Ty->isComplexIntegerType())
531 Encoding = llvm::dwarf::DW_ATE_lo_user;
533 uint64_t Size = CGM.getContext().getTypeSize(Ty);
534 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
535 return DBuilder.createBasicType("complex", Size, Align, Encoding);
538 /// CreateCVRType - Get the qualified type from the cache or create
539 /// a new one if necessary.
540 llvm::DIType *CGDebugInfo::CreateQualifiedType(QualType Ty,
541 llvm::DIFile *Unit) {
542 QualifierCollector Qc;
543 const Type *T = Qc.strip(Ty);
545 // Ignore these qualifiers for now.
546 Qc.removeObjCGCAttr();
547 Qc.removeAddressSpace();
548 Qc.removeObjCLifetime();
550 // We will create one Derived type for one qualifier and recurse to handle any
552 llvm::dwarf::Tag Tag;
554 Tag = llvm::dwarf::DW_TAG_const_type;
556 } else if (Qc.hasVolatile()) {
557 Tag = llvm::dwarf::DW_TAG_volatile_type;
559 } else if (Qc.hasRestrict()) {
560 Tag = llvm::dwarf::DW_TAG_restrict_type;
563 assert(Qc.empty() && "Unknown type qualifier for debug info");
564 return getOrCreateType(QualType(T, 0), Unit);
567 auto *FromTy = getOrCreateType(Qc.apply(CGM.getContext(), T), Unit);
569 // No need to fill in the Name, Line, Size, Alignment, Offset in case of
570 // CVR derived types.
571 return DBuilder.createQualifiedType(Tag, FromTy);
574 llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty,
575 llvm::DIFile *Unit) {
577 // The frontend treats 'id' as a typedef to an ObjCObjectType,
578 // whereas 'id<protocol>' is treated as an ObjCPointerType. For the
579 // debug info, we want to emit 'id' in both cases.
580 if (Ty->isObjCQualifiedIdType())
581 return getOrCreateType(CGM.getContext().getObjCIdType(), Unit);
583 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
584 Ty->getPointeeType(), Unit);
587 llvm::DIType *CGDebugInfo::CreateType(const PointerType *Ty,
588 llvm::DIFile *Unit) {
589 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
590 Ty->getPointeeType(), Unit);
593 /// In C++ mode, types have linkage, so we can rely on the ODR and
594 /// on their mangled names, if they're external.
595 static SmallString<256> getUniqueTagTypeName(const TagType *Ty,
597 llvm::DICompileUnit *TheCU) {
598 SmallString<256> FullName;
599 // FIXME: ODR should apply to ObjC++ exactly the same wasy it does to C++.
600 // For now, only apply ODR with C++.
601 const TagDecl *TD = Ty->getDecl();
602 if (TheCU->getSourceLanguage() != llvm::dwarf::DW_LANG_C_plus_plus ||
603 !TD->isExternallyVisible())
605 // Microsoft Mangler does not have support for mangleCXXRTTIName yet.
606 if (CGM.getTarget().getCXXABI().isMicrosoft())
609 // TODO: This is using the RTTI name. Is there a better way to get
610 // a unique string for a type?
611 llvm::raw_svector_ostream Out(FullName);
612 CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(QualType(Ty, 0), Out);
617 static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD) {
618 llvm::dwarf::Tag Tag;
619 if (RD->isStruct() || RD->isInterface())
620 Tag = llvm::dwarf::DW_TAG_structure_type;
621 else if (RD->isUnion())
622 Tag = llvm::dwarf::DW_TAG_union_type;
624 // FIXME: This could be a struct type giving a default visibility different
625 // than C++ class type, but needs llvm metadata changes first.
626 assert(RD->isClass());
627 Tag = llvm::dwarf::DW_TAG_class_type;
632 // Creates a forward declaration for a RecordDecl in the given context.
633 llvm::DICompositeType *
634 CGDebugInfo::getOrCreateRecordFwdDecl(const RecordType *Ty,
635 llvm::DIScope *Ctx) {
636 const RecordDecl *RD = Ty->getDecl();
637 if (llvm::DIType *T = getTypeOrNull(CGM.getContext().getRecordType(RD)))
638 return cast<llvm::DICompositeType>(T);
639 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
640 unsigned Line = getLineNumber(RD->getLocation());
641 StringRef RDName = getClassName(RD);
646 const RecordDecl *D = RD->getDefinition();
647 if (D && D->isCompleteDefinition()) {
648 Size = CGM.getContext().getTypeSize(Ty);
649 Align = CGM.getContext().getTypeAlign(Ty);
653 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
654 llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
655 getTagForRecord(RD), RDName, Ctx, DefUnit, Line, 0, Size, Align,
656 llvm::DINode::FlagFwdDecl, FullName);
657 ReplaceMap.emplace_back(
658 std::piecewise_construct, std::make_tuple(Ty),
659 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
663 llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
666 llvm::DIFile *Unit) {
667 if (Tag == llvm::dwarf::DW_TAG_reference_type ||
668 Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)
669 return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit));
671 // Bit size, align and offset of the type.
672 // Size is always the size of a pointer. We can't use getTypeSize here
673 // because that does not return the correct value for references.
674 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
675 uint64_t Size = CGM.getTarget().getPointerWidth(AS);
676 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
678 return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
682 llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
683 llvm::DIType *&Cache) {
686 Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
687 TheCU, getOrCreateMainFile(), 0);
688 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
689 Cache = DBuilder.createPointerType(Cache, Size);
693 llvm::DIType *CGDebugInfo::CreateType(const BlockPointerType *Ty,
694 llvm::DIFile *Unit) {
695 if (BlockLiteralGeneric)
696 return BlockLiteralGeneric;
698 SmallVector<llvm::Metadata *, 8> EltTys;
700 uint64_t FieldSize, FieldOffset;
702 llvm::DINodeArray Elements;
705 FType = CGM.getContext().UnsignedLongTy;
706 EltTys.push_back(CreateMemberType(Unit, FType, "reserved", &FieldOffset));
707 EltTys.push_back(CreateMemberType(Unit, FType, "Size", &FieldOffset));
709 Elements = DBuilder.getOrCreateArray(EltTys);
712 unsigned Flags = llvm::DINode::FlagAppleBlock;
713 unsigned LineNo = getLineNumber(CurLoc);
716 DBuilder.createStructType(Unit, "__block_descriptor", Unit, LineNo,
717 FieldOffset, 0, Flags, nullptr, Elements);
719 // Bit size, align and offset of the type.
720 uint64_t Size = CGM.getContext().getTypeSize(Ty);
722 auto *DescTy = DBuilder.createPointerType(EltTy, Size);
725 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
726 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
727 FType = CGM.getContext().IntTy;
728 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
729 EltTys.push_back(CreateMemberType(Unit, FType, "__reserved", &FieldOffset));
730 FType = CGM.getContext().getPointerType(Ty->getPointeeType());
731 EltTys.push_back(CreateMemberType(Unit, FType, "__FuncPtr", &FieldOffset));
733 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
734 FieldSize = CGM.getContext().getTypeSize(Ty);
735 FieldAlign = CGM.getContext().getTypeAlign(Ty);
736 EltTys.push_back(DBuilder.createMemberType(Unit, "__descriptor", Unit, LineNo,
737 FieldSize, FieldAlign, FieldOffset,
740 FieldOffset += FieldSize;
741 Elements = DBuilder.getOrCreateArray(EltTys);
744 DBuilder.createStructType(Unit, "__block_literal_generic", Unit, LineNo,
745 FieldOffset, 0, Flags, nullptr, Elements);
747 BlockLiteralGeneric = DBuilder.createPointerType(EltTy, Size);
748 return BlockLiteralGeneric;
751 llvm::DIType *CGDebugInfo::CreateType(const TemplateSpecializationType *Ty,
752 llvm::DIFile *Unit) {
753 assert(Ty->isTypeAlias());
754 llvm::DIType *Src = getOrCreateType(Ty->getAliasedType(), Unit);
757 llvm::raw_svector_ostream OS(NS);
758 Ty->getTemplateName().print(OS, CGM.getContext().getPrintingPolicy(),
759 /*qualified*/ false);
761 TemplateSpecializationType::PrintTemplateArgumentList(
762 OS, Ty->getArgs(), Ty->getNumArgs(),
763 CGM.getContext().getPrintingPolicy());
765 TypeAliasDecl *AliasDecl = cast<TypeAliasTemplateDecl>(
766 Ty->getTemplateName().getAsTemplateDecl())->getTemplatedDecl();
768 SourceLocation Loc = AliasDecl->getLocation();
769 return DBuilder.createTypedef(
770 Src, internString(OS.str()), getOrCreateFile(Loc), getLineNumber(Loc),
771 getContextDescriptor(cast<Decl>(AliasDecl->getDeclContext())));
774 llvm::DIType *CGDebugInfo::CreateType(const TypedefType *Ty,
775 llvm::DIFile *Unit) {
776 // We don't set size information, but do specify where the typedef was
778 SourceLocation Loc = Ty->getDecl()->getLocation();
780 // Typedefs are derived from some other type.
781 return DBuilder.createTypedef(
782 getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit),
783 Ty->getDecl()->getName(), getOrCreateFile(Loc), getLineNumber(Loc),
784 getContextDescriptor(cast<Decl>(Ty->getDecl()->getDeclContext())));
787 llvm::DIType *CGDebugInfo::CreateType(const FunctionType *Ty,
788 llvm::DIFile *Unit) {
789 SmallVector<llvm::Metadata *, 16> EltTys;
791 // Add the result type at least.
792 EltTys.push_back(getOrCreateType(Ty->getReturnType(), Unit));
794 // Set up remainder of arguments if there is a prototype.
795 // otherwise emit it as a variadic function.
796 if (isa<FunctionNoProtoType>(Ty))
797 EltTys.push_back(DBuilder.createUnspecifiedParameter());
798 else if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(Ty)) {
799 for (unsigned i = 0, e = FPT->getNumParams(); i != e; ++i)
800 EltTys.push_back(getOrCreateType(FPT->getParamType(i), Unit));
801 if (FPT->isVariadic())
802 EltTys.push_back(DBuilder.createUnspecifiedParameter());
805 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
806 return DBuilder.createSubroutineType(Unit, EltTypeArray);
809 /// Convert an AccessSpecifier into the corresponding DINode flag.
810 /// As an optimization, return 0 if the access specifier equals the
811 /// default for the containing type.
812 static unsigned getAccessFlag(AccessSpecifier Access, const RecordDecl *RD) {
813 AccessSpecifier Default = clang::AS_none;
814 if (RD && RD->isClass())
815 Default = clang::AS_private;
816 else if (RD && (RD->isStruct() || RD->isUnion()))
817 Default = clang::AS_public;
819 if (Access == Default)
823 case clang::AS_private:
824 return llvm::DINode::FlagPrivate;
825 case clang::AS_protected:
826 return llvm::DINode::FlagProtected;
827 case clang::AS_public:
828 return llvm::DINode::FlagPublic;
832 llvm_unreachable("unexpected access enumerator");
835 llvm::DIType *CGDebugInfo::createFieldType(
836 StringRef name, QualType type, uint64_t sizeInBitsOverride,
837 SourceLocation loc, AccessSpecifier AS, uint64_t offsetInBits,
838 llvm::DIFile *tunit, llvm::DIScope *scope, const RecordDecl *RD) {
839 llvm::DIType *debugType = getOrCreateType(type, tunit);
841 // Get the location for the field.
842 llvm::DIFile *file = getOrCreateFile(loc);
843 unsigned line = getLineNumber(loc);
845 uint64_t SizeInBits = 0;
846 unsigned AlignInBits = 0;
847 if (!type->isIncompleteArrayType()) {
848 TypeInfo TI = CGM.getContext().getTypeInfo(type);
849 SizeInBits = TI.Width;
850 AlignInBits = TI.Align;
852 if (sizeInBitsOverride)
853 SizeInBits = sizeInBitsOverride;
856 unsigned flags = getAccessFlag(AS, RD);
857 return DBuilder.createMemberType(scope, name, file, line, SizeInBits,
858 AlignInBits, offsetInBits, flags, debugType);
861 /// CollectRecordLambdaFields - Helper for CollectRecordFields.
862 void CGDebugInfo::CollectRecordLambdaFields(
863 const CXXRecordDecl *CXXDecl, SmallVectorImpl<llvm::Metadata *> &elements,
864 llvm::DIType *RecordTy) {
865 // For C++11 Lambdas a Field will be the same as a Capture, but the Capture
866 // has the name and the location of the variable so we should iterate over
867 // both concurrently.
868 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(CXXDecl);
869 RecordDecl::field_iterator Field = CXXDecl->field_begin();
870 unsigned fieldno = 0;
871 for (CXXRecordDecl::capture_const_iterator I = CXXDecl->captures_begin(),
872 E = CXXDecl->captures_end();
873 I != E; ++I, ++Field, ++fieldno) {
874 const LambdaCapture &C = *I;
875 if (C.capturesVariable()) {
876 VarDecl *V = C.getCapturedVar();
877 llvm::DIFile *VUnit = getOrCreateFile(C.getLocation());
878 StringRef VName = V->getName();
879 uint64_t SizeInBitsOverride = 0;
880 if (Field->isBitField()) {
881 SizeInBitsOverride = Field->getBitWidthValue(CGM.getContext());
882 assert(SizeInBitsOverride && "found named 0-width bitfield");
884 llvm::DIType *fieldType = createFieldType(
885 VName, Field->getType(), SizeInBitsOverride, C.getLocation(),
886 Field->getAccess(), layout.getFieldOffset(fieldno), VUnit, RecordTy,
888 elements.push_back(fieldType);
889 } else if (C.capturesThis()) {
890 // TODO: Need to handle 'this' in some way by probably renaming the
891 // this of the lambda class and having a field member of 'this' or
892 // by using AT_object_pointer for the function and having that be
893 // used as 'this' for semantic references.
894 FieldDecl *f = *Field;
895 llvm::DIFile *VUnit = getOrCreateFile(f->getLocation());
896 QualType type = f->getType();
897 llvm::DIType *fieldType = createFieldType(
898 "this", type, 0, f->getLocation(), f->getAccess(),
899 layout.getFieldOffset(fieldno), VUnit, RecordTy, CXXDecl);
901 elements.push_back(fieldType);
906 /// Helper for CollectRecordFields.
907 llvm::DIDerivedType *
908 CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy,
909 const RecordDecl *RD) {
910 // Create the descriptor for the static variable, with or without
911 // constant initializers.
912 Var = Var->getCanonicalDecl();
913 llvm::DIFile *VUnit = getOrCreateFile(Var->getLocation());
914 llvm::DIType *VTy = getOrCreateType(Var->getType(), VUnit);
916 unsigned LineNumber = getLineNumber(Var->getLocation());
917 StringRef VName = Var->getName();
918 llvm::Constant *C = nullptr;
919 if (Var->getInit()) {
920 const APValue *Value = Var->evaluateValue();
923 C = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->getInt());
924 if (Value->isFloat())
925 C = llvm::ConstantFP::get(CGM.getLLVMContext(), Value->getFloat());
929 unsigned Flags = getAccessFlag(Var->getAccess(), RD);
930 llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
931 RecordTy, VName, VUnit, LineNumber, VTy, Flags, C);
932 StaticDataMemberCache[Var->getCanonicalDecl()].reset(GV);
936 /// CollectRecordNormalField - Helper for CollectRecordFields.
937 void CGDebugInfo::CollectRecordNormalField(
938 const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit,
939 SmallVectorImpl<llvm::Metadata *> &elements, llvm::DIType *RecordTy,
940 const RecordDecl *RD) {
941 StringRef name = field->getName();
942 QualType type = field->getType();
944 // Ignore unnamed fields unless they're anonymous structs/unions.
945 if (name.empty() && !type->isRecordType())
948 uint64_t SizeInBitsOverride = 0;
949 if (field->isBitField()) {
950 SizeInBitsOverride = field->getBitWidthValue(CGM.getContext());
951 assert(SizeInBitsOverride && "found named 0-width bitfield");
954 llvm::DIType *fieldType =
955 createFieldType(name, type, SizeInBitsOverride, field->getLocation(),
956 field->getAccess(), OffsetInBits, tunit, RecordTy, RD);
958 elements.push_back(fieldType);
961 /// CollectRecordFields - A helper function to collect debug info for
962 /// record fields. This is used while creating debug info entry for a Record.
963 void CGDebugInfo::CollectRecordFields(
964 const RecordDecl *record, llvm::DIFile *tunit,
965 SmallVectorImpl<llvm::Metadata *> &elements,
966 llvm::DICompositeType *RecordTy) {
967 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(record);
969 if (CXXDecl && CXXDecl->isLambda())
970 CollectRecordLambdaFields(CXXDecl, elements, RecordTy);
972 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(record);
974 // Field number for non-static fields.
975 unsigned fieldNo = 0;
977 // Static and non-static members should appear in the same order as
978 // the corresponding declarations in the source program.
979 for (const auto *I : record->decls())
980 if (const auto *V = dyn_cast<VarDecl>(I)) {
981 // Reuse the existing static member declaration if one exists
982 auto MI = StaticDataMemberCache.find(V->getCanonicalDecl());
983 if (MI != StaticDataMemberCache.end()) {
985 "Static data member declaration should still exist");
986 elements.push_back(cast<llvm::DIDerivedTypeBase>(MI->second));
988 auto Field = CreateRecordStaticField(V, RecordTy, record);
989 elements.push_back(Field);
991 } else if (const auto *field = dyn_cast<FieldDecl>(I)) {
992 CollectRecordNormalField(field, layout.getFieldOffset(fieldNo), tunit,
993 elements, RecordTy, record);
995 // Bump field number for next field.
1001 /// getOrCreateMethodType - CXXMethodDecl's type is a FunctionType. This
1002 /// function type is not updated to include implicit "this" pointer. Use this
1003 /// routine to get a method type which includes "this" pointer.
1004 llvm::DISubroutineType *
1005 CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method,
1006 llvm::DIFile *Unit) {
1007 const FunctionProtoType *Func = Method->getType()->getAs<FunctionProtoType>();
1008 if (Method->isStatic())
1009 return cast_or_null<llvm::DISubroutineType>(
1010 getOrCreateType(QualType(Func, 0), Unit));
1011 return getOrCreateInstanceMethodType(Method->getThisType(CGM.getContext()),
1015 llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType(
1016 QualType ThisPtr, const FunctionProtoType *Func, llvm::DIFile *Unit) {
1017 // Add "this" pointer.
1018 llvm::DITypeRefArray Args(
1019 cast<llvm::DISubroutineType>(getOrCreateType(QualType(Func, 0), Unit))
1021 assert(Args.size() && "Invalid number of arguments!");
1023 SmallVector<llvm::Metadata *, 16> Elts;
1025 // First element is always return type. For 'void' functions it is NULL.
1026 Elts.push_back(Args[0]);
1028 // "this" pointer is always first argument.
1029 const CXXRecordDecl *RD = ThisPtr->getPointeeCXXRecordDecl();
1030 if (isa<ClassTemplateSpecializationDecl>(RD)) {
1031 // Create pointer type directly in this case.
1032 const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr);
1033 QualType PointeeTy = ThisPtrTy->getPointeeType();
1034 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
1035 uint64_t Size = CGM.getTarget().getPointerWidth(AS);
1036 uint64_t Align = CGM.getContext().getTypeAlign(ThisPtrTy);
1037 llvm::DIType *PointeeType = getOrCreateType(PointeeTy, Unit);
1038 llvm::DIType *ThisPtrType =
1039 DBuilder.createPointerType(PointeeType, Size, Align);
1040 TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
1041 // TODO: This and the artificial type below are misleading, the
1042 // types aren't artificial the argument is, but the current
1043 // metadata doesn't represent that.
1044 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1045 Elts.push_back(ThisPtrType);
1047 llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);
1048 TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
1049 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1050 Elts.push_back(ThisPtrType);
1053 // Copy rest of the arguments.
1054 for (unsigned i = 1, e = Args.size(); i != e; ++i)
1055 Elts.push_back(Args[i]);
1057 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
1060 if (Func->getExtProtoInfo().RefQualifier == RQ_LValue)
1061 Flags |= llvm::DINode::FlagLValueReference;
1062 if (Func->getExtProtoInfo().RefQualifier == RQ_RValue)
1063 Flags |= llvm::DINode::FlagRValueReference;
1065 return DBuilder.createSubroutineType(Unit, EltTypeArray, Flags);
1068 /// isFunctionLocalClass - Return true if CXXRecordDecl is defined
1069 /// inside a function.
1070 static bool isFunctionLocalClass(const CXXRecordDecl *RD) {
1071 if (const CXXRecordDecl *NRD = dyn_cast<CXXRecordDecl>(RD->getDeclContext()))
1072 return isFunctionLocalClass(NRD);
1073 if (isa<FunctionDecl>(RD->getDeclContext()))
1078 /// CreateCXXMemberFunction - A helper function to create a subprogram for
1079 /// a single member function GlobalDecl.
1080 llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
1081 const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {
1083 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
1085 StringRef MethodName = getFunctionName(Method);
1086 llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit);
1088 // Since a single ctor/dtor corresponds to multiple functions, it doesn't
1089 // make sense to give a single ctor/dtor a linkage name.
1090 StringRef MethodLinkageName;
1091 if (!IsCtorOrDtor && !isFunctionLocalClass(Method->getParent()))
1092 MethodLinkageName = CGM.getMangledName(Method);
1094 // Get the location for the method.
1095 llvm::DIFile *MethodDefUnit = nullptr;
1096 unsigned MethodLine = 0;
1097 if (!Method->isImplicit()) {
1098 MethodDefUnit = getOrCreateFile(Method->getLocation());
1099 MethodLine = getLineNumber(Method->getLocation());
1102 // Collect virtual method info.
1103 llvm::DIType *ContainingType = nullptr;
1104 unsigned Virtuality = 0;
1105 unsigned VIndex = 0;
1107 if (Method->isVirtual()) {
1108 if (Method->isPure())
1109 Virtuality = llvm::dwarf::DW_VIRTUALITY_pure_virtual;
1111 Virtuality = llvm::dwarf::DW_VIRTUALITY_virtual;
1113 // It doesn't make sense to give a virtual destructor a vtable index,
1114 // since a single destructor has two entries in the vtable.
1115 // FIXME: Add proper support for debug info for virtual calls in
1116 // the Microsoft ABI, where we may use multiple vptrs to make a vftable
1117 // lookup if we have multiple or virtual inheritance.
1118 if (!isa<CXXDestructorDecl>(Method) &&
1119 !CGM.getTarget().getCXXABI().isMicrosoft())
1120 VIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(Method);
1121 ContainingType = RecordTy;
1125 if (Method->isImplicit())
1126 Flags |= llvm::DINode::FlagArtificial;
1127 Flags |= getAccessFlag(Method->getAccess(), Method->getParent());
1128 if (const CXXConstructorDecl *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
1129 if (CXXC->isExplicit())
1130 Flags |= llvm::DINode::FlagExplicit;
1131 } else if (const CXXConversionDecl *CXXC =
1132 dyn_cast<CXXConversionDecl>(Method)) {
1133 if (CXXC->isExplicit())
1134 Flags |= llvm::DINode::FlagExplicit;
1136 if (Method->hasPrototype())
1137 Flags |= llvm::DINode::FlagPrototyped;
1138 if (Method->getRefQualifier() == RQ_LValue)
1139 Flags |= llvm::DINode::FlagLValueReference;
1140 if (Method->getRefQualifier() == RQ_RValue)
1141 Flags |= llvm::DINode::FlagRValueReference;
1143 llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
1144 llvm::DISubprogram *SP = DBuilder.createMethod(
1145 RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
1146 MethodTy, /*isLocalToUnit=*/false,
1147 /* isDefinition=*/false, Virtuality, VIndex, ContainingType, Flags,
1148 CGM.getLangOpts().Optimize, nullptr, TParamsArray.get());
1150 SPCache[Method->getCanonicalDecl()].reset(SP);
1155 /// CollectCXXMemberFunctions - A helper function to collect debug info for
1156 /// C++ member functions. This is used while creating debug info entry for
1158 void CGDebugInfo::CollectCXXMemberFunctions(
1159 const CXXRecordDecl *RD, llvm::DIFile *Unit,
1160 SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy) {
1162 // Since we want more than just the individual member decls if we
1163 // have templated functions iterate over every declaration to gather
1165 for (const auto *I : RD->decls()) {
1166 const auto *Method = dyn_cast<CXXMethodDecl>(I);
1167 // If the member is implicit, don't add it to the member list. This avoids
1168 // the member being added to type units by LLVM, while still allowing it
1169 // to be emitted into the type declaration/reference inside the compile
1171 // FIXME: Handle Using(Shadow?)Decls here to create
1172 // DW_TAG_imported_declarations inside the class for base decls brought into
1173 // derived classes. GDB doesn't seem to notice/leverage these when I tried
1174 // it, so I'm not rushing to fix this. (GCC seems to produce them, if
1176 if (!Method || Method->isImplicit())
1179 if (Method->getType()->getAs<FunctionProtoType>()->getContainedAutoType())
1182 // Reuse the existing member function declaration if it exists.
1183 // It may be associated with the declaration of the type & should be
1184 // reused as we're building the definition.
1186 // This situation can arise in the vtable-based debug info reduction where
1187 // implicit members are emitted in a non-vtable TU.
1188 auto MI = SPCache.find(Method->getCanonicalDecl());
1189 EltTys.push_back(MI == SPCache.end()
1190 ? CreateCXXMemberFunction(Method, Unit, RecordTy)
1191 : static_cast<llvm::Metadata *>(MI->second));
1195 /// CollectCXXBases - A helper function to collect debug info for
1196 /// C++ base classes. This is used while creating debug info entry for
1198 void CGDebugInfo::CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile *Unit,
1199 SmallVectorImpl<llvm::Metadata *> &EltTys,
1200 llvm::DIType *RecordTy) {
1201 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1202 for (const auto &BI : RD->bases()) {
1203 unsigned BFlags = 0;
1204 uint64_t BaseOffset;
1206 const CXXRecordDecl *Base =
1207 cast<CXXRecordDecl>(BI.getType()->getAs<RecordType>()->getDecl());
1209 if (BI.isVirtual()) {
1210 if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1211 // virtual base offset offset is -ve. The code generator emits dwarf
1212 // expression where it expects +ve number.
1213 BaseOffset = 0 - CGM.getItaniumVTableContext()
1214 .getVirtualBaseOffsetOffset(RD, Base)
1217 // In the MS ABI, store the vbtable offset, which is analogous to the
1218 // vbase offset offset in Itanium.
1220 4 * CGM.getMicrosoftVTableContext().getVBTableIndex(RD, Base);
1222 BFlags = llvm::DINode::FlagVirtual;
1224 BaseOffset = CGM.getContext().toBits(RL.getBaseClassOffset(Base));
1225 // FIXME: Inconsistent units for BaseOffset. It is in bytes when
1226 // BI->isVirtual() and bits when not.
1228 BFlags |= getAccessFlag(BI.getAccessSpecifier(), RD);
1229 llvm::DIType *DTy = DBuilder.createInheritance(
1230 RecordTy, getOrCreateType(BI.getType(), Unit), BaseOffset, BFlags);
1231 EltTys.push_back(DTy);
1235 /// CollectTemplateParams - A helper function to collect template parameters.
1237 CGDebugInfo::CollectTemplateParams(const TemplateParameterList *TPList,
1238 ArrayRef<TemplateArgument> TAList,
1239 llvm::DIFile *Unit) {
1240 SmallVector<llvm::Metadata *, 16> TemplateParams;
1241 for (unsigned i = 0, e = TAList.size(); i != e; ++i) {
1242 const TemplateArgument &TA = TAList[i];
1245 Name = TPList->getParam(i)->getName();
1246 switch (TA.getKind()) {
1247 case TemplateArgument::Type: {
1248 llvm::DIType *TTy = getOrCreateType(TA.getAsType(), Unit);
1249 TemplateParams.push_back(
1250 DBuilder.createTemplateTypeParameter(TheCU, Name, TTy));
1252 case TemplateArgument::Integral: {
1253 llvm::DIType *TTy = getOrCreateType(TA.getIntegralType(), Unit);
1254 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1256 llvm::ConstantInt::get(CGM.getLLVMContext(), TA.getAsIntegral())));
1258 case TemplateArgument::Declaration: {
1259 const ValueDecl *D = TA.getAsDecl();
1260 QualType T = TA.getParamTypeForDecl().getDesugaredType(CGM.getContext());
1261 llvm::DIType *TTy = getOrCreateType(T, Unit);
1262 llvm::Constant *V = nullptr;
1263 const CXXMethodDecl *MD;
1264 // Variable pointer template parameters have a value that is the address
1266 if (const auto *VD = dyn_cast<VarDecl>(D))
1267 V = CGM.GetAddrOfGlobalVar(VD);
1268 // Member function pointers have special support for building them, though
1269 // this is currently unsupported in LLVM CodeGen.
1270 else if ((MD = dyn_cast<CXXMethodDecl>(D)) && MD->isInstance())
1271 V = CGM.getCXXABI().EmitMemberPointer(MD);
1272 else if (const auto *FD = dyn_cast<FunctionDecl>(D))
1273 V = CGM.GetAddrOfFunction(FD);
1274 // Member data pointers have special handling too to compute the fixed
1275 // offset within the object.
1276 else if (const auto *MPT = dyn_cast<MemberPointerType>(T.getTypePtr())) {
1277 // These five lines (& possibly the above member function pointer
1278 // handling) might be able to be refactored to use similar code in
1279 // CodeGenModule::getMemberPointerConstant
1280 uint64_t fieldOffset = CGM.getContext().getFieldOffset(D);
1282 CGM.getContext().toCharUnitsFromBits((int64_t)fieldOffset);
1283 V = CGM.getCXXABI().EmitMemberDataPointer(MPT, chars);
1285 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1287 cast_or_null<llvm::Constant>(V->stripPointerCasts())));
1289 case TemplateArgument::NullPtr: {
1290 QualType T = TA.getNullPtrType();
1291 llvm::DIType *TTy = getOrCreateType(T, Unit);
1292 llvm::Constant *V = nullptr;
1293 // Special case member data pointer null values since they're actually -1
1295 if (const MemberPointerType *MPT =
1296 dyn_cast<MemberPointerType>(T.getTypePtr()))
1297 // But treat member function pointers as simple zero integers because
1298 // it's easier than having a special case in LLVM's CodeGen. If LLVM
1299 // CodeGen grows handling for values of non-null member function
1300 // pointers then perhaps we could remove this special case and rely on
1301 // EmitNullMemberPointer for member function pointers.
1302 if (MPT->isMemberDataPointer())
1303 V = CGM.getCXXABI().EmitNullMemberPointer(MPT);
1305 V = llvm::ConstantInt::get(CGM.Int8Ty, 0);
1306 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1307 TheCU, Name, TTy, cast<llvm::Constant>(V)));
1309 case TemplateArgument::Template:
1310 TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(
1311 TheCU, Name, nullptr,
1312 TA.getAsTemplate().getAsTemplateDecl()->getQualifiedNameAsString()));
1314 case TemplateArgument::Pack:
1315 TemplateParams.push_back(DBuilder.createTemplateParameterPack(
1316 TheCU, Name, nullptr,
1317 CollectTemplateParams(nullptr, TA.getPackAsArray(), Unit)));
1319 case TemplateArgument::Expression: {
1320 const Expr *E = TA.getAsExpr();
1321 QualType T = E->getType();
1323 T = CGM.getContext().getLValueReferenceType(T);
1324 llvm::Constant *V = CGM.EmitConstantExpr(E, T);
1325 assert(V && "Expression in template argument isn't constant");
1326 llvm::DIType *TTy = getOrCreateType(T, Unit);
1327 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1328 TheCU, Name, TTy, cast<llvm::Constant>(V->stripPointerCasts())));
1330 // And the following should never occur:
1331 case TemplateArgument::TemplateExpansion:
1332 case TemplateArgument::Null:
1334 "These argument types shouldn't exist in concrete types");
1337 return DBuilder.getOrCreateArray(TemplateParams);
1340 /// CollectFunctionTemplateParams - A helper function to collect debug
1341 /// info for function template parameters.
1343 CGDebugInfo::CollectFunctionTemplateParams(const FunctionDecl *FD,
1344 llvm::DIFile *Unit) {
1345 if (FD->getTemplatedKind() ==
1346 FunctionDecl::TK_FunctionTemplateSpecialization) {
1347 const TemplateParameterList *TList = FD->getTemplateSpecializationInfo()
1349 ->getTemplateParameters();
1350 return CollectTemplateParams(
1351 TList, FD->getTemplateSpecializationArgs()->asArray(), Unit);
1353 return llvm::DINodeArray();
1356 /// CollectCXXTemplateParams - A helper function to collect debug info for
1357 /// template parameters.
1358 llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(
1359 const ClassTemplateSpecializationDecl *TSpecial, llvm::DIFile *Unit) {
1360 // Always get the full list of parameters, not just the ones from
1361 // the specialization.
1362 TemplateParameterList *TPList =
1363 TSpecial->getSpecializedTemplate()->getTemplateParameters();
1364 const TemplateArgumentList &TAList = TSpecial->getTemplateArgs();
1365 return CollectTemplateParams(TPList, TAList.asArray(), Unit);
1368 /// getOrCreateVTablePtrType - Return debug info descriptor for vtable.
1369 llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
1371 return VTablePtrType;
1373 ASTContext &Context = CGM.getContext();
1376 llvm::Metadata *STy = getOrCreateType(Context.IntTy, Unit);
1377 llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);
1378 llvm::DIType *SubTy = DBuilder.createSubroutineType(Unit, SElements);
1379 unsigned Size = Context.getTypeSize(Context.VoidPtrTy);
1380 llvm::DIType *vtbl_ptr_type =
1381 DBuilder.createPointerType(SubTy, Size, 0, "__vtbl_ptr_type");
1382 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
1383 return VTablePtrType;
1386 /// getVTableName - Get vtable name for the given Class.
1387 StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) {
1388 // Copy the gdb compatible name on the side and use its reference.
1389 return internString("_vptr$", RD->getNameAsString());
1392 /// CollectVTableInfo - If the C++ class has vtable info then insert appropriate
1393 /// debug info entry in EltTys vector.
1394 void CGDebugInfo::CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile *Unit,
1395 SmallVectorImpl<llvm::Metadata *> &EltTys) {
1396 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1398 // If there is a primary base then it will hold vtable info.
1399 if (RL.getPrimaryBase())
1402 // If this class is not dynamic then there is not any vtable info to collect.
1403 if (!RD->isDynamicClass())
1406 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
1407 llvm::DIType *VPTR = DBuilder.createMemberType(
1408 Unit, getVTableName(RD), Unit, 0, Size, 0, 0,
1409 llvm::DINode::FlagArtificial, getOrCreateVTablePtrType(Unit));
1410 EltTys.push_back(VPTR);
1413 /// getOrCreateRecordType - Emit record type's standalone debug info.
1414 llvm::DIType *CGDebugInfo::getOrCreateRecordType(QualType RTy,
1415 SourceLocation Loc) {
1416 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
1417 llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
1421 /// getOrCreateInterfaceType - Emit an objective c interface type standalone
1423 llvm::DIType *CGDebugInfo::getOrCreateInterfaceType(QualType D,
1424 SourceLocation Loc) {
1425 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
1426 llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc));
1427 RetainedTypes.push_back(D.getAsOpaquePtr());
1431 void CGDebugInfo::completeType(const EnumDecl *ED) {
1432 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
1434 QualType Ty = CGM.getContext().getEnumType(ED);
1435 void *TyPtr = Ty.getAsOpaquePtr();
1436 auto I = TypeCache.find(TyPtr);
1437 if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())
1439 llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<EnumType>());
1440 assert(!Res->isForwardDecl());
1441 TypeCache[TyPtr].reset(Res);
1444 void CGDebugInfo::completeType(const RecordDecl *RD) {
1445 if (DebugKind > CodeGenOptions::LimitedDebugInfo ||
1446 !CGM.getLangOpts().CPlusPlus)
1447 completeRequiredType(RD);
1450 void CGDebugInfo::completeRequiredType(const RecordDecl *RD) {
1451 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
1454 if (const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
1455 if (CXXDecl->isDynamicClass())
1458 QualType Ty = CGM.getContext().getRecordType(RD);
1459 llvm::DIType *T = getTypeOrNull(Ty);
1460 if (T && T->isForwardDecl())
1461 completeClassData(RD);
1464 void CGDebugInfo::completeClassData(const RecordDecl *RD) {
1465 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
1467 QualType Ty = CGM.getContext().getRecordType(RD);
1468 void *TyPtr = Ty.getAsOpaquePtr();
1469 auto I = TypeCache.find(TyPtr);
1470 if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
1472 llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<RecordType>());
1473 assert(!Res->isForwardDecl());
1474 TypeCache[TyPtr].reset(Res);
1477 static bool hasExplicitMemberDefinition(CXXRecordDecl::method_iterator I,
1478 CXXRecordDecl::method_iterator End) {
1479 for (; I != End; ++I)
1480 if (FunctionDecl *Tmpl = I->getInstantiatedFromMemberFunction())
1481 if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&
1482 !I->getMemberSpecializationInfo()->isExplicitSpecialization())
1487 static bool shouldOmitDefinition(CodeGenOptions::DebugInfoKind DebugKind,
1488 const RecordDecl *RD,
1489 const LangOptions &LangOpts) {
1490 if (DebugKind > CodeGenOptions::LimitedDebugInfo)
1493 if (!LangOpts.CPlusPlus)
1496 if (!RD->isCompleteDefinitionRequired())
1499 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
1504 if (CXXDecl->hasDefinition() && CXXDecl->isDynamicClass())
1507 TemplateSpecializationKind Spec = TSK_Undeclared;
1508 if (const ClassTemplateSpecializationDecl *SD =
1509 dyn_cast<ClassTemplateSpecializationDecl>(RD))
1510 Spec = SD->getSpecializationKind();
1512 if (Spec == TSK_ExplicitInstantiationDeclaration &&
1513 hasExplicitMemberDefinition(CXXDecl->method_begin(),
1514 CXXDecl->method_end()))
1520 /// CreateType - get structure or union type.
1521 llvm::DIType *CGDebugInfo::CreateType(const RecordType *Ty) {
1522 RecordDecl *RD = Ty->getDecl();
1523 llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(QualType(Ty, 0)));
1524 if (T || shouldOmitDefinition(DebugKind, RD, CGM.getLangOpts())) {
1526 T = getOrCreateRecordFwdDecl(
1527 Ty, getContextDescriptor(cast<Decl>(RD->getDeclContext())));
1531 return CreateTypeDefinition(Ty);
1534 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) {
1535 RecordDecl *RD = Ty->getDecl();
1537 // Get overall information about the record type for the debug info.
1538 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
1540 // Records and classes and unions can all be recursive. To handle them, we
1541 // first generate a debug descriptor for the struct as a forward declaration.
1542 // Then (if it is a definition) we go through and get debug info for all of
1543 // its members. Finally, we create a descriptor for the complete type (which
1544 // may refer to the forward decl if the struct is recursive) and replace all
1545 // uses of the forward declaration with the final definition.
1548 cast<llvm::DICompositeType>(getOrCreateLimitedType(Ty, DefUnit));
1550 const RecordDecl *D = RD->getDefinition();
1551 if (!D || !D->isCompleteDefinition())
1554 if (const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
1555 CollectContainingType(CXXDecl, FwdDecl);
1557 // Push the struct on region stack.
1558 LexicalBlockStack.emplace_back(&*FwdDecl);
1559 RegionMap[Ty->getDecl()].reset(FwdDecl);
1561 // Convert all the elements.
1562 SmallVector<llvm::Metadata *, 16> EltTys;
1563 // what about nested types?
1565 // Note: The split of CXXDecl information here is intentional, the
1566 // gdb tests will depend on a certain ordering at printout. The debug
1567 // information offsets are still correct if we merge them all together
1569 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
1571 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
1572 CollectVTableInfo(CXXDecl, DefUnit, EltTys);
1575 // Collect data fields (including static variables and any initializers).
1576 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
1578 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
1580 LexicalBlockStack.pop_back();
1581 RegionMap.erase(Ty->getDecl());
1583 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
1584 DBuilder.replaceArrays(FwdDecl, Elements);
1586 if (FwdDecl->isTemporary())
1588 llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
1590 RegionMap[Ty->getDecl()].reset(FwdDecl);
1594 /// CreateType - get objective-c object type.
1595 llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectType *Ty,
1596 llvm::DIFile *Unit) {
1597 // Ignore protocols.
1598 return getOrCreateType(Ty->getBaseType(), Unit);
1601 /// \return true if Getter has the default name for the property PD.
1602 static bool hasDefaultGetterName(const ObjCPropertyDecl *PD,
1603 const ObjCMethodDecl *Getter) {
1608 assert(Getter->getDeclName().isObjCZeroArgSelector());
1609 return PD->getName() ==
1610 Getter->getDeclName().getObjCSelector().getNameForSlot(0);
1613 /// \return true if Setter has the default name for the property PD.
1614 static bool hasDefaultSetterName(const ObjCPropertyDecl *PD,
1615 const ObjCMethodDecl *Setter) {
1620 assert(Setter->getDeclName().isObjCOneArgSelector());
1621 return SelectorTable::constructSetterName(PD->getName()) ==
1622 Setter->getDeclName().getObjCSelector().getNameForSlot(0);
1625 /// CreateType - get objective-c interface type.
1626 llvm::DIType *CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
1627 llvm::DIFile *Unit) {
1628 ObjCInterfaceDecl *ID = Ty->getDecl();
1632 // Get overall information about the record type for the debug info.
1633 llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation());
1634 unsigned Line = getLineNumber(ID->getLocation());
1636 static_cast<llvm::dwarf::SourceLanguage>(TheCU->getSourceLanguage());
1638 // If this is just a forward declaration return a special forward-declaration
1639 // debug type since we won't be able to lay out the entire type.
1640 ObjCInterfaceDecl *Def = ID->getDefinition();
1641 if (!Def || !Def->getImplementation()) {
1642 llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(
1643 llvm::dwarf::DW_TAG_structure_type, ID->getName(), TheCU, DefUnit, Line,
1645 ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit));
1649 return CreateTypeDefinition(Ty, Unit);
1652 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty,
1653 llvm::DIFile *Unit) {
1654 ObjCInterfaceDecl *ID = Ty->getDecl();
1655 llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation());
1656 unsigned Line = getLineNumber(ID->getLocation());
1657 unsigned RuntimeLang = TheCU->getSourceLanguage();
1659 // Bit size, align and offset of the type.
1660 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1661 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1664 if (ID->getImplementation())
1665 Flags |= llvm::DINode::FlagObjcClassComplete;
1667 llvm::DICompositeType *RealDecl = DBuilder.createStructType(
1668 Unit, ID->getName(), DefUnit, Line, Size, Align, Flags, nullptr,
1669 llvm::DINodeArray(), RuntimeLang);
1671 QualType QTy(Ty, 0);
1672 TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl);
1674 // Push the struct on region stack.
1675 LexicalBlockStack.emplace_back(RealDecl);
1676 RegionMap[Ty->getDecl()].reset(RealDecl);
1678 // Convert all the elements.
1679 SmallVector<llvm::Metadata *, 16> EltTys;
1681 ObjCInterfaceDecl *SClass = ID->getSuperClass();
1683 llvm::DIType *SClassTy =
1684 getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit);
1688 llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0, 0);
1689 EltTys.push_back(InhTag);
1692 // Create entries for all of the properties.
1693 for (const auto *PD : ID->properties()) {
1694 SourceLocation Loc = PD->getLocation();
1695 llvm::DIFile *PUnit = getOrCreateFile(Loc);
1696 unsigned PLine = getLineNumber(Loc);
1697 ObjCMethodDecl *Getter = PD->getGetterMethodDecl();
1698 ObjCMethodDecl *Setter = PD->getSetterMethodDecl();
1699 llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(
1700 PD->getName(), PUnit, PLine,
1701 hasDefaultGetterName(PD, Getter) ? ""
1702 : getSelectorName(PD->getGetterName()),
1703 hasDefaultSetterName(PD, Setter) ? ""
1704 : getSelectorName(PD->getSetterName()),
1705 PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit));
1706 EltTys.push_back(PropertyNode);
1709 const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(ID);
1710 unsigned FieldNo = 0;
1711 for (ObjCIvarDecl *Field = ID->all_declared_ivar_begin(); Field;
1712 Field = Field->getNextIvar(), ++FieldNo) {
1713 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
1717 StringRef FieldName = Field->getName();
1719 // Ignore unnamed fields.
1720 if (FieldName.empty())
1723 // Get the location for the field.
1724 llvm::DIFile *FieldDefUnit = getOrCreateFile(Field->getLocation());
1725 unsigned FieldLine = getLineNumber(Field->getLocation());
1726 QualType FType = Field->getType();
1727 uint64_t FieldSize = 0;
1728 unsigned FieldAlign = 0;
1730 if (!FType->isIncompleteArrayType()) {
1732 // Bit size, align and offset of the type.
1733 FieldSize = Field->isBitField()
1734 ? Field->getBitWidthValue(CGM.getContext())
1735 : CGM.getContext().getTypeSize(FType);
1736 FieldAlign = CGM.getContext().getTypeAlign(FType);
1739 uint64_t FieldOffset;
1740 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
1741 // We don't know the runtime offset of an ivar if we're using the
1742 // non-fragile ABI. For bitfields, use the bit offset into the first
1743 // byte of storage of the bitfield. For other fields, use zero.
1744 if (Field->isBitField()) {
1746 CGM.getObjCRuntime().ComputeBitfieldBitOffset(CGM, ID, Field);
1747 FieldOffset %= CGM.getContext().getCharWidth();
1752 FieldOffset = RL.getFieldOffset(FieldNo);
1756 if (Field->getAccessControl() == ObjCIvarDecl::Protected)
1757 Flags = llvm::DINode::FlagProtected;
1758 else if (Field->getAccessControl() == ObjCIvarDecl::Private)
1759 Flags = llvm::DINode::FlagPrivate;
1760 else if (Field->getAccessControl() == ObjCIvarDecl::Public)
1761 Flags = llvm::DINode::FlagPublic;
1763 llvm::MDNode *PropertyNode = nullptr;
1764 if (ObjCImplementationDecl *ImpD = ID->getImplementation()) {
1765 if (ObjCPropertyImplDecl *PImpD =
1766 ImpD->FindPropertyImplIvarDecl(Field->getIdentifier())) {
1767 if (ObjCPropertyDecl *PD = PImpD->getPropertyDecl()) {
1768 SourceLocation Loc = PD->getLocation();
1769 llvm::DIFile *PUnit = getOrCreateFile(Loc);
1770 unsigned PLine = getLineNumber(Loc);
1771 ObjCMethodDecl *Getter = PD->getGetterMethodDecl();
1772 ObjCMethodDecl *Setter = PD->getSetterMethodDecl();
1773 PropertyNode = DBuilder.createObjCProperty(
1774 PD->getName(), PUnit, PLine,
1775 hasDefaultGetterName(PD, Getter) ? "" : getSelectorName(
1776 PD->getGetterName()),
1777 hasDefaultSetterName(PD, Setter) ? "" : getSelectorName(
1778 PD->getSetterName()),
1779 PD->getPropertyAttributes(),
1780 getOrCreateType(PD->getType(), PUnit));
1784 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine,
1785 FieldSize, FieldAlign, FieldOffset, Flags,
1786 FieldTy, PropertyNode);
1787 EltTys.push_back(FieldTy);
1790 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
1791 DBuilder.replaceArrays(RealDecl, Elements);
1793 LexicalBlockStack.pop_back();
1797 llvm::DIType *CGDebugInfo::CreateType(const VectorType *Ty,
1798 llvm::DIFile *Unit) {
1799 llvm::DIType *ElementTy = getOrCreateType(Ty->getElementType(), Unit);
1800 int64_t Count = Ty->getNumElements();
1802 // If number of elements are not known then this is an unbounded array.
1803 // Use Count == -1 to express such arrays.
1806 llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(0, Count);
1807 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
1809 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1810 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1812 return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
1815 llvm::DIType *CGDebugInfo::CreateType(const ArrayType *Ty, llvm::DIFile *Unit) {
1819 // FIXME: make getTypeAlign() aware of VLAs and incomplete array types
1820 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(Ty)) {
1823 CGM.getContext().getTypeAlign(CGM.getContext().getBaseElementType(VAT));
1824 } else if (Ty->isIncompleteArrayType()) {
1826 if (Ty->getElementType()->isIncompleteType())
1829 Align = CGM.getContext().getTypeAlign(Ty->getElementType());
1830 } else if (Ty->isIncompleteType()) {
1834 // Size and align of the whole array, not the element type.
1835 Size = CGM.getContext().getTypeSize(Ty);
1836 Align = CGM.getContext().getTypeAlign(Ty);
1839 // Add the dimensions of the array. FIXME: This loses CV qualifiers from
1840 // interior arrays, do we care? Why aren't nested arrays represented the
1841 // obvious/recursive way?
1842 SmallVector<llvm::Metadata *, 8> Subscripts;
1843 QualType EltTy(Ty, 0);
1844 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
1845 // If the number of elements is known, then count is that number. Otherwise,
1846 // it's -1. This allows us to represent a subrange with an array of 0
1847 // elements, like this:
1852 int64_t Count = -1; // Count == -1 is an unbounded array.
1853 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(Ty))
1854 Count = CAT->getSize().getZExtValue();
1856 // FIXME: Verify this is right for VLAs.
1857 Subscripts.push_back(DBuilder.getOrCreateSubrange(0, Count));
1858 EltTy = Ty->getElementType();
1861 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
1863 return DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
1867 llvm::DIType *CGDebugInfo::CreateType(const LValueReferenceType *Ty,
1868 llvm::DIFile *Unit) {
1869 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty,
1870 Ty->getPointeeType(), Unit);
1873 llvm::DIType *CGDebugInfo::CreateType(const RValueReferenceType *Ty,
1874 llvm::DIFile *Unit) {
1875 return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type, Ty,
1876 Ty->getPointeeType(), Unit);
1879 llvm::DIType *CGDebugInfo::CreateType(const MemberPointerType *Ty,
1881 uint64_t Size = CGM.getCXXABI().isTypeInfoCalculable(QualType(Ty, 0))
1882 ? CGM.getContext().getTypeSize(Ty)
1884 llvm::DIType *ClassType = getOrCreateType(QualType(Ty->getClass(), 0), U);
1885 if (Ty->isMemberDataPointerType())
1886 return DBuilder.createMemberPointerType(
1887 getOrCreateType(Ty->getPointeeType(), U), ClassType, Size);
1889 const FunctionProtoType *FPT =
1890 Ty->getPointeeType()->getAs<FunctionProtoType>();
1891 return DBuilder.createMemberPointerType(
1892 getOrCreateInstanceMethodType(CGM.getContext().getPointerType(QualType(
1893 Ty->getClass(), FPT->getTypeQuals())),
1898 llvm::DIType *CGDebugInfo::CreateType(const AtomicType *Ty, llvm::DIFile *U) {
1899 // Ignore the atomic wrapping
1900 // FIXME: What is the correct representation?
1901 return getOrCreateType(Ty->getValueType(), U);
1904 /// CreateEnumType - get enumeration type.
1905 llvm::DIType *CGDebugInfo::CreateEnumType(const EnumType *Ty) {
1906 const EnumDecl *ED = Ty->getDecl();
1909 if (!ED->getTypeForDecl()->isIncompleteType()) {
1910 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
1911 Align = CGM.getContext().getTypeAlign(ED->getTypeForDecl());
1914 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
1916 // If this is just a forward declaration, construct an appropriately
1917 // marked node and just return it.
1918 if (!ED->getDefinition()) {
1919 llvm::DIScope *EDContext =
1920 getContextDescriptor(cast<Decl>(ED->getDeclContext()));
1921 llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
1922 unsigned Line = getLineNumber(ED->getLocation());
1923 StringRef EDName = ED->getName();
1924 llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType(
1925 llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit, Line,
1926 0, Size, Align, llvm::DINode::FlagFwdDecl, FullName);
1927 ReplaceMap.emplace_back(
1928 std::piecewise_construct, std::make_tuple(Ty),
1929 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
1933 return CreateTypeDefinition(Ty);
1936 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) {
1937 const EnumDecl *ED = Ty->getDecl();
1940 if (!ED->getTypeForDecl()->isIncompleteType()) {
1941 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
1942 Align = CGM.getContext().getTypeAlign(ED->getTypeForDecl());
1945 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
1947 // Create elements for each enumerator.
1948 SmallVector<llvm::Metadata *, 16> Enumerators;
1949 ED = ED->getDefinition();
1950 for (const auto *Enum : ED->enumerators()) {
1951 Enumerators.push_back(DBuilder.createEnumerator(
1952 Enum->getName(), Enum->getInitVal().getSExtValue()));
1955 // Return a CompositeType for the enum itself.
1956 llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
1958 llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
1959 unsigned Line = getLineNumber(ED->getLocation());
1960 llvm::DIScope *EnumContext =
1961 getContextDescriptor(cast<Decl>(ED->getDeclContext()));
1962 llvm::DIType *ClassTy =
1963 ED->isFixed() ? getOrCreateType(ED->getIntegerType(), DefUnit) : nullptr;
1964 return DBuilder.createEnumerationType(EnumContext, ED->getName(), DefUnit,
1965 Line, Size, Align, EltArray, ClassTy,
1969 static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C) {
1972 Qualifiers InnerQuals = T.getLocalQualifiers();
1973 // Qualifiers::operator+() doesn't like it if you add a Qualifier
1974 // that is already there.
1975 Quals += Qualifiers::removeCommonQualifiers(Quals, InnerQuals);
1976 Quals += InnerQuals;
1978 switch (T->getTypeClass()) {
1980 return C.getQualifiedType(T.getTypePtr(), Quals);
1981 case Type::TemplateSpecialization: {
1982 const auto *Spec = cast<TemplateSpecializationType>(T);
1983 if (Spec->isTypeAlias())
1984 return C.getQualifiedType(T.getTypePtr(), Quals);
1985 T = Spec->desugar();
1988 case Type::TypeOfExpr:
1989 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
1992 T = cast<TypeOfType>(T)->getUnderlyingType();
1994 case Type::Decltype:
1995 T = cast<DecltypeType>(T)->getUnderlyingType();
1997 case Type::UnaryTransform:
1998 T = cast<UnaryTransformType>(T)->getUnderlyingType();
2000 case Type::Attributed:
2001 T = cast<AttributedType>(T)->getEquivalentType();
2003 case Type::Elaborated:
2004 T = cast<ElaboratedType>(T)->getNamedType();
2007 T = cast<ParenType>(T)->getInnerType();
2009 case Type::SubstTemplateTypeParm:
2010 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
2013 QualType DT = cast<AutoType>(T)->getDeducedType();
2014 assert(!DT.isNull() && "Undeduced types shouldn't reach here.");
2019 assert(T != LastT && "Type unwrapping failed to unwrap!");
2024 /// getType - Get the type from the cache or return null type if it doesn't
2026 llvm::DIType *CGDebugInfo::getTypeOrNull(QualType Ty) {
2028 // Unwrap the type as needed for debug information.
2029 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
2031 auto it = TypeCache.find(Ty.getAsOpaquePtr());
2032 if (it != TypeCache.end()) {
2033 // Verify that the debug info still exists.
2034 if (llvm::Metadata *V = it->second)
2035 return cast<llvm::DIType>(V);
2041 void CGDebugInfo::completeTemplateDefinition(
2042 const ClassTemplateSpecializationDecl &SD) {
2043 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2046 completeClassData(&SD);
2047 // In case this type has no member function definitions being emitted, ensure
2049 RetainedTypes.push_back(CGM.getContext().getRecordType(&SD).getAsOpaquePtr());
2052 /// getOrCreateType - Get the type from the cache or create a new
2053 /// one if necessary.
2054 llvm::DIType *CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile *Unit) {
2058 // Unwrap the type as needed for debug information.
2059 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
2061 if (auto *T = getTypeOrNull(Ty))
2064 // Otherwise create the type.
2065 llvm::DIType *Res = CreateTypeNode(Ty, Unit);
2066 void *TyPtr = Ty.getAsOpaquePtr();
2068 // And update the type cache.
2069 TypeCache[TyPtr].reset(Res);
2074 /// Currently the checksum of an interface includes the number of
2075 /// ivars and property accessors.
2076 unsigned CGDebugInfo::Checksum(const ObjCInterfaceDecl *ID) {
2077 // The assumption is that the number of ivars can only increase
2078 // monotonically, so it is safe to just use their current number as
2081 for (const ObjCIvarDecl *Ivar = ID->all_declared_ivar_begin();
2082 Ivar != nullptr; Ivar = Ivar->getNextIvar())
2088 ObjCInterfaceDecl *CGDebugInfo::getObjCInterfaceDecl(QualType Ty) {
2089 switch (Ty->getTypeClass()) {
2090 case Type::ObjCObjectPointer:
2091 return getObjCInterfaceDecl(
2092 cast<ObjCObjectPointerType>(Ty)->getPointeeType());
2093 case Type::ObjCInterface:
2094 return cast<ObjCInterfaceType>(Ty)->getDecl();
2100 /// CreateTypeNode - Create a new debug type node.
2101 llvm::DIType *CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile *Unit) {
2102 // Handle qualifiers, which recursively handles what they refer to.
2103 if (Ty.hasLocalQualifiers())
2104 return CreateQualifiedType(Ty, Unit);
2106 // Work out details of type.
2107 switch (Ty->getTypeClass()) {
2108 #define TYPE(Class, Base)
2109 #define ABSTRACT_TYPE(Class, Base)
2110 #define NON_CANONICAL_TYPE(Class, Base)
2111 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
2112 #include "clang/AST/TypeNodes.def"
2113 llvm_unreachable("Dependent types cannot show up in debug information");
2115 case Type::ExtVector:
2117 return CreateType(cast<VectorType>(Ty), Unit);
2118 case Type::ObjCObjectPointer:
2119 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
2120 case Type::ObjCObject:
2121 return CreateType(cast<ObjCObjectType>(Ty), Unit);
2122 case Type::ObjCInterface:
2123 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
2125 return CreateType(cast<BuiltinType>(Ty));
2127 return CreateType(cast<ComplexType>(Ty));
2129 return CreateType(cast<PointerType>(Ty), Unit);
2130 case Type::Adjusted:
2132 // Decayed and adjusted types use the adjusted type in LLVM and DWARF.
2134 cast<PointerType>(cast<AdjustedType>(Ty)->getAdjustedType()), Unit);
2135 case Type::BlockPointer:
2136 return CreateType(cast<BlockPointerType>(Ty), Unit);
2138 return CreateType(cast<TypedefType>(Ty), Unit);
2140 return CreateType(cast<RecordType>(Ty));
2142 return CreateEnumType(cast<EnumType>(Ty));
2143 case Type::FunctionProto:
2144 case Type::FunctionNoProto:
2145 return CreateType(cast<FunctionType>(Ty), Unit);
2146 case Type::ConstantArray:
2147 case Type::VariableArray:
2148 case Type::IncompleteArray:
2149 return CreateType(cast<ArrayType>(Ty), Unit);
2151 case Type::LValueReference:
2152 return CreateType(cast<LValueReferenceType>(Ty), Unit);
2153 case Type::RValueReference:
2154 return CreateType(cast<RValueReferenceType>(Ty), Unit);
2156 case Type::MemberPointer:
2157 return CreateType(cast<MemberPointerType>(Ty), Unit);
2160 return CreateType(cast<AtomicType>(Ty), Unit);
2162 case Type::TemplateSpecialization:
2163 return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
2166 case Type::Attributed:
2167 case Type::Elaborated:
2169 case Type::SubstTemplateTypeParm:
2170 case Type::TypeOfExpr:
2172 case Type::Decltype:
2173 case Type::UnaryTransform:
2174 case Type::PackExpansion:
2178 llvm_unreachable("type should have been unwrapped!");
2181 /// getOrCreateLimitedType - Get the type from the cache or create a new
2182 /// limited type if necessary.
2183 llvm::DIType *CGDebugInfo::getOrCreateLimitedType(const RecordType *Ty,
2184 llvm::DIFile *Unit) {
2185 QualType QTy(Ty, 0);
2187 auto *T = cast_or_null<llvm::DICompositeTypeBase>(getTypeOrNull(QTy));
2189 // We may have cached a forward decl when we could have created
2190 // a non-forward decl. Go ahead and create a non-forward decl
2192 if (T && !T->isForwardDecl())
2195 // Otherwise create the type.
2196 llvm::DICompositeType *Res = CreateLimitedType(Ty);
2198 // Propagate members from the declaration to the definition
2199 // CreateType(const RecordType*) will overwrite this with the members in the
2200 // correct order if the full type is needed.
2201 DBuilder.replaceArrays(Res, T ? T->getElements() : llvm::DINodeArray());
2203 // And update the type cache.
2204 TypeCache[QTy.getAsOpaquePtr()].reset(Res);
2208 // TODO: Currently used for context chains when limiting debug info.
2209 llvm::DICompositeType *CGDebugInfo::CreateLimitedType(const RecordType *Ty) {
2210 RecordDecl *RD = Ty->getDecl();
2212 // Get overall information about the record type for the debug info.
2213 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
2214 unsigned Line = getLineNumber(RD->getLocation());
2215 StringRef RDName = getClassName(RD);
2217 llvm::DIScope *RDContext =
2218 getContextDescriptor(cast<Decl>(RD->getDeclContext()));
2220 // If we ended up creating the type during the context chain construction,
2221 // just return that.
2222 auto *T = cast_or_null<llvm::DICompositeType>(
2223 getTypeOrNull(CGM.getContext().getRecordType(RD)));
2224 if (T && (!T->isForwardDecl() || !RD->getDefinition()))
2227 // If this is just a forward or incomplete declaration, construct an
2228 // appropriately marked node and just return it.
2229 const RecordDecl *D = RD->getDefinition();
2230 if (!D || !D->isCompleteDefinition())
2231 return getOrCreateRecordFwdDecl(Ty, RDContext);
2233 uint64_t Size = CGM.getContext().getTypeSize(Ty);
2234 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
2236 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
2238 llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
2239 getTagForRecord(RD), RDName, RDContext, DefUnit, Line, 0, Size, Align, 0,
2242 RegionMap[Ty->getDecl()].reset(RealDecl);
2243 TypeCache[QualType(Ty, 0).getAsOpaquePtr()].reset(RealDecl);
2245 if (const ClassTemplateSpecializationDecl *TSpecial =
2246 dyn_cast<ClassTemplateSpecializationDecl>(RD))
2247 DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),
2248 CollectCXXTemplateParams(TSpecial, DefUnit));
2252 void CGDebugInfo::CollectContainingType(const CXXRecordDecl *RD,
2253 llvm::DICompositeType *RealDecl) {
2254 // A class's primary base or the class itself contains the vtable.
2255 llvm::DICompositeType *ContainingType = nullptr;
2256 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2257 if (const CXXRecordDecl *PBase = RL.getPrimaryBase()) {
2258 // Seek non-virtual primary base root.
2260 const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase);
2261 const CXXRecordDecl *PBT = BRL.getPrimaryBase();
2262 if (PBT && !BRL.isPrimaryBaseVirtual())
2267 ContainingType = cast<llvm::DICompositeType>(
2268 getOrCreateType(QualType(PBase->getTypeForDecl(), 0),
2269 getOrCreateFile(RD->getLocation())));
2270 } else if (RD->isDynamicClass())
2271 ContainingType = RealDecl;
2273 DBuilder.replaceVTableHolder(RealDecl, ContainingType);
2276 /// CreateMemberType - Create new member and increase Offset by FType's size.
2277 llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit, QualType FType,
2278 StringRef Name, uint64_t *Offset) {
2279 llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
2280 uint64_t FieldSize = CGM.getContext().getTypeSize(FType);
2281 unsigned FieldAlign = CGM.getContext().getTypeAlign(FType);
2282 llvm::DIType *Ty = DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize,
2283 FieldAlign, *Offset, 0, FieldTy);
2284 *Offset += FieldSize;
2288 void CGDebugInfo::collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit,
2290 StringRef &LinkageName,
2291 llvm::DIScope *&FDContext,
2292 llvm::DINodeArray &TParamsArray,
2294 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
2295 Name = getFunctionName(FD);
2296 // Use mangled name as linkage name for C/C++ functions.
2297 if (FD->hasPrototype()) {
2298 LinkageName = CGM.getMangledName(GD);
2299 Flags |= llvm::DINode::FlagPrototyped;
2301 // No need to replicate the linkage name if it isn't different from the
2302 // subprogram name, no need to have it at all unless coverage is enabled or
2303 // debug is set to more than just line tables.
2304 if (LinkageName == Name ||
2305 (!CGM.getCodeGenOpts().EmitGcovArcs &&
2306 !CGM.getCodeGenOpts().EmitGcovNotes &&
2307 DebugKind <= CodeGenOptions::DebugLineTablesOnly))
2308 LinkageName = StringRef();
2310 if (DebugKind >= CodeGenOptions::LimitedDebugInfo) {
2311 if (const NamespaceDecl *NSDecl =
2312 dyn_cast_or_null<NamespaceDecl>(FD->getDeclContext()))
2313 FDContext = getOrCreateNameSpace(NSDecl);
2314 else if (const RecordDecl *RDecl =
2315 dyn_cast_or_null<RecordDecl>(FD->getDeclContext()))
2316 FDContext = getContextDescriptor(cast<Decl>(RDecl));
2317 // Collect template parameters.
2318 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
2322 void CGDebugInfo::collectVarDeclProps(const VarDecl *VD, llvm::DIFile *&Unit,
2323 unsigned &LineNo, QualType &T,
2324 StringRef &Name, StringRef &LinkageName,
2325 llvm::DIScope *&VDContext) {
2326 Unit = getOrCreateFile(VD->getLocation());
2327 LineNo = getLineNumber(VD->getLocation());
2329 setLocation(VD->getLocation());
2332 if (T->isIncompleteArrayType()) {
2333 // CodeGen turns int[] into int[1] so we'll do the same here.
2334 llvm::APInt ConstVal(32, 1);
2335 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
2337 T = CGM.getContext().getConstantArrayType(ET, ConstVal,
2338 ArrayType::Normal, 0);
2341 Name = VD->getName();
2342 if (VD->getDeclContext() && !isa<FunctionDecl>(VD->getDeclContext()) &&
2343 !isa<ObjCMethodDecl>(VD->getDeclContext()))
2344 LinkageName = CGM.getMangledName(VD);
2345 if (LinkageName == Name)
2346 LinkageName = StringRef();
2348 // Since we emit declarations (DW_AT_members) for static members, place the
2349 // definition of those static members in the namespace they were declared in
2350 // in the source code (the lexical decl context).
2351 // FIXME: Generalize this for even non-member global variables where the
2352 // declaration and definition may have different lexical decl contexts, once
2353 // we have support for emitting declarations of (non-member) global variables.
2354 const DeclContext *DC = VD->isStaticDataMember() ? VD->getLexicalDeclContext()
2355 : VD->getDeclContext();
2356 // When a record type contains an in-line initialization of a static data
2357 // member, and the record type is marked as __declspec(dllexport), an implicit
2358 // definition of the member will be created in the record context. DWARF
2359 // doesn't seem to have a nice way to describe this in a form that consumers
2360 // are likely to understand, so fake the "normal" situation of a definition
2361 // outside the class by putting it in the global scope.
2363 DC = CGM.getContext().getTranslationUnitDecl();
2364 VDContext = getContextDescriptor(dyn_cast<Decl>(DC));
2367 llvm::DISubprogram *
2368 CGDebugInfo::getFunctionForwardDeclaration(const FunctionDecl *FD) {
2369 llvm::DINodeArray TParamsArray;
2370 StringRef Name, LinkageName;
2372 SourceLocation Loc = FD->getLocation();
2373 llvm::DIFile *Unit = getOrCreateFile(Loc);
2374 llvm::DIScope *DContext = Unit;
2375 unsigned Line = getLineNumber(Loc);
2377 collectFunctionDeclProps(FD, Unit, Name, LinkageName, DContext,
2378 TParamsArray, Flags);
2379 // Build function type.
2380 SmallVector<QualType, 16> ArgTypes;
2381 for (const ParmVarDecl *Parm: FD->parameters())
2382 ArgTypes.push_back(Parm->getType());
2384 CGM.getContext().getFunctionType(FD->getReturnType(), ArgTypes,
2385 FunctionProtoType::ExtProtoInfo());
2386 llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
2387 DContext, Name, LinkageName, Unit, Line,
2388 getOrCreateFunctionType(FD, FnType, Unit), !FD->isExternallyVisible(),
2389 false /*declaration*/, 0, Flags, CGM.getLangOpts().Optimize, nullptr,
2390 TParamsArray.get(), getFunctionDeclaration(FD));
2391 const FunctionDecl *CanonDecl = cast<FunctionDecl>(FD->getCanonicalDecl());
2392 FwdDeclReplaceMap.emplace_back(std::piecewise_construct,
2393 std::make_tuple(CanonDecl),
2394 std::make_tuple(SP));
2398 llvm::DIGlobalVariable *
2399 CGDebugInfo::getGlobalVariableForwardDeclaration(const VarDecl *VD) {
2401 StringRef Name, LinkageName;
2402 SourceLocation Loc = VD->getLocation();
2403 llvm::DIFile *Unit = getOrCreateFile(Loc);
2404 llvm::DIScope *DContext = Unit;
2405 unsigned Line = getLineNumber(Loc);
2407 collectVarDeclProps(VD, Unit, Line, T, Name, LinkageName, DContext);
2408 auto *GV = DBuilder.createTempGlobalVariableFwdDecl(
2409 DContext, Name, LinkageName, Unit, Line, getOrCreateType(T, Unit),
2410 !VD->isExternallyVisible(), nullptr, nullptr);
2411 FwdDeclReplaceMap.emplace_back(
2412 std::piecewise_construct,
2413 std::make_tuple(cast<VarDecl>(VD->getCanonicalDecl())),
2414 std::make_tuple(static_cast<llvm::Metadata *>(GV)));
2418 llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(const Decl *D) {
2419 // We only need a declaration (not a definition) of the type - so use whatever
2420 // we would otherwise do to get a type for a pointee. (forward declarations in
2421 // limited debug info, full definitions (if the type definition is available)
2422 // in unlimited debug info)
2423 if (const TypeDecl *TD = dyn_cast<TypeDecl>(D))
2424 return getOrCreateType(CGM.getContext().getTypeDeclType(TD),
2425 getOrCreateFile(TD->getLocation()));
2426 auto I = DeclCache.find(D->getCanonicalDecl());
2428 if (I != DeclCache.end())
2429 return dyn_cast_or_null<llvm::DINode>(I->second);
2431 // No definition for now. Emit a forward definition that might be
2432 // merged with a potential upcoming definition.
2433 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
2434 return getFunctionForwardDeclaration(FD);
2435 else if (const auto *VD = dyn_cast<VarDecl>(D))
2436 return getGlobalVariableForwardDeclaration(VD);
2441 /// getFunctionDeclaration - Return debug info descriptor to describe method
2442 /// declaration for the given method definition.
2443 llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(const Decl *D) {
2444 if (!D || DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2447 const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
2452 auto *S = getContextDescriptor(cast<Decl>(D->getDeclContext()));
2454 auto MI = SPCache.find(FD->getCanonicalDecl());
2455 if (MI == SPCache.end()) {
2456 if (const CXXMethodDecl *MD =
2457 dyn_cast<CXXMethodDecl>(FD->getCanonicalDecl())) {
2458 return CreateCXXMemberFunction(MD, getOrCreateFile(MD->getLocation()),
2459 cast<llvm::DICompositeType>(S));
2462 if (MI != SPCache.end()) {
2463 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
2464 if (SP && !SP->isDefinition())
2468 for (auto NextFD : FD->redecls()) {
2469 auto MI = SPCache.find(NextFD->getCanonicalDecl());
2470 if (MI != SPCache.end()) {
2471 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
2472 if (SP && !SP->isDefinition())
2479 // getOrCreateFunctionType - Construct type. If it is a c++ method, include
2480 // implicit parameter "this".
2481 llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(const Decl *D,
2484 if (!D || DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2485 // Create fake but valid subroutine type. Otherwise -verify would fail, and
2486 // subprogram DIE will miss DW_AT_decl_file and DW_AT_decl_line fields.
2487 return DBuilder.createSubroutineType(F,
2488 DBuilder.getOrCreateTypeArray(None));
2490 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
2491 return getOrCreateMethodType(Method, F);
2492 if (const ObjCMethodDecl *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
2493 // Add "self" and "_cmd"
2494 SmallVector<llvm::Metadata *, 16> Elts;
2496 // First element is always return type. For 'void' functions it is NULL.
2497 QualType ResultTy = OMethod->getReturnType();
2499 // Replace the instancetype keyword with the actual type.
2500 if (ResultTy == CGM.getContext().getObjCInstanceType())
2501 ResultTy = CGM.getContext().getPointerType(
2502 QualType(OMethod->getClassInterface()->getTypeForDecl(), 0));
2504 Elts.push_back(getOrCreateType(ResultTy, F));
2505 // "self" pointer is always first argument.
2506 QualType SelfDeclTy = OMethod->getSelfDecl()->getType();
2507 Elts.push_back(CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F)));
2508 // "_cmd" pointer is always second argument.
2509 Elts.push_back(DBuilder.createArtificialType(
2510 getOrCreateType(OMethod->getCmdDecl()->getType(), F)));
2511 // Get rest of the arguments.
2512 for (const auto *PI : OMethod->params())
2513 Elts.push_back(getOrCreateType(PI->getType(), F));
2514 // Variadic methods need a special marker at the end of the type list.
2515 if (OMethod->isVariadic())
2516 Elts.push_back(DBuilder.createUnspecifiedParameter());
2518 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
2519 return DBuilder.createSubroutineType(F, EltTypeArray);
2522 // Handle variadic function types; they need an additional
2523 // unspecified parameter.
2524 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
2525 if (FD->isVariadic()) {
2526 SmallVector<llvm::Metadata *, 16> EltTys;
2527 EltTys.push_back(getOrCreateType(FD->getReturnType(), F));
2528 if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FnType))
2529 for (unsigned i = 0, e = FPT->getNumParams(); i != e; ++i)
2530 EltTys.push_back(getOrCreateType(FPT->getParamType(i), F));
2531 EltTys.push_back(DBuilder.createUnspecifiedParameter());
2532 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
2533 return DBuilder.createSubroutineType(F, EltTypeArray);
2536 return cast<llvm::DISubroutineType>(getOrCreateType(FnType, F));
2539 /// EmitFunctionStart - Constructs the debug code for entering a function.
2540 void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, SourceLocation Loc,
2541 SourceLocation ScopeLoc, QualType FnType,
2542 llvm::Function *Fn, CGBuilderTy &Builder) {
2545 StringRef LinkageName;
2547 FnBeginRegionCount.push_back(LexicalBlockStack.size());
2549 const Decl *D = GD.getDecl();
2550 bool HasDecl = (D != nullptr);
2553 llvm::DIFile *Unit = getOrCreateFile(Loc);
2554 llvm::DIScope *FDContext = Unit;
2555 llvm::DINodeArray TParamsArray;
2557 // Use llvm function name.
2558 LinkageName = Fn->getName();
2559 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2560 // If there is a subprogram for this function available then use it.
2561 auto FI = SPCache.find(FD->getCanonicalDecl());
2562 if (FI != SPCache.end()) {
2563 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
2564 if (SP && SP->isDefinition()) {
2565 LexicalBlockStack.emplace_back(SP);
2566 RegionMap[D].reset(SP);
2570 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
2571 TParamsArray, Flags);
2572 } else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D)) {
2573 Name = getObjCMethodName(OMD);
2574 Flags |= llvm::DINode::FlagPrototyped;
2576 // Use llvm function name.
2577 Name = Fn->getName();
2578 Flags |= llvm::DINode::FlagPrototyped;
2580 if (!Name.empty() && Name[0] == '\01')
2581 Name = Name.substr(1);
2583 if (!HasDecl || D->isImplicit()) {
2584 Flags |= llvm::DINode::FlagArtificial;
2585 // Artificial functions without a location should not silently reuse CurLoc.
2586 if (Loc.isInvalid())
2587 CurLoc = SourceLocation();
2589 unsigned LineNo = getLineNumber(Loc);
2590 unsigned ScopeLine = getLineNumber(ScopeLoc);
2592 // FIXME: The function declaration we're constructing here is mostly reusing
2593 // declarations from CXXMethodDecl and not constructing new ones for arbitrary
2594 // FunctionDecls. When/if we fix this we can have FDContext be TheCU/null for
2595 // all subprograms instead of the actual context since subprogram definitions
2596 // are emitted as CU level entities by the backend.
2597 llvm::DISubprogram *SP = DBuilder.createFunction(
2598 FDContext, Name, LinkageName, Unit, LineNo,
2599 getOrCreateFunctionType(D, FnType, Unit), Fn->hasInternalLinkage(),
2600 true /*definition*/, ScopeLine, Flags, CGM.getLangOpts().Optimize, Fn,
2601 TParamsArray.get(), getFunctionDeclaration(D));
2602 // We might get here with a VarDecl in the case we're generating
2603 // code for the initialization of globals. Do not record these decls
2604 // as they will overwrite the actual VarDecl Decl in the cache.
2605 if (HasDecl && isa<FunctionDecl>(D))
2606 DeclCache[D->getCanonicalDecl()].reset(static_cast<llvm::Metadata *>(SP));
2608 // Push the function onto the lexical block stack.
2609 LexicalBlockStack.emplace_back(SP);
2612 RegionMap[D].reset(SP);
2615 /// EmitLocation - Emit metadata to indicate a change in line/column
2616 /// information in the source file. If the location is invalid, the
2617 /// previous location will be reused.
2618 void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc) {
2619 // Update our current location
2622 if (CurLoc.isInvalid() || CurLoc.isMacroID())
2625 llvm::MDNode *Scope = LexicalBlockStack.back();
2626 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
2627 getLineNumber(CurLoc), getColumnNumber(CurLoc), Scope));
2630 /// CreateLexicalBlock - Creates a new lexical block node and pushes it on
2632 void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) {
2633 llvm::MDNode *Back = nullptr;
2634 if (!LexicalBlockStack.empty())
2635 Back = LexicalBlockStack.back().get();
2636 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
2637 cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
2638 getColumnNumber(CurLoc)));
2641 /// EmitLexicalBlockStart - Constructs the debug code for entering a declarative
2642 /// region - beginning of a DW_TAG_lexical_block.
2643 void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder,
2644 SourceLocation Loc) {
2645 // Set our current location.
2648 // Emit a line table change for the current location inside the new scope.
2649 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
2650 getLineNumber(Loc), getColumnNumber(Loc), LexicalBlockStack.back()));
2652 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2655 // Create a new lexical block and push it on the stack.
2656 CreateLexicalBlock(Loc);
2659 /// EmitLexicalBlockEnd - Constructs the debug code for exiting a declarative
2660 /// region - end of a DW_TAG_lexical_block.
2661 void CGDebugInfo::EmitLexicalBlockEnd(CGBuilderTy &Builder,
2662 SourceLocation Loc) {
2663 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
2665 // Provide an entry in the line table for the end of the block.
2666 EmitLocation(Builder, Loc);
2668 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2671 LexicalBlockStack.pop_back();
2674 /// EmitFunctionEnd - Constructs the debug code for exiting a function.
2675 void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder) {
2676 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
2677 unsigned RCount = FnBeginRegionCount.back();
2678 assert(RCount <= LexicalBlockStack.size() && "Region stack mismatch");
2680 // Pop all regions for this function.
2681 while (LexicalBlockStack.size() != RCount) {
2682 // Provide an entry in the line table for the end of the block.
2683 EmitLocation(Builder, CurLoc);
2684 LexicalBlockStack.pop_back();
2686 FnBeginRegionCount.pop_back();
2689 // EmitTypeForVarWithBlocksAttr - Build up structure info for the byref.
2690 // See BuildByRefType.
2691 llvm::DIType *CGDebugInfo::EmitTypeForVarWithBlocksAttr(const VarDecl *VD,
2692 uint64_t *XOffset) {
2694 SmallVector<llvm::Metadata *, 5> EltTys;
2696 uint64_t FieldSize, FieldOffset;
2697 unsigned FieldAlign;
2699 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
2700 QualType Type = VD->getType();
2703 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
2704 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
2705 EltTys.push_back(CreateMemberType(Unit, FType, "__forwarding", &FieldOffset));
2706 FType = CGM.getContext().IntTy;
2707 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
2708 EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset));
2710 bool HasCopyAndDispose = CGM.getContext().BlockRequiresCopying(Type, VD);
2711 if (HasCopyAndDispose) {
2712 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
2714 CreateMemberType(Unit, FType, "__copy_helper", &FieldOffset));
2716 CreateMemberType(Unit, FType, "__destroy_helper", &FieldOffset));
2718 bool HasByrefExtendedLayout;
2719 Qualifiers::ObjCLifetime Lifetime;
2720 if (CGM.getContext().getByrefLifetime(Type, Lifetime,
2721 HasByrefExtendedLayout) &&
2722 HasByrefExtendedLayout) {
2723 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
2725 CreateMemberType(Unit, FType, "__byref_variable_layout", &FieldOffset));
2728 CharUnits Align = CGM.getContext().getDeclAlign(VD);
2729 if (Align > CGM.getContext().toCharUnitsFromBits(
2730 CGM.getTarget().getPointerAlign(0))) {
2731 CharUnits FieldOffsetInBytes =
2732 CGM.getContext().toCharUnitsFromBits(FieldOffset);
2733 CharUnits AlignedOffsetInBytes =
2734 FieldOffsetInBytes.RoundUpToAlignment(Align);
2735 CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;
2737 if (NumPaddingBytes.isPositive()) {
2738 llvm::APInt pad(32, NumPaddingBytes.getQuantity());
2739 FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy,
2740 pad, ArrayType::Normal, 0);
2741 EltTys.push_back(CreateMemberType(Unit, FType, "", &FieldOffset));
2746 llvm::DIType *FieldTy = getOrCreateType(FType, Unit);
2747 FieldSize = CGM.getContext().getTypeSize(FType);
2748 FieldAlign = CGM.getContext().toBits(Align);
2750 *XOffset = FieldOffset;
2751 FieldTy = DBuilder.createMemberType(Unit, VD->getName(), Unit, 0, FieldSize,
2752 FieldAlign, FieldOffset, 0, FieldTy);
2753 EltTys.push_back(FieldTy);
2754 FieldOffset += FieldSize;
2756 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2758 unsigned Flags = llvm::DINode::FlagBlockByrefStruct;
2760 return DBuilder.createStructType(Unit, "", Unit, 0, FieldOffset, 0, Flags,
2764 /// EmitDeclare - Emit local variable declaration debug info.
2765 void CGDebugInfo::EmitDeclare(const VarDecl *VD, llvm::dwarf::Tag Tag,
2766 llvm::Value *Storage, unsigned ArgNo,
2767 CGBuilderTy &Builder) {
2768 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
2769 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
2772 VD->isImplicit() || (isa<Decl>(VD->getDeclContext()) &&
2773 cast<Decl>(VD->getDeclContext())->isImplicit());
2774 llvm::DIFile *Unit = nullptr;
2776 Unit = getOrCreateFile(VD->getLocation());
2778 uint64_t XOffset = 0;
2779 if (VD->hasAttr<BlocksAttr>())
2780 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
2782 Ty = getOrCreateType(VD->getType(), Unit);
2784 // If there is no debug info for this type then do not emit debug info
2785 // for this variable.
2789 // Get location information.
2791 unsigned Column = 0;
2793 Line = getLineNumber(VD->getLocation());
2794 Column = getColumnNumber(VD->getLocation());
2796 SmallVector<int64_t, 9> Expr;
2798 if (VD->isImplicit())
2799 Flags |= llvm::DINode::FlagArtificial;
2800 // If this is the first argument and it is implicit then
2801 // give it an object pointer flag.
2802 // FIXME: There has to be a better way to do this, but for static
2803 // functions there won't be an implicit param at arg1 and
2804 // otherwise it is 'self' or 'this'.
2805 if (isa<ImplicitParamDecl>(VD) && ArgNo == 1)
2806 Flags |= llvm::DINode::FlagObjectPointer;
2807 if (llvm::Argument *Arg = dyn_cast<llvm::Argument>(Storage))
2808 if (Arg->getType()->isPointerTy() && !Arg->hasByValAttr() &&
2809 !VD->getType()->isPointerType())
2810 Expr.push_back(llvm::dwarf::DW_OP_deref);
2812 auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
2814 StringRef Name = VD->getName();
2815 if (!Name.empty()) {
2816 if (VD->hasAttr<BlocksAttr>()) {
2817 CharUnits offset = CharUnits::fromQuantity(32);
2818 Expr.push_back(llvm::dwarf::DW_OP_plus);
2819 // offset of __forwarding field
2820 offset = CGM.getContext().toCharUnitsFromBits(
2821 CGM.getTarget().getPointerWidth(0));
2822 Expr.push_back(offset.getQuantity());
2823 Expr.push_back(llvm::dwarf::DW_OP_deref);
2824 Expr.push_back(llvm::dwarf::DW_OP_plus);
2825 // offset of x field
2826 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
2827 Expr.push_back(offset.getQuantity());
2829 // Create the descriptor for the variable.
2830 auto *D = DBuilder.createLocalVariable(Tag, Scope, VD->getName(), Unit,
2833 // Insert an llvm.dbg.declare into the current block.
2834 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
2835 llvm::DebugLoc::get(Line, Column, Scope),
2836 Builder.GetInsertBlock());
2838 } else if (isa<VariableArrayType>(VD->getType()))
2839 Expr.push_back(llvm::dwarf::DW_OP_deref);
2840 } else if (const RecordType *RT = dyn_cast<RecordType>(VD->getType())) {
2841 // If VD is an anonymous union then Storage represents value for
2842 // all union fields.
2843 const RecordDecl *RD = cast<RecordDecl>(RT->getDecl());
2844 if (RD->isUnion() && RD->isAnonymousStructOrUnion()) {
2845 // GDB has trouble finding local variables in anonymous unions, so we emit
2846 // artifical local variables for each of the members.
2848 // FIXME: Remove this code as soon as GDB supports this.
2849 // The debug info verifier in LLVM operates based on the assumption that a
2850 // variable has the same size as its storage and we had to disable the check
2851 // for artificial variables.
2852 for (const auto *Field : RD->fields()) {
2853 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
2854 StringRef FieldName = Field->getName();
2856 // Ignore unnamed fields. Do not ignore unnamed records.
2857 if (FieldName.empty() && !isa<RecordType>(Field->getType()))
2860 // Use VarDecl's Tag, Scope and Line number.
2861 auto *D = DBuilder.createLocalVariable(
2862 Tag, Scope, FieldName, Unit, Line, FieldTy,
2863 CGM.getLangOpts().Optimize, Flags | llvm::DINode::FlagArtificial,
2866 // Insert an llvm.dbg.declare into the current block.
2867 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
2868 llvm::DebugLoc::get(Line, Column, Scope),
2869 Builder.GetInsertBlock());
2874 // Create the descriptor for the variable.
2876 DBuilder.createLocalVariable(Tag, Scope, Name, Unit, Line, Ty,
2877 CGM.getLangOpts().Optimize, Flags, ArgNo);
2879 // Insert an llvm.dbg.declare into the current block.
2880 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
2881 llvm::DebugLoc::get(Line, Column, Scope),
2882 Builder.GetInsertBlock());
2885 void CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD,
2886 llvm::Value *Storage,
2887 CGBuilderTy &Builder) {
2888 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
2889 EmitDeclare(VD, llvm::dwarf::DW_TAG_auto_variable, Storage, 0, Builder);
2892 /// Look up the completed type for a self pointer in the TypeCache and
2893 /// create a copy of it with the ObjectPointer and Artificial flags
2894 /// set. If the type is not cached, a new one is created. This should
2895 /// never happen though, since creating a type for the implicit self
2896 /// argument implies that we already parsed the interface definition
2897 /// and the ivar declarations in the implementation.
2898 llvm::DIType *CGDebugInfo::CreateSelfType(const QualType &QualTy,
2900 llvm::DIType *CachedTy = getTypeOrNull(QualTy);
2903 return DBuilder.createObjectPointerType(Ty);
2906 void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
2907 const VarDecl *VD, llvm::Value *Storage, CGBuilderTy &Builder,
2908 const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) {
2909 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
2910 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
2912 if (Builder.GetInsertBlock() == nullptr)
2915 bool isByRef = VD->hasAttr<BlocksAttr>();
2917 uint64_t XOffset = 0;
2918 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
2921 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
2923 Ty = getOrCreateType(VD->getType(), Unit);
2925 // Self is passed along as an implicit non-arg variable in a
2926 // block. Mark it as the object pointer.
2927 if (isa<ImplicitParamDecl>(VD) && VD->getName() == "self")
2928 Ty = CreateSelfType(VD->getType(), Ty);
2930 // Get location information.
2931 unsigned Line = getLineNumber(VD->getLocation());
2932 unsigned Column = getColumnNumber(VD->getLocation());
2934 const llvm::DataLayout &target = CGM.getDataLayout();
2936 CharUnits offset = CharUnits::fromQuantity(
2937 target.getStructLayout(blockInfo.StructureType)
2938 ->getElementOffset(blockInfo.getCapture(VD).getIndex()));
2940 SmallVector<int64_t, 9> addr;
2941 if (isa<llvm::AllocaInst>(Storage))
2942 addr.push_back(llvm::dwarf::DW_OP_deref);
2943 addr.push_back(llvm::dwarf::DW_OP_plus);
2944 addr.push_back(offset.getQuantity());
2946 addr.push_back(llvm::dwarf::DW_OP_deref);
2947 addr.push_back(llvm::dwarf::DW_OP_plus);
2948 // offset of __forwarding field
2950 CGM.getContext().toCharUnitsFromBits(target.getPointerSizeInBits(0));
2951 addr.push_back(offset.getQuantity());
2952 addr.push_back(llvm::dwarf::DW_OP_deref);
2953 addr.push_back(llvm::dwarf::DW_OP_plus);
2954 // offset of x field
2955 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
2956 addr.push_back(offset.getQuantity());
2959 // Create the descriptor for the variable.
2960 auto *D = DBuilder.createLocalVariable(
2961 llvm::dwarf::DW_TAG_auto_variable,
2962 cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->getName(), Unit,
2965 // Insert an llvm.dbg.declare into the current block.
2966 auto DL = llvm::DebugLoc::get(Line, Column, LexicalBlockStack.back());
2968 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(addr), DL,
2971 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(addr), DL,
2972 Builder.GetInsertBlock());
2975 /// EmitDeclareOfArgVariable - Emit call to llvm.dbg.declare for an argument
2976 /// variable declaration.
2977 void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI,
2979 CGBuilderTy &Builder) {
2980 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
2981 EmitDeclare(VD, llvm::dwarf::DW_TAG_arg_variable, AI, ArgNo, Builder);
2985 struct BlockLayoutChunk {
2986 uint64_t OffsetInBits;
2987 const BlockDecl::Capture *Capture;
2989 bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) {
2990 return l.OffsetInBits < r.OffsetInBits;
2994 void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
2997 llvm::Value *LocalAddr,
2998 CGBuilderTy &Builder) {
2999 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
3000 ASTContext &C = CGM.getContext();
3001 const BlockDecl *blockDecl = block.getBlockDecl();
3003 // Collect some general information about the block's location.
3004 SourceLocation loc = blockDecl->getCaretLocation();
3005 llvm::DIFile *tunit = getOrCreateFile(loc);
3006 unsigned line = getLineNumber(loc);
3007 unsigned column = getColumnNumber(loc);
3009 // Build the debug-info type for the block literal.
3010 getContextDescriptor(cast<Decl>(blockDecl->getDeclContext()));
3012 const llvm::StructLayout *blockLayout =
3013 CGM.getDataLayout().getStructLayout(block.StructureType);
3015 SmallVector<llvm::Metadata *, 16> fields;
3016 fields.push_back(createFieldType("__isa", C.VoidPtrTy, 0, loc, AS_public,
3017 blockLayout->getElementOffsetInBits(0),
3019 fields.push_back(createFieldType("__flags", C.IntTy, 0, loc, AS_public,
3020 blockLayout->getElementOffsetInBits(1),
3022 fields.push_back(createFieldType("__reserved", C.IntTy, 0, loc, AS_public,
3023 blockLayout->getElementOffsetInBits(2),
3025 auto *FnTy = block.getBlockExpr()->getFunctionType();
3026 auto FnPtrType = CGM.getContext().getPointerType(FnTy->desugar());
3027 fields.push_back(createFieldType("__FuncPtr", FnPtrType, 0, loc, AS_public,
3028 blockLayout->getElementOffsetInBits(3),
3030 fields.push_back(createFieldType(
3031 "__descriptor", C.getPointerType(block.NeedsCopyDispose
3032 ? C.getBlockDescriptorExtendedType()
3033 : C.getBlockDescriptorType()),
3034 0, loc, AS_public, blockLayout->getElementOffsetInBits(4), tunit, tunit));
3036 // We want to sort the captures by offset, not because DWARF
3037 // requires this, but because we're paranoid about debuggers.
3038 SmallVector<BlockLayoutChunk, 8> chunks;
3041 if (blockDecl->capturesCXXThis()) {
3042 BlockLayoutChunk chunk;
3043 chunk.OffsetInBits =
3044 blockLayout->getElementOffsetInBits(block.CXXThisIndex);
3045 chunk.Capture = nullptr;
3046 chunks.push_back(chunk);
3049 // Variable captures.
3050 for (const auto &capture : blockDecl->captures()) {
3051 const VarDecl *variable = capture.getVariable();
3052 const CGBlockInfo::Capture &captureInfo = block.getCapture(variable);
3054 // Ignore constant captures.
3055 if (captureInfo.isConstant())
3058 BlockLayoutChunk chunk;
3059 chunk.OffsetInBits =
3060 blockLayout->getElementOffsetInBits(captureInfo.getIndex());
3061 chunk.Capture = &capture;
3062 chunks.push_back(chunk);
3066 llvm::array_pod_sort(chunks.begin(), chunks.end());
3068 for (SmallVectorImpl<BlockLayoutChunk>::iterator i = chunks.begin(),
3071 uint64_t offsetInBits = i->OffsetInBits;
3072 const BlockDecl::Capture *capture = i->Capture;
3074 // If we have a null capture, this must be the C++ 'this' capture.
3076 const CXXMethodDecl *method =
3077 cast<CXXMethodDecl>(blockDecl->getNonClosureContext());
3078 QualType type = method->getThisType(C);
3080 fields.push_back(createFieldType("this", type, 0, loc, AS_public,
3081 offsetInBits, tunit, tunit));
3085 const VarDecl *variable = capture->getVariable();
3086 StringRef name = variable->getName();
3088 llvm::DIType *fieldType;
3089 if (capture->isByRef()) {
3090 TypeInfo PtrInfo = C.getTypeInfo(C.VoidPtrTy);
3092 // FIXME: this creates a second copy of this type!
3094 fieldType = EmitTypeForVarWithBlocksAttr(variable, &xoffset);
3095 fieldType = DBuilder.createPointerType(fieldType, PtrInfo.Width);
3097 DBuilder.createMemberType(tunit, name, tunit, line, PtrInfo.Width,
3098 PtrInfo.Align, offsetInBits, 0, fieldType);
3100 fieldType = createFieldType(name, variable->getType(), 0, loc, AS_public,
3101 offsetInBits, tunit, tunit);
3103 fields.push_back(fieldType);
3106 SmallString<36> typeName;
3107 llvm::raw_svector_ostream(typeName) << "__block_literal_"
3108 << CGM.getUniqueBlockCount();
3110 llvm::DINodeArray fieldsArray = DBuilder.getOrCreateArray(fields);
3112 llvm::DIType *type = DBuilder.createStructType(
3113 tunit, typeName.str(), tunit, line,
3114 CGM.getContext().toBits(block.BlockSize),
3115 CGM.getContext().toBits(block.BlockAlign), 0, nullptr, fieldsArray);
3116 type = DBuilder.createPointerType(type, CGM.PointerWidthInBits);
3118 // Get overall information about the block.
3119 unsigned flags = llvm::DINode::FlagArtificial;
3120 auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back());
3122 // Create the descriptor for the parameter.
3123 auto *debugVar = DBuilder.createLocalVariable(
3124 llvm::dwarf::DW_TAG_arg_variable, scope, Arg->getName(), tunit, line,
3125 type, CGM.getLangOpts().Optimize, flags, ArgNo);
3128 // Insert an llvm.dbg.value into the current block.
3129 DBuilder.insertDbgValueIntrinsic(
3130 LocalAddr, 0, debugVar, DBuilder.createExpression(),
3131 llvm::DebugLoc::get(line, column, scope), Builder.GetInsertBlock());
3134 // Insert an llvm.dbg.declare into the current block.
3135 DBuilder.insertDeclare(Arg, debugVar, DBuilder.createExpression(),
3136 llvm::DebugLoc::get(line, column, scope),
3137 Builder.GetInsertBlock());
3140 /// If D is an out-of-class definition of a static data member of a class, find
3141 /// its corresponding in-class declaration.
3142 llvm::DIDerivedType *
3143 CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(const VarDecl *D) {
3144 if (!D->isStaticDataMember())
3147 auto MI = StaticDataMemberCache.find(D->getCanonicalDecl());
3148 if (MI != StaticDataMemberCache.end()) {
3149 assert(MI->second && "Static data member declaration should still exist");
3150 return cast<llvm::DIDerivedType>(MI->second);
3153 // If the member wasn't found in the cache, lazily construct and add it to the
3154 // type (used when a limited form of the type is emitted).
3155 auto DC = D->getDeclContext();
3157 cast<llvm::DICompositeType>(getContextDescriptor(cast<Decl>(DC)));
3158 return CreateRecordStaticField(D, Ctxt, cast<RecordDecl>(DC));
3161 /// Recursively collect all of the member fields of a global anonymous decl and
3162 /// create static variables for them. The first time this is called it needs
3163 /// to be on a union and then from there we can have additional unnamed fields.
3164 llvm::DIGlobalVariable *CGDebugInfo::CollectAnonRecordDecls(
3165 const RecordDecl *RD, llvm::DIFile *Unit, unsigned LineNo,
3166 StringRef LinkageName, llvm::GlobalVariable *Var, llvm::DIScope *DContext) {
3167 llvm::DIGlobalVariable *GV = nullptr;
3169 for (const auto *Field : RD->fields()) {
3170 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
3171 StringRef FieldName = Field->getName();
3173 // Ignore unnamed fields, but recurse into anonymous records.
3174 if (FieldName.empty()) {
3175 const RecordType *RT = dyn_cast<RecordType>(Field->getType());
3177 GV = CollectAnonRecordDecls(RT->getDecl(), Unit, LineNo, LinkageName,
3181 // Use VarDecl's Tag, Scope and Line number.
3182 GV = DBuilder.createGlobalVariable(DContext, FieldName, LinkageName, Unit,
3184 Var->hasInternalLinkage(), Var, nullptr);
3189 /// EmitGlobalVariable - Emit information about a global variable.
3190 void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
3192 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
3193 // Create global variable debug descriptor.
3194 llvm::DIFile *Unit = nullptr;
3195 llvm::DIScope *DContext = nullptr;
3197 StringRef DeclName, LinkageName;
3199 collectVarDeclProps(D, Unit, LineNo, T, DeclName, LinkageName, DContext);
3201 // Attempt to store one global variable for the declaration - even if we
3202 // emit a lot of fields.
3203 llvm::DIGlobalVariable *GV = nullptr;
3205 // If this is an anonymous union then we'll want to emit a global
3206 // variable for each member of the anonymous union so that it's possible
3207 // to find the name of any field in the union.
3208 if (T->isUnionType() && DeclName.empty()) {
3209 const RecordDecl *RD = cast<RecordType>(T)->getDecl();
3210 assert(RD->isAnonymousStructOrUnion() &&
3211 "unnamed non-anonymous struct or union?");
3212 GV = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
3214 GV = DBuilder.createGlobalVariable(
3215 DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit),
3216 Var->hasInternalLinkage(), Var,
3217 getOrCreateStaticDataMemberDeclarationOrNull(D));
3219 DeclCache[D->getCanonicalDecl()].reset(static_cast<llvm::Metadata *>(GV));
3222 /// EmitGlobalVariable - Emit global variable's debug info.
3223 void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD,
3224 llvm::Constant *Init) {
3225 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
3226 // Create the descriptor for the variable.
3227 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
3228 StringRef Name = VD->getName();
3229 llvm::DIType *Ty = getOrCreateType(VD->getType(), Unit);
3230 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(VD)) {
3231 const EnumDecl *ED = cast<EnumDecl>(ECD->getDeclContext());
3232 assert(isa<EnumType>(ED->getTypeForDecl()) && "Enum without EnumType?");
3233 Ty = getOrCreateType(QualType(ED->getTypeForDecl(), 0), Unit);
3235 // Do not use global variables for enums.
3238 if (Ty->getTag() == llvm::dwarf::DW_TAG_enumeration_type)
3240 // Do not emit separate definitions for function local const/statics.
3241 if (isa<FunctionDecl>(VD->getDeclContext()))
3243 VD = cast<ValueDecl>(VD->getCanonicalDecl());
3244 auto *VarD = cast<VarDecl>(VD);
3245 if (VarD->isStaticDataMember()) {
3246 auto *RD = cast<RecordDecl>(VarD->getDeclContext());
3247 getContextDescriptor(RD);
3248 // Ensure that the type is retained even though it's otherwise unreferenced.
3249 RetainedTypes.push_back(
3250 CGM.getContext().getRecordType(RD).getAsOpaquePtr());
3254 llvm::DIScope *DContext =
3255 getContextDescriptor(dyn_cast<Decl>(VD->getDeclContext()));
3257 auto &GV = DeclCache[VD];
3260 GV.reset(DBuilder.createGlobalVariable(
3261 DContext, Name, StringRef(), Unit, getLineNumber(VD->getLocation()), Ty,
3262 true, Init, getOrCreateStaticDataMemberDeclarationOrNull(VarD)));
3265 llvm::DIScope *CGDebugInfo::getCurrentContextDescriptor(const Decl *D) {
3266 if (!LexicalBlockStack.empty())
3267 return LexicalBlockStack.back();
3268 return getContextDescriptor(D);
3271 void CGDebugInfo::EmitUsingDirective(const UsingDirectiveDecl &UD) {
3272 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
3274 DBuilder.createImportedModule(
3275 getCurrentContextDescriptor(cast<Decl>(UD.getDeclContext())),
3276 getOrCreateNameSpace(UD.getNominatedNamespace()),
3277 getLineNumber(UD.getLocation()));
3280 void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) {
3281 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
3283 assert(UD.shadow_size() &&
3284 "We shouldn't be codegening an invalid UsingDecl containing no decls");
3285 // Emitting one decl is sufficient - debuggers can detect that this is an
3286 // overloaded name & provide lookup for all the overloads.
3287 const UsingShadowDecl &USD = **UD.shadow_begin();
3288 if (llvm::DINode *Target =
3289 getDeclarationOrDefinition(USD.getUnderlyingDecl()))
3290 DBuilder.createImportedDeclaration(
3291 getCurrentContextDescriptor(cast<Decl>(USD.getDeclContext())), Target,
3292 getLineNumber(USD.getLocation()));
3295 llvm::DIImportedEntity *
3296 CGDebugInfo::EmitNamespaceAlias(const NamespaceAliasDecl &NA) {
3297 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
3299 auto &VH = NamespaceAliasCache[&NA];
3301 return cast<llvm::DIImportedEntity>(VH);
3302 llvm::DIImportedEntity *R;
3303 if (const NamespaceAliasDecl *Underlying =
3304 dyn_cast<NamespaceAliasDecl>(NA.getAliasedNamespace()))
3305 // This could cache & dedup here rather than relying on metadata deduping.
3306 R = DBuilder.createImportedDeclaration(
3307 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
3308 EmitNamespaceAlias(*Underlying), getLineNumber(NA.getLocation()),
3311 R = DBuilder.createImportedDeclaration(
3312 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
3313 getOrCreateNameSpace(cast<NamespaceDecl>(NA.getAliasedNamespace())),
3314 getLineNumber(NA.getLocation()), NA.getName());
3319 /// getOrCreateNamesSpace - Return namespace descriptor for the given
3322 CGDebugInfo::getOrCreateNameSpace(const NamespaceDecl *NSDecl) {
3323 NSDecl = NSDecl->getCanonicalDecl();
3324 auto I = NameSpaceCache.find(NSDecl);
3325 if (I != NameSpaceCache.end())
3326 return cast<llvm::DINamespace>(I->second);
3328 unsigned LineNo = getLineNumber(NSDecl->getLocation());
3329 llvm::DIFile *FileD = getOrCreateFile(NSDecl->getLocation());
3330 llvm::DIScope *Context =
3331 getContextDescriptor(dyn_cast<Decl>(NSDecl->getDeclContext()));
3332 llvm::DINamespace *NS =
3333 DBuilder.createNameSpace(Context, NSDecl->getName(), FileD, LineNo);
3334 NameSpaceCache[NSDecl].reset(NS);
3338 void CGDebugInfo::finalize() {
3339 // Creating types might create further types - invalidating the current
3340 // element and the size(), so don't cache/reference them.
3341 for (size_t i = 0; i != ObjCInterfaceCache.size(); ++i) {
3342 ObjCInterfaceCacheEntry E = ObjCInterfaceCache[i];
3343 llvm::DIType *Ty = E.Type->getDecl()->getDefinition()
3344 ? CreateTypeDefinition(E.Type, E.Unit)
3346 DBuilder.replaceTemporary(llvm::TempDIType(E.Decl), Ty);
3349 for (auto p : ReplaceMap) {
3351 auto *Ty = cast<llvm::DIType>(p.second);
3352 assert(Ty->isForwardDecl());
3354 auto it = TypeCache.find(p.first);
3355 assert(it != TypeCache.end());
3358 DBuilder.replaceTemporary(llvm::TempDIType(Ty),
3359 cast<llvm::DIType>(it->second));
3362 for (const auto &p : FwdDeclReplaceMap) {
3364 llvm::TempMDNode FwdDecl(cast<llvm::MDNode>(p.second));
3365 llvm::Metadata *Repl;
3367 auto it = DeclCache.find(p.first);
3368 // If there has been no definition for the declaration, call RAUW
3369 // with ourselves, that will destroy the temporary MDNode and
3370 // replace it with a standard one, avoiding leaking memory.
3371 if (it == DeclCache.end())
3376 DBuilder.replaceTemporary(std::move(FwdDecl), cast<llvm::MDNode>(Repl));
3379 // We keep our own list of retained types, because we need to look
3380 // up the final type in the type cache.
3381 for (std::vector<void *>::const_iterator RI = RetainedTypes.begin(),
3382 RE = RetainedTypes.end(); RI != RE; ++RI)
3383 DBuilder.retainType(cast<llvm::DIType>(TypeCache[*RI]));
3385 DBuilder.finalize();
3388 void CGDebugInfo::EmitExplicitCastType(QualType Ty) {
3389 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
3392 if (auto *DieTy = getOrCreateType(Ty, getOrCreateMainFile()))
3393 // Don't ignore in case of explicit cast where it is referenced indirectly.
3394 DBuilder.retainType(DieTy);