Bug Summary

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