Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

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