Bug Summary

File:tools/clang/lib/CodeGen/CGDebugInfo.cpp
Warning:line 1557, column 40
Called C++ object pointer is null

Annotated Source Code

1//===--- CGDebugInfo.cpp - Emit Debug Information for a Module ------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This coordinates the debug information generation while generating code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CGDebugInfo.h"
15#include "CGBlocks.h"
16#include "CGCXXABI.h"
17#include "CGObjCRuntime.h"
18#include "CGRecordLayout.h"
19#include "CodeGenFunction.h"
20#include "CodeGenModule.h"
21#include "clang/AST/ASTContext.h"
22#include "clang/AST/DeclFriend.h"
23#include "clang/AST/DeclObjC.h"
24#include "clang/AST/DeclTemplate.h"
25#include "clang/AST/Expr.h"
26#include "clang/AST/RecordLayout.h"
27#include "clang/Basic/FileManager.h"
28#include "clang/Basic/SourceManager.h"
29#include "clang/Basic/Version.h"
30#include "clang/Frontend/CodeGenOptions.h"
31#include "clang/Lex/HeaderSearchOptions.h"
32#include "clang/Lex/ModuleMap.h"
33#include "clang/Lex/PreprocessorOptions.h"
34#include "llvm/ADT/DenseSet.h"
35#include "llvm/ADT/SmallVector.h"
36#include "llvm/ADT/StringExtras.h"
37#include "llvm/IR/Constants.h"
38#include "llvm/IR/DataLayout.h"
39#include "llvm/IR/DerivedTypes.h"
40#include "llvm/IR/Instructions.h"
41#include "llvm/IR/Intrinsics.h"
42#include "llvm/IR/Module.h"
43#include "llvm/Support/FileSystem.h"
44#include "llvm/Support/MD5.h"
45#include "llvm/Support/Path.h"
46using namespace clang;
47using namespace clang::CodeGen;
48
49static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx) {
50 auto TI = Ctx.getTypeInfo(Ty);
51 return TI.AlignIsRequired ? TI.Align : 0;
52}
53
54static uint32_t getTypeAlignIfRequired(QualType Ty, const ASTContext &Ctx) {
55 return getTypeAlignIfRequired(Ty.getTypePtr(), Ctx);
56}
57
58static uint32_t getDeclAlignIfRequired(const Decl *D, const ASTContext &Ctx) {
59 return D->hasAttr<AlignedAttr>() ? D->getMaxAlignment() : 0;
60}
61
62CGDebugInfo::CGDebugInfo(CodeGenModule &CGM)
63 : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
64 DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),
65 DBuilder(CGM.getModule()) {
66 for (const auto &KV : CGM.getCodeGenOpts().DebugPrefixMap)
67 DebugPrefixMap[KV.first] = KV.second;
68 CreateCompileUnit();
69}
70
71CGDebugInfo::~CGDebugInfo() {
72 assert(LexicalBlockStack.empty() &&((LexicalBlockStack.empty() && "Region stack mismatch, stack not empty!"
) ? static_cast<void> (0) : __assert_fail ("LexicalBlockStack.empty() && \"Region stack mismatch, stack not empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 73, __PRETTY_FUNCTION__))
73 "Region stack mismatch, stack not empty!")((LexicalBlockStack.empty() && "Region stack mismatch, stack not empty!"
) ? static_cast<void> (0) : __assert_fail ("LexicalBlockStack.empty() && \"Region stack mismatch, stack not empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 73, __PRETTY_FUNCTION__))
;
74}
75
76ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
77 SourceLocation TemporaryLocation)
78 : CGF(&CGF) {
79 init(TemporaryLocation);
80}
81
82ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
83 bool DefaultToEmpty,
84 SourceLocation TemporaryLocation)
85 : CGF(&CGF) {
86 init(TemporaryLocation, DefaultToEmpty);
87}
88
89void ApplyDebugLocation::init(SourceLocation TemporaryLocation,
90 bool DefaultToEmpty) {
91 auto *DI = CGF->getDebugInfo();
92 if (!DI) {
93 CGF = nullptr;
94 return;
95 }
96
97 OriginalLocation = CGF->Builder.getCurrentDebugLocation();
98 if (TemporaryLocation.isValid()) {
99 DI->EmitLocation(CGF->Builder, TemporaryLocation);
100 return;
101 }
102
103 if (DefaultToEmpty) {
104 CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc());
105 return;
106 }
107
108 // Construct a location that has a valid scope, but no line info.
109 assert(!DI->LexicalBlockStack.empty())((!DI->LexicalBlockStack.empty()) ? static_cast<void>
(0) : __assert_fail ("!DI->LexicalBlockStack.empty()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 109, __PRETTY_FUNCTION__))
;
110 CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
111 0, 0, DI->LexicalBlockStack.back(), DI->getInlinedAt()));
112}
113
114ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E)
115 : CGF(&CGF) {
116 init(E->getExprLoc());
117}
118
119ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, llvm::DebugLoc Loc)
120 : CGF(&CGF) {
121 if (!CGF.getDebugInfo()) {
122 this->CGF = nullptr;
123 return;
124 }
125 OriginalLocation = CGF.Builder.getCurrentDebugLocation();
126 if (Loc)
127 CGF.Builder.SetCurrentDebugLocation(std::move(Loc));
128}
129
130ApplyDebugLocation::~ApplyDebugLocation() {
131 // Query CGF so the location isn't overwritten when location updates are
132 // temporarily disabled (for C++ default function arguments)
133 if (CGF)
134 CGF->Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
135}
136
137ApplyInlineDebugLocation::ApplyInlineDebugLocation(CodeGenFunction &CGF,
138 GlobalDecl InlinedFn)
139 : CGF(&CGF) {
140 if (!CGF.getDebugInfo()) {
141 this->CGF = nullptr;
142 return;
143 }
144 auto &DI = *CGF.getDebugInfo();
145 SavedLocation = DI.getLocation();
146 assert((DI.getInlinedAt() ==(((DI.getInlinedAt() == CGF.Builder.getCurrentDebugLocation()
->getInlinedAt()) && "CGDebugInfo and IRBuilder are out of sync"
) ? static_cast<void> (0) : __assert_fail ("(DI.getInlinedAt() == CGF.Builder.getCurrentDebugLocation()->getInlinedAt()) && \"CGDebugInfo and IRBuilder are out of sync\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 148, __PRETTY_FUNCTION__))
147 CGF.Builder.getCurrentDebugLocation()->getInlinedAt()) &&(((DI.getInlinedAt() == CGF.Builder.getCurrentDebugLocation()
->getInlinedAt()) && "CGDebugInfo and IRBuilder are out of sync"
) ? static_cast<void> (0) : __assert_fail ("(DI.getInlinedAt() == CGF.Builder.getCurrentDebugLocation()->getInlinedAt()) && \"CGDebugInfo and IRBuilder are out of sync\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 148, __PRETTY_FUNCTION__))
148 "CGDebugInfo and IRBuilder are out of sync")(((DI.getInlinedAt() == CGF.Builder.getCurrentDebugLocation()
->getInlinedAt()) && "CGDebugInfo and IRBuilder are out of sync"
) ? static_cast<void> (0) : __assert_fail ("(DI.getInlinedAt() == CGF.Builder.getCurrentDebugLocation()->getInlinedAt()) && \"CGDebugInfo and IRBuilder are out of sync\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 148, __PRETTY_FUNCTION__))
;
149
150 DI.EmitInlineFunctionStart(CGF.Builder, InlinedFn);
151}
152
153ApplyInlineDebugLocation::~ApplyInlineDebugLocation() {
154 if (!CGF)
155 return;
156 auto &DI = *CGF->getDebugInfo();
157 DI.EmitInlineFunctionEnd(CGF->Builder);
158 DI.EmitLocation(CGF->Builder, SavedLocation);
159}
160
161void CGDebugInfo::setLocation(SourceLocation Loc) {
162 // If the new location isn't valid return.
163 if (Loc.isInvalid())
164 return;
165
166 CurLoc = CGM.getContext().getSourceManager().getExpansionLoc(Loc);
167
168 // If we've changed files in the middle of a lexical scope go ahead
169 // and create a new lexical scope with file node if it's different
170 // from the one in the scope.
171 if (LexicalBlockStack.empty())
172 return;
173
174 SourceManager &SM = CGM.getContext().getSourceManager();
175 auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
176 PresumedLoc PCLoc = SM.getPresumedLoc(CurLoc);
177
178 if (PCLoc.isInvalid() || Scope->getFilename() == PCLoc.getFilename())
179 return;
180
181 if (auto *LBF = dyn_cast<llvm::DILexicalBlockFile>(Scope)) {
182 LexicalBlockStack.pop_back();
183 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlockFile(
184 LBF->getScope(), getOrCreateFile(CurLoc)));
185 } else if (isa<llvm::DILexicalBlock>(Scope) ||
186 isa<llvm::DISubprogram>(Scope)) {
187 LexicalBlockStack.pop_back();
188 LexicalBlockStack.emplace_back(
189 DBuilder.createLexicalBlockFile(Scope, getOrCreateFile(CurLoc)));
190 }
191}
192
193llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(const Decl *D) {
194 llvm::DIScope *Mod = getParentModuleOrNull(D);
195 return getContextDescriptor(cast<Decl>(D->getDeclContext()),
196 Mod ? Mod : TheCU);
197}
198
199llvm::DIScope *CGDebugInfo::getContextDescriptor(const Decl *Context,
200 llvm::DIScope *Default) {
201 if (!Context)
202 return Default;
203
204 auto I = RegionMap.find(Context);
205 if (I != RegionMap.end()) {
206 llvm::Metadata *V = I->second;
207 return dyn_cast_or_null<llvm::DIScope>(V);
208 }
209
210 // Check namespace.
211 if (const auto *NSDecl = dyn_cast<NamespaceDecl>(Context))
212 return getOrCreateNamespace(NSDecl);
213
214 if (const auto *RDecl = dyn_cast<RecordDecl>(Context))
215 if (!RDecl->isDependentType())
216 return getOrCreateType(CGM.getContext().getTypeDeclType(RDecl),
217 getOrCreateMainFile());
218 return Default;
219}
220
221StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) {
222 assert(FD && "Invalid FunctionDecl!")((FD && "Invalid FunctionDecl!") ? static_cast<void
> (0) : __assert_fail ("FD && \"Invalid FunctionDecl!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 222, __PRETTY_FUNCTION__))
;
223 IdentifierInfo *FII = FD->getIdentifier();
224 FunctionTemplateSpecializationInfo *Info =
225 FD->getTemplateSpecializationInfo();
226
227 // Emit the unqualified name in normal operation. LLVM and the debugger can
228 // compute the fully qualified name from the scope chain. If we're only
229 // emitting line table info, there won't be any scope chains, so emit the
230 // fully qualified name here so that stack traces are more accurate.
231 // FIXME: Do this when emitting DWARF as well as when emitting CodeView after
232 // evaluating the size impact.
233 bool UseQualifiedName = DebugKind == codegenoptions::DebugLineTablesOnly &&
234 CGM.getCodeGenOpts().EmitCodeView;
235
236 if (!Info && FII && !UseQualifiedName)
237 return FII->getName();
238
239 SmallString<128> NS;
240 llvm::raw_svector_ostream OS(NS);
241 PrintingPolicy Policy(CGM.getLangOpts());
242 Policy.MSVCFormatting = CGM.getCodeGenOpts().EmitCodeView;
243 if (!UseQualifiedName)
244 FD->printName(OS);
245 else
246 FD->printQualifiedName(OS, Policy);
247
248 // Add any template specialization args.
249 if (Info) {
250 const TemplateArgumentList *TArgs = Info->TemplateArguments;
251 TemplateSpecializationType::PrintTemplateArgumentList(OS, TArgs->asArray(),
252 Policy);
253 }
254
255 // Copy this name on the side and use its reference.
256 return internString(OS.str());
257}
258
259StringRef CGDebugInfo::getObjCMethodName(const ObjCMethodDecl *OMD) {
260 SmallString<256> MethodName;
261 llvm::raw_svector_ostream OS(MethodName);
262 OS << (OMD->isInstanceMethod() ? '-' : '+') << '[';
263 const DeclContext *DC = OMD->getDeclContext();
264 if (const auto *OID = dyn_cast<ObjCImplementationDecl>(DC)) {
265 OS << OID->getName();
266 } else if (const auto *OID = dyn_cast<ObjCInterfaceDecl>(DC)) {
267 OS << OID->getName();
268 } else if (const auto *OC = dyn_cast<ObjCCategoryDecl>(DC)) {
269 if (OC->IsClassExtension()) {
270 OS << OC->getClassInterface()->getName();
271 } else {
272 OS << OC->getIdentifier()->getNameStart() << '('
273 << OC->getIdentifier()->getNameStart() << ')';
274 }
275 } else if (const auto *OCD = dyn_cast<ObjCCategoryImplDecl>(DC)) {
276 OS << OCD->getClassInterface()->getName() << '('
277 << OCD->getName() << ')';
278 } else if (isa<ObjCProtocolDecl>(DC)) {
279 // We can extract the type of the class from the self pointer.
280 if (ImplicitParamDecl *SelfDecl = OMD->getSelfDecl()) {
281 QualType ClassTy =
282 cast<ObjCObjectPointerType>(SelfDecl->getType())->getPointeeType();
283 ClassTy.print(OS, PrintingPolicy(LangOptions()));
284 }
285 }
286 OS << ' ' << OMD->getSelector().getAsString() << ']';
287
288 return internString(OS.str());
289}
290
291StringRef CGDebugInfo::getSelectorName(Selector S) {
292 return internString(S.getAsString());
293}
294
295StringRef CGDebugInfo::getClassName(const RecordDecl *RD) {
296 if (isa<ClassTemplateSpecializationDecl>(RD)) {
297 SmallString<128> Name;
298 llvm::raw_svector_ostream OS(Name);
299 RD->getNameForDiagnostic(OS, CGM.getContext().getPrintingPolicy(),
300 /*Qualified*/ false);
301
302 // Copy this name on the side and use its reference.
303 return internString(Name);
304 }
305
306 // quick optimization to avoid having to intern strings that are already
307 // stored reliably elsewhere
308 if (const IdentifierInfo *II = RD->getIdentifier())
309 return II->getName();
310
311 // The CodeView printer in LLVM wants to see the names of unnamed types: it is
312 // used to reconstruct the fully qualified type names.
313 if (CGM.getCodeGenOpts().EmitCodeView) {
314 if (const TypedefNameDecl *D = RD->getTypedefNameForAnonDecl()) {
315 assert(RD->getDeclContext() == D->getDeclContext() &&((RD->getDeclContext() == D->getDeclContext() &&
"Typedef should not be in another decl context!") ? static_cast
<void> (0) : __assert_fail ("RD->getDeclContext() == D->getDeclContext() && \"Typedef should not be in another decl context!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 316, __PRETTY_FUNCTION__))
316 "Typedef should not be in another decl context!")((RD->getDeclContext() == D->getDeclContext() &&
"Typedef should not be in another decl context!") ? static_cast
<void> (0) : __assert_fail ("RD->getDeclContext() == D->getDeclContext() && \"Typedef should not be in another decl context!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 316, __PRETTY_FUNCTION__))
;
317 assert(D->getDeclName().getAsIdentifierInfo() &&((D->getDeclName().getAsIdentifierInfo() && "Typedef was not named!"
) ? static_cast<void> (0) : __assert_fail ("D->getDeclName().getAsIdentifierInfo() && \"Typedef was not named!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 318, __PRETTY_FUNCTION__))
318 "Typedef was not named!")((D->getDeclName().getAsIdentifierInfo() && "Typedef was not named!"
) ? static_cast<void> (0) : __assert_fail ("D->getDeclName().getAsIdentifierInfo() && \"Typedef was not named!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 318, __PRETTY_FUNCTION__))
;
319 return D->getDeclName().getAsIdentifierInfo()->getName();
320 }
321
322 if (CGM.getLangOpts().CPlusPlus) {
323 StringRef Name;
324
325 ASTContext &Context = CGM.getContext();
326 if (const DeclaratorDecl *DD = Context.getDeclaratorForUnnamedTagDecl(RD))
327 // Anonymous types without a name for linkage purposes have their
328 // declarator mangled in if they have one.
329 Name = DD->getName();
330 else if (const TypedefNameDecl *TND =
331 Context.getTypedefNameForUnnamedTagDecl(RD))
332 // Anonymous types without a name for linkage purposes have their
333 // associate typedef mangled in if they have one.
334 Name = TND->getName();
335
336 if (!Name.empty()) {
337 SmallString<256> UnnamedType("<unnamed-type-");
338 UnnamedType += Name;
339 UnnamedType += '>';
340 return internString(UnnamedType);
341 }
342 }
343 }
344
345 return StringRef();
346}
347
348llvm::DIFile::ChecksumKind
349CGDebugInfo::computeChecksum(FileID FID, SmallString<32> &Checksum) const {
350 Checksum.clear();
351
352 if (!CGM.getCodeGenOpts().EmitCodeView)
353 return llvm::DIFile::CSK_None;
354
355 SourceManager &SM = CGM.getContext().getSourceManager();
356 bool Invalid;
357 llvm::MemoryBuffer *MemBuffer = SM.getBuffer(FID, &Invalid);
358 if (Invalid)
359 return llvm::DIFile::CSK_None;
360
361 llvm::MD5 Hash;
362 llvm::MD5::MD5Result Result;
363
364 Hash.update(MemBuffer->getBuffer());
365 Hash.final(Result);
366
367 Hash.stringifyResult(Result, Checksum);
368 return llvm::DIFile::CSK_MD5;
369}
370
371llvm::DIFile *CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
372 if (!Loc.isValid())
373 // If Location is not valid then use main input file.
374 return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
375 remapDIPath(TheCU->getDirectory()),
376 TheCU->getFile()->getChecksumKind(),
377 TheCU->getFile()->getChecksum());
378
379 SourceManager &SM = CGM.getContext().getSourceManager();
380 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
381
382 if (PLoc.isInvalid() || StringRef(PLoc.getFilename()).empty())
383 // If the location is not valid then use main input file.
384 return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
385 remapDIPath(TheCU->getDirectory()),
386 TheCU->getFile()->getChecksumKind(),
387 TheCU->getFile()->getChecksum());
388
389 // Cache the results.
390 const char *fname = PLoc.getFilename();
391 auto it = DIFileCache.find(fname);
392
393 if (it != DIFileCache.end()) {
394 // Verify that the information still exists.
395 if (llvm::Metadata *V = it->second)
396 return cast<llvm::DIFile>(V);
397 }
398
399 SmallString<32> Checksum;
400 llvm::DIFile::ChecksumKind CSKind =
401 computeChecksum(SM.getFileID(Loc), Checksum);
402
403 llvm::DIFile *F = DBuilder.createFile(remapDIPath(PLoc.getFilename()),
404 remapDIPath(getCurrentDirname()),
405 CSKind, Checksum);
406
407 DIFileCache[fname].reset(F);
408 return F;
409}
410
411llvm::DIFile *CGDebugInfo::getOrCreateMainFile() {
412 return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
413 remapDIPath(TheCU->getDirectory()),
414 TheCU->getFile()->getChecksumKind(),
415 TheCU->getFile()->getChecksum());
416}
417
418std::string CGDebugInfo::remapDIPath(StringRef Path) const {
419 for (const auto &Entry : DebugPrefixMap)
420 if (Path.startswith(Entry.first))
421 return (Twine(Entry.second) + Path.substr(Entry.first.size())).str();
422 return Path.str();
423}
424
425unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) {
426 if (Loc.isInvalid() && CurLoc.isInvalid())
427 return 0;
428 SourceManager &SM = CGM.getContext().getSourceManager();
429 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
430 return PLoc.isValid() ? PLoc.getLine() : 0;
431}
432
433unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc, bool Force) {
434 // We may not want column information at all.
435 if (!Force && !CGM.getCodeGenOpts().DebugColumnInfo)
436 return 0;
437
438 // If the location is invalid then use the current column.
439 if (Loc.isInvalid() && CurLoc.isInvalid())
440 return 0;
441 SourceManager &SM = CGM.getContext().getSourceManager();
442 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
443 return PLoc.isValid() ? PLoc.getColumn() : 0;
444}
445
446StringRef CGDebugInfo::getCurrentDirname() {
447 if (!CGM.getCodeGenOpts().DebugCompilationDir.empty())
448 return CGM.getCodeGenOpts().DebugCompilationDir;
449
450 if (!CWDName.empty())
451 return CWDName;
452 SmallString<256> CWD;
453 llvm::sys::fs::current_path(CWD);
454 return CWDName = internString(CWD);
455}
456
457void CGDebugInfo::CreateCompileUnit() {
458 SmallString<32> Checksum;
459 llvm::DIFile::ChecksumKind CSKind = llvm::DIFile::CSK_None;
460
461 // Should we be asking the SourceManager for the main file name, instead of
462 // accepting it as an argument? This just causes the main file name to
463 // mismatch with source locations and create extra lexical scopes or
464 // mismatched debug info (a CU with a DW_AT_file of "-", because that's what
465 // the driver passed, but functions/other things have DW_AT_file of "<stdin>"
466 // because that's what the SourceManager says)
467
468 // Get absolute path name.
469 SourceManager &SM = CGM.getContext().getSourceManager();
470 std::string MainFileName = CGM.getCodeGenOpts().MainFileName;
471 if (MainFileName.empty())
472 MainFileName = "<stdin>";
473
474 // The main file name provided via the "-main-file-name" option contains just
475 // the file name itself with no path information. This file name may have had
476 // a relative path, so we look into the actual file entry for the main
477 // file to determine the real absolute path for the file.
478 std::string MainFileDir;
479 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
480 MainFileDir = remapDIPath(MainFile->getDir()->getName());
481 if (MainFileDir != ".") {
482 llvm::SmallString<1024> MainFileDirSS(MainFileDir);
483 llvm::sys::path::append(MainFileDirSS, MainFileName);
484 MainFileName = MainFileDirSS.str();
485 }
486 CSKind = computeChecksum(SM.getMainFileID(), Checksum);
487 }
488
489 llvm::dwarf::SourceLanguage LangTag;
490 const LangOptions &LO = CGM.getLangOpts();
491 if (LO.CPlusPlus) {
492 if (LO.ObjC1)
493 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
494 else
495 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
496 } else if (LO.ObjC1) {
497 LangTag = llvm::dwarf::DW_LANG_ObjC;
498 } else if (LO.RenderScript) {
499 LangTag = llvm::dwarf::DW_LANG_GOOGLE_RenderScript;
500 } else if (LO.C99) {
501 LangTag = llvm::dwarf::DW_LANG_C99;
502 } else {
503 LangTag = llvm::dwarf::DW_LANG_C89;
504 }
505
506 std::string Producer = getClangFullVersion();
507
508 // Figure out which version of the ObjC runtime we have.
509 unsigned RuntimeVers = 0;
510 if (LO.ObjC1)
511 RuntimeVers = LO.ObjCRuntime.isNonFragile() ? 2 : 1;
512
513 llvm::DICompileUnit::DebugEmissionKind EmissionKind;
514 switch (DebugKind) {
515 case codegenoptions::NoDebugInfo:
516 case codegenoptions::LocTrackingOnly:
517 EmissionKind = llvm::DICompileUnit::NoDebug;
518 break;
519 case codegenoptions::DebugLineTablesOnly:
520 EmissionKind = llvm::DICompileUnit::LineTablesOnly;
521 break;
522 case codegenoptions::LimitedDebugInfo:
523 case codegenoptions::FullDebugInfo:
524 EmissionKind = llvm::DICompileUnit::FullDebug;
525 break;
526 }
527
528 // Create new compile unit.
529 // FIXME - Eliminate TheCU.
530 TheCU = DBuilder.createCompileUnit(
531 LangTag,
532 DBuilder.createFile(remapDIPath(MainFileName),
533 remapDIPath(getCurrentDirname()), CSKind, Checksum),
534 Producer, LO.Optimize, CGM.getCodeGenOpts().DwarfDebugFlags, RuntimeVers,
535 CGM.getCodeGenOpts().EnableSplitDwarf
536 ? ""
537 : CGM.getCodeGenOpts().SplitDwarfFile,
538 EmissionKind, 0 /* DWOid */, CGM.getCodeGenOpts().SplitDwarfInlining,
539 CGM.getCodeGenOpts().DebugInfoForProfiling);
540}
541
542llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
543 llvm::dwarf::TypeKind Encoding;
544 StringRef BTName;
545 switch (BT->getKind()) {
546#define BUILTIN_TYPE(Id, SingletonId)
547#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
548#include "clang/AST/BuiltinTypes.def"
549 case BuiltinType::Dependent:
550 llvm_unreachable("Unexpected builtin type")::llvm::llvm_unreachable_internal("Unexpected builtin type", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 550)
;
551 case BuiltinType::NullPtr:
552 return DBuilder.createNullPtrType();
553 case BuiltinType::Void:
554 return nullptr;
555 case BuiltinType::ObjCClass:
556 if (!ClassTy)
557 ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
558 "objc_class", TheCU,
559 getOrCreateMainFile(), 0);
560 return ClassTy;
561 case BuiltinType::ObjCId: {
562 // typedef struct objc_class *Class;
563 // typedef struct objc_object {
564 // Class isa;
565 // } *id;
566
567 if (ObjTy)
568 return ObjTy;
569
570 if (!ClassTy)
571 ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
572 "objc_class", TheCU,
573 getOrCreateMainFile(), 0);
574
575 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
576
577 auto *ISATy = DBuilder.createPointerType(ClassTy, Size);
578
579 ObjTy = DBuilder.createStructType(
580 TheCU, "objc_object", getOrCreateMainFile(), 0, 0, 0,
581 llvm::DINode::FlagZero, nullptr, llvm::DINodeArray());
582
583 DBuilder.replaceArrays(
584 ObjTy, DBuilder.getOrCreateArray(&*DBuilder.createMemberType(
585 ObjTy, "isa", getOrCreateMainFile(), 0, Size, 0, 0,
586 llvm::DINode::FlagZero, ISATy)));
587 return ObjTy;
588 }
589 case BuiltinType::ObjCSel: {
590 if (!SelTy)
591 SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
592 "objc_selector", TheCU,
593 getOrCreateMainFile(), 0);
594 return SelTy;
595 }
596
597#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
598 case BuiltinType::Id: \
599 return getOrCreateStructPtrType("opencl_" #ImgType "_" #Suffix "_t", \
600 SingletonId);
601#include "clang/Basic/OpenCLImageTypes.def"
602 case BuiltinType::OCLSampler:
603 return getOrCreateStructPtrType("opencl_sampler_t",
604 OCLSamplerDITy);
605 case BuiltinType::OCLEvent:
606 return getOrCreateStructPtrType("opencl_event_t", OCLEventDITy);
607 case BuiltinType::OCLClkEvent:
608 return getOrCreateStructPtrType("opencl_clk_event_t", OCLClkEventDITy);
609 case BuiltinType::OCLQueue:
610 return getOrCreateStructPtrType("opencl_queue_t", OCLQueueDITy);
611 case BuiltinType::OCLReserveID:
612 return getOrCreateStructPtrType("opencl_reserve_id_t", OCLReserveIDDITy);
613
614 case BuiltinType::UChar:
615 case BuiltinType::Char_U:
616 Encoding = llvm::dwarf::DW_ATE_unsigned_char;
617 break;
618 case BuiltinType::Char_S:
619 case BuiltinType::SChar:
620 Encoding = llvm::dwarf::DW_ATE_signed_char;
621 break;
622 case BuiltinType::Char16:
623 case BuiltinType::Char32:
624 Encoding = llvm::dwarf::DW_ATE_UTF;
625 break;
626 case BuiltinType::UShort:
627 case BuiltinType::UInt:
628 case BuiltinType::UInt128:
629 case BuiltinType::ULong:
630 case BuiltinType::WChar_U:
631 case BuiltinType::ULongLong:
632 Encoding = llvm::dwarf::DW_ATE_unsigned;
633 break;
634 case BuiltinType::Short:
635 case BuiltinType::Int:
636 case BuiltinType::Int128:
637 case BuiltinType::Long:
638 case BuiltinType::WChar_S:
639 case BuiltinType::LongLong:
640 Encoding = llvm::dwarf::DW_ATE_signed;
641 break;
642 case BuiltinType::Bool:
643 Encoding = llvm::dwarf::DW_ATE_boolean;
644 break;
645 case BuiltinType::Half:
646 case BuiltinType::Float:
647 case BuiltinType::LongDouble:
648 case BuiltinType::Float128:
649 case BuiltinType::Double:
650 // FIXME: For targets where long double and __float128 have the same size,
651 // they are currently indistinguishable in the debugger without some
652 // special treatment. However, there is currently no consensus on encoding
653 // and this should be updated once a DWARF encoding exists for distinct
654 // floating point types of the same size.
655 Encoding = llvm::dwarf::DW_ATE_float;
656 break;
657 }
658
659 switch (BT->getKind()) {
660 case BuiltinType::Long:
661 BTName = "long int";
662 break;
663 case BuiltinType::LongLong:
664 BTName = "long long int";
665 break;
666 case BuiltinType::ULong:
667 BTName = "long unsigned int";
668 break;
669 case BuiltinType::ULongLong:
670 BTName = "long long unsigned int";
671 break;
672 default:
673 BTName = BT->getName(CGM.getLangOpts());
674 break;
675 }
676 // Bit size and offset of the type.
677 uint64_t Size = CGM.getContext().getTypeSize(BT);
678 return DBuilder.createBasicType(BTName, Size, Encoding);
679}
680
681llvm::DIType *CGDebugInfo::CreateType(const ComplexType *Ty) {
682 // Bit size and offset of the type.
683 llvm::dwarf::TypeKind Encoding = llvm::dwarf::DW_ATE_complex_float;
684 if (Ty->isComplexIntegerType())
685 Encoding = llvm::dwarf::DW_ATE_lo_user;
686
687 uint64_t Size = CGM.getContext().getTypeSize(Ty);
688 return DBuilder.createBasicType("complex", Size, Encoding);
689}
690
691llvm::DIType *CGDebugInfo::CreateQualifiedType(QualType Ty,
692 llvm::DIFile *Unit) {
693 QualifierCollector Qc;
694 const Type *T = Qc.strip(Ty);
695
696 // Ignore these qualifiers for now.
697 Qc.removeObjCGCAttr();
698 Qc.removeAddressSpace();
699 Qc.removeObjCLifetime();
700
701 // We will create one Derived type for one qualifier and recurse to handle any
702 // additional ones.
703 llvm::dwarf::Tag Tag;
704 if (Qc.hasConst()) {
705 Tag = llvm::dwarf::DW_TAG_const_type;
706 Qc.removeConst();
707 } else if (Qc.hasVolatile()) {
708 Tag = llvm::dwarf::DW_TAG_volatile_type;
709 Qc.removeVolatile();
710 } else if (Qc.hasRestrict()) {
711 Tag = llvm::dwarf::DW_TAG_restrict_type;
712 Qc.removeRestrict();
713 } else {
714 assert(Qc.empty() && "Unknown type qualifier for debug info")((Qc.empty() && "Unknown type qualifier for debug info"
) ? static_cast<void> (0) : __assert_fail ("Qc.empty() && \"Unknown type qualifier for debug info\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 714, __PRETTY_FUNCTION__))
;
715 return getOrCreateType(QualType(T, 0), Unit);
716 }
717
718 auto *FromTy = getOrCreateType(Qc.apply(CGM.getContext(), T), Unit);
719
720 // No need to fill in the Name, Line, Size, Alignment, Offset in case of
721 // CVR derived types.
722 return DBuilder.createQualifiedType(Tag, FromTy);
723}
724
725llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty,
726 llvm::DIFile *Unit) {
727
728 // The frontend treats 'id' as a typedef to an ObjCObjectType,
729 // whereas 'id<protocol>' is treated as an ObjCPointerType. For the
730 // debug info, we want to emit 'id' in both cases.
731 if (Ty->isObjCQualifiedIdType())
732 return getOrCreateType(CGM.getContext().getObjCIdType(), Unit);
733
734 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
735 Ty->getPointeeType(), Unit);
736}
737
738llvm::DIType *CGDebugInfo::CreateType(const PointerType *Ty,
739 llvm::DIFile *Unit) {
740 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
741 Ty->getPointeeType(), Unit);
742}
743
744/// \return whether a C++ mangling exists for the type defined by TD.
745static bool hasCXXMangling(const TagDecl *TD, llvm::DICompileUnit *TheCU) {
746 switch (TheCU->getSourceLanguage()) {
747 case llvm::dwarf::DW_LANG_C_plus_plus:
748 return true;
749 case llvm::dwarf::DW_LANG_ObjC_plus_plus:
750 return isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD);
751 default:
752 return false;
753 }
754}
755
756/// In C++ mode, types have linkage, so we can rely on the ODR and
757/// on their mangled names, if they're external.
758static SmallString<256> getUniqueTagTypeName(const TagType *Ty,
759 CodeGenModule &CGM,
760 llvm::DICompileUnit *TheCU) {
761 SmallString<256> FullName;
762 const TagDecl *TD = Ty->getDecl();
763
764 if (!hasCXXMangling(TD, TheCU) || !TD->isExternallyVisible())
765 return FullName;
766
767 // TODO: This is using the RTTI name. Is there a better way to get
768 // a unique string for a type?
769 llvm::raw_svector_ostream Out(FullName);
770 CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(QualType(Ty, 0), Out);
771 return FullName;
772}
773
774/// \return the approproate DWARF tag for a composite type.
775static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD) {
776 llvm::dwarf::Tag Tag;
777 if (RD->isStruct() || RD->isInterface())
778 Tag = llvm::dwarf::DW_TAG_structure_type;
779 else if (RD->isUnion())
780 Tag = llvm::dwarf::DW_TAG_union_type;
781 else {
782 // FIXME: This could be a struct type giving a default visibility different
783 // than C++ class type, but needs llvm metadata changes first.
784 assert(RD->isClass())((RD->isClass()) ? static_cast<void> (0) : __assert_fail
("RD->isClass()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 784, __PRETTY_FUNCTION__))
;
785 Tag = llvm::dwarf::DW_TAG_class_type;
786 }
787 return Tag;
788}
789
790llvm::DICompositeType *
791CGDebugInfo::getOrCreateRecordFwdDecl(const RecordType *Ty,
792 llvm::DIScope *Ctx) {
793 const RecordDecl *RD = Ty->getDecl();
794 if (llvm::DIType *T = getTypeOrNull(CGM.getContext().getRecordType(RD)))
795 return cast<llvm::DICompositeType>(T);
796 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
797 unsigned Line = getLineNumber(RD->getLocation());
798 StringRef RDName = getClassName(RD);
799
800 uint64_t Size = 0;
801 uint32_t Align = 0;
802
803 // Create the type.
804 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
805 llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
806 getTagForRecord(RD), RDName, Ctx, DefUnit, Line, 0, Size, Align,
807 llvm::DINode::FlagFwdDecl, FullName);
808 ReplaceMap.emplace_back(
809 std::piecewise_construct, std::make_tuple(Ty),
810 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
811 return RetTy;
812}
813
814llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
815 const Type *Ty,
816 QualType PointeeTy,
817 llvm::DIFile *Unit) {
818 // Bit size, align and offset of the type.
819 // Size is always the size of a pointer. We can't use getTypeSize here
820 // because that does not return the correct value for references.
821 unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(PointeeTy);
822 uint64_t Size = CGM.getTarget().getPointerWidth(AddressSpace);
823 auto Align = getTypeAlignIfRequired(Ty, CGM.getContext());
824 Optional<unsigned> DWARFAddressSpace =
825 CGM.getTarget().getDWARFAddressSpace(AddressSpace);
826
827 if (Tag == llvm::dwarf::DW_TAG_reference_type ||
828 Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)
829 return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit),
830 Size, Align, DWARFAddressSpace);
831 else
832 return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
833 Align, DWARFAddressSpace);
834}
835
836llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
837 llvm::DIType *&Cache) {
838 if (Cache)
839 return Cache;
840 Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
841 TheCU, getOrCreateMainFile(), 0);
842 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
843 Cache = DBuilder.createPointerType(Cache, Size);
844 return Cache;
845}
846
847llvm::DIType *CGDebugInfo::CreateType(const BlockPointerType *Ty,
848 llvm::DIFile *Unit) {
849 SmallVector<llvm::Metadata *, 8> EltTys;
850 QualType FType;
851 uint64_t FieldSize, FieldOffset;
852 uint32_t FieldAlign;
853 llvm::DINodeArray Elements;
854
855 FieldOffset = 0;
856 FType = CGM.getContext().UnsignedLongTy;
857 EltTys.push_back(CreateMemberType(Unit, FType, "reserved", &FieldOffset));
858 EltTys.push_back(CreateMemberType(Unit, FType, "Size", &FieldOffset));
859
860 Elements = DBuilder.getOrCreateArray(EltTys);
861 EltTys.clear();
862
863 llvm::DINode::DIFlags Flags = llvm::DINode::FlagAppleBlock;
864 unsigned LineNo = 0;
865
866 auto *EltTy =
867 DBuilder.createStructType(Unit, "__block_descriptor", nullptr, LineNo,
868 FieldOffset, 0, Flags, nullptr, Elements);
869
870 // Bit size, align and offset of the type.
871 uint64_t Size = CGM.getContext().getTypeSize(Ty);
872
873 auto *DescTy = DBuilder.createPointerType(EltTy, Size);
874
875 FieldOffset = 0;
876 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
877 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
878 FType = CGM.getContext().IntTy;
879 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
880 EltTys.push_back(CreateMemberType(Unit, FType, "__reserved", &FieldOffset));
881 FType = CGM.getContext().getPointerType(Ty->getPointeeType());
882 EltTys.push_back(CreateMemberType(Unit, FType, "__FuncPtr", &FieldOffset));
883
884 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
885 FieldSize = CGM.getContext().getTypeSize(Ty);
886 FieldAlign = CGM.getContext().getTypeAlign(Ty);
887 EltTys.push_back(DBuilder.createMemberType(
888 Unit, "__descriptor", nullptr, LineNo, FieldSize, FieldAlign, FieldOffset,
889 llvm::DINode::FlagZero, DescTy));
890
891 FieldOffset += FieldSize;
892 Elements = DBuilder.getOrCreateArray(EltTys);
893
894 // The __block_literal_generic structs are marked with a special
895 // DW_AT_APPLE_BLOCK attribute and are an implementation detail only
896 // the debugger needs to know about. To allow type uniquing, emit
897 // them without a name or a location.
898 EltTy =
899 DBuilder.createStructType(Unit, "", nullptr, LineNo,
900 FieldOffset, 0, Flags, nullptr, Elements);
901
902 return DBuilder.createPointerType(EltTy, Size);
903}
904
905llvm::DIType *CGDebugInfo::CreateType(const TemplateSpecializationType *Ty,
906 llvm::DIFile *Unit) {
907 assert(Ty->isTypeAlias())((Ty->isTypeAlias()) ? static_cast<void> (0) : __assert_fail
("Ty->isTypeAlias()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 907, __PRETTY_FUNCTION__))
;
908 llvm::DIType *Src = getOrCreateType(Ty->getAliasedType(), Unit);
909
910 SmallString<128> NS;
911 llvm::raw_svector_ostream OS(NS);
912 Ty->getTemplateName().print(OS, CGM.getContext().getPrintingPolicy(),
913 /*qualified*/ false);
914
915 TemplateSpecializationType::PrintTemplateArgumentList(
916 OS, Ty->template_arguments(),
917 CGM.getContext().getPrintingPolicy());
918
919 auto *AliasDecl = cast<TypeAliasTemplateDecl>(
920 Ty->getTemplateName().getAsTemplateDecl())->getTemplatedDecl();
921
922 SourceLocation Loc = AliasDecl->getLocation();
923 return DBuilder.createTypedef(Src, OS.str(), getOrCreateFile(Loc),
924 getLineNumber(Loc),
925 getDeclContextDescriptor(AliasDecl));
926}
927
928llvm::DIType *CGDebugInfo::CreateType(const TypedefType *Ty,
929 llvm::DIFile *Unit) {
930 // We don't set size information, but do specify where the typedef was
931 // declared.
932 SourceLocation Loc = Ty->getDecl()->getLocation();
933
934 // Typedefs are derived from some other type.
935 return DBuilder.createTypedef(
936 getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit),
937 Ty->getDecl()->getName(), getOrCreateFile(Loc), getLineNumber(Loc),
938 getDeclContextDescriptor(Ty->getDecl()));
939}
940
941static unsigned getDwarfCC(CallingConv CC) {
942 switch (CC) {
943 case CC_C:
944 // Avoid emitting DW_AT_calling_convention if the C convention was used.
945 return 0;
946
947 case CC_X86StdCall:
948 return llvm::dwarf::DW_CC_BORLAND_stdcall;
949 case CC_X86FastCall:
950 return llvm::dwarf::DW_CC_BORLAND_msfastcall;
951 case CC_X86ThisCall:
952 return llvm::dwarf::DW_CC_BORLAND_thiscall;
953 case CC_X86VectorCall:
954 return llvm::dwarf::DW_CC_LLVM_vectorcall;
955 case CC_X86Pascal:
956 return llvm::dwarf::DW_CC_BORLAND_pascal;
957
958 // FIXME: Create new DW_CC_ codes for these calling conventions.
959 case CC_X86_64Win64:
960 case CC_X86_64SysV:
961 case CC_AAPCS:
962 case CC_AAPCS_VFP:
963 case CC_IntelOclBicc:
964 case CC_SpirFunction:
965 case CC_OpenCLKernel:
966 case CC_Swift:
967 case CC_PreserveMost:
968 case CC_PreserveAll:
969 case CC_X86RegCall:
970 return 0;
971 }
972 return 0;
973}
974
975llvm::DIType *CGDebugInfo::CreateType(const FunctionType *Ty,
976 llvm::DIFile *Unit) {
977 SmallVector<llvm::Metadata *, 16> EltTys;
978
979 // Add the result type at least.
980 EltTys.push_back(getOrCreateType(Ty->getReturnType(), Unit));
981
982 // Set up remainder of arguments if there is a prototype.
983 // otherwise emit it as a variadic function.
984 if (isa<FunctionNoProtoType>(Ty))
985 EltTys.push_back(DBuilder.createUnspecifiedParameter());
986 else if (const auto *FPT = dyn_cast<FunctionProtoType>(Ty)) {
987 for (const QualType &ParamType : FPT->param_types())
988 EltTys.push_back(getOrCreateType(ParamType, Unit));
989 if (FPT->isVariadic())
990 EltTys.push_back(DBuilder.createUnspecifiedParameter());
991 }
992
993 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
994 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
995 getDwarfCC(Ty->getCallConv()));
996}
997
998/// Convert an AccessSpecifier into the corresponding DINode flag.
999/// As an optimization, return 0 if the access specifier equals the
1000/// default for the containing type.
1001static llvm::DINode::DIFlags getAccessFlag(AccessSpecifier Access,
1002 const RecordDecl *RD) {
1003 AccessSpecifier Default = clang::AS_none;
1004 if (RD && RD->isClass())
1005 Default = clang::AS_private;
1006 else if (RD && (RD->isStruct() || RD->isUnion()))
1007 Default = clang::AS_public;
1008
1009 if (Access == Default)
1010 return llvm::DINode::FlagZero;
1011
1012 switch (Access) {
1013 case clang::AS_private:
1014 return llvm::DINode::FlagPrivate;
1015 case clang::AS_protected:
1016 return llvm::DINode::FlagProtected;
1017 case clang::AS_public:
1018 return llvm::DINode::FlagPublic;
1019 case clang::AS_none:
1020 return llvm::DINode::FlagZero;
1021 }
1022 llvm_unreachable("unexpected access enumerator")::llvm::llvm_unreachable_internal("unexpected access enumerator"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1022)
;
1023}
1024
1025llvm::DIType *CGDebugInfo::createBitFieldType(const FieldDecl *BitFieldDecl,
1026 llvm::DIScope *RecordTy,
1027 const RecordDecl *RD) {
1028 StringRef Name = BitFieldDecl->getName();
1029 QualType Ty = BitFieldDecl->getType();
1030 SourceLocation Loc = BitFieldDecl->getLocation();
1031 llvm::DIFile *VUnit = getOrCreateFile(Loc);
1032 llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);
1033
1034 // Get the location for the field.
1035 llvm::DIFile *File = getOrCreateFile(Loc);
1036 unsigned Line = getLineNumber(Loc);
1037
1038 const CGBitFieldInfo &BitFieldInfo =
1039 CGM.getTypes().getCGRecordLayout(RD).getBitFieldInfo(BitFieldDecl);
1040 uint64_t SizeInBits = BitFieldInfo.Size;
1041 assert(SizeInBits > 0 && "found named 0-width bitfield")((SizeInBits > 0 && "found named 0-width bitfield"
) ? static_cast<void> (0) : __assert_fail ("SizeInBits > 0 && \"found named 0-width bitfield\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1041, __PRETTY_FUNCTION__))
;
1042 uint64_t StorageOffsetInBits =
1043 CGM.getContext().toBits(BitFieldInfo.StorageOffset);
1044 uint64_t Offset = BitFieldInfo.Offset;
1045 // The bit offsets for big endian machines are reversed for big
1046 // endian target, compensate for that as the DIDerivedType requires
1047 // un-reversed offsets.
1048 if (CGM.getDataLayout().isBigEndian())
1049 Offset = BitFieldInfo.StorageSize - BitFieldInfo.Size - Offset;
1050 uint64_t OffsetInBits = StorageOffsetInBits + Offset;
1051 llvm::DINode::DIFlags Flags = getAccessFlag(BitFieldDecl->getAccess(), RD);
1052 return DBuilder.createBitFieldMemberType(
1053 RecordTy, Name, File, Line, SizeInBits, OffsetInBits, StorageOffsetInBits,
1054 Flags, DebugType);
1055}
1056
1057llvm::DIType *
1058CGDebugInfo::createFieldType(StringRef name, QualType type, SourceLocation loc,
1059 AccessSpecifier AS, uint64_t offsetInBits,
1060 uint32_t AlignInBits, llvm::DIFile *tunit,
1061 llvm::DIScope *scope, const RecordDecl *RD) {
1062 llvm::DIType *debugType = getOrCreateType(type, tunit);
1063
1064 // Get the location for the field.
1065 llvm::DIFile *file = getOrCreateFile(loc);
1066 unsigned line = getLineNumber(loc);
1067
1068 uint64_t SizeInBits = 0;
1069 auto Align = AlignInBits;
1070 if (!type->isIncompleteArrayType()) {
1071 TypeInfo TI = CGM.getContext().getTypeInfo(type);
1072 SizeInBits = TI.Width;
1073 if (!Align)
1074 Align = getTypeAlignIfRequired(type, CGM.getContext());
1075 }
1076
1077 llvm::DINode::DIFlags flags = getAccessFlag(AS, RD);
1078 return DBuilder.createMemberType(scope, name, file, line, SizeInBits,
1079 Align, offsetInBits, flags, debugType);
1080}
1081
1082void CGDebugInfo::CollectRecordLambdaFields(
1083 const CXXRecordDecl *CXXDecl, SmallVectorImpl<llvm::Metadata *> &elements,
1084 llvm::DIType *RecordTy) {
1085 // For C++11 Lambdas a Field will be the same as a Capture, but the Capture
1086 // has the name and the location of the variable so we should iterate over
1087 // both concurrently.
1088 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(CXXDecl);
1089 RecordDecl::field_iterator Field = CXXDecl->field_begin();
1090 unsigned fieldno = 0;
1091 for (CXXRecordDecl::capture_const_iterator I = CXXDecl->captures_begin(),
1092 E = CXXDecl->captures_end();
1093 I != E; ++I, ++Field, ++fieldno) {
1094 const LambdaCapture &C = *I;
1095 if (C.capturesVariable()) {
1096 SourceLocation Loc = C.getLocation();
1097 assert(!Field->isBitField() && "lambdas don't have bitfield members!")((!Field->isBitField() && "lambdas don't have bitfield members!"
) ? static_cast<void> (0) : __assert_fail ("!Field->isBitField() && \"lambdas don't have bitfield members!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1097, __PRETTY_FUNCTION__))
;
1098 VarDecl *V = C.getCapturedVar();
1099 StringRef VName = V->getName();
1100 llvm::DIFile *VUnit = getOrCreateFile(Loc);
1101 auto Align = getDeclAlignIfRequired(V, CGM.getContext());
1102 llvm::DIType *FieldType = createFieldType(
1103 VName, Field->getType(), Loc, Field->getAccess(),
1104 layout.getFieldOffset(fieldno), Align, VUnit, RecordTy, CXXDecl);
1105 elements.push_back(FieldType);
1106 } else if (C.capturesThis()) {
1107 // TODO: Need to handle 'this' in some way by probably renaming the
1108 // this of the lambda class and having a field member of 'this' or
1109 // by using AT_object_pointer for the function and having that be
1110 // used as 'this' for semantic references.
1111 FieldDecl *f = *Field;
1112 llvm::DIFile *VUnit = getOrCreateFile(f->getLocation());
1113 QualType type = f->getType();
1114 llvm::DIType *fieldType = createFieldType(
1115 "this", type, f->getLocation(), f->getAccess(),
1116 layout.getFieldOffset(fieldno), VUnit, RecordTy, CXXDecl);
1117
1118 elements.push_back(fieldType);
1119 }
1120 }
1121}
1122
1123llvm::DIDerivedType *
1124CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy,
1125 const RecordDecl *RD) {
1126 // Create the descriptor for the static variable, with or without
1127 // constant initializers.
1128 Var = Var->getCanonicalDecl();
1129 llvm::DIFile *VUnit = getOrCreateFile(Var->getLocation());
1130 llvm::DIType *VTy = getOrCreateType(Var->getType(), VUnit);
1131
1132 unsigned LineNumber = getLineNumber(Var->getLocation());
1133 StringRef VName = Var->getName();
1134 llvm::Constant *C = nullptr;
1135 if (Var->getInit()) {
1136 const APValue *Value = Var->evaluateValue();
1137 if (Value) {
1138 if (Value->isInt())
1139 C = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->getInt());
1140 if (Value->isFloat())
1141 C = llvm::ConstantFP::get(CGM.getLLVMContext(), Value->getFloat());
1142 }
1143 }
1144
1145 llvm::DINode::DIFlags Flags = getAccessFlag(Var->getAccess(), RD);
1146 auto Align = getDeclAlignIfRequired(Var, CGM.getContext());
1147 llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
1148 RecordTy, VName, VUnit, LineNumber, VTy, Flags, C, Align);
1149 StaticDataMemberCache[Var->getCanonicalDecl()].reset(GV);
1150 return GV;
1151}
1152
1153void CGDebugInfo::CollectRecordNormalField(
1154 const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit,
1155 SmallVectorImpl<llvm::Metadata *> &elements, llvm::DIType *RecordTy,
1156 const RecordDecl *RD) {
1157 StringRef name = field->getName();
1158 QualType type = field->getType();
1159
1160 // Ignore unnamed fields unless they're anonymous structs/unions.
1161 if (name.empty() && !type->isRecordType())
1162 return;
1163
1164 llvm::DIType *FieldType;
1165 if (field->isBitField()) {
1166 FieldType = createBitFieldType(field, RecordTy, RD);
1167 } else {
1168 auto Align = getDeclAlignIfRequired(field, CGM.getContext());
1169 FieldType =
1170 createFieldType(name, type, field->getLocation(), field->getAccess(),
1171 OffsetInBits, Align, tunit, RecordTy, RD);
1172 }
1173
1174 elements.push_back(FieldType);
1175}
1176
1177void CGDebugInfo::CollectRecordNestedRecord(
1178 const RecordDecl *RD, SmallVectorImpl<llvm::Metadata *> &elements) {
1179 QualType Ty = CGM.getContext().getTypeDeclType(RD);
1180 // Injected class names are not considered nested records.
1181 if (isa<InjectedClassNameType>(Ty))
1182 return;
1183 SourceLocation Loc = RD->getLocation();
1184 llvm::DIType *nestedType = getOrCreateType(Ty, getOrCreateFile(Loc));
1185 elements.push_back(nestedType);
1186}
1187
1188void CGDebugInfo::CollectRecordFields(
1189 const RecordDecl *record, llvm::DIFile *tunit,
1190 SmallVectorImpl<llvm::Metadata *> &elements,
1191 llvm::DICompositeType *RecordTy) {
1192 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(record);
1193
1194 if (CXXDecl && CXXDecl->isLambda())
1195 CollectRecordLambdaFields(CXXDecl, elements, RecordTy);
1196 else {
1197 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(record);
1198
1199 // Debug info for nested records is included in the member list only for
1200 // CodeView.
1201 bool IncludeNestedRecords = CGM.getCodeGenOpts().EmitCodeView;
1202
1203 // Field number for non-static fields.
1204 unsigned fieldNo = 0;
1205
1206 // Static and non-static members should appear in the same order as
1207 // the corresponding declarations in the source program.
1208 for (const auto *I : record->decls())
1209 if (const auto *V = dyn_cast<VarDecl>(I)) {
1210 if (V->hasAttr<NoDebugAttr>())
1211 continue;
1212 // Reuse the existing static member declaration if one exists
1213 auto MI = StaticDataMemberCache.find(V->getCanonicalDecl());
1214 if (MI != StaticDataMemberCache.end()) {
1215 assert(MI->second &&((MI->second && "Static data member declaration should still exist"
) ? static_cast<void> (0) : __assert_fail ("MI->second && \"Static data member declaration should still exist\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1216, __PRETTY_FUNCTION__))
1216 "Static data member declaration should still exist")((MI->second && "Static data member declaration should still exist"
) ? static_cast<void> (0) : __assert_fail ("MI->second && \"Static data member declaration should still exist\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1216, __PRETTY_FUNCTION__))
;
1217 elements.push_back(MI->second);
1218 } else {
1219 auto Field = CreateRecordStaticField(V, RecordTy, record);
1220 elements.push_back(Field);
1221 }
1222 } else if (const auto *field = dyn_cast<FieldDecl>(I)) {
1223 CollectRecordNormalField(field, layout.getFieldOffset(fieldNo), tunit,
1224 elements, RecordTy, record);
1225
1226 // Bump field number for next field.
1227 ++fieldNo;
1228 } else if (const auto *nestedRec = dyn_cast<CXXRecordDecl>(I))
1229 if (IncludeNestedRecords && !nestedRec->isImplicit() &&
1230 nestedRec->getDeclContext() == record)
1231 CollectRecordNestedRecord(nestedRec, elements);
1232 }
1233}
1234
1235llvm::DISubroutineType *
1236CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method,
1237 llvm::DIFile *Unit) {
1238 const FunctionProtoType *Func = Method->getType()->getAs<FunctionProtoType>();
1239 if (Method->isStatic())
1240 return cast_or_null<llvm::DISubroutineType>(
1241 getOrCreateType(QualType(Func, 0), Unit));
1242 return getOrCreateInstanceMethodType(Method->getThisType(CGM.getContext()),
1243 Func, Unit);
1244}
1245
1246llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType(
1247 QualType ThisPtr, const FunctionProtoType *Func, llvm::DIFile *Unit) {
1248 // Add "this" pointer.
1249 llvm::DITypeRefArray Args(
1250 cast<llvm::DISubroutineType>(getOrCreateType(QualType(Func, 0), Unit))
1251 ->getTypeArray());
1252 assert(Args.size() && "Invalid number of arguments!")((Args.size() && "Invalid number of arguments!") ? static_cast
<void> (0) : __assert_fail ("Args.size() && \"Invalid number of arguments!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1252, __PRETTY_FUNCTION__))
;
1253
1254 SmallVector<llvm::Metadata *, 16> Elts;
1255
1256 // First element is always return type. For 'void' functions it is NULL.
1257 Elts.push_back(Args[0]);
1258
1259 // "this" pointer is always first argument.
1260 const CXXRecordDecl *RD = ThisPtr->getPointeeCXXRecordDecl();
1261 if (isa<ClassTemplateSpecializationDecl>(RD)) {
1262 // Create pointer type directly in this case.
1263 const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr);
1264 QualType PointeeTy = ThisPtrTy->getPointeeType();
1265 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
1266 uint64_t Size = CGM.getTarget().getPointerWidth(AS);
1267 auto Align = getTypeAlignIfRequired(ThisPtrTy, CGM.getContext());
1268 llvm::DIType *PointeeType = getOrCreateType(PointeeTy, Unit);
1269 llvm::DIType *ThisPtrType =
1270 DBuilder.createPointerType(PointeeType, Size, Align);
1271 TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
1272 // TODO: This and the artificial type below are misleading, the
1273 // types aren't artificial the argument is, but the current
1274 // metadata doesn't represent that.
1275 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1276 Elts.push_back(ThisPtrType);
1277 } else {
1278 llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);
1279 TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
1280 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1281 Elts.push_back(ThisPtrType);
1282 }
1283
1284 // Copy rest of the arguments.
1285 for (unsigned i = 1, e = Args.size(); i != e; ++i)
1286 Elts.push_back(Args[i]);
1287
1288 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
1289
1290 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1291 if (Func->getExtProtoInfo().RefQualifier == RQ_LValue)
1292 Flags |= llvm::DINode::FlagLValueReference;
1293 if (Func->getExtProtoInfo().RefQualifier == RQ_RValue)
1294 Flags |= llvm::DINode::FlagRValueReference;
1295
1296 return DBuilder.createSubroutineType(EltTypeArray, Flags,
1297 getDwarfCC(Func->getCallConv()));
1298}
1299
1300/// isFunctionLocalClass - Return true if CXXRecordDecl is defined
1301/// inside a function.
1302static bool isFunctionLocalClass(const CXXRecordDecl *RD) {
1303 if (const auto *NRD = dyn_cast<CXXRecordDecl>(RD->getDeclContext()))
1304 return isFunctionLocalClass(NRD);
1305 if (isa<FunctionDecl>(RD->getDeclContext()))
1306 return true;
1307 return false;
1308}
1309
1310llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
1311 const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {
1312 bool IsCtorOrDtor =
1313 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
1314
1315 StringRef MethodName = getFunctionName(Method);
1316 llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit);
1317
1318 // Since a single ctor/dtor corresponds to multiple functions, it doesn't
1319 // make sense to give a single ctor/dtor a linkage name.
1320 StringRef MethodLinkageName;
1321 // FIXME: 'isFunctionLocalClass' seems like an arbitrary/unintentional
1322 // property to use here. It may've been intended to model "is non-external
1323 // type" but misses cases of non-function-local but non-external classes such
1324 // as those in anonymous namespaces as well as the reverse - external types
1325 // that are function local, such as those in (non-local) inline functions.
1326 if (!IsCtorOrDtor && !isFunctionLocalClass(Method->getParent()))
11
Taking true branch
1327 MethodLinkageName = CGM.getMangledName(Method);
1328
1329 // Get the location for the method.
1330 llvm::DIFile *MethodDefUnit = nullptr;
1331 unsigned MethodLine = 0;
1332 if (!Method->isImplicit()) {
12
Assuming the condition is false
13
Taking false branch
1333 MethodDefUnit = getOrCreateFile(Method->getLocation());
1334 MethodLine = getLineNumber(Method->getLocation());
1335 }
1336
1337 // Collect virtual method info.
1338 llvm::DIType *ContainingType = nullptr;
1339 unsigned Virtuality = 0;
1340 unsigned VIndex = 0;
1341 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1342 int ThisAdjustment = 0;
1343
1344 if (Method->isVirtual()) {
14
Taking false branch
1345 if (Method->isPure())
1346 Virtuality = llvm::dwarf::DW_VIRTUALITY_pure_virtual;
1347 else
1348 Virtuality = llvm::dwarf::DW_VIRTUALITY_virtual;
1349
1350 if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1351 // It doesn't make sense to give a virtual destructor a vtable index,
1352 // since a single destructor has two entries in the vtable.
1353 if (!isa<CXXDestructorDecl>(Method))
1354 VIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(Method);
1355 } else {
1356 // Emit MS ABI vftable information. There is only one entry for the
1357 // deleting dtor.
1358 const auto *DD = dyn_cast<CXXDestructorDecl>(Method);
1359 GlobalDecl GD = DD ? GlobalDecl(DD, Dtor_Deleting) : GlobalDecl(Method);
1360 MicrosoftVTableContext::MethodVFTableLocation ML =
1361 CGM.getMicrosoftVTableContext().getMethodVFTableLocation(GD);
1362 VIndex = ML.Index;
1363
1364 // CodeView only records the vftable offset in the class that introduces
1365 // the virtual method. This is possible because, unlike Itanium, the MS
1366 // C++ ABI does not include all virtual methods from non-primary bases in
1367 // the vtable for the most derived class. For example, if C inherits from
1368 // A and B, C's primary vftable will not include B's virtual methods.
1369 if (Method->begin_overridden_methods() == Method->end_overridden_methods())
1370 Flags |= llvm::DINode::FlagIntroducedVirtual;
1371
1372 // The 'this' adjustment accounts for both the virtual and non-virtual
1373 // portions of the adjustment. Presumably the debugger only uses it when
1374 // it knows the dynamic type of an object.
1375 ThisAdjustment = CGM.getCXXABI()
1376 .getVirtualFunctionPrologueThisAdjustment(GD)
1377 .getQuantity();
1378 }
1379 ContainingType = RecordTy;
1380 }
1381
1382 if (Method->isImplicit())
15
Assuming the condition is false
16
Taking false branch
1383 Flags |= llvm::DINode::FlagArtificial;
1384 Flags |= getAccessFlag(Method->getAccess(), Method->getParent());
1385 if (const auto *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
17
Taking false branch
1386 if (CXXC->isExplicit())
1387 Flags |= llvm::DINode::FlagExplicit;
1388 } else if (const auto *CXXC = dyn_cast<CXXConversionDecl>(Method)) {
18
Taking false branch
1389 if (CXXC->isExplicit())
1390 Flags |= llvm::DINode::FlagExplicit;
1391 }
1392 if (Method->hasPrototype())
19
Assuming the condition is false
20
Taking false branch
1393 Flags |= llvm::DINode::FlagPrototyped;
1394 if (Method->getRefQualifier() == RQ_LValue)
21
Taking false branch
1395 Flags |= llvm::DINode::FlagLValueReference;
1396 if (Method->getRefQualifier() == RQ_RValue)
22
Taking false branch
1397 Flags |= llvm::DINode::FlagRValueReference;
1398
1399 llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
23
Calling 'CGDebugInfo::CollectFunctionTemplateParams'
1400 llvm::DISubprogram *SP = DBuilder.createMethod(
1401 RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
1402 MethodTy, /*isLocalToUnit=*/false, /*isDefinition=*/false, Virtuality,
1403 VIndex, ThisAdjustment, ContainingType, Flags, CGM.getLangOpts().Optimize,
1404 TParamsArray.get());
1405
1406 SPCache[Method->getCanonicalDecl()].reset(SP);
1407
1408 return SP;
1409}
1410
1411void CGDebugInfo::CollectCXXMemberFunctions(
1412 const CXXRecordDecl *RD, llvm::DIFile *Unit,
1413 SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy) {
1414
1415 // Since we want more than just the individual member decls if we
1416 // have templated functions iterate over every declaration to gather
1417 // the functions.
1418 for (const auto *I : RD->decls()) {
1419 const auto *Method = dyn_cast<CXXMethodDecl>(I);
1420 // If the member is implicit, don't add it to the member list. This avoids
1421 // the member being added to type units by LLVM, while still allowing it
1422 // to be emitted into the type declaration/reference inside the compile
1423 // unit.
1424 // Ditto 'nodebug' methods, for consistency with CodeGenFunction.cpp.
1425 // FIXME: Handle Using(Shadow?)Decls here to create
1426 // DW_TAG_imported_declarations inside the class for base decls brought into
1427 // derived classes. GDB doesn't seem to notice/leverage these when I tried
1428 // it, so I'm not rushing to fix this. (GCC seems to produce them, if
1429 // referenced)
1430 if (!Method || Method->isImplicit() || Method->hasAttr<NoDebugAttr>())
4
Assuming 'Method' is non-null
5
Assuming the condition is false
6
Taking false branch
1431 continue;
1
Execution continues on line 1418
2
Execution continues on line 1418
3
Execution continues on line 1418
1432
1433 if (Method->getType()->getAs<FunctionProtoType>()->getContainedAutoType())
7
Taking false branch
1434 continue;
1435
1436 // Reuse the existing member function declaration if it exists.
1437 // It may be associated with the declaration of the type & should be
1438 // reused as we're building the definition.
1439 //
1440 // This situation can arise in the vtable-based debug info reduction where
1441 // implicit members are emitted in a non-vtable TU.
1442 auto MI = SPCache.find(Method->getCanonicalDecl());
1443 EltTys.push_back(MI == SPCache.end()
8
Assuming the condition is true
9
'?' condition is true
1444 ? CreateCXXMemberFunction(Method, Unit, RecordTy)
10
Calling 'CGDebugInfo::CreateCXXMemberFunction'
1445 : static_cast<llvm::Metadata *>(MI->second));
1446 }
1447}
1448
1449void CGDebugInfo::CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile *Unit,
1450 SmallVectorImpl<llvm::Metadata *> &EltTys,
1451 llvm::DIType *RecordTy) {
1452 llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> SeenTypes;
1453 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->bases(), SeenTypes,
1454 llvm::DINode::FlagZero);
1455
1456 // If we are generating CodeView debug info, we also need to emit records for
1457 // indirect virtual base classes.
1458 if (CGM.getCodeGenOpts().EmitCodeView) {
1459 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->vbases(), SeenTypes,
1460 llvm::DINode::FlagIndirectVirtualBase);
1461 }
1462}
1463
1464void CGDebugInfo::CollectCXXBasesAux(
1465 const CXXRecordDecl *RD, llvm::DIFile *Unit,
1466 SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy,
1467 const CXXRecordDecl::base_class_const_range &Bases,
1468 llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> &SeenTypes,
1469 llvm::DINode::DIFlags StartingFlags) {
1470 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1471 for (const auto &BI : Bases) {
1472 const auto *Base =
1473 cast<CXXRecordDecl>(BI.getType()->getAs<RecordType>()->getDecl());
1474 if (!SeenTypes.insert(Base).second)
1475 continue;
1476 auto *BaseTy = getOrCreateType(BI.getType(), Unit);
1477 llvm::DINode::DIFlags BFlags = StartingFlags;
1478 uint64_t BaseOffset;
1479
1480 if (BI.isVirtual()) {
1481 if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1482 // virtual base offset offset is -ve. The code generator emits dwarf
1483 // expression where it expects +ve number.
1484 BaseOffset = 0 - CGM.getItaniumVTableContext()
1485 .getVirtualBaseOffsetOffset(RD, Base)
1486 .getQuantity();
1487 } else {
1488 // In the MS ABI, store the vbtable offset, which is analogous to the
1489 // vbase offset offset in Itanium.
1490 BaseOffset =
1491 4 * CGM.getMicrosoftVTableContext().getVBTableIndex(RD, Base);
1492 }
1493 BFlags |= llvm::DINode::FlagVirtual;
1494 } else
1495 BaseOffset = CGM.getContext().toBits(RL.getBaseClassOffset(Base));
1496 // FIXME: Inconsistent units for BaseOffset. It is in bytes when
1497 // BI->isVirtual() and bits when not.
1498
1499 BFlags |= getAccessFlag(BI.getAccessSpecifier(), RD);
1500 llvm::DIType *DTy =
1501 DBuilder.createInheritance(RecordTy, BaseTy, BaseOffset, BFlags);
1502 EltTys.push_back(DTy);
1503 }
1504}
1505
1506llvm::DINodeArray
1507CGDebugInfo::CollectTemplateParams(const TemplateParameterList *TPList,
1508 ArrayRef<TemplateArgument> TAList,
1509 llvm::DIFile *Unit) {
1510 SmallVector<llvm::Metadata *, 16> TemplateParams;
1511 for (unsigned i = 0, e = TAList.size(); i != e; ++i) {
27
Assuming 'i' is not equal to 'e'
28
Loop condition is true. Entering loop body
34
Assuming 'i' is not equal to 'e'
35
Loop condition is true. Entering loop body
40
Assuming 'i' is not equal to 'e'
41
Loop condition is true. Entering loop body
45
Assuming 'i' is not equal to 'e'
46
Loop condition is true. Entering loop body
1512 const TemplateArgument &TA = TAList[i];
1513 StringRef Name;
1514 if (TPList)
29
Assuming 'TPList' is null
30
Taking false branch
36
Taking false branch
42
Taking false branch
47
Taking false branch
1515 Name = TPList->getParam(i)->getName();
1516 switch (TA.getKind()) {
31
Control jumps to 'case Expression:' at line 1588
37
Control jumps to 'case Expression:' at line 1588
43
Control jumps to 'case Template:' at line 1578
48
Control jumps to 'case Declaration:' at line 1528
1517 case TemplateArgument::Type: {
1518 llvm::DIType *TTy = getOrCreateType(TA.getAsType(), Unit);
1519 TemplateParams.push_back(
1520 DBuilder.createTemplateTypeParameter(TheCU, Name, TTy));
1521 } break;
1522 case TemplateArgument::Integral: {
1523 llvm::DIType *TTy = getOrCreateType(TA.getIntegralType(), Unit);
1524 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1525 TheCU, Name, TTy,
1526 llvm::ConstantInt::get(CGM.getLLVMContext(), TA.getAsIntegral())));
1527 } break;
1528 case TemplateArgument::Declaration: {
1529 const ValueDecl *D = TA.getAsDecl();
1530 QualType T = TA.getParamTypeForDecl().getDesugaredType(CGM.getContext());
1531 llvm::DIType *TTy = getOrCreateType(T, Unit);
1532 llvm::Constant *V = nullptr;
49
'V' initialized to a null pointer value
1533 const CXXMethodDecl *MD;
1534 // Variable pointer template parameters have a value that is the address
1535 // of the variable.
1536 if (const auto *VD = dyn_cast<VarDecl>(D))
50
Taking false branch
1537 V = CGM.GetAddrOfGlobalVar(VD);
1538 // Member function pointers have special support for building them, though
1539 // this is currently unsupported in LLVM CodeGen.
1540 else if ((MD = dyn_cast<CXXMethodDecl>(D)) && MD->isInstance())
1541 V = CGM.getCXXABI().EmitMemberFunctionPointer(MD);
1542 else if (const auto *FD = dyn_cast<FunctionDecl>(D))
51
Taking false branch
1543 V = CGM.GetAddrOfFunction(FD);
1544 // Member data pointers have special handling too to compute the fixed
1545 // offset within the object.
1546 else if (const auto *MPT = dyn_cast<MemberPointerType>(T.getTypePtr())) {
52
Taking false branch
1547 // These five lines (& possibly the above member function pointer
1548 // handling) might be able to be refactored to use similar code in
1549 // CodeGenModule::getMemberPointerConstant
1550 uint64_t fieldOffset = CGM.getContext().getFieldOffset(D);
1551 CharUnits chars =
1552 CGM.getContext().toCharUnitsFromBits((int64_t)fieldOffset);
1553 V = CGM.getCXXABI().EmitMemberDataPointer(MPT, chars);
1554 }
1555 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1556 TheCU, Name, TTy,
1557 cast_or_null<llvm::Constant>(V->stripPointerCasts())));
53
Called C++ object pointer is null
1558 } break;
1559 case TemplateArgument::NullPtr: {
1560 QualType T = TA.getNullPtrType();
1561 llvm::DIType *TTy = getOrCreateType(T, Unit);
1562 llvm::Constant *V = nullptr;
1563 // Special case member data pointer null values since they're actually -1
1564 // instead of zero.
1565 if (const auto *MPT = dyn_cast<MemberPointerType>(T.getTypePtr()))
1566 // But treat member function pointers as simple zero integers because
1567 // it's easier than having a special case in LLVM's CodeGen. If LLVM
1568 // CodeGen grows handling for values of non-null member function
1569 // pointers then perhaps we could remove this special case and rely on
1570 // EmitNullMemberPointer for member function pointers.
1571 if (MPT->isMemberDataPointer())
1572 V = CGM.getCXXABI().EmitNullMemberPointer(MPT);
1573 if (!V)
1574 V = llvm::ConstantInt::get(CGM.Int8Ty, 0);
1575 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1576 TheCU, Name, TTy, V));
1577 } break;
1578 case TemplateArgument::Template:
1579 TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(
1580 TheCU, Name, nullptr,
1581 TA.getAsTemplate().getAsTemplateDecl()->getQualifiedNameAsString()));
1582 break;
44
Execution continues on line 1511
1583 case TemplateArgument::Pack:
1584 TemplateParams.push_back(DBuilder.createTemplateParameterPack(
1585 TheCU, Name, nullptr,
1586 CollectTemplateParams(nullptr, TA.getPackAsArray(), Unit)));
1587 break;
1588 case TemplateArgument::Expression: {
1589 const Expr *E = TA.getAsExpr();
1590 QualType T = E->getType();
1591 if (E->isGLValue())
32
Taking false branch
38
Taking false branch
1592 T = CGM.getContext().getLValueReferenceType(T);
1593 llvm::Constant *V = CGM.EmitConstantExpr(E, T);
1594 assert(V && "Expression in template argument isn't constant")((V && "Expression in template argument isn't constant"
) ? static_cast<void> (0) : __assert_fail ("V && \"Expression in template argument isn't constant\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1594, __PRETTY_FUNCTION__))
;
1595 llvm::DIType *TTy = getOrCreateType(T, Unit);
1596 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1597 TheCU, Name, TTy, V->stripPointerCasts()));
1598 } break;
33
Execution continues on line 1511
39
Execution continues on line 1511
1599 // And the following should never occur:
1600 case TemplateArgument::TemplateExpansion:
1601 case TemplateArgument::Null:
1602 llvm_unreachable(::llvm::llvm_unreachable_internal("These argument types shouldn't exist in concrete types"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1603)
1603 "These argument types shouldn't exist in concrete types")::llvm::llvm_unreachable_internal("These argument types shouldn't exist in concrete types"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1603)
;
1604 }
1605 }
1606 return DBuilder.getOrCreateArray(TemplateParams);
1607}
1608
1609llvm::DINodeArray
1610CGDebugInfo::CollectFunctionTemplateParams(const FunctionDecl *FD,
1611 llvm::DIFile *Unit) {
1612 if (FD->getTemplatedKind() ==
24
Assuming the condition is true
25
Taking true branch
1613 FunctionDecl::TK_FunctionTemplateSpecialization) {
1614 const TemplateParameterList *TList = FD->getTemplateSpecializationInfo()
1615 ->getTemplate()
1616 ->getTemplateParameters();
1617 return CollectTemplateParams(
26
Calling 'CGDebugInfo::CollectTemplateParams'
1618 TList, FD->getTemplateSpecializationArgs()->asArray(), Unit);
1619 }
1620 return llvm::DINodeArray();
1621}
1622
1623llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(
1624 const ClassTemplateSpecializationDecl *TSpecial, llvm::DIFile *Unit) {
1625 // Always get the full list of parameters, not just the ones from
1626 // the specialization.
1627 TemplateParameterList *TPList =
1628 TSpecial->getSpecializedTemplate()->getTemplateParameters();
1629 const TemplateArgumentList &TAList = TSpecial->getTemplateArgs();
1630 return CollectTemplateParams(TPList, TAList.asArray(), Unit);
1631}
1632
1633llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
1634 if (VTablePtrType)
1635 return VTablePtrType;
1636
1637 ASTContext &Context = CGM.getContext();
1638
1639 /* Function type */
1640 llvm::Metadata *STy = getOrCreateType(Context.IntTy, Unit);
1641 llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);
1642 llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements);
1643 unsigned Size = Context.getTypeSize(Context.VoidPtrTy);
1644 unsigned VtblPtrAddressSpace = CGM.getTarget().getVtblPtrAddressSpace();
1645 Optional<unsigned> DWARFAddressSpace =
1646 CGM.getTarget().getDWARFAddressSpace(VtblPtrAddressSpace);
1647
1648 llvm::DIType *vtbl_ptr_type =
1649 DBuilder.createPointerType(SubTy, Size, 0, DWARFAddressSpace,
1650 "__vtbl_ptr_type");
1651 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
1652 return VTablePtrType;
1653}
1654
1655StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) {
1656 // Copy the gdb compatible name on the side and use its reference.
1657 return internString("_vptr$", RD->getNameAsString());
1658}
1659
1660void CGDebugInfo::CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile *Unit,
1661 SmallVectorImpl<llvm::Metadata *> &EltTys,
1662 llvm::DICompositeType *RecordTy) {
1663 // If this class is not dynamic then there is not any vtable info to collect.
1664 if (!RD->isDynamicClass())
1665 return;
1666
1667 // Don't emit any vtable shape or vptr info if this class doesn't have an
1668 // extendable vfptr. This can happen if the class doesn't have virtual
1669 // methods, or in the MS ABI if those virtual methods only come from virtually
1670 // inherited bases.
1671 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1672 if (!RL.hasExtendableVFPtr())
1673 return;
1674
1675 // CodeView needs to know how large the vtable of every dynamic class is, so
1676 // emit a special named pointer type into the element list. The vptr type
1677 // points to this type as well.
1678 llvm::DIType *VPtrTy = nullptr;
1679 bool NeedVTableShape = CGM.getCodeGenOpts().EmitCodeView &&
1680 CGM.getTarget().getCXXABI().isMicrosoft();
1681 if (NeedVTableShape) {
1682 uint64_t PtrWidth =
1683 CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
1684 const VTableLayout &VFTLayout =
1685 CGM.getMicrosoftVTableContext().getVFTableLayout(RD, CharUnits::Zero());
1686 unsigned VSlotCount =
1687 VFTLayout.vtable_components().size() - CGM.getLangOpts().RTTIData;
1688 unsigned VTableWidth = PtrWidth * VSlotCount;
1689 unsigned VtblPtrAddressSpace = CGM.getTarget().getVtblPtrAddressSpace();
1690 Optional<unsigned> DWARFAddressSpace =
1691 CGM.getTarget().getDWARFAddressSpace(VtblPtrAddressSpace);
1692
1693 // Create a very wide void* type and insert it directly in the element list.
1694 llvm::DIType *VTableType =
1695 DBuilder.createPointerType(nullptr, VTableWidth, 0, DWARFAddressSpace,
1696 "__vtbl_ptr_type");
1697 EltTys.push_back(VTableType);
1698
1699 // The vptr is a pointer to this special vtable type.
1700 VPtrTy = DBuilder.createPointerType(VTableType, PtrWidth);
1701 }
1702
1703 // If there is a primary base then the artificial vptr member lives there.
1704 if (RL.getPrimaryBase())
1705 return;
1706
1707 if (!VPtrTy)
1708 VPtrTy = getOrCreateVTablePtrType(Unit);
1709
1710 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
1711 llvm::DIType *VPtrMember = DBuilder.createMemberType(
1712 Unit, getVTableName(RD), Unit, 0, Size, 0, 0,
1713 llvm::DINode::FlagArtificial, VPtrTy);
1714 EltTys.push_back(VPtrMember);
1715}
1716
1717llvm::DIType *CGDebugInfo::getOrCreateRecordType(QualType RTy,
1718 SourceLocation Loc) {
1719 assert(DebugKind >= codegenoptions::LimitedDebugInfo)((DebugKind >= codegenoptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= codegenoptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1719, __PRETTY_FUNCTION__))
;
1720 llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
1721 return T;
1722}
1723
1724llvm::DIType *CGDebugInfo::getOrCreateInterfaceType(QualType D,
1725 SourceLocation Loc) {
1726 return getOrCreateStandaloneType(D, Loc);
1727}
1728
1729llvm::DIType *CGDebugInfo::getOrCreateStandaloneType(QualType D,
1730 SourceLocation Loc) {
1731 assert(DebugKind >= codegenoptions::LimitedDebugInfo)((DebugKind >= codegenoptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= codegenoptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1731, __PRETTY_FUNCTION__))
;
1732 assert(!D.isNull() && "null type")((!D.isNull() && "null type") ? static_cast<void>
(0) : __assert_fail ("!D.isNull() && \"null type\"",
"/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1732, __PRETTY_FUNCTION__))
;
1733 llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc));
1734 assert(T && "could not create debug info for type")((T && "could not create debug info for type") ? static_cast
<void> (0) : __assert_fail ("T && \"could not create debug info for type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1734, __PRETTY_FUNCTION__))
;
1735
1736 RetainedTypes.push_back(D.getAsOpaquePtr());
1737 return T;
1738}
1739
1740void CGDebugInfo::completeType(const EnumDecl *ED) {
1741 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
1742 return;
1743 QualType Ty = CGM.getContext().getEnumType(ED);
1744 void *TyPtr = Ty.getAsOpaquePtr();
1745 auto I = TypeCache.find(TyPtr);
1746 if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())
1747 return;
1748 llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<EnumType>());
1749 assert(!Res->isForwardDecl())((!Res->isForwardDecl()) ? static_cast<void> (0) : __assert_fail
("!Res->isForwardDecl()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1749, __PRETTY_FUNCTION__))
;
1750 TypeCache[TyPtr].reset(Res);
1751}
1752
1753void CGDebugInfo::completeType(const RecordDecl *RD) {
1754 if (DebugKind > codegenoptions::LimitedDebugInfo ||
1755 !CGM.getLangOpts().CPlusPlus)
1756 completeRequiredType(RD);
1757}
1758
1759/// Return true if the class or any of its methods are marked dllimport.
1760static bool isClassOrMethodDLLImport(const CXXRecordDecl *RD) {
1761 if (RD->hasAttr<DLLImportAttr>())
1762 return true;
1763 for (const CXXMethodDecl *MD : RD->methods())
1764 if (MD->hasAttr<DLLImportAttr>())
1765 return true;
1766 return false;
1767}
1768
1769void CGDebugInfo::completeClassData(const RecordDecl *RD) {
1770 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1771 if (CXXRD->isDynamicClass() &&
1772 CGM.getVTableLinkage(CXXRD) ==
1773 llvm::GlobalValue::AvailableExternallyLinkage &&
1774 !isClassOrMethodDLLImport(CXXRD))
1775 return;
1776 completeClass(RD);
1777}
1778
1779void CGDebugInfo::completeClass(const RecordDecl *RD) {
1780 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
1781 return;
1782 QualType Ty = CGM.getContext().getRecordType(RD);
1783 void *TyPtr = Ty.getAsOpaquePtr();
1784 auto I = TypeCache.find(TyPtr);
1785 if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
1786 return;
1787 llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<RecordType>());
1788 assert(!Res->isForwardDecl())((!Res->isForwardDecl()) ? static_cast<void> (0) : __assert_fail
("!Res->isForwardDecl()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1788, __PRETTY_FUNCTION__))
;
1789 TypeCache[TyPtr].reset(Res);
1790}
1791
1792static bool hasExplicitMemberDefinition(CXXRecordDecl::method_iterator I,
1793 CXXRecordDecl::method_iterator End) {
1794 for (CXXMethodDecl *MD : llvm::make_range(I, End))
1795 if (FunctionDecl *Tmpl = MD->getInstantiatedFromMemberFunction())
1796 if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&
1797 !MD->getMemberSpecializationInfo()->isExplicitSpecialization())
1798 return true;
1799 return false;
1800}
1801
1802/// Does a type definition exist in an imported clang module?
1803static bool isDefinedInClangModule(const RecordDecl *RD) {
1804 // Only definitions that where imported from an AST file come from a module.
1805 if (!RD || !RD->isFromASTFile())
1806 return false;
1807 // Anonymous entities cannot be addressed. Treat them as not from module.
1808 if (!RD->isExternallyVisible() && RD->getName().empty())
1809 return false;
1810 if (auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) {
1811 if (!CXXDecl->isCompleteDefinition())
1812 return false;
1813 auto TemplateKind = CXXDecl->getTemplateSpecializationKind();
1814 if (TemplateKind != TSK_Undeclared) {
1815 // This is a template, check the origin of the first member.
1816 if (CXXDecl->field_begin() == CXXDecl->field_end())
1817 return TemplateKind == TSK_ExplicitInstantiationDeclaration;
1818 if (!CXXDecl->field_begin()->isFromASTFile())
1819 return false;
1820 }
1821 }
1822 return true;
1823}
1824
1825static bool shouldOmitDefinition(codegenoptions::DebugInfoKind DebugKind,
1826 bool DebugTypeExtRefs, const RecordDecl *RD,
1827 const LangOptions &LangOpts) {
1828 if (DebugTypeExtRefs && isDefinedInClangModule(RD->getDefinition()))
1829 return true;
1830
1831 if (auto *ES = RD->getASTContext().getExternalSource())
1832 if (ES->hasExternalDefinitions(RD) == ExternalASTSource::EK_Always)
1833 return true;
1834
1835 if (DebugKind > codegenoptions::LimitedDebugInfo)
1836 return false;
1837
1838 if (!LangOpts.CPlusPlus)
1839 return false;
1840
1841 if (!RD->isCompleteDefinitionRequired())
1842 return true;
1843
1844 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
1845
1846 if (!CXXDecl)
1847 return false;
1848
1849 // Only emit complete debug info for a dynamic class when its vtable is
1850 // emitted. However, Microsoft debuggers don't resolve type information
1851 // across DLL boundaries, so skip this optimization if the class or any of its
1852 // methods are marked dllimport. This isn't a complete solution, since objects
1853 // without any dllimport methods can be used in one DLL and constructed in
1854 // another, but it is the current behavior of LimitedDebugInfo.
1855 if (CXXDecl->hasDefinition() && CXXDecl->isDynamicClass() &&
1856 !isClassOrMethodDLLImport(CXXDecl))
1857 return true;
1858
1859 TemplateSpecializationKind Spec = TSK_Undeclared;
1860 if (const auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
1861 Spec = SD->getSpecializationKind();
1862
1863 if (Spec == TSK_ExplicitInstantiationDeclaration &&
1864 hasExplicitMemberDefinition(CXXDecl->method_begin(),
1865 CXXDecl->method_end()))
1866 return true;
1867
1868 return false;
1869}
1870
1871void CGDebugInfo::completeRequiredType(const RecordDecl *RD) {
1872 if (shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD, CGM.getLangOpts()))
1873 return;
1874
1875 QualType Ty = CGM.getContext().getRecordType(RD);
1876 llvm::DIType *T = getTypeOrNull(Ty);
1877 if (T && T->isForwardDecl())
1878 completeClassData(RD);
1879}
1880
1881llvm::DIType *CGDebugInfo::CreateType(const RecordType *Ty) {
1882 RecordDecl *RD = Ty->getDecl();
1883 llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(QualType(Ty, 0)));
1884 if (T || shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD,
1885 CGM.getLangOpts())) {
1886 if (!T)
1887 T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));
1888 return T;
1889 }
1890
1891 return CreateTypeDefinition(Ty);
1892}
1893
1894llvm::DIType *CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) {
1895 RecordDecl *RD = Ty->getDecl();
1896
1897 // Get overall information about the record type for the debug info.
1898 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
1899
1900 // Records and classes and unions can all be recursive. To handle them, we
1901 // first generate a debug descriptor for the struct as a forward declaration.
1902 // Then (if it is a definition) we go through and get debug info for all of
1903 // its members. Finally, we create a descriptor for the complete type (which
1904 // may refer to the forward decl if the struct is recursive) and replace all
1905 // uses of the forward declaration with the final definition.
1906 llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty, DefUnit);
1907
1908 const RecordDecl *D = RD->getDefinition();
1909 if (!D || !D->isCompleteDefinition())
1910 return FwdDecl;
1911
1912 if (const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
1913 CollectContainingType(CXXDecl, FwdDecl);
1914
1915 // Push the struct on region stack.
1916 LexicalBlockStack.emplace_back(&*FwdDecl);
1917 RegionMap[Ty->getDecl()].reset(FwdDecl);
1918
1919 // Convert all the elements.
1920 SmallVector<llvm::Metadata *, 16> EltTys;
1921 // what about nested types?
1922
1923 // Note: The split of CXXDecl information here is intentional, the
1924 // gdb tests will depend on a certain ordering at printout. The debug
1925 // information offsets are still correct if we merge them all together
1926 // though.
1927 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
1928 if (CXXDecl) {
1929 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
1930 CollectVTableInfo(CXXDecl, DefUnit, EltTys, FwdDecl);
1931 }
1932
1933 // Collect data fields (including static variables and any initializers).
1934 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
1935 if (CXXDecl)
1936 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
1937
1938 LexicalBlockStack.pop_back();
1939 RegionMap.erase(Ty->getDecl());
1940
1941 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
1942 DBuilder.replaceArrays(FwdDecl, Elements);
1943
1944 if (FwdDecl->isTemporary())
1945 FwdDecl =
1946 llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
1947
1948 RegionMap[Ty->getDecl()].reset(FwdDecl);
1949 return FwdDecl;
1950}
1951
1952llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectType *Ty,
1953 llvm::DIFile *Unit) {
1954 // Ignore protocols.
1955 return getOrCreateType(Ty->getBaseType(), Unit);
1956}
1957
1958llvm::DIType *CGDebugInfo::CreateType(const ObjCTypeParamType *Ty,
1959 llvm::DIFile *Unit) {
1960 // Ignore protocols.
1961 SourceLocation Loc = Ty->getDecl()->getLocation();
1962
1963 // Use Typedefs to represent ObjCTypeParamType.
1964 return DBuilder.createTypedef(
1965 getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit),
1966 Ty->getDecl()->getName(), getOrCreateFile(Loc), getLineNumber(Loc),
1967 getDeclContextDescriptor(Ty->getDecl()));
1968}
1969
1970/// \return true if Getter has the default name for the property PD.
1971static bool hasDefaultGetterName(const ObjCPropertyDecl *PD,
1972 const ObjCMethodDecl *Getter) {
1973 assert(PD)((PD) ? static_cast<void> (0) : __assert_fail ("PD", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1973, __PRETTY_FUNCTION__))
;
1974 if (!Getter)
1975 return true;
1976
1977 assert(Getter->getDeclName().isObjCZeroArgSelector())((Getter->getDeclName().isObjCZeroArgSelector()) ? static_cast
<void> (0) : __assert_fail ("Getter->getDeclName().isObjCZeroArgSelector()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1977, __PRETTY_FUNCTION__))
;
1978 return PD->getName() ==
1979 Getter->getDeclName().getObjCSelector().getNameForSlot(0);
1980}
1981
1982/// \return true if Setter has the default name for the property PD.
1983static bool hasDefaultSetterName(const ObjCPropertyDecl *PD,
1984 const ObjCMethodDecl *Setter) {
1985 assert(PD)((PD) ? static_cast<void> (0) : __assert_fail ("PD", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1985, __PRETTY_FUNCTION__))
;
1986 if (!Setter)
1987 return true;
1988
1989 assert(Setter->getDeclName().isObjCOneArgSelector())((Setter->getDeclName().isObjCOneArgSelector()) ? static_cast
<void> (0) : __assert_fail ("Setter->getDeclName().isObjCOneArgSelector()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1989, __PRETTY_FUNCTION__))
;
1990 return SelectorTable::constructSetterName(PD->getName()) ==
1991 Setter->getDeclName().getObjCSelector().getNameForSlot(0);
1992}
1993
1994llvm::DIType *CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
1995 llvm::DIFile *Unit) {
1996 ObjCInterfaceDecl *ID = Ty->getDecl();
1997 if (!ID)
1998 return nullptr;
1999
2000 // Return a forward declaration if this type was imported from a clang module,
2001 // and this is not the compile unit with the implementation of the type (which
2002 // may contain hidden ivars).
2003 if (DebugTypeExtRefs && ID->isFromASTFile() && ID->getDefinition() &&
2004 !ID->getImplementation())
2005 return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
2006 ID->getName(),
2007 getDeclContextDescriptor(ID), Unit, 0);
2008
2009 // Get overall information about the record type for the debug info.
2010 llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation());
2011 unsigned Line = getLineNumber(ID->getLocation());
2012 auto RuntimeLang =
2013 static_cast<llvm::dwarf::SourceLanguage>(TheCU->getSourceLanguage());
2014
2015 // If this is just a forward declaration return a special forward-declaration
2016 // debug type since we won't be able to lay out the entire type.
2017 ObjCInterfaceDecl *Def = ID->getDefinition();
2018 if (!Def || !Def->getImplementation()) {
2019 llvm::DIScope *Mod = getParentModuleOrNull(ID);
2020 llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(
2021 llvm::dwarf::DW_TAG_structure_type, ID->getName(), Mod ? Mod : TheCU,
2022 DefUnit, Line, RuntimeLang);
2023 ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit));
2024 return FwdDecl;
2025 }
2026
2027 return CreateTypeDefinition(Ty, Unit);
2028}
2029
2030llvm::DIModule *
2031CGDebugInfo::getOrCreateModuleRef(ExternalASTSource::ASTSourceDescriptor Mod,
2032 bool CreateSkeletonCU) {
2033 // Use the Module pointer as the key into the cache. This is a
2034 // nullptr if the "Module" is a PCH, which is safe because we don't
2035 // support chained PCH debug info, so there can only be a single PCH.
2036 const Module *M = Mod.getModuleOrNull();
2037 auto ModRef = ModuleCache.find(M);
2038 if (ModRef != ModuleCache.end())
2039 return cast<llvm::DIModule>(ModRef->second);
2040
2041 // Macro definitions that were defined with "-D" on the command line.
2042 SmallString<128> ConfigMacros;
2043 {
2044 llvm::raw_svector_ostream OS(ConfigMacros);
2045 const auto &PPOpts = CGM.getPreprocessorOpts();
2046 unsigned I = 0;
2047 // Translate the macro definitions back into a commmand line.
2048 for (auto &M : PPOpts.Macros) {
2049 if (++I > 1)
2050 OS << " ";
2051 const std::string &Macro = M.first;
2052 bool Undef = M.second;
2053 OS << "\"-" << (Undef ? 'U' : 'D');
2054 for (char c : Macro)
2055 switch (c) {
2056 case '\\' : OS << "\\\\"; break;
2057 case '"' : OS << "\\\""; break;
2058 default: OS << c;
2059 }
2060 OS << '\"';
2061 }
2062 }
2063
2064 bool IsRootModule = M ? !M->Parent : true;
2065 if (CreateSkeletonCU && IsRootModule) {
2066 // PCH files don't have a signature field in the control block,
2067 // but LLVM detects skeleton CUs by looking for a non-zero DWO id.
2068 // We use the lower 64 bits for debug info.
2069 uint64_t Signature =
2070 Mod.getSignature()
2071 ? (uint64_t)Mod.getSignature()[1] << 32 | Mod.getSignature()[0]
2072 : ~1ULL;
2073 llvm::DIBuilder DIB(CGM.getModule());
2074 DIB.createCompileUnit(TheCU->getSourceLanguage(),
2075 DIB.createFile(Mod.getModuleName(), Mod.getPath()),
2076 TheCU->getProducer(), true, StringRef(), 0,
2077 Mod.getASTFile(), llvm::DICompileUnit::FullDebug,
2078 Signature);
2079 DIB.finalize();
2080 }
2081 llvm::DIModule *Parent =
2082 IsRootModule ? nullptr
2083 : getOrCreateModuleRef(
2084 ExternalASTSource::ASTSourceDescriptor(*M->Parent),
2085 CreateSkeletonCU);
2086 llvm::DIModule *DIMod =
2087 DBuilder.createModule(Parent, Mod.getModuleName(), ConfigMacros,
2088 Mod.getPath(), CGM.getHeaderSearchOpts().Sysroot);
2089 ModuleCache[M].reset(DIMod);
2090 return DIMod;
2091}
2092
2093llvm::DIType *CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty,
2094 llvm::DIFile *Unit) {
2095 ObjCInterfaceDecl *ID = Ty->getDecl();
2096 llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation());
2097 unsigned Line = getLineNumber(ID->getLocation());
2098 unsigned RuntimeLang = TheCU->getSourceLanguage();
2099
2100 // Bit size, align and offset of the type.
2101 uint64_t Size = CGM.getContext().getTypeSize(Ty);
2102 auto Align = getTypeAlignIfRequired(Ty, CGM.getContext());
2103
2104 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2105 if (ID->getImplementation())
2106 Flags |= llvm::DINode::FlagObjcClassComplete;
2107
2108 llvm::DIScope *Mod = getParentModuleOrNull(ID);
2109 llvm::DICompositeType *RealDecl = DBuilder.createStructType(
2110 Mod ? Mod : Unit, ID->getName(), DefUnit, Line, Size, Align, Flags,
2111 nullptr, llvm::DINodeArray(), RuntimeLang);
2112
2113 QualType QTy(Ty, 0);
2114 TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl);
2115
2116 // Push the struct on region stack.
2117 LexicalBlockStack.emplace_back(RealDecl);
2118 RegionMap[Ty->getDecl()].reset(RealDecl);
2119
2120 // Convert all the elements.
2121 SmallVector<llvm::Metadata *, 16> EltTys;
2122
2123 ObjCInterfaceDecl *SClass = ID->getSuperClass();
2124 if (SClass) {
2125 llvm::DIType *SClassTy =
2126 getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit);
2127 if (!SClassTy)
2128 return nullptr;
2129
2130 llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0,
2131 llvm::DINode::FlagZero);
2132 EltTys.push_back(InhTag);
2133 }
2134
2135 // Create entries for all of the properties.
2136 auto AddProperty = [&](const ObjCPropertyDecl *PD) {
2137 SourceLocation Loc = PD->getLocation();
2138 llvm::DIFile *PUnit = getOrCreateFile(Loc);
2139 unsigned PLine = getLineNumber(Loc);
2140 ObjCMethodDecl *Getter = PD->getGetterMethodDecl();
2141 ObjCMethodDecl *Setter = PD->getSetterMethodDecl();
2142 llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(
2143 PD->getName(), PUnit, PLine,
2144 hasDefaultGetterName(PD, Getter) ? ""
2145 : getSelectorName(PD->getGetterName()),
2146 hasDefaultSetterName(PD, Setter) ? ""
2147 : getSelectorName(PD->getSetterName()),
2148 PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit));
2149 EltTys.push_back(PropertyNode);
2150 };
2151 {
2152 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
2153 for (const ObjCCategoryDecl *ClassExt : ID->known_extensions())
2154 for (auto *PD : ClassExt->properties()) {
2155 PropertySet.insert(PD->getIdentifier());
2156 AddProperty(PD);
2157 }
2158 for (const auto *PD : ID->properties()) {
2159 // Don't emit duplicate metadata for properties that were already in a
2160 // class extension.
2161 if (!PropertySet.insert(PD->getIdentifier()).second)
2162 continue;
2163 AddProperty(PD);
2164 }
2165 }
2166
2167 const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(ID);
2168 unsigned FieldNo = 0;
2169 for (ObjCIvarDecl *Field = ID->all_declared_ivar_begin(); Field;
2170 Field = Field->getNextIvar(), ++FieldNo) {
2171 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
2172 if (!FieldTy)
2173 return nullptr;
2174
2175 StringRef FieldName = Field->getName();
2176
2177 // Ignore unnamed fields.
2178 if (FieldName.empty())
2179 continue;
2180
2181 // Get the location for the field.
2182 llvm::DIFile *FieldDefUnit = getOrCreateFile(Field->getLocation());
2183 unsigned FieldLine = getLineNumber(Field->getLocation());
2184 QualType FType = Field->getType();
2185 uint64_t FieldSize = 0;
2186 uint32_t FieldAlign = 0;
2187
2188 if (!FType->isIncompleteArrayType()) {
2189
2190 // Bit size, align and offset of the type.
2191 FieldSize = Field->isBitField()
2192 ? Field->getBitWidthValue(CGM.getContext())
2193 : CGM.getContext().getTypeSize(FType);
2194 FieldAlign = getTypeAlignIfRequired(FType, CGM.getContext());
2195 }
2196
2197 uint64_t FieldOffset;
2198 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
2199 // We don't know the runtime offset of an ivar if we're using the
2200 // non-fragile ABI. For bitfields, use the bit offset into the first
2201 // byte of storage of the bitfield. For other fields, use zero.
2202 if (Field->isBitField()) {
2203 FieldOffset =
2204 CGM.getObjCRuntime().ComputeBitfieldBitOffset(CGM, ID, Field);
2205 FieldOffset %= CGM.getContext().getCharWidth();
2206 } else {
2207 FieldOffset = 0;
2208 }
2209 } else {
2210 FieldOffset = RL.getFieldOffset(FieldNo);
2211 }
2212
2213 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2214 if (Field->getAccessControl() == ObjCIvarDecl::Protected)
2215 Flags = llvm::DINode::FlagProtected;
2216 else if (Field->getAccessControl() == ObjCIvarDecl::Private)
2217 Flags = llvm::DINode::FlagPrivate;
2218 else if (Field->getAccessControl() == ObjCIvarDecl::Public)
2219 Flags = llvm::DINode::FlagPublic;
2220
2221 llvm::MDNode *PropertyNode = nullptr;
2222 if (ObjCImplementationDecl *ImpD = ID->getImplementation()) {
2223 if (ObjCPropertyImplDecl *PImpD =
2224 ImpD->FindPropertyImplIvarDecl(Field->getIdentifier())) {
2225 if (ObjCPropertyDecl *PD = PImpD->getPropertyDecl()) {
2226 SourceLocation Loc = PD->getLocation();
2227 llvm::DIFile *PUnit = getOrCreateFile(Loc);
2228 unsigned PLine = getLineNumber(Loc);
2229 ObjCMethodDecl *Getter = PD->getGetterMethodDecl();
2230 ObjCMethodDecl *Setter = PD->getSetterMethodDecl();
2231 PropertyNode = DBuilder.createObjCProperty(
2232 PD->getName(), PUnit, PLine,
2233 hasDefaultGetterName(PD, Getter) ? "" : getSelectorName(
2234 PD->getGetterName()),
2235 hasDefaultSetterName(PD, Setter) ? "" : getSelectorName(
2236 PD->getSetterName()),
2237 PD->getPropertyAttributes(),
2238 getOrCreateType(PD->getType(), PUnit));
2239 }
2240 }
2241 }
2242 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine,
2243 FieldSize, FieldAlign, FieldOffset, Flags,
2244 FieldTy, PropertyNode);
2245 EltTys.push_back(FieldTy);
2246 }
2247
2248 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2249 DBuilder.replaceArrays(RealDecl, Elements);
2250
2251 LexicalBlockStack.pop_back();
2252 return RealDecl;
2253}
2254
2255llvm::DIType *CGDebugInfo::CreateType(const VectorType *Ty,
2256 llvm::DIFile *Unit) {
2257 llvm::DIType *ElementTy = getOrCreateType(Ty->getElementType(), Unit);
2258 int64_t Count = Ty->getNumElements();
2259 if (Count == 0)
2260 // If number of elements are not known then this is an unbounded array.
2261 // Use Count == -1 to express such arrays.
2262 Count = -1;
2263
2264 llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(0, Count);
2265 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
2266
2267 uint64_t Size = CGM.getContext().getTypeSize(Ty);
2268 auto Align = getTypeAlignIfRequired(Ty, CGM.getContext());
2269
2270 return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
2271}
2272
2273llvm::DIType *CGDebugInfo::CreateType(const ArrayType *Ty, llvm::DIFile *Unit) {
2274 uint64_t Size;
2275 uint32_t Align;
2276
2277 // FIXME: make getTypeAlign() aware of VLAs and incomplete array types
2278 if (const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
2279 Size = 0;
2280 Align = getTypeAlignIfRequired(CGM.getContext().getBaseElementType(VAT),
2281 CGM.getContext());
2282 } else if (Ty->isIncompleteArrayType()) {
2283 Size = 0;
2284 if (Ty->getElementType()->isIncompleteType())
2285 Align = 0;
2286 else
2287 Align = getTypeAlignIfRequired(Ty->getElementType(), CGM.getContext());
2288 } else if (Ty->isIncompleteType()) {
2289 Size = 0;
2290 Align = 0;
2291 } else {
2292 // Size and align of the whole array, not the element type.
2293 Size = CGM.getContext().getTypeSize(Ty);
2294 Align = getTypeAlignIfRequired(Ty, CGM.getContext());
2295 }
2296
2297 // Add the dimensions of the array. FIXME: This loses CV qualifiers from
2298 // interior arrays, do we care? Why aren't nested arrays represented the
2299 // obvious/recursive way?
2300 SmallVector<llvm::Metadata *, 8> Subscripts;
2301 QualType EltTy(Ty, 0);
2302 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
2303 // If the number of elements is known, then count is that number. Otherwise,
2304 // it's -1. This allows us to represent a subrange with an array of 0
2305 // elements, like this:
2306 //
2307 // struct foo {
2308 // int x[0];
2309 // };
2310 int64_t Count = -1; // Count == -1 is an unbounded array.
2311 if (const auto *CAT = dyn_cast<ConstantArrayType>(Ty))
2312 Count = CAT->getSize().getZExtValue();
2313 else if (const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
2314 if (Expr *Size = VAT->getSizeExpr()) {
2315 llvm::APSInt V;
2316 if (Size->EvaluateAsInt(V, CGM.getContext()))
2317 Count = V.getExtValue();
2318 }
2319 }
2320
2321 // FIXME: Verify this is right for VLAs.
2322 Subscripts.push_back(DBuilder.getOrCreateSubrange(0, Count));
2323 EltTy = Ty->getElementType();
2324 }
2325
2326 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
2327
2328 return DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
2329 SubscriptArray);
2330}
2331
2332llvm::DIType *CGDebugInfo::CreateType(const LValueReferenceType *Ty,
2333 llvm::DIFile *Unit) {
2334 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty,
2335 Ty->getPointeeType(), Unit);
2336}
2337
2338llvm::DIType *CGDebugInfo::CreateType(const RValueReferenceType *Ty,
2339 llvm::DIFile *Unit) {
2340 return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type, Ty,
2341 Ty->getPointeeType(), Unit);
2342}
2343
2344llvm::DIType *CGDebugInfo::CreateType(const MemberPointerType *Ty,
2345 llvm::DIFile *U) {
2346 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2347 uint64_t Size = 0;
2348
2349 if (!Ty->isIncompleteType()) {
2350 Size = CGM.getContext().getTypeSize(Ty);
2351
2352 // Set the MS inheritance model. There is no flag for the unspecified model.
2353 if (CGM.getTarget().getCXXABI().isMicrosoft()) {
2354 switch (Ty->getMostRecentCXXRecordDecl()->getMSInheritanceModel()) {
2355 case MSInheritanceAttr::Keyword_single_inheritance:
2356 Flags |= llvm::DINode::FlagSingleInheritance;
2357 break;
2358 case MSInheritanceAttr::Keyword_multiple_inheritance:
2359 Flags |= llvm::DINode::FlagMultipleInheritance;
2360 break;
2361 case MSInheritanceAttr::Keyword_virtual_inheritance:
2362 Flags |= llvm::DINode::FlagVirtualInheritance;
2363 break;
2364 case MSInheritanceAttr::Keyword_unspecified_inheritance:
2365 break;
2366 }
2367 }
2368 }
2369
2370 llvm::DIType *ClassType = getOrCreateType(QualType(Ty->getClass(), 0), U);
2371 if (Ty->isMemberDataPointerType())
2372 return DBuilder.createMemberPointerType(
2373 getOrCreateType(Ty->getPointeeType(), U), ClassType, Size, /*Align=*/0,
2374 Flags);
2375
2376 const FunctionProtoType *FPT =
2377 Ty->getPointeeType()->getAs<FunctionProtoType>();
2378 return DBuilder.createMemberPointerType(
2379 getOrCreateInstanceMethodType(CGM.getContext().getPointerType(QualType(
2380 Ty->getClass(), FPT->getTypeQuals())),
2381 FPT, U),
2382 ClassType, Size, /*Align=*/0, Flags);
2383}
2384
2385llvm::DIType *CGDebugInfo::CreateType(const AtomicType *Ty, llvm::DIFile *U) {
2386 auto *FromTy = getOrCreateType(Ty->getValueType(), U);
2387 return DBuilder.createQualifiedType(llvm::dwarf::DW_TAG_atomic_type, FromTy);
2388}
2389
2390llvm::DIType* CGDebugInfo::CreateType(const PipeType *Ty,
2391 llvm::DIFile *U) {
2392 return getOrCreateType(Ty->getElementType(), U);
2393}
2394
2395llvm::DIType *CGDebugInfo::CreateEnumType(const EnumType *Ty) {
2396 const EnumDecl *ED = Ty->getDecl();
2397
2398 uint64_t Size = 0;
2399 uint32_t Align = 0;
2400 if (!ED->getTypeForDecl()->isIncompleteType()) {
2401 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
2402 Align = getDeclAlignIfRequired(ED, CGM.getContext());
2403 }
2404
2405 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
2406
2407 bool isImportedFromModule =
2408 DebugTypeExtRefs && ED->isFromASTFile() && ED->getDefinition();
2409
2410 // If this is just a forward declaration, construct an appropriately
2411 // marked node and just return it.
2412 if (isImportedFromModule || !ED->getDefinition()) {
2413 // Note that it is possible for enums to be created as part of
2414 // their own declcontext. In this case a FwdDecl will be created
2415 // twice. This doesn't cause a problem because both FwdDecls are
2416 // entered into the ReplaceMap: finalize() will replace the first
2417 // FwdDecl with the second and then replace the second with
2418 // complete type.
2419 llvm::DIScope *EDContext = getDeclContextDescriptor(ED);
2420 llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
2421 llvm::TempDIScope TmpContext(DBuilder.createReplaceableCompositeType(
2422 llvm::dwarf::DW_TAG_enumeration_type, "", TheCU, DefUnit, 0));
2423
2424 unsigned Line = getLineNumber(ED->getLocation());
2425 StringRef EDName = ED->getName();
2426 llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType(
2427 llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit, Line,
2428 0, Size, Align, llvm::DINode::FlagFwdDecl, FullName);
2429
2430 ReplaceMap.emplace_back(
2431 std::piecewise_construct, std::make_tuple(Ty),
2432 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
2433 return RetTy;
2434 }
2435
2436 return CreateTypeDefinition(Ty);
2437}
2438
2439llvm::DIType *CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) {
2440 const EnumDecl *ED = Ty->getDecl();
2441 uint64_t Size = 0;
2442 uint32_t Align = 0;
2443 if (!ED->getTypeForDecl()->isIncompleteType()) {
2444 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
2445 Align = getDeclAlignIfRequired(ED, CGM.getContext());
2446 }
2447
2448 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
2449
2450 // Create elements for each enumerator.
2451 SmallVector<llvm::Metadata *, 16> Enumerators;
2452 ED = ED->getDefinition();
2453 for (const auto *Enum : ED->enumerators()) {
2454 Enumerators.push_back(DBuilder.createEnumerator(
2455 Enum->getName(), Enum->getInitVal().getSExtValue()));
2456 }
2457
2458 // Return a CompositeType for the enum itself.
2459 llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
2460
2461 llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
2462 unsigned Line = getLineNumber(ED->getLocation());
2463 llvm::DIScope *EnumContext = getDeclContextDescriptor(ED);
2464 llvm::DIType *ClassTy =
2465 ED->isFixed() ? getOrCreateType(ED->getIntegerType(), DefUnit) : nullptr;
2466 return DBuilder.createEnumerationType(EnumContext, ED->getName(), DefUnit,
2467 Line, Size, Align, EltArray, ClassTy,
2468 FullName);
2469}
2470
2471llvm::DIMacro *CGDebugInfo::CreateMacro(llvm::DIMacroFile *Parent,
2472 unsigned MType, SourceLocation LineLoc,
2473 StringRef Name, StringRef Value) {
2474 unsigned Line = LineLoc.isInvalid() ? 0 : getLineNumber(LineLoc);
2475 return DBuilder.createMacro(Parent, Line, MType, Name, Value);
2476}
2477
2478llvm::DIMacroFile *CGDebugInfo::CreateTempMacroFile(llvm::DIMacroFile *Parent,
2479 SourceLocation LineLoc,
2480 SourceLocation FileLoc) {
2481 llvm::DIFile *FName = getOrCreateFile(FileLoc);
2482 unsigned Line = LineLoc.isInvalid() ? 0 : getLineNumber(LineLoc);
2483 return DBuilder.createTempMacroFile(Parent, Line, FName);
2484}
2485
2486static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C) {
2487 Qualifiers Quals;
2488 do {
2489 Qualifiers InnerQuals = T.getLocalQualifiers();
2490 // Qualifiers::operator+() doesn't like it if you add a Qualifier
2491 // that is already there.
2492 Quals += Qualifiers::removeCommonQualifiers(Quals, InnerQuals);
2493 Quals += InnerQuals;
2494 QualType LastT = T;
2495 switch (T->getTypeClass()) {
2496 default:
2497 return C.getQualifiedType(T.getTypePtr(), Quals);
2498 case Type::TemplateSpecialization: {
2499 const auto *Spec = cast<TemplateSpecializationType>(T);
2500 if (Spec->isTypeAlias())
2501 return C.getQualifiedType(T.getTypePtr(), Quals);
2502 T = Spec->desugar();
2503 break;
2504 }
2505 case Type::TypeOfExpr:
2506 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
2507 break;
2508 case Type::TypeOf:
2509 T = cast<TypeOfType>(T)->getUnderlyingType();
2510 break;
2511 case Type::Decltype:
2512 T = cast<DecltypeType>(T)->getUnderlyingType();
2513 break;
2514 case Type::UnaryTransform:
2515 T = cast<UnaryTransformType>(T)->getUnderlyingType();
2516 break;
2517 case Type::Attributed:
2518 T = cast<AttributedType>(T)->getEquivalentType();
2519 break;
2520 case Type::Elaborated:
2521 T = cast<ElaboratedType>(T)->getNamedType();
2522 break;
2523 case Type::Paren:
2524 T = cast<ParenType>(T)->getInnerType();
2525 break;
2526 case Type::SubstTemplateTypeParm:
2527 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
2528 break;
2529 case Type::Auto:
2530 case Type::DeducedTemplateSpecialization: {
2531 QualType DT = cast<DeducedType>(T)->getDeducedType();
2532 assert(!DT.isNull() && "Undeduced types shouldn't reach here.")((!DT.isNull() && "Undeduced types shouldn't reach here."
) ? static_cast<void> (0) : __assert_fail ("!DT.isNull() && \"Undeduced types shouldn't reach here.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2532, __PRETTY_FUNCTION__))
;
2533 T = DT;
2534 break;
2535 }
2536 case Type::Adjusted:
2537 case Type::Decayed:
2538 // Decayed and adjusted types use the adjusted type in LLVM and DWARF.
2539 T = cast<AdjustedType>(T)->getAdjustedType();
2540 break;
2541 }
2542
2543 assert(T != LastT && "Type unwrapping failed to unwrap!")((T != LastT && "Type unwrapping failed to unwrap!") ?
static_cast<void> (0) : __assert_fail ("T != LastT && \"Type unwrapping failed to unwrap!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2543, __PRETTY_FUNCTION__))
;
2544 (void)LastT;
2545 } while (true);
2546}
2547
2548llvm::DIType *CGDebugInfo::getTypeOrNull(QualType Ty) {
2549
2550 // Unwrap the type as needed for debug information.
2551 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
2552
2553 auto it = TypeCache.find(Ty.getAsOpaquePtr());
2554 if (it != TypeCache.end()) {
2555 // Verify that the debug info still exists.
2556 if (llvm::Metadata *V = it->second)
2557 return cast<llvm::DIType>(V);
2558 }
2559
2560 return nullptr;
2561}
2562
2563void CGDebugInfo::completeTemplateDefinition(
2564 const ClassTemplateSpecializationDecl &SD) {
2565 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
2566 return;
2567 completeUnusedClass(SD);
2568}
2569
2570void CGDebugInfo::completeUnusedClass(const CXXRecordDecl &D) {
2571 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
2572 return;
2573
2574 completeClassData(&D);
2575 // In case this type has no member function definitions being emitted, ensure
2576 // it is retained
2577 RetainedTypes.push_back(CGM.getContext().getRecordType(&D).getAsOpaquePtr());
2578}
2579
2580llvm::DIType *CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile *Unit) {
2581 if (Ty.isNull())
2582 return nullptr;
2583
2584 // Unwrap the type as needed for debug information.
2585 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
2586
2587 if (auto *T = getTypeOrNull(Ty))
2588 return T;
2589
2590 llvm::DIType *Res = CreateTypeNode(Ty, Unit);
2591 void* TyPtr = Ty.getAsOpaquePtr();
2592
2593 // And update the type cache.
2594 TypeCache[TyPtr].reset(Res);
2595
2596 return Res;
2597}
2598
2599llvm::DIModule *CGDebugInfo::getParentModuleOrNull(const Decl *D) {
2600 // A forward declaration inside a module header does not belong to the module.
2601 if (isa<RecordDecl>(D) && !cast<RecordDecl>(D)->getDefinition())
2602 return nullptr;
2603 if (DebugTypeExtRefs && D->isFromASTFile()) {
2604 // Record a reference to an imported clang module or precompiled header.
2605 auto *Reader = CGM.getContext().getExternalSource();
2606 auto Idx = D->getOwningModuleID();
2607 auto Info = Reader->getSourceDescriptor(Idx);
2608 if (Info)
2609 return getOrCreateModuleRef(*Info, /*SkeletonCU=*/true);
2610 } else if (ClangModuleMap) {
2611 // We are building a clang module or a precompiled header.
2612 //
2613 // TODO: When D is a CXXRecordDecl or a C++ Enum, the ODR applies
2614 // and it wouldn't be necessary to specify the parent scope
2615 // because the type is already unique by definition (it would look
2616 // like the output of -fno-standalone-debug). On the other hand,
2617 // the parent scope helps a consumer to quickly locate the object
2618 // file where the type's definition is located, so it might be
2619 // best to make this behavior a command line or debugger tuning
2620 // option.
2621 FullSourceLoc Loc(D->getLocation(), CGM.getContext().getSourceManager());
2622 if (Module *M = D->getOwningModule()) {
2623 // This is a (sub-)module.
2624 auto Info = ExternalASTSource::ASTSourceDescriptor(*M);
2625 return getOrCreateModuleRef(Info, /*SkeletonCU=*/false);
2626 } else {
2627 // This the precompiled header being built.
2628 return getOrCreateModuleRef(PCHDescriptor, /*SkeletonCU=*/false);
2629 }
2630 }
2631
2632 return nullptr;
2633}
2634
2635llvm::DIType *CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile *Unit) {
2636 // Handle qualifiers, which recursively handles what they refer to.
2637 if (Ty.hasLocalQualifiers())
2638 return CreateQualifiedType(Ty, Unit);
2639
2640 // Work out details of type.
2641 switch (Ty->getTypeClass()) {
2642#define TYPE(Class, Base)
2643#define ABSTRACT_TYPE(Class, Base)
2644#define NON_CANONICAL_TYPE(Class, Base)
2645#define DEPENDENT_TYPE(Class, Base) case Type::Class:
2646#include "clang/AST/TypeNodes.def"
2647 llvm_unreachable("Dependent types cannot show up in debug information")::llvm::llvm_unreachable_internal("Dependent types cannot show up in debug information"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2647)
;
2648
2649 case Type::ExtVector:
2650 case Type::Vector:
2651 return CreateType(cast<VectorType>(Ty), Unit);
2652 case Type::ObjCObjectPointer:
2653 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
2654 case Type::ObjCObject:
2655 return CreateType(cast<ObjCObjectType>(Ty), Unit);
2656 case Type::ObjCTypeParam:
2657 return CreateType(cast<ObjCTypeParamType>(Ty), Unit);
2658 case Type::ObjCInterface:
2659 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
2660 case Type::Builtin:
2661 return CreateType(cast<BuiltinType>(Ty));
2662 case Type::Complex:
2663 return CreateType(cast<ComplexType>(Ty));
2664 case Type::Pointer:
2665 return CreateType(cast<PointerType>(Ty), Unit);
2666 case Type::BlockPointer:
2667 return CreateType(cast<BlockPointerType>(Ty), Unit);
2668 case Type::Typedef:
2669 return CreateType(cast<TypedefType>(Ty), Unit);
2670 case Type::Record:
2671 return CreateType(cast<RecordType>(Ty));
2672 case Type::Enum:
2673 return CreateEnumType(cast<EnumType>(Ty));
2674 case Type::FunctionProto:
2675 case Type::FunctionNoProto:
2676 return CreateType(cast<FunctionType>(Ty), Unit);
2677 case Type::ConstantArray:
2678 case Type::VariableArray:
2679 case Type::IncompleteArray:
2680 return CreateType(cast<ArrayType>(Ty), Unit);
2681
2682 case Type::LValueReference:
2683 return CreateType(cast<LValueReferenceType>(Ty), Unit);
2684 case Type::RValueReference:
2685 return CreateType(cast<RValueReferenceType>(Ty), Unit);
2686
2687 case Type::MemberPointer:
2688 return CreateType(cast<MemberPointerType>(Ty), Unit);
2689
2690 case Type::Atomic:
2691 return CreateType(cast<AtomicType>(Ty), Unit);
2692
2693 case Type::Pipe:
2694 return CreateType(cast<PipeType>(Ty), Unit);
2695
2696 case Type::TemplateSpecialization:
2697 return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
2698
2699 case Type::Auto:
2700 case Type::Attributed:
2701 case Type::Adjusted:
2702 case Type::Decayed:
2703 case Type::DeducedTemplateSpecialization:
2704 case Type::Elaborated:
2705 case Type::Paren:
2706 case Type::SubstTemplateTypeParm:
2707 case Type::TypeOfExpr:
2708 case Type::TypeOf:
2709 case Type::Decltype:
2710 case Type::UnaryTransform:
2711 case Type::PackExpansion:
2712 break;
2713 }
2714
2715 llvm_unreachable("type should have been unwrapped!")::llvm::llvm_unreachable_internal("type should have been unwrapped!"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2715)
;
2716}
2717
2718llvm::DICompositeType *CGDebugInfo::getOrCreateLimitedType(const RecordType *Ty,
2719 llvm::DIFile *Unit) {
2720 QualType QTy(Ty, 0);
2721
2722 auto *T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));
2723
2724 // We may have cached a forward decl when we could have created
2725 // a non-forward decl. Go ahead and create a non-forward decl
2726 // now.
2727 if (T && !T->isForwardDecl())
2728 return T;
2729
2730 // Otherwise create the type.
2731 llvm::DICompositeType *Res = CreateLimitedType(Ty);
2732
2733 // Propagate members from the declaration to the definition
2734 // CreateType(const RecordType*) will overwrite this with the members in the
2735 // correct order if the full type is needed.
2736 DBuilder.replaceArrays(Res, T ? T->getElements() : llvm::DINodeArray());
2737
2738 // And update the type cache.
2739 TypeCache[QTy.getAsOpaquePtr()].reset(Res);
2740 return Res;
2741}
2742
2743// TODO: Currently used for context chains when limiting debug info.
2744llvm::DICompositeType *CGDebugInfo::CreateLimitedType(const RecordType *Ty) {
2745 RecordDecl *RD = Ty->getDecl();
2746
2747 // Get overall information about the record type for the debug info.
2748 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
2749 unsigned Line = getLineNumber(RD->getLocation());
2750 StringRef RDName = getClassName(RD);
2751
2752 llvm::DIScope *RDContext = getDeclContextDescriptor(RD);
2753
2754 // If we ended up creating the type during the context chain construction,
2755 // just return that.
2756 auto *T = cast_or_null<llvm::DICompositeType>(
2757 getTypeOrNull(CGM.getContext().getRecordType(RD)));
2758 if (T && (!T->isForwardDecl() || !RD->getDefinition()))
2759 return T;
2760
2761 // If this is just a forward or incomplete declaration, construct an
2762 // appropriately marked node and just return it.
2763 const RecordDecl *D = RD->getDefinition();
2764 if (!D || !D->isCompleteDefinition())
2765 return getOrCreateRecordFwdDecl(Ty, RDContext);
2766
2767 uint64_t Size = CGM.getContext().getTypeSize(Ty);
2768 auto Align = getDeclAlignIfRequired(D, CGM.getContext());
2769
2770 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
2771
2772 llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
2773 getTagForRecord(RD), RDName, RDContext, DefUnit, Line, 0, Size, Align,
2774 llvm::DINode::FlagZero, FullName);
2775
2776 // Elements of composite types usually have back to the type, creating
2777 // uniquing cycles. Distinct nodes are more efficient.
2778 switch (RealDecl->getTag()) {
2779 default:
2780 llvm_unreachable("invalid composite type tag")::llvm::llvm_unreachable_internal("invalid composite type tag"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2780)
;
2781
2782 case llvm::dwarf::DW_TAG_array_type:
2783 case llvm::dwarf::DW_TAG_enumeration_type:
2784 // Array elements and most enumeration elements don't have back references,
2785 // so they don't tend to be involved in uniquing cycles and there is some
2786 // chance of merging them when linking together two modules. Only make
2787 // them distinct if they are ODR-uniqued.
2788 if (FullName.empty())
2789 break;
2790 LLVM_FALLTHROUGH[[clang::fallthrough]];
2791
2792 case llvm::dwarf::DW_TAG_structure_type:
2793 case llvm::dwarf::DW_TAG_union_type:
2794 case llvm::dwarf::DW_TAG_class_type:
2795 // Immediatley resolve to a distinct node.
2796 RealDecl =
2797 llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
2798 break;
2799 }
2800
2801 RegionMap[Ty->getDecl()].reset(RealDecl);
2802 TypeCache[QualType(Ty, 0).getAsOpaquePtr()].reset(RealDecl);
2803
2804 if (const auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
2805 DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),
2806 CollectCXXTemplateParams(TSpecial, DefUnit));
2807 return RealDecl;
2808}
2809
2810void CGDebugInfo::CollectContainingType(const CXXRecordDecl *RD,
2811 llvm::DICompositeType *RealDecl) {
2812 // A class's primary base or the class itself contains the vtable.
2813 llvm::DICompositeType *ContainingType = nullptr;
2814 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2815 if (const CXXRecordDecl *PBase = RL.getPrimaryBase()) {
2816 // Seek non-virtual primary base root.
2817 while (1) {
2818 const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase);
2819 const CXXRecordDecl *PBT = BRL.getPrimaryBase();
2820 if (PBT && !BRL.isPrimaryBaseVirtual())
2821 PBase = PBT;
2822 else
2823 break;
2824 }
2825 ContainingType = cast<llvm::DICompositeType>(
2826 getOrCreateType(QualType(PBase->getTypeForDecl(), 0),
2827 getOrCreateFile(RD->getLocation())));
2828 } else if (RD->isDynamicClass())
2829 ContainingType = RealDecl;
2830
2831 DBuilder.replaceVTableHolder(RealDecl, ContainingType);
2832}
2833
2834llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit, QualType FType,
2835 StringRef Name, uint64_t *Offset) {
2836 llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
2837 uint64_t FieldSize = CGM.getContext().getTypeSize(FType);
2838 auto FieldAlign = getTypeAlignIfRequired(FType, CGM.getContext());
2839 llvm::DIType *Ty =
2840 DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize, FieldAlign,
2841 *Offset, llvm::DINode::FlagZero, FieldTy);
2842 *Offset += FieldSize;
2843 return Ty;
2844}
2845
2846void CGDebugInfo::collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit,
2847 StringRef &Name,
2848 StringRef &LinkageName,
2849 llvm::DIScope *&FDContext,
2850 llvm::DINodeArray &TParamsArray,
2851 llvm::DINode::DIFlags &Flags) {
2852 const auto *FD = cast<FunctionDecl>(GD.getDecl());
2853 Name = getFunctionName(FD);
2854 // Use mangled name as linkage name for C/C++ functions.
2855 if (FD->hasPrototype()) {
2856 LinkageName = CGM.getMangledName(GD);
2857 Flags |= llvm::DINode::FlagPrototyped;
2858 }
2859 // No need to replicate the linkage name if it isn't different from the
2860 // subprogram name, no need to have it at all unless coverage is enabled or
2861 // debug is set to more than just line tables or extra debug info is needed.
2862 if (LinkageName == Name || (!CGM.getCodeGenOpts().EmitGcovArcs &&
2863 !CGM.getCodeGenOpts().EmitGcovNotes &&
2864 !CGM.getCodeGenOpts().DebugInfoForProfiling &&
2865 DebugKind <= codegenoptions::DebugLineTablesOnly))
2866 LinkageName = StringRef();
2867
2868 if (DebugKind >= codegenoptions::LimitedDebugInfo) {
2869 if (const NamespaceDecl *NSDecl =
2870 dyn_cast_or_null<NamespaceDecl>(FD->getDeclContext()))
2871 FDContext = getOrCreateNamespace(NSDecl);
2872 else if (const RecordDecl *RDecl =
2873 dyn_cast_or_null<RecordDecl>(FD->getDeclContext())) {
2874 llvm::DIScope *Mod = getParentModuleOrNull(RDecl);
2875 FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU);
2876 }
2877 // Check if it is a noreturn-marked function
2878 if (FD->isNoReturn())
2879 Flags |= llvm::DINode::FlagNoReturn;
2880 // Collect template parameters.
2881 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
2882 }
2883}
2884
2885void CGDebugInfo::collectVarDeclProps(const VarDecl *VD, llvm::DIFile *&Unit,
2886 unsigned &LineNo, QualType &T,
2887 StringRef &Name, StringRef &LinkageName,
2888 llvm::DIScope *&VDContext) {
2889 Unit = getOrCreateFile(VD->getLocation());
2890 LineNo = getLineNumber(VD->getLocation());
2891
2892 setLocation(VD->getLocation());
2893
2894 T = VD->getType();
2895 if (T->isIncompleteArrayType()) {
2896 // CodeGen turns int[] into int[1] so we'll do the same here.
2897 llvm::APInt ConstVal(32, 1);
2898 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
2899
2900 T = CGM.getContext().getConstantArrayType(ET, ConstVal,
2901 ArrayType::Normal, 0);
2902 }
2903
2904 Name = VD->getName();
2905 if (VD->getDeclContext() && !isa<FunctionDecl>(VD->getDeclContext()) &&
2906 !isa<ObjCMethodDecl>(VD->getDeclContext()))
2907 LinkageName = CGM.getMangledName(VD);
2908 if (LinkageName == Name)
2909 LinkageName = StringRef();
2910
2911 // Since we emit declarations (DW_AT_members) for static members, place the
2912 // definition of those static members in the namespace they were declared in
2913 // in the source code (the lexical decl context).
2914 // FIXME: Generalize this for even non-member global variables where the
2915 // declaration and definition may have different lexical decl contexts, once
2916 // we have support for emitting declarations of (non-member) global variables.
2917 const DeclContext *DC = VD->isStaticDataMember() ? VD->getLexicalDeclContext()
2918 : VD->getDeclContext();
2919 // When a record type contains an in-line initialization of a static data
2920 // member, and the record type is marked as __declspec(dllexport), an implicit
2921 // definition of the member will be created in the record context. DWARF
2922 // doesn't seem to have a nice way to describe this in a form that consumers
2923 // are likely to understand, so fake the "normal" situation of a definition
2924 // outside the class by putting it in the global scope.
2925 if (DC->isRecord())
2926 DC = CGM.getContext().getTranslationUnitDecl();
2927
2928 llvm::DIScope *Mod = getParentModuleOrNull(VD);
2929 VDContext = getContextDescriptor(cast<Decl>(DC), Mod ? Mod : TheCU);
2930}
2931
2932llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(GlobalDecl GD,
2933 bool Stub) {
2934 llvm::DINodeArray TParamsArray;
2935 StringRef Name, LinkageName;
2936 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2937 SourceLocation Loc = GD.getDecl()->getLocation();
2938 llvm::DIFile *Unit = getOrCreateFile(Loc);
2939 llvm::DIScope *DContext = Unit;
2940 unsigned Line = getLineNumber(Loc);
2941 collectFunctionDeclProps(GD, Unit, Name, LinkageName, DContext,
2942 TParamsArray, Flags);
2943 auto *FD = dyn_cast<FunctionDecl>(GD.getDecl());
2944
2945 // Build function type.
2946 SmallVector<QualType, 16> ArgTypes;
2947 if (FD)
2948 for (const ParmVarDecl *Parm : FD->parameters())
2949 ArgTypes.push_back(Parm->getType());
2950 CallingConv CC = FD->getType()->castAs<FunctionType>()->getCallConv();
2951 QualType FnType = CGM.getContext().getFunctionType(
2952 FD->getReturnType(), ArgTypes, FunctionProtoType::ExtProtoInfo(CC));
2953 if (Stub) {
2954 return DBuilder.createFunction(
2955 DContext, Name, LinkageName, Unit, Line,
2956 getOrCreateFunctionType(GD.getDecl(), FnType, Unit),
2957 !FD->isExternallyVisible(),
2958 /* isDefinition = */ true, 0, Flags, CGM.getLangOpts().Optimize,
2959 TParamsArray.get(), getFunctionDeclaration(FD));
2960 }
2961
2962 llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
2963 DContext, Name, LinkageName, Unit, Line,
2964 getOrCreateFunctionType(GD.getDecl(), FnType, Unit),
2965 !FD->isExternallyVisible(),
2966 /* isDefinition = */ false, 0, Flags, CGM.getLangOpts().Optimize,
2967 TParamsArray.get(), getFunctionDeclaration(FD));
2968 const auto *CanonDecl = cast<FunctionDecl>(FD->getCanonicalDecl());
2969 FwdDeclReplaceMap.emplace_back(std::piecewise_construct,
2970 std::make_tuple(CanonDecl),
2971 std::make_tuple(SP));
2972 return SP;
2973}
2974
2975llvm::DISubprogram *
2976CGDebugInfo::getFunctionForwardDeclaration(GlobalDecl GD) {
2977 return getFunctionFwdDeclOrStub(GD, /* Stub = */ false);
2978}
2979
2980llvm::DISubprogram *
2981CGDebugInfo::getFunctionStub(GlobalDecl GD) {
2982 return getFunctionFwdDeclOrStub(GD, /* Stub = */ true);
2983}
2984
2985llvm::DIGlobalVariable *
2986CGDebugInfo::getGlobalVariableForwardDeclaration(const VarDecl *VD) {
2987 QualType T;
2988 StringRef Name, LinkageName;
2989 SourceLocation Loc = VD->getLocation();
2990 llvm::DIFile *Unit = getOrCreateFile(Loc);
2991 llvm::DIScope *DContext = Unit;
2992 unsigned Line = getLineNumber(Loc);
2993
2994 collectVarDeclProps(VD, Unit, Line, T, Name, LinkageName, DContext);
2995 auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
2996 auto *GV = DBuilder.createTempGlobalVariableFwdDecl(
2997 DContext, Name, LinkageName, Unit, Line, getOrCreateType(T, Unit),
2998 !VD->isExternallyVisible(), nullptr, Align);
2999 FwdDeclReplaceMap.emplace_back(
3000 std::piecewise_construct,
3001 std::make_tuple(cast<VarDecl>(VD->getCanonicalDecl())),
3002 std::make_tuple(static_cast<llvm::Metadata *>(GV)));
3003 return GV;
3004}
3005
3006llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(const Decl *D) {
3007 // We only need a declaration (not a definition) of the type - so use whatever
3008 // we would otherwise do to get a type for a pointee. (forward declarations in
3009 // limited debug info, full definitions (if the type definition is available)
3010 // in unlimited debug info)
3011 if (const auto *TD = dyn_cast<TypeDecl>(D))
3012 return getOrCreateType(CGM.getContext().getTypeDeclType(TD),
3013 getOrCreateFile(TD->getLocation()));
3014 auto I = DeclCache.find(D->getCanonicalDecl());
3015
3016 if (I != DeclCache.end()) {
3017 auto N = I->second;
3018 if (auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(N))
3019 return GVE->getVariable();
3020 return dyn_cast_or_null<llvm::DINode>(N);
3021 }
3022
3023 // No definition for now. Emit a forward definition that might be
3024 // merged with a potential upcoming definition.
3025 if (const auto *FD = dyn_cast<FunctionDecl>(D))
3026 return getFunctionForwardDeclaration(FD);
3027 else if (const auto *VD = dyn_cast<VarDecl>(D))
3028 return getGlobalVariableForwardDeclaration(VD);
3029
3030 return nullptr;
3031}
3032
3033llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(const Decl *D) {
3034 if (!D || DebugKind <= codegenoptions::DebugLineTablesOnly)
3035 return nullptr;
3036
3037 const auto *FD = dyn_cast<FunctionDecl>(D);
3038 if (!FD)
3039 return nullptr;
3040
3041 // Setup context.
3042 auto *S = getDeclContextDescriptor(D);
3043
3044 auto MI = SPCache.find(FD->getCanonicalDecl());
3045 if (MI == SPCache.end()) {
3046 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD->getCanonicalDecl())) {
3047 return CreateCXXMemberFunction(MD, getOrCreateFile(MD->getLocation()),
3048 cast<llvm::DICompositeType>(S));
3049 }
3050 }
3051 if (MI != SPCache.end()) {
3052 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3053 if (SP && !SP->isDefinition())
3054 return SP;
3055 }
3056
3057 for (auto NextFD : FD->redecls()) {
3058 auto MI = SPCache.find(NextFD->getCanonicalDecl());
3059 if (MI != SPCache.end()) {
3060 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3061 if (SP && !SP->isDefinition())
3062 return SP;
3063 }
3064 }
3065 return nullptr;
3066}
3067
3068// getOrCreateFunctionType - Construct type. If it is a c++ method, include
3069// implicit parameter "this".
3070llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(const Decl *D,
3071 QualType FnType,
3072 llvm::DIFile *F) {
3073 if (!D || DebugKind <= codegenoptions::DebugLineTablesOnly)
3074 // Create fake but valid subroutine type. Otherwise -verify would fail, and
3075 // subprogram DIE will miss DW_AT_decl_file and DW_AT_decl_line fields.
3076 return DBuilder.createSubroutineType(DBuilder.getOrCreateTypeArray(None));
3077
3078 if (const auto *Method = dyn_cast<CXXMethodDecl>(D))
3079 return getOrCreateMethodType(Method, F);
3080
3081 const auto *FTy = FnType->getAs<FunctionType>();
3082 CallingConv CC = FTy ? FTy->getCallConv() : CallingConv::CC_C;
3083
3084 if (const auto *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
3085 // Add "self" and "_cmd"
3086 SmallVector<llvm::Metadata *, 16> Elts;
3087
3088 // First element is always return type. For 'void' functions it is NULL.
3089 QualType ResultTy = OMethod->getReturnType();
3090
3091 // Replace the instancetype keyword with the actual type.
3092 if (ResultTy == CGM.getContext().getObjCInstanceType())
3093 ResultTy = CGM.getContext().getPointerType(
3094 QualType(OMethod->getClassInterface()->getTypeForDecl(), 0));
3095
3096 Elts.push_back(getOrCreateType(ResultTy, F));
3097 // "self" pointer is always first argument.
3098 QualType SelfDeclTy;
3099 if (auto *SelfDecl = OMethod->getSelfDecl())
3100 SelfDeclTy = SelfDecl->getType();
3101 else if (auto *FPT = dyn_cast<FunctionProtoType>(FnType))
3102 if (FPT->getNumParams() > 1)
3103 SelfDeclTy = FPT->getParamType(0);
3104 if (!SelfDeclTy.isNull())
3105 Elts.push_back(CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F)));
3106 // "_cmd" pointer is always second argument.
3107 Elts.push_back(DBuilder.createArtificialType(
3108 getOrCreateType(CGM.getContext().getObjCSelType(), F)));
3109 // Get rest of the arguments.
3110 for (const auto *PI : OMethod->parameters())
3111 Elts.push_back(getOrCreateType(PI->getType(), F));
3112 // Variadic methods need a special marker at the end of the type list.
3113 if (OMethod->isVariadic())
3114 Elts.push_back(DBuilder.createUnspecifiedParameter());
3115
3116 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
3117 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
3118 getDwarfCC(CC));
3119 }
3120
3121 // Handle variadic function types; they need an additional
3122 // unspecified parameter.
3123 if (const auto *FD = dyn_cast<FunctionDecl>(D))
3124 if (FD->isVariadic()) {
3125 SmallVector<llvm::Metadata *, 16> EltTys;
3126 EltTys.push_back(getOrCreateType(FD->getReturnType(), F));
3127 if (const auto *FPT = dyn_cast<FunctionProtoType>(FnType))
3128 for (QualType ParamType : FPT->param_types())
3129 EltTys.push_back(getOrCreateType(ParamType, F));
3130 EltTys.push_back(DBuilder.createUnspecifiedParameter());
3131 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
3132 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
3133 getDwarfCC(CC));
3134 }
3135
3136 return cast<llvm::DISubroutineType>(getOrCreateType(FnType, F));
3137}
3138
3139void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, SourceLocation Loc,
3140 SourceLocation ScopeLoc, QualType FnType,
3141 llvm::Function *Fn, CGBuilderTy &Builder) {
3142
3143 StringRef Name;
3144 StringRef LinkageName;
3145
3146 FnBeginRegionCount.push_back(LexicalBlockStack.size());
3147
3148 const Decl *D = GD.getDecl();
3149 bool HasDecl = (D != nullptr);
3150
3151 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3152 llvm::DIFile *Unit = getOrCreateFile(Loc);
3153 llvm::DIScope *FDContext = Unit;
3154 llvm::DINodeArray TParamsArray;
3155 if (!HasDecl) {
3156 // Use llvm function name.
3157 LinkageName = Fn->getName();
3158 } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
3159 // If there is a subprogram for this function available then use it.
3160 auto FI = SPCache.find(FD->getCanonicalDecl());
3161 if (FI != SPCache.end()) {
3162 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
3163 if (SP && SP->isDefinition()) {
3164 LexicalBlockStack.emplace_back(SP);
3165 RegionMap[D].reset(SP);
3166 return;
3167 }
3168 }
3169 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
3170 TParamsArray, Flags);
3171 } else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
3172 Name = getObjCMethodName(OMD);
3173 Flags |= llvm::DINode::FlagPrototyped;
3174 } else {
3175 // Use llvm function name.
3176 Name = Fn->getName();
3177 Flags |= llvm::DINode::FlagPrototyped;
3178 }
3179 if (Name.startswith("\01"))
3180 Name = Name.substr(1);
3181
3182 if (!HasDecl || D->isImplicit()) {
3183 Flags |= llvm::DINode::FlagArtificial;
3184 // Artificial functions should not silently reuse CurLoc.
3185 CurLoc = SourceLocation();
3186 }
3187 unsigned LineNo = getLineNumber(Loc);
3188 unsigned ScopeLine = getLineNumber(ScopeLoc);
3189
3190 // FIXME: The function declaration we're constructing here is mostly reusing
3191 // declarations from CXXMethodDecl and not constructing new ones for arbitrary
3192 // FunctionDecls. When/if we fix this we can have FDContext be TheCU/null for
3193 // all subprograms instead of the actual context since subprogram definitions
3194 // are emitted as CU level entities by the backend.
3195 llvm::DISubprogram *SP = DBuilder.createFunction(
3196 FDContext, Name, LinkageName, Unit, LineNo,
3197 getOrCreateFunctionType(D, FnType, Unit), Fn->hasLocalLinkage(),
3198 true /*definition*/, ScopeLine, Flags, CGM.getLangOpts().Optimize,
3199 TParamsArray.get(), getFunctionDeclaration(D));
3200 Fn->setSubprogram(SP);
3201 // We might get here with a VarDecl in the case we're generating
3202 // code for the initialization of globals. Do not record these decls
3203 // as they will overwrite the actual VarDecl Decl in the cache.
3204 if (HasDecl && isa<FunctionDecl>(D))
3205 DeclCache[D->getCanonicalDecl()].reset(SP);
3206
3207 // Push the function onto the lexical block stack.
3208 LexicalBlockStack.emplace_back(SP);
3209
3210 if (HasDecl)
3211 RegionMap[D].reset(SP);
3212}
3213
3214void CGDebugInfo::EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc,
3215 QualType FnType) {
3216 StringRef Name;
3217 StringRef LinkageName;
3218
3219 const Decl *D = GD.getDecl();
3220 if (!D)
3221 return;
3222
3223 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3224 llvm::DIFile *Unit = getOrCreateFile(Loc);
3225 llvm::DIScope *FDContext = getDeclContextDescriptor(D);
3226 llvm::DINodeArray TParamsArray;
3227 if (isa<FunctionDecl>(D)) {
3228 // If there is a DISubprogram for this function available then use it.
3229 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
3230 TParamsArray, Flags);
3231 } else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
3232 Name = getObjCMethodName(OMD);
3233 Flags |= llvm::DINode::FlagPrototyped;
3234 } else {
3235 llvm_unreachable("not a function or ObjC method")::llvm::llvm_unreachable_internal("not a function or ObjC method"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3235)
;
3236 }
3237 if (!Name.empty() && Name[0] == '\01')
3238 Name = Name.substr(1);
3239
3240 if (D->isImplicit()) {
3241 Flags |= llvm::DINode::FlagArtificial;
3242 // Artificial functions without a location should not silently reuse CurLoc.
3243 if (Loc.isInvalid())
3244 CurLoc = SourceLocation();
3245 }
3246 unsigned LineNo = getLineNumber(Loc);
3247 unsigned ScopeLine = 0;
3248
3249 DBuilder.retainType(DBuilder.createFunction(
3250 FDContext, Name, LinkageName, Unit, LineNo,
3251 getOrCreateFunctionType(D, FnType, Unit), false /*internalLinkage*/,
3252 false /*definition*/, ScopeLine, Flags, CGM.getLangOpts().Optimize,
3253 TParamsArray.get(), getFunctionDeclaration(D)));
3254}
3255
3256void CGDebugInfo::EmitInlineFunctionStart(CGBuilderTy &Builder, GlobalDecl GD) {
3257 const auto *FD = cast<FunctionDecl>(GD.getDecl());
3258 // If there is a subprogram for this function available then use it.
3259 auto FI = SPCache.find(FD->getCanonicalDecl());
3260 llvm::DISubprogram *SP = nullptr;
3261 if (FI != SPCache.end())
3262 SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
3263 if (!SP)
3264 SP = getFunctionStub(GD);
3265 FnBeginRegionCount.push_back(LexicalBlockStack.size());
3266 LexicalBlockStack.emplace_back(SP);
3267 setInlinedAt(Builder.getCurrentDebugLocation());
3268 EmitLocation(Builder, FD->getLocation());
3269}
3270
3271void CGDebugInfo::EmitInlineFunctionEnd(CGBuilderTy &Builder) {
3272 assert(CurInlinedAt && "unbalanced inline scope stack")((CurInlinedAt && "unbalanced inline scope stack") ? static_cast
<void> (0) : __assert_fail ("CurInlinedAt && \"unbalanced inline scope stack\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3272, __PRETTY_FUNCTION__))
;
3273 EmitFunctionEnd(Builder, nullptr);
3274 setInlinedAt(llvm::DebugLoc(CurInlinedAt).getInlinedAt());
3275}
3276
3277void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc) {
3278 // Update our current location
3279 setLocation(Loc);
3280
3281 if (CurLoc.isInvalid() || CurLoc.isMacroID())
3282 return;
3283
3284 llvm::MDNode *Scope = LexicalBlockStack.back();
3285 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
3286 getLineNumber(CurLoc), getColumnNumber(CurLoc), Scope, CurInlinedAt));
3287}
3288
3289void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) {
3290 llvm::MDNode *Back = nullptr;
3291 if (!LexicalBlockStack.empty())
3292 Back = LexicalBlockStack.back().get();
3293 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
3294 cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
3295 getColumnNumber(CurLoc)));
3296}
3297
3298void CGDebugInfo::AppendAddressSpaceXDeref(
3299 unsigned AddressSpace,
3300 SmallVectorImpl<int64_t> &Expr) const {
3301 Optional<unsigned> DWARFAddressSpace =
3302 CGM.getTarget().getDWARFAddressSpace(AddressSpace);
3303 if (!DWARFAddressSpace)
3304 return;
3305
3306 Expr.push_back(llvm::dwarf::DW_OP_constu);
3307 Expr.push_back(DWARFAddressSpace.getValue());
3308 Expr.push_back(llvm::dwarf::DW_OP_swap);
3309 Expr.push_back(llvm::dwarf::DW_OP_xderef);
3310}
3311
3312void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder,
3313 SourceLocation Loc) {
3314 // Set our current location.
3315 setLocation(Loc);
3316
3317 // Emit a line table change for the current location inside the new scope.
3318 Builder.SetCurrentDebugLocation(
3319 llvm::DebugLoc::get(getLineNumber(Loc), getColumnNumber(Loc),
3320 LexicalBlockStack.back(), CurInlinedAt));
3321
3322 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
3323 return;
3324
3325 // Create a new lexical block and push it on the stack.
3326 CreateLexicalBlock(Loc);
3327}
3328
3329void CGDebugInfo::EmitLexicalBlockEnd(CGBuilderTy &Builder,
3330 SourceLocation Loc) {
3331 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!")((!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"
) ? static_cast<void> (0) : __assert_fail ("!LexicalBlockStack.empty() && \"Region stack mismatch, stack empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3331, __PRETTY_FUNCTION__))
;
3332
3333 // Provide an entry in the line table for the end of the block.
3334 EmitLocation(Builder, Loc);
3335
3336 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
3337 return;
3338
3339 LexicalBlockStack.pop_back();
3340}
3341
3342void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder, llvm::Function *Fn) {
3343 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!")((!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"
) ? static_cast<void> (0) : __assert_fail ("!LexicalBlockStack.empty() && \"Region stack mismatch, stack empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3343, __PRETTY_FUNCTION__))
;
3344 unsigned RCount = FnBeginRegionCount.back();
3345 assert(RCount <= LexicalBlockStack.size() && "Region stack mismatch")((RCount <= LexicalBlockStack.size() && "Region stack mismatch"
) ? static_cast<void> (0) : __assert_fail ("RCount <= LexicalBlockStack.size() && \"Region stack mismatch\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3345, __PRETTY_FUNCTION__))
;
3346
3347 // Pop all regions for this function.
3348 while (LexicalBlockStack.size() != RCount) {
3349 // Provide an entry in the line table for the end of the block.
3350 EmitLocation(Builder, CurLoc);
3351 LexicalBlockStack.pop_back();
3352 }
3353 FnBeginRegionCount.pop_back();
3354
3355 if (Fn && Fn->getSubprogram())
3356 DBuilder.finalizeSubprogram(Fn->getSubprogram());
3357}
3358
3359llvm::DIType *CGDebugInfo::EmitTypeForVarWithBlocksAttr(const VarDecl *VD,
3360 uint64_t *XOffset) {
3361
3362 SmallVector<llvm::Metadata *, 5> EltTys;
3363 QualType FType;
3364 uint64_t FieldSize, FieldOffset;
3365 uint32_t FieldAlign;
3366
3367 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
3368 QualType Type = VD->getType();
3369
3370 FieldOffset = 0;
3371 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
3372 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
3373 EltTys.push_back(CreateMemberType(Unit, FType, "__forwarding", &FieldOffset));
3374 FType = CGM.getContext().IntTy;
3375 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
3376 EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset));
3377
3378 bool HasCopyAndDispose = CGM.getContext().BlockRequiresCopying(Type, VD);
3379 if (HasCopyAndDispose) {
3380 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
3381 EltTys.push_back(
3382 CreateMemberType(Unit, FType, "__copy_helper", &FieldOffset));
3383 EltTys.push_back(
3384 CreateMemberType(Unit, FType, "__destroy_helper", &FieldOffset));
3385 }
3386 bool HasByrefExtendedLayout;
3387 Qualifiers::ObjCLifetime Lifetime;
3388 if (CGM.getContext().getByrefLifetime(Type, Lifetime,
3389 HasByrefExtendedLayout) &&
3390 HasByrefExtendedLayout) {
3391 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
3392 EltTys.push_back(
3393 CreateMemberType(Unit, FType, "__byref_variable_layout", &FieldOffset));
3394 }
3395
3396 CharUnits Align = CGM.getContext().getDeclAlign(VD);
3397 if (Align > CGM.getContext().toCharUnitsFromBits(
3398 CGM.getTarget().getPointerAlign(0))) {
3399 CharUnits FieldOffsetInBytes =
3400 CGM.getContext().toCharUnitsFromBits(FieldOffset);
3401 CharUnits AlignedOffsetInBytes = FieldOffsetInBytes.alignTo(Align);
3402 CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;
3403
3404 if (NumPaddingBytes.isPositive()) {
3405 llvm::APInt pad(32, NumPaddingBytes.getQuantity());
3406 FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy,
3407 pad, ArrayType::Normal, 0);
3408 EltTys.push_back(CreateMemberType(Unit, FType, "", &FieldOffset));
3409 }
3410 }
3411
3412 FType = Type;
3413 llvm::DIType *FieldTy = getOrCreateType(FType, Unit);
3414 FieldSize = CGM.getContext().getTypeSize(FType);
3415 FieldAlign = CGM.getContext().toBits(Align);
3416
3417 *XOffset = FieldOffset;
3418 FieldTy = DBuilder.createMemberType(Unit, VD->getName(), Unit, 0, FieldSize,
3419 FieldAlign, FieldOffset,
3420 llvm::DINode::FlagZero, FieldTy);
3421 EltTys.push_back(FieldTy);
3422 FieldOffset += FieldSize;
3423
3424 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
3425
3426 llvm::DINode::DIFlags Flags = llvm::DINode::FlagBlockByrefStruct;
3427
3428 return DBuilder.createStructType(Unit, "", Unit, 0, FieldOffset, 0, Flags,
3429 nullptr, Elements);
3430}
3431
3432void CGDebugInfo::EmitDeclare(const VarDecl *VD, llvm::Value *Storage,
3433 llvm::Optional<unsigned> ArgNo,
3434 CGBuilderTy &Builder) {
3435 assert(DebugKind >= codegenoptions::LimitedDebugInfo)((DebugKind >= codegenoptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= codegenoptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3435, __PRETTY_FUNCTION__))
;
3436 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!")((!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"
) ? static_cast<void> (0) : __assert_fail ("!LexicalBlockStack.empty() && \"Region stack mismatch, stack empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3436, __PRETTY_FUNCTION__))
;
3437 if (VD->hasAttr<NoDebugAttr>())
3438 return;
3439
3440 bool Unwritten =
3441 VD->isImplicit() || (isa<Decl>(VD->getDeclContext()) &&
3442 cast<Decl>(VD->getDeclContext())->isImplicit());
3443 llvm::DIFile *Unit = nullptr;
3444 if (!Unwritten)
3445 Unit = getOrCreateFile(VD->getLocation());
3446 llvm::DIType *Ty;
3447 uint64_t XOffset = 0;
3448 if (VD->hasAttr<BlocksAttr>())
3449 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
3450 else
3451 Ty = getOrCreateType(VD->getType(), Unit);
3452
3453 // If there is no debug info for this type then do not emit debug info
3454 // for this variable.
3455 if (!Ty)
3456 return;
3457
3458 // Get location information.
3459 unsigned Line = 0;
3460 unsigned Column = 0;
3461 if (!Unwritten) {
3462 Line = getLineNumber(VD->getLocation());
3463 Column = getColumnNumber(VD->getLocation());
3464 }
3465 SmallVector<int64_t, 13> Expr;
3466 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3467 if (VD->isImplicit())
3468 Flags |= llvm::DINode::FlagArtificial;
3469
3470 auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
3471
3472 unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(VD->getType());
3473 AppendAddressSpaceXDeref(AddressSpace, Expr);
3474
3475 // If this is implicit parameter of CXXThis or ObjCSelf kind, then give it an
3476 // object pointer flag.
3477 if (const auto *IPD = dyn_cast<ImplicitParamDecl>(VD)) {
3478 if (IPD->getParameterKind() == ImplicitParamDecl::CXXThis ||
3479 IPD->getParameterKind() == ImplicitParamDecl::ObjCSelf)
3480 Flags |= llvm::DINode::FlagObjectPointer;
3481 }
3482
3483 // Note: Older versions of clang used to emit byval references with an extra
3484 // DW_OP_deref, because they referenced the IR arg directly instead of
3485 // referencing an alloca. Newer versions of LLVM don't treat allocas
3486 // differently from other function arguments when used in a dbg.declare.
3487 auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
3488 StringRef Name = VD->getName();
3489 if (!Name.empty()) {
3490 if (VD->hasAttr<BlocksAttr>()) {
3491 // Here, we need an offset *into* the alloca.
3492 CharUnits offset = CharUnits::fromQuantity(32);
3493 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3494 // offset of __forwarding field
3495 offset = CGM.getContext().toCharUnitsFromBits(
3496 CGM.getTarget().getPointerWidth(0));
3497 Expr.push_back(offset.getQuantity());
3498 Expr.push_back(llvm::dwarf::DW_OP_deref);
3499 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3500 // offset of x field
3501 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
3502 Expr.push_back(offset.getQuantity());
3503 }
3504 } else if (const auto *RT = dyn_cast<RecordType>(VD->getType())) {
3505 // If VD is an anonymous union then Storage represents value for
3506 // all union fields.
3507 const auto *RD = cast<RecordDecl>(RT->getDecl());
3508 if (RD->isUnion() && RD->isAnonymousStructOrUnion()) {
3509 // GDB has trouble finding local variables in anonymous unions, so we emit
3510 // artifical local variables for each of the members.
3511 //
3512 // FIXME: Remove this code as soon as GDB supports this.
3513 // The debug info verifier in LLVM operates based on the assumption that a
3514 // variable has the same size as its storage and we had to disable the check
3515 // for artificial variables.
3516 for (const auto *Field : RD->fields()) {
3517 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
3518 StringRef FieldName = Field->getName();
3519
3520 // Ignore unnamed fields. Do not ignore unnamed records.
3521 if (FieldName.empty() && !isa<RecordType>(Field->getType()))
3522 continue;
3523
3524 // Use VarDecl's Tag, Scope and Line number.
3525 auto FieldAlign = getDeclAlignIfRequired(Field, CGM.getContext());
3526 auto *D = DBuilder.createAutoVariable(
3527 Scope, FieldName, Unit, Line, FieldTy, CGM.getLangOpts().Optimize,
3528 Flags | llvm::DINode::FlagArtificial, FieldAlign);
3529
3530 // Insert an llvm.dbg.declare into the current block.
3531 DBuilder.insertDeclare(
3532 Storage, D, DBuilder.createExpression(Expr),
3533 llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
3534 Builder.GetInsertBlock());
3535 }
3536 }
3537 }
3538
3539 // Create the descriptor for the variable.
3540 auto *D = ArgNo
3541 ? DBuilder.createParameterVariable(
3542 Scope, Name, *ArgNo, Unit, Line, Ty,
3543 CGM.getLangOpts().Optimize, Flags)
3544 : DBuilder.createAutoVariable(Scope, Name, Unit, Line, Ty,
3545 CGM.getLangOpts().Optimize, Flags,
3546 Align);
3547
3548 // Insert an llvm.dbg.declare into the current block.
3549 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
3550 llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
3551 Builder.GetInsertBlock());
3552}
3553
3554void CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD,
3555 llvm::Value *Storage,
3556 CGBuilderTy &Builder) {
3557 assert(DebugKind >= codegenoptions::LimitedDebugInfo)((DebugKind >= codegenoptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= codegenoptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3557, __PRETTY_FUNCTION__))
;
3558 EmitDeclare(VD, Storage, llvm::None, Builder);
3559}
3560
3561llvm::DIType *CGDebugInfo::CreateSelfType(const QualType &QualTy,
3562 llvm::DIType *Ty) {
3563 llvm::DIType *CachedTy = getTypeOrNull(QualTy);
3564 if (CachedTy)
3565 Ty = CachedTy;
3566 return DBuilder.createObjectPointerType(Ty);
3567}
3568
3569void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
3570 const VarDecl *VD, llvm::Value *Storage, CGBuilderTy &Builder,
3571 const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) {
3572 assert(DebugKind >= codegenoptions::LimitedDebugInfo)((DebugKind >= codegenoptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= codegenoptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3572, __PRETTY_FUNCTION__))
;
3573 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!")((!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"
) ? static_cast<void> (0) : __assert_fail ("!LexicalBlockStack.empty() && \"Region stack mismatch, stack empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3573, __PRETTY_FUNCTION__))
;
3574
3575 if (Builder.GetInsertBlock() == nullptr)
3576 return;
3577 if (VD->hasAttr<NoDebugAttr>())
3578 return;
3579
3580 bool isByRef = VD->hasAttr<BlocksAttr>();
3581
3582 uint64_t XOffset = 0;
3583 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
3584 llvm::DIType *Ty;
3585 if (isByRef)
3586 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
3587 else
3588 Ty = getOrCreateType(VD->getType(), Unit);
3589
3590 // Self is passed along as an implicit non-arg variable in a
3591 // block. Mark it as the object pointer.
3592 if (const auto *IPD = dyn_cast<ImplicitParamDecl>(VD))
3593 if (IPD->getParameterKind() == ImplicitParamDecl::ObjCSelf)
3594 Ty = CreateSelfType(VD->getType(), Ty);
3595
3596 // Get location information.
3597 unsigned Line = getLineNumber(VD->getLocation());
3598 unsigned Column = getColumnNumber(VD->getLocation());
3599
3600 const llvm::DataLayout &target = CGM.getDataLayout();
3601
3602 CharUnits offset = CharUnits::fromQuantity(
3603 target.getStructLayout(blockInfo.StructureType)
3604 ->getElementOffset(blockInfo.getCapture(VD).getIndex()));
3605
3606 SmallVector<int64_t, 9> addr;
3607 addr.push_back(llvm::dwarf::DW_OP_deref);
3608 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3609 addr.push_back(offset.getQuantity());
3610 if (isByRef) {
3611 addr.push_back(llvm::dwarf::DW_OP_deref);
3612 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3613 // offset of __forwarding field
3614 offset =
3615 CGM.getContext().toCharUnitsFromBits(target.getPointerSizeInBits(0));
3616 addr.push_back(offset.getQuantity());
3617 addr.push_back(llvm::dwarf::DW_OP_deref);
3618 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3619 // offset of x field
3620 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
3621 addr.push_back(offset.getQuantity());
3622 }
3623
3624 // Create the descriptor for the variable.
3625 auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
3626 auto *D = DBuilder.createAutoVariable(
3627 cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->getName(), Unit,
3628 Line, Ty, false, llvm::DINode::FlagZero, Align);
3629
3630 // Insert an llvm.dbg.declare into the current block.
3631 auto DL =
3632 llvm::DebugLoc::get(Line, Column, LexicalBlockStack.back(), CurInlinedAt);
3633 auto *Expr = DBuilder.createExpression(addr);
3634 if (InsertPoint)
3635 DBuilder.insertDeclare(Storage, D, Expr, DL, InsertPoint);
3636 else
3637 DBuilder.insertDeclare(Storage, D, Expr, DL, Builder.GetInsertBlock());
3638}
3639
3640void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI,
3641 unsigned ArgNo,
3642 CGBuilderTy &Builder) {
3643 assert(DebugKind >= codegenoptions::LimitedDebugInfo)((DebugKind >= codegenoptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= codegenoptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3643, __PRETTY_FUNCTION__))
;
3644 EmitDeclare(VD, AI, ArgNo, Builder);
3645}
3646
3647namespace {
3648struct BlockLayoutChunk {
3649 uint64_t OffsetInBits;
3650 const BlockDecl::Capture *Capture;
3651};
3652bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) {
3653 return l.OffsetInBits < r.OffsetInBits;
3654}
3655}
3656
3657void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
3658 llvm::Value *Arg,
3659 unsigned ArgNo,
3660 llvm::Value *LocalAddr,
3661 CGBuilderTy &Builder) {
3662 assert(DebugKind >= codegenoptions::LimitedDebugInfo)((DebugKind >= codegenoptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= codegenoptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3662, __PRETTY_FUNCTION__))
;
3663 ASTContext &C = CGM.getContext();
3664 const BlockDecl *blockDecl = block.getBlockDecl();
3665
3666 // Collect some general information about the block's location.
3667 SourceLocation loc = blockDecl->getCaretLocation();
3668 llvm::DIFile *tunit = getOrCreateFile(loc);
3669 unsigned line = getLineNumber(loc);
3670 unsigned column = getColumnNumber(loc);
3671
3672 // Build the debug-info type for the block literal.
3673 getDeclContextDescriptor(blockDecl);
3674
3675 const llvm::StructLayout *blockLayout =
3676 CGM.getDataLayout().getStructLayout(block.StructureType);
3677
3678 SmallVector<llvm::Metadata *, 16> fields;
3679 fields.push_back(createFieldType("__isa", C.VoidPtrTy, loc, AS_public,
3680 blockLayout->getElementOffsetInBits(0),
3681 tunit, tunit));
3682 fields.push_back(createFieldType("__flags", C.IntTy, loc, AS_public,
3683 blockLayout->getElementOffsetInBits(1),
3684 tunit, tunit));
3685 fields.push_back(createFieldType("__reserved", C.IntTy, loc, AS_public,
3686 blockLayout->getElementOffsetInBits(2),
3687 tunit, tunit));
3688 auto *FnTy = block.getBlockExpr()->getFunctionType();
3689 auto FnPtrType = CGM.getContext().getPointerType(FnTy->desugar());
3690 fields.push_back(createFieldType("__FuncPtr", FnPtrType, loc, AS_public,
3691 blockLayout->getElementOffsetInBits(3),
3692 tunit, tunit));
3693 fields.push_back(createFieldType(
3694 "__descriptor", C.getPointerType(block.NeedsCopyDispose
3695 ? C.getBlockDescriptorExtendedType()
3696 : C.getBlockDescriptorType()),
3697 loc, AS_public, blockLayout->getElementOffsetInBits(4), tunit, tunit));
3698
3699 // We want to sort the captures by offset, not because DWARF
3700 // requires this, but because we're paranoid about debuggers.
3701 SmallVector<BlockLayoutChunk, 8> chunks;
3702
3703 // 'this' capture.
3704 if (blockDecl->capturesCXXThis()) {
3705 BlockLayoutChunk chunk;
3706 chunk.OffsetInBits =
3707 blockLayout->getElementOffsetInBits(block.CXXThisIndex);
3708 chunk.Capture = nullptr;
3709 chunks.push_back(chunk);
3710 }
3711
3712 // Variable captures.
3713 for (const auto &capture : blockDecl->captures()) {
3714 const VarDecl *variable = capture.getVariable();
3715 const CGBlockInfo::Capture &captureInfo = block.getCapture(variable);
3716
3717 // Ignore constant captures.
3718 if (captureInfo.isConstant())
3719 continue;
3720
3721 BlockLayoutChunk chunk;
3722 chunk.OffsetInBits =
3723 blockLayout->getElementOffsetInBits(captureInfo.getIndex());
3724 chunk.Capture = &capture;
3725 chunks.push_back(chunk);
3726 }
3727
3728 // Sort by offset.
3729 llvm::array_pod_sort(chunks.begin(), chunks.end());
3730
3731 for (const BlockLayoutChunk &Chunk : chunks) {
3732 uint64_t offsetInBits = Chunk.OffsetInBits;
3733 const BlockDecl::Capture *capture = Chunk.Capture;
3734
3735 // If we have a null capture, this must be the C++ 'this' capture.
3736 if (!capture) {
3737 QualType type;
3738 if (auto *Method =
3739 cast_or_null<CXXMethodDecl>(blockDecl->getNonClosureContext()))
3740 type = Method->getThisType(C);
3741 else if (auto *RDecl = dyn_cast<CXXRecordDecl>(blockDecl->getParent()))
3742 type = QualType(RDecl->getTypeForDecl(), 0);
3743 else
3744 llvm_unreachable("unexpected block declcontext")::llvm::llvm_unreachable_internal("unexpected block declcontext"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3744)
;
3745
3746 fields.push_back(createFieldType("this", type, loc, AS_public,
3747 offsetInBits, tunit, tunit));
3748 continue;
3749 }
3750
3751 const VarDecl *variable = capture->getVariable();
3752 StringRef name = variable->getName();
3753
3754 llvm::DIType *fieldType;
3755 if (capture->isByRef()) {
3756 TypeInfo PtrInfo = C.getTypeInfo(C.VoidPtrTy);
3757 auto Align = PtrInfo.AlignIsRequired ? PtrInfo.Align : 0;
3758
3759 // FIXME: this creates a second copy of this type!
3760 uint64_t xoffset;
3761 fieldType = EmitTypeForVarWithBlocksAttr(variable, &xoffset);
3762 fieldType = DBuilder.createPointerType(fieldType, PtrInfo.Width);
3763 fieldType = DBuilder.createMemberType(tunit, name, tunit, line,
3764 PtrInfo.Width, Align, offsetInBits,
3765 llvm::DINode::FlagZero, fieldType);
3766 } else {
3767 auto Align = getDeclAlignIfRequired(variable, CGM.getContext());
3768 fieldType = createFieldType(name, variable->getType(), loc, AS_public,
3769 offsetInBits, Align, tunit, tunit);
3770 }
3771 fields.push_back(fieldType);
3772 }
3773
3774 SmallString<36> typeName;
3775 llvm::raw_svector_ostream(typeName) << "__block_literal_"
3776 << CGM.getUniqueBlockCount();
3777
3778 llvm::DINodeArray fieldsArray = DBuilder.getOrCreateArray(fields);
3779
3780 llvm::DIType *type =
3781 DBuilder.createStructType(tunit, typeName.str(), tunit, line,
3782 CGM.getContext().toBits(block.BlockSize), 0,
3783 llvm::DINode::FlagZero, nullptr, fieldsArray);
3784 type = DBuilder.createPointerType(type, CGM.PointerWidthInBits);
3785
3786 // Get overall information about the block.
3787 llvm::DINode::DIFlags flags = llvm::DINode::FlagArtificial;
3788 auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back());
3789
3790 // Create the descriptor for the parameter.
3791 auto *debugVar = DBuilder.createParameterVariable(
3792 scope, Arg->getName(), ArgNo, tunit, line, type,
3793 CGM.getLangOpts().Optimize, flags);
3794
3795 if (LocalAddr) {
3796 // Insert an llvm.dbg.value into the current block.
3797 DBuilder.insertDbgValueIntrinsic(
3798 LocalAddr, 0, debugVar, DBuilder.createExpression(),
3799 llvm::DebugLoc::get(line, column, scope, CurInlinedAt),
3800 Builder.GetInsertBlock());
3801 }
3802
3803 // Insert an llvm.dbg.declare into the current block.
3804 DBuilder.insertDeclare(Arg, debugVar, DBuilder.createExpression(),
3805 llvm::DebugLoc::get(line, column, scope, CurInlinedAt),
3806 Builder.GetInsertBlock());
3807}
3808
3809llvm::DIDerivedType *
3810CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(const VarDecl *D) {
3811 if (!D->isStaticDataMember())
3812 return nullptr;
3813
3814 auto MI = StaticDataMemberCache.find(D->getCanonicalDecl());
3815 if (MI != StaticDataMemberCache.end()) {
3816 assert(MI->second && "Static data member declaration should still exist")((MI->second && "Static data member declaration should still exist"
) ? static_cast<void> (0) : __assert_fail ("MI->second && \"Static data member declaration should still exist\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3816, __PRETTY_FUNCTION__))
;
3817 return MI->second;
3818 }
3819
3820 // If the member wasn't found in the cache, lazily construct and add it to the
3821 // type (used when a limited form of the type is emitted).
3822 auto DC = D->getDeclContext();
3823 auto *Ctxt = cast<llvm::DICompositeType>(getDeclContextDescriptor(D));
3824 return CreateRecordStaticField(D, Ctxt, cast<RecordDecl>(DC));
3825}
3826
3827llvm::DIGlobalVariableExpression *CGDebugInfo::CollectAnonRecordDecls(
3828 const RecordDecl *RD, llvm::DIFile *Unit, unsigned LineNo,
3829 StringRef LinkageName, llvm::GlobalVariable *Var, llvm::DIScope *DContext) {
3830 llvm::DIGlobalVariableExpression *GVE = nullptr;
3831
3832 for (const auto *Field : RD->fields()) {
3833 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
3834 StringRef FieldName = Field->getName();
3835
3836 // Ignore unnamed fields, but recurse into anonymous records.
3837 if (FieldName.empty()) {
3838 if (const auto *RT = dyn_cast<RecordType>(Field->getType()))
3839 GVE = CollectAnonRecordDecls(RT->getDecl(), Unit, LineNo, LinkageName,
3840 Var, DContext);
3841 continue;
3842 }
3843 // Use VarDecl's Tag, Scope and Line number.
3844 GVE = DBuilder.createGlobalVariableExpression(
3845 DContext, FieldName, LinkageName, Unit, LineNo, FieldTy,
3846 Var->hasLocalLinkage());
3847 Var->addDebugInfo(GVE);
3848 }
3849 return GVE;
3850}
3851
3852void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
3853 const VarDecl *D) {
3854 assert(DebugKind >= codegenoptions::LimitedDebugInfo)((DebugKind >= codegenoptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= codegenoptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3854, __PRETTY_FUNCTION__))
;
3855 if (D->hasAttr<NoDebugAttr>())
3856 return;
3857
3858 // If we already created a DIGlobalVariable for this declaration, just attach
3859 // it to the llvm::GlobalVariable.
3860 auto Cached = DeclCache.find(D->getCanonicalDecl());
3861 if (Cached != DeclCache.end())
3862 return Var->addDebugInfo(
3863 cast<llvm::DIGlobalVariableExpression>(Cached->second));
3864
3865 // Create global variable debug descriptor.
3866 llvm::DIFile *Unit = nullptr;
3867 llvm::DIScope *DContext = nullptr;
3868 unsigned LineNo;
3869 StringRef DeclName, LinkageName;
3870 QualType T;
3871 collectVarDeclProps(D, Unit, LineNo, T, DeclName, LinkageName, DContext);
3872
3873 // Attempt to store one global variable for the declaration - even if we
3874 // emit a lot of fields.
3875 llvm::DIGlobalVariableExpression *GVE = nullptr;
3876
3877 // If this is an anonymous union then we'll want to emit a global
3878 // variable for each member of the anonymous union so that it's possible
3879 // to find the name of any field in the union.
3880 if (T->isUnionType() && DeclName.empty()) {
3881 const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
3882 assert(RD->isAnonymousStructOrUnion() &&((RD->isAnonymousStructOrUnion() && "unnamed non-anonymous struct or union?"
) ? static_cast<void> (0) : __assert_fail ("RD->isAnonymousStructOrUnion() && \"unnamed non-anonymous struct or union?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3883, __PRETTY_FUNCTION__))
3883 "unnamed non-anonymous struct or union?")((RD->isAnonymousStructOrUnion() && "unnamed non-anonymous struct or union?"
) ? static_cast<void> (0) : __assert_fail ("RD->isAnonymousStructOrUnion() && \"unnamed non-anonymous struct or union?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3883, __PRETTY_FUNCTION__))
;
3884 GVE = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
3885 } else {
3886 auto Align = getDeclAlignIfRequired(D, CGM.getContext());
3887
3888 SmallVector<int64_t, 4> Expr;
3889 unsigned AddressSpace =
3890 CGM.getContext().getTargetAddressSpace(D->getType());
3891 AppendAddressSpaceXDeref(AddressSpace, Expr);
3892
3893 GVE = DBuilder.createGlobalVariableExpression(
3894 DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit),
3895 Var->hasLocalLinkage(),
3896 Expr.empty() ? nullptr : DBuilder.createExpression(Expr),
3897 getOrCreateStaticDataMemberDeclarationOrNull(D), Align);
3898 Var->addDebugInfo(GVE);
3899 }
3900 DeclCache[D->getCanonicalDecl()].reset(GVE);
3901}
3902
3903void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) {
3904 assert(DebugKind >= codegenoptions::LimitedDebugInfo)((DebugKind >= codegenoptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= codegenoptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3904, __PRETTY_FUNCTION__))
;
3905 if (VD->hasAttr<NoDebugAttr>())
3906 return;
3907 auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
3908 // Create the descriptor for the variable.
3909 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
3910 StringRef Name = VD->getName();
3911 llvm::DIType *Ty = getOrCreateType(VD->getType(), Unit);
3912 if (const auto *ECD = dyn_cast<EnumConstantDecl>(VD)) {
3913 const auto *ED = cast<EnumDecl>(ECD->getDeclContext());
3914 assert(isa<EnumType>(ED->getTypeForDecl()) && "Enum without EnumType?")((isa<EnumType>(ED->getTypeForDecl()) && "Enum without EnumType?"
) ? static_cast<void> (0) : __assert_fail ("isa<EnumType>(ED->getTypeForDecl()) && \"Enum without EnumType?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3914, __PRETTY_FUNCTION__))
;
3915 Ty = getOrCreateType(QualType(ED->getTypeForDecl(), 0), Unit);
3916 }
3917 // Do not use global variables for enums.
3918 //
3919 // FIXME: why not?
3920 if (Ty->getTag() == llvm::dwarf::DW_TAG_enumeration_type)
3921 return;
3922 // Do not emit separate definitions for function local const/statics.
3923 if (isa<FunctionDecl>(VD->getDeclContext()))
3924 return;
3925 VD = cast<ValueDecl>(VD->getCanonicalDecl());
3926 auto *VarD = cast<VarDecl>(VD);
3927 if (VarD->isStaticDataMember()) {
3928 auto *RD = cast<RecordDecl>(VarD->getDeclContext());
3929 getDeclContextDescriptor(VarD);
3930 // Ensure that the type is retained even though it's otherwise unreferenced.
3931 //
3932 // FIXME: This is probably unnecessary, since Ty should reference RD
3933 // through its scope.
3934 RetainedTypes.push_back(
3935 CGM.getContext().getRecordType(RD).getAsOpaquePtr());
3936 return;
3937 }
3938
3939 llvm::DIScope *DContext = getDeclContextDescriptor(VD);
3940
3941 auto &GV = DeclCache[VD];
3942 if (GV)
3943 return;
3944 llvm::DIExpression *InitExpr = nullptr;
3945 if (CGM.getContext().getTypeSize(VD->getType()) <= 64) {
3946 // FIXME: Add a representation for integer constants wider than 64 bits.
3947 if (Init.isInt())
3948 InitExpr =
3949 DBuilder.createConstantValueExpression(Init.getInt().getExtValue());
3950 else if (Init.isFloat())
3951 InitExpr = DBuilder.createConstantValueExpression(
3952 Init.getFloat().bitcastToAPInt().getZExtValue());
3953 }
3954 GV.reset(DBuilder.createGlobalVariableExpression(
3955 DContext, Name, StringRef(), Unit, getLineNumber(VD->getLocation()), Ty,
3956 true, InitExpr, getOrCreateStaticDataMemberDeclarationOrNull(VarD),
3957 Align));
3958}
3959
3960llvm::DIScope *CGDebugInfo::getCurrentContextDescriptor(const Decl *D) {
3961 if (!LexicalBlockStack.empty())
3962 return LexicalBlockStack.back();
3963 llvm::DIScope *Mod = getParentModuleOrNull(D);
3964 return getContextDescriptor(D, Mod ? Mod : TheCU);
3965}
3966
3967void CGDebugInfo::EmitUsingDirective(const UsingDirectiveDecl &UD) {
3968 if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
3969 return;
3970 const NamespaceDecl *NSDecl = UD.getNominatedNamespace();
3971 if (!NSDecl->isAnonymousNamespace() ||
3972 CGM.getCodeGenOpts().DebugExplicitImport) {
3973 DBuilder.createImportedModule(
3974 getCurrentContextDescriptor(cast<Decl>(UD.getDeclContext())),
3975 getOrCreateNamespace(NSDecl),
3976 getLineNumber(UD.getLocation()));
3977 }
3978}
3979
3980void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) {
3981 if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
3982 return;
3983 assert(UD.shadow_size() &&((UD.shadow_size() && "We shouldn't be codegening an invalid UsingDecl containing no decls"
) ? static_cast<void> (0) : __assert_fail ("UD.shadow_size() && \"We shouldn't be codegening an invalid UsingDecl containing no decls\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3984, __PRETTY_FUNCTION__))
3984 "We shouldn't be codegening an invalid UsingDecl containing no decls")((UD.shadow_size() && "We shouldn't be codegening an invalid UsingDecl containing no decls"
) ? static_cast<void> (0) : __assert_fail ("UD.shadow_size() && \"We shouldn't be codegening an invalid UsingDecl containing no decls\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3984, __PRETTY_FUNCTION__))
;
3985 // Emitting one decl is sufficient - debuggers can detect that this is an
3986 // overloaded name & provide lookup for all the overloads.
3987 const UsingShadowDecl &USD = **UD.shadow_begin();
3988
3989 // FIXME: Skip functions with undeduced auto return type for now since we
3990 // don't currently have the plumbing for separate declarations & definitions
3991 // of free functions and mismatched types (auto in the declaration, concrete
3992 // return type in the definition)
3993 if (const auto *FD = dyn_cast<FunctionDecl>(USD.getUnderlyingDecl()))
3994 if (const auto *AT =
3995 FD->getType()->getAs<FunctionProtoType>()->getContainedAutoType())
3996 if (AT->getDeducedType().isNull())
3997 return;
3998 if (llvm::DINode *Target =
3999 getDeclarationOrDefinition(USD.getUnderlyingDecl()))
4000 DBuilder.createImportedDeclaration(
4001 getCurrentContextDescriptor(cast<Decl>(USD.getDeclContext())), Target,
4002 getLineNumber(USD.getLocation()));
4003}
4004
4005void CGDebugInfo::EmitImportDecl(const ImportDecl &ID) {
4006 if (CGM.getCodeGenOpts().getDebuggerTuning() != llvm::DebuggerKind::LLDB)
4007 return;
4008 if (Module *M = ID.getImportedModule()) {
4009 auto Info = ExternalASTSource::ASTSourceDescriptor(*M);
4010 DBuilder.createImportedDeclaration(
4011 getCurrentContextDescriptor(cast<Decl>(ID.getDeclContext())),
4012 getOrCreateModuleRef(Info, DebugTypeExtRefs),
4013 getLineNumber(ID.getLocation()));
4014 }
4015}
4016
4017llvm::DIImportedEntity *
4018CGDebugInfo::EmitNamespaceAlias(const NamespaceAliasDecl &NA) {
4019 if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
4020 return nullptr;
4021 auto &VH = NamespaceAliasCache[&NA];
4022 if (VH)
4023 return cast<llvm::DIImportedEntity>(VH);
4024 llvm::DIImportedEntity *R;
4025 if (const auto *Underlying =
4026 dyn_cast<NamespaceAliasDecl>(NA.getAliasedNamespace()))
4027 // This could cache & dedup here rather than relying on metadata deduping.
4028 R = DBuilder.createImportedDeclaration(
4029 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
4030 EmitNamespaceAlias(*Underlying), getLineNumber(NA.getLocation()),
4031 NA.getName());
4032 else
4033 R = DBuilder.createImportedDeclaration(
4034 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
4035 getOrCreateNamespace(cast<NamespaceDecl>(NA.getAliasedNamespace())),
4036 getLineNumber(NA.getLocation()), NA.getName());
4037 VH.reset(R);
4038 return R;
4039}
4040
4041llvm::DINamespace *
4042CGDebugInfo::getOrCreateNamespace(const NamespaceDecl *NSDecl) {
4043 // Don't canonicalize the NamespaceDecl here: The DINamespace will be uniqued
4044 // if necessary, and this way multiple declarations of the same namespace in
4045 // different parent modules stay distinct.
4046 auto I = NamespaceCache.find(NSDecl);
4047 if (I != NamespaceCache.end())
4048 return cast<llvm::DINamespace>(I->second);
4049
4050 llvm::DIScope *Context = getDeclContextDescriptor(NSDecl);
4051 // Don't trust the context if it is a DIModule (see comment above).
4052 llvm::DINamespace *NS =
4053 DBuilder.createNameSpace(Context, NSDecl->getName(), NSDecl->isInline());
4054 NamespaceCache[NSDecl].reset(NS);
4055 return NS;
4056}
4057
4058void CGDebugInfo::setDwoId(uint64_t Signature) {
4059 assert(TheCU && "no main compile unit")((TheCU && "no main compile unit") ? static_cast<void
> (0) : __assert_fail ("TheCU && \"no main compile unit\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 4059, __PRETTY_FUNCTION__))
;
4060 TheCU->setDWOId(Signature);
4061}
4062
4063
4064void CGDebugInfo::finalize() {
4065 // Creating types might create further types - invalidating the current
4066 // element and the size(), so don't cache/reference them.
4067 for (size_t i = 0; i != ObjCInterfaceCache.size(); ++i) {
4068 ObjCInterfaceCacheEntry E = ObjCInterfaceCache[i];
4069 llvm::DIType *Ty = E.Type->getDecl()->getDefinition()
4070 ? CreateTypeDefinition(E.Type, E.Unit)
4071 : E.Decl;
4072 DBuilder.replaceTemporary(llvm::TempDIType(E.Decl), Ty);
4073 }
4074
4075 for (auto p : ReplaceMap) {
4076 assert(p.second)((p.second) ? static_cast<void> (0) : __assert_fail ("p.second"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 4076, __PRETTY_FUNCTION__))
;
4077 auto *Ty = cast<llvm::DIType>(p.second);
4078 assert(Ty->isForwardDecl())((Ty->isForwardDecl()) ? static_cast<void> (0) : __assert_fail
("Ty->isForwardDecl()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 4078, __PRETTY_FUNCTION__))
;
4079
4080 auto it = TypeCache.find(p.first);
4081 assert(it != TypeCache.end())((it != TypeCache.end()) ? static_cast<void> (0) : __assert_fail
("it != TypeCache.end()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 4081, __PRETTY_FUNCTION__))
;
4082 assert(it->second)((it->second) ? static_cast<void> (0) : __assert_fail
("it->second", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 4082, __PRETTY_FUNCTION__))
;
4083
4084 DBuilder.replaceTemporary(llvm::TempDIType(Ty),
4085 cast<llvm::DIType>(it->second));
4086 }
4087
4088 for (const auto &p : FwdDeclReplaceMap) {
4089 assert(p.second)((p.second) ? static_cast<void> (0) : __assert_fail ("p.second"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 4089, __PRETTY_FUNCTION__))
;
4090 llvm::TempMDNode FwdDecl(cast<llvm::MDNode>(p.second));
4091 llvm::Metadata *Repl;
4092
4093 auto it = DeclCache.find(p.first);
4094 // If there has been no definition for the declaration, call RAUW
4095 // with ourselves, that will destroy the temporary MDNode and
4096 // replace it with a standard one, avoiding leaking memory.
4097 if (it == DeclCache.end())
4098 Repl = p.second;
4099 else
4100 Repl = it->second;
4101
4102 if (auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(Repl))
4103 Repl = GVE->getVariable();
4104 DBuilder.replaceTemporary(std::move(FwdDecl), cast<llvm::MDNode>(Repl));
4105 }
4106
4107 // We keep our own list of retained types, because we need to look
4108 // up the final type in the type cache.
4109 for (auto &RT : RetainedTypes)
4110 if (auto MD = TypeCache[RT])
4111 DBuilder.retainType(cast<llvm::DIType>(MD));
4112
4113 DBuilder.finalize();
4114}
4115
4116void CGDebugInfo::EmitExplicitCastType(QualType Ty) {
4117 if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
4118 return;
4119
4120 if (auto *DieTy = getOrCreateType(Ty, getOrCreateMainFile()))
4121 // Don't ignore in case of explicit cast where it is referenced indirectly.
4122 DBuilder.retainType(DieTy);
4123}
4124
4125llvm::DebugLoc CGDebugInfo::SourceLocToDebugLoc(SourceLocation Loc) {
4126 if (LexicalBlockStack.empty())
4127 return llvm::DebugLoc();
4128
4129 llvm::MDNode *Scope = LexicalBlockStack.back();
4130 return llvm::DebugLoc::get(
4131 getLineNumber(Loc), getColumnNumber(Loc), Scope);
4132}