Bug Summary

File:tools/clang/lib/CodeGen/CGDebugInfo.cpp
Location:line 1290, column 49
Description:Called C++ object pointer is null

Annotated Source Code

1//===--- CGDebugInfo.cpp - Emit Debug Information for a Module ------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This coordinates the debug information generation while generating code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CGDebugInfo.h"
15#include "CGBlocks.h"
16#include "CGCXXABI.h"
17#include "CGObjCRuntime.h"
18#include "CodeGenFunction.h"
19#include "CodeGenModule.h"
20#include "clang/AST/ASTContext.h"
21#include "clang/AST/DeclFriend.h"
22#include "clang/AST/DeclObjC.h"
23#include "clang/AST/DeclTemplate.h"
24#include "clang/AST/Expr.h"
25#include "clang/AST/RecordLayout.h"
26#include "clang/Basic/FileManager.h"
27#include "clang/Basic/SourceManager.h"
28#include "clang/Basic/Version.h"
29#include "clang/Frontend/CodeGenOptions.h"
30#include "llvm/ADT/SmallVector.h"
31#include "llvm/ADT/StringExtras.h"
32#include "llvm/IR/Constants.h"
33#include "llvm/IR/DataLayout.h"
34#include "llvm/IR/DerivedTypes.h"
35#include "llvm/IR/Instructions.h"
36#include "llvm/IR/Intrinsics.h"
37#include "llvm/IR/Module.h"
38#include "llvm/Support/Dwarf.h"
39#include "llvm/Support/FileSystem.h"
40#include "llvm/Support/Path.h"
41using namespace clang;
42using namespace clang::CodeGen;
43
44CGDebugInfo::CGDebugInfo(CodeGenModule &CGM)
45 : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
46 DBuilder(CGM.getModule()) {
47 CreateCompileUnit();
48}
49
50CGDebugInfo::~CGDebugInfo() {
51 assert(LexicalBlockStack.empty() &&((LexicalBlockStack.empty() && "Region stack mismatch, stack not empty!"
) ? static_cast<void> (0) : __assert_fail ("LexicalBlockStack.empty() && \"Region stack mismatch, stack not empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 52, __PRETTY_FUNCTION__))
52 "Region stack mismatch, stack not empty!")((LexicalBlockStack.empty() && "Region stack mismatch, stack not empty!"
) ? static_cast<void> (0) : __assert_fail ("LexicalBlockStack.empty() && \"Region stack mismatch, stack not empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 52, __PRETTY_FUNCTION__));
53}
54
55SaveAndRestoreLocation::SaveAndRestoreLocation(CodeGenFunction &CGF,
56 CGBuilderTy &B)
57 : DI(CGF.getDebugInfo()), Builder(B) {
58 if (DI) {
59 SavedLoc = DI->getLocation();
60 DI->CurLoc = SourceLocation();
61 }
62}
63
64SaveAndRestoreLocation::~SaveAndRestoreLocation() {
65 if (DI)
66 DI->EmitLocation(Builder, SavedLoc);
67}
68
69NoLocation::NoLocation(CodeGenFunction &CGF, CGBuilderTy &B)
70 : SaveAndRestoreLocation(CGF, B) {
71 if (DI)
72 Builder.SetCurrentDebugLocation(llvm::DebugLoc());
73}
74
75NoLocation::~NoLocation() {
76 if (DI)
77 assert(Builder.getCurrentDebugLocation().isUnknown())((Builder.getCurrentDebugLocation().isUnknown()) ? static_cast
<void> (0) : __assert_fail ("Builder.getCurrentDebugLocation().isUnknown()"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 77, __PRETTY_FUNCTION__));
78}
79
80ArtificialLocation::ArtificialLocation(CodeGenFunction &CGF, CGBuilderTy &B)
81 : SaveAndRestoreLocation(CGF, B) {
82 if (DI)
83 Builder.SetCurrentDebugLocation(llvm::DebugLoc());
84}
85
86void ArtificialLocation::Emit() {
87 if (DI) {
88 // Sync the Builder.
89 DI->EmitLocation(Builder, SavedLoc);
90 DI->CurLoc = SourceLocation();
91 // Construct a location that has a valid scope, but no line info.
92 assert(!DI->LexicalBlockStack.empty())((!DI->LexicalBlockStack.empty()) ? static_cast<void>
(0) : __assert_fail ("!DI->LexicalBlockStack.empty()", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 92, __PRETTY_FUNCTION__));
93 llvm::DIDescriptor Scope(DI->LexicalBlockStack.back());
94 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(0, 0, Scope));
95 }
96}
97
98ArtificialLocation::~ArtificialLocation() {
99 if (DI)
100 assert(Builder.getCurrentDebugLocation().getLine() == 0)((Builder.getCurrentDebugLocation().getLine() == 0) ? static_cast
<void> (0) : __assert_fail ("Builder.getCurrentDebugLocation().getLine() == 0"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 100, __PRETTY_FUNCTION__));
101}
102
103void CGDebugInfo::setLocation(SourceLocation Loc) {
104 // If the new location isn't valid return.
105 if (Loc.isInvalid()) return;
106
107 CurLoc = CGM.getContext().getSourceManager().getExpansionLoc(Loc);
108
109 // If we've changed files in the middle of a lexical scope go ahead
110 // and create a new lexical scope with file node if it's different
111 // from the one in the scope.
112 if (LexicalBlockStack.empty()) return;
113
114 SourceManager &SM = CGM.getContext().getSourceManager();
115 llvm::DIScope Scope(LexicalBlockStack.back());
116 PresumedLoc PCLoc = SM.getPresumedLoc(CurLoc);
117
118 if (PCLoc.isInvalid() || Scope.getFilename() == PCLoc.getFilename())
119 return;
120
121 if (Scope.isLexicalBlockFile()) {
122 llvm::DILexicalBlockFile LBF = llvm::DILexicalBlockFile(Scope);
123 llvm::DIDescriptor D
124 = DBuilder.createLexicalBlockFile(LBF.getScope(),
125 getOrCreateFile(CurLoc));
126 llvm::MDNode *N = D;
127 LexicalBlockStack.pop_back();
128 LexicalBlockStack.push_back(N);
129 } else if (Scope.isLexicalBlock() || Scope.isSubprogram()) {
130 llvm::DIDescriptor D
131 = DBuilder.createLexicalBlockFile(Scope, getOrCreateFile(CurLoc));
132 llvm::MDNode *N = D;
133 LexicalBlockStack.pop_back();
134 LexicalBlockStack.push_back(N);
135 }
136}
137
138/// getContextDescriptor - Get context info for the decl.
139llvm::DIScope CGDebugInfo::getContextDescriptor(const Decl *Context) {
140 if (!Context)
141 return TheCU;
142
143 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator
144 I = RegionMap.find(Context);
145 if (I != RegionMap.end()) {
146 llvm::Value *V = I->second;
147 return llvm::DIScope(dyn_cast_or_null<llvm::MDNode>(V));
148 }
149
150 // Check namespace.
151 if (const NamespaceDecl *NSDecl = dyn_cast<NamespaceDecl>(Context))
152 return getOrCreateNameSpace(NSDecl);
153
154 if (const RecordDecl *RDecl = dyn_cast<RecordDecl>(Context))
155 if (!RDecl->isDependentType())
156 return getOrCreateType(CGM.getContext().getTypeDeclType(RDecl),
157 getOrCreateMainFile());
158 return TheCU;
159}
160
161/// getFunctionName - Get function name for the given FunctionDecl. If the
162/// name is constructed on demand (e.g. C++ destructor) then the name
163/// is stored on the side.
164StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) {
165 assert (FD && "Invalid FunctionDecl!")((FD && "Invalid FunctionDecl!") ? static_cast<void
> (0) : __assert_fail ("FD && \"Invalid FunctionDecl!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 165, __PRETTY_FUNCTION__));
166 IdentifierInfo *FII = FD->getIdentifier();
167 FunctionTemplateSpecializationInfo *Info
168 = FD->getTemplateSpecializationInfo();
169 if (!Info && FII)
170 return FII->getName();
171
172 // Otherwise construct human readable name for debug info.
173 SmallString<128> NS;
174 llvm::raw_svector_ostream OS(NS);
175 FD->printName(OS);
176
177 // Add any template specialization args.
178 if (Info) {
179 const TemplateArgumentList *TArgs = Info->TemplateArguments;
180 const TemplateArgument *Args = TArgs->data();
181 unsigned NumArgs = TArgs->size();
182 PrintingPolicy Policy(CGM.getLangOpts());
183 TemplateSpecializationType::PrintTemplateArgumentList(OS, Args, NumArgs,
184 Policy);
185 }
186
187 // Copy this name on the side and use its reference.
188 return internString(OS.str());
189}
190
191StringRef CGDebugInfo::getObjCMethodName(const ObjCMethodDecl *OMD) {
192 SmallString<256> MethodName;
193 llvm::raw_svector_ostream OS(MethodName);
194 OS << (OMD->isInstanceMethod() ? '-' : '+') << '[';
195 const DeclContext *DC = OMD->getDeclContext();
196 if (const ObjCImplementationDecl *OID =
197 dyn_cast<const ObjCImplementationDecl>(DC)) {
198 OS << OID->getName();
199 } else if (const ObjCInterfaceDecl *OID =
200 dyn_cast<const ObjCInterfaceDecl>(DC)) {
201 OS << OID->getName();
202 } else if (const ObjCCategoryImplDecl *OCD =
203 dyn_cast<const ObjCCategoryImplDecl>(DC)){
204 OS << ((const NamedDecl *)OCD)->getIdentifier()->getNameStart() << '(' <<
205 OCD->getIdentifier()->getNameStart() << ')';
206 } else if (isa<ObjCProtocolDecl>(DC)) {
207 // We can extract the type of the class from the self pointer.
208 if (ImplicitParamDecl* SelfDecl = OMD->getSelfDecl()) {
209 QualType ClassTy =
210 cast<ObjCObjectPointerType>(SelfDecl->getType())->getPointeeType();
211 ClassTy.print(OS, PrintingPolicy(LangOptions()));
212 }
213 }
214 OS << ' ' << OMD->getSelector().getAsString() << ']';
215
216 return internString(OS.str());
217}
218
219/// getSelectorName - Return selector name. This is used for debugging
220/// info.
221StringRef CGDebugInfo::getSelectorName(Selector S) {
222 return internString(S.getAsString());
223}
224
225/// getClassName - Get class name including template argument list.
226StringRef
227CGDebugInfo::getClassName(const RecordDecl *RD) {
228 // quick optimization to avoid having to intern strings that are already
229 // stored reliably elsewhere
230 if (!isa<ClassTemplateSpecializationDecl>(RD))
231 return RD->getName();
232
233 SmallString<128> Name;
234 {
235 llvm::raw_svector_ostream OS(Name);
236 RD->getNameForDiagnostic(OS, CGM.getContext().getPrintingPolicy(),
237 /*Qualified*/ false);
238 }
239
240 // Copy this name on the side and use its reference.
241 return internString(Name);
242}
243
244/// getOrCreateFile - Get the file debug info descriptor for the input location.
245llvm::DIFile CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
246 if (!Loc.isValid())
247 // If Location is not valid then use main input file.
248 return DBuilder.createFile(TheCU.getFilename(), TheCU.getDirectory());
249
250 SourceManager &SM = CGM.getContext().getSourceManager();
251 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
252
253 if (PLoc.isInvalid() || StringRef(PLoc.getFilename()).empty())
254 // If the location is not valid then use main input file.
255 return DBuilder.createFile(TheCU.getFilename(), TheCU.getDirectory());
256
257 // Cache the results.
258 const char *fname = PLoc.getFilename();
259 llvm::DenseMap<const char *, llvm::WeakVH>::iterator it =
260 DIFileCache.find(fname);
261
262 if (it != DIFileCache.end()) {
263 // Verify that the information still exists.
264 if (llvm::Value *V = it->second)
265 return llvm::DIFile(cast<llvm::MDNode>(V));
266 }
267
268 llvm::DIFile F = DBuilder.createFile(PLoc.getFilename(), getCurrentDirname());
269
270 DIFileCache[fname] = F;
271 return F;
272}
273
274/// getOrCreateMainFile - Get the file info for main compile unit.
275llvm::DIFile CGDebugInfo::getOrCreateMainFile() {
276 return DBuilder.createFile(TheCU.getFilename(), TheCU.getDirectory());
277}
278
279/// getLineNumber - Get line number for the location. If location is invalid
280/// then use current location.
281unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) {
282 if (Loc.isInvalid() && CurLoc.isInvalid())
283 return 0;
284 SourceManager &SM = CGM.getContext().getSourceManager();
285 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
286 return PLoc.isValid()? PLoc.getLine() : 0;
287}
288
289/// getColumnNumber - Get column number for the location.
290unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc, bool Force) {
291 // We may not want column information at all.
292 if (!Force && !CGM.getCodeGenOpts().DebugColumnInfo)
293 return 0;
294
295 // If the location is invalid then use the current column.
296 if (Loc.isInvalid() && CurLoc.isInvalid())
297 return 0;
298 SourceManager &SM = CGM.getContext().getSourceManager();
299 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
300 return PLoc.isValid()? PLoc.getColumn() : 0;
301}
302
303StringRef CGDebugInfo::getCurrentDirname() {
304 if (!CGM.getCodeGenOpts().DebugCompilationDir.empty())
305 return CGM.getCodeGenOpts().DebugCompilationDir;
306
307 if (!CWDName.empty())
308 return CWDName;
309 SmallString<256> CWD;
310 llvm::sys::fs::current_path(CWD);
311 return CWDName = internString(CWD);
312}
313
314/// CreateCompileUnit - Create new compile unit.
315void CGDebugInfo::CreateCompileUnit() {
316
317 // Should we be asking the SourceManager for the main file name, instead of
318 // accepting it as an argument? This just causes the main file name to
319 // mismatch with source locations and create extra lexical scopes or
320 // mismatched debug info (a CU with a DW_AT_file of "-", because that's what
321 // the driver passed, but functions/other things have DW_AT_file of "<stdin>"
322 // because that's what the SourceManager says)
323
324 // Get absolute path name.
325 SourceManager &SM = CGM.getContext().getSourceManager();
326 std::string MainFileName = CGM.getCodeGenOpts().MainFileName;
327 if (MainFileName.empty())
328 MainFileName = "<stdin>";
329
330 // The main file name provided via the "-main-file-name" option contains just
331 // the file name itself with no path information. This file name may have had
332 // a relative path, so we look into the actual file entry for the main
333 // file to determine the real absolute path for the file.
334 std::string MainFileDir;
335 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
336 MainFileDir = MainFile->getDir()->getName();
337 if (MainFileDir != ".") {
338 llvm::SmallString<1024> MainFileDirSS(MainFileDir);
339 llvm::sys::path::append(MainFileDirSS, MainFileName);
340 MainFileName = MainFileDirSS.str();
341 }
342 }
343
344 // Save filename string.
345 StringRef Filename = internString(MainFileName);
346
347 // Save split dwarf file string.
348 std::string SplitDwarfFile = CGM.getCodeGenOpts().SplitDwarfFile;
349 StringRef SplitDwarfFilename = internString(SplitDwarfFile);
350
351 llvm::dwarf::SourceLanguage LangTag;
352 const LangOptions &LO = CGM.getLangOpts();
353 if (LO.CPlusPlus) {
354 if (LO.ObjC1)
355 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
356 else
357 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
358 } else if (LO.ObjC1) {
359 LangTag = llvm::dwarf::DW_LANG_ObjC;
360 } else if (LO.C99) {
361 LangTag = llvm::dwarf::DW_LANG_C99;
362 } else {
363 LangTag = llvm::dwarf::DW_LANG_C89;
364 }
365
366 std::string Producer = getClangFullVersion();
367
368 // Figure out which version of the ObjC runtime we have.
369 unsigned RuntimeVers = 0;
370 if (LO.ObjC1)
371 RuntimeVers = LO.ObjCRuntime.isNonFragile() ? 2 : 1;
372
373 // Create new compile unit.
374 // FIXME - Eliminate TheCU.
375 TheCU = DBuilder.createCompileUnit(
376 LangTag, Filename, getCurrentDirname(), Producer, LO.Optimize,
377 CGM.getCodeGenOpts().DwarfDebugFlags, RuntimeVers, SplitDwarfFilename,
378 DebugKind <= CodeGenOptions::DebugLineTablesOnly
379 ? llvm::DIBuilder::LineTablesOnly
380 : llvm::DIBuilder::FullDebug,
381 DebugKind != CodeGenOptions::LocTrackingOnly);
382}
383
384/// CreateType - Get the Basic type from the cache or create a new
385/// one if necessary.
386llvm::DIType CGDebugInfo::CreateType(const BuiltinType *BT) {
387 llvm::dwarf::TypeKind Encoding;
388 StringRef BTName;
389 switch (BT->getKind()) {
390#define BUILTIN_TYPE(Id, SingletonId)
391#define PLACEHOLDER_TYPE(Id, SingletonId) \
392 case BuiltinType::Id:
393#include "clang/AST/BuiltinTypes.def"
394 case BuiltinType::Dependent:
395 llvm_unreachable("Unexpected builtin type")::llvm::llvm_unreachable_internal("Unexpected builtin type", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 395);
396 case BuiltinType::NullPtr:
397 return DBuilder.createNullPtrType();
398 case BuiltinType::Void:
399 return llvm::DIType();
400 case BuiltinType::ObjCClass:
401 if (!ClassTy)
402 ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
403 "objc_class", TheCU,
404 getOrCreateMainFile(), 0);
405 return ClassTy;
406 case BuiltinType::ObjCId: {
407 // typedef struct objc_class *Class;
408 // typedef struct objc_object {
409 // Class isa;
410 // } *id;
411
412 if (ObjTy)
413 return ObjTy;
414
415 if (!ClassTy)
416 ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
417 "objc_class", TheCU,
418 getOrCreateMainFile(), 0);
419
420 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
421
422 llvm::DIType ISATy = DBuilder.createPointerType(ClassTy, Size);
423
424 ObjTy =
425 DBuilder.createStructType(TheCU, "objc_object", getOrCreateMainFile(),
426 0, 0, 0, 0, llvm::DIType(), llvm::DIArray());
427
428 ObjTy.setArrays(DBuilder.getOrCreateArray(&*DBuilder.createMemberType(
429 ObjTy, "isa", getOrCreateMainFile(), 0, Size, 0, 0, 0, ISATy)));
430 return ObjTy;
431 }
432 case BuiltinType::ObjCSel: {
433 if (!SelTy)
434 SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
435 "objc_selector", TheCU,
436 getOrCreateMainFile(), 0);
437 return SelTy;
438 }
439
440 case BuiltinType::OCLImage1d:
441 return getOrCreateStructPtrType("opencl_image1d_t",
442 OCLImage1dDITy);
443 case BuiltinType::OCLImage1dArray:
444 return getOrCreateStructPtrType("opencl_image1d_array_t",
445 OCLImage1dArrayDITy);
446 case BuiltinType::OCLImage1dBuffer:
447 return getOrCreateStructPtrType("opencl_image1d_buffer_t",
448 OCLImage1dBufferDITy);
449 case BuiltinType::OCLImage2d:
450 return getOrCreateStructPtrType("opencl_image2d_t",
451 OCLImage2dDITy);
452 case BuiltinType::OCLImage2dArray:
453 return getOrCreateStructPtrType("opencl_image2d_array_t",
454 OCLImage2dArrayDITy);
455 case BuiltinType::OCLImage3d:
456 return getOrCreateStructPtrType("opencl_image3d_t",
457 OCLImage3dDITy);
458 case BuiltinType::OCLSampler:
459 return DBuilder.createBasicType("opencl_sampler_t",
460 CGM.getContext().getTypeSize(BT),
461 CGM.getContext().getTypeAlign(BT),
462 llvm::dwarf::DW_ATE_unsigned);
463 case BuiltinType::OCLEvent:
464 return getOrCreateStructPtrType("opencl_event_t",
465 OCLEventDITy);
466
467 case BuiltinType::UChar:
468 case BuiltinType::Char_U: Encoding = llvm::dwarf::DW_ATE_unsigned_char; break;
469 case BuiltinType::Char_S:
470 case BuiltinType::SChar: Encoding = llvm::dwarf::DW_ATE_signed_char; break;
471 case BuiltinType::Char16:
472 case BuiltinType::Char32: Encoding = llvm::dwarf::DW_ATE_UTF; break;
473 case BuiltinType::UShort:
474 case BuiltinType::UInt:
475 case BuiltinType::UInt128:
476 case BuiltinType::ULong:
477 case BuiltinType::WChar_U:
478 case BuiltinType::ULongLong: Encoding = llvm::dwarf::DW_ATE_unsigned; break;
479 case BuiltinType::Short:
480 case BuiltinType::Int:
481 case BuiltinType::Int128:
482 case BuiltinType::Long:
483 case BuiltinType::WChar_S:
484 case BuiltinType::LongLong: Encoding = llvm::dwarf::DW_ATE_signed; break;
485 case BuiltinType::Bool: Encoding = llvm::dwarf::DW_ATE_boolean; break;
486 case BuiltinType::Half:
487 case BuiltinType::Float:
488 case BuiltinType::LongDouble:
489 case BuiltinType::Double: Encoding = llvm::dwarf::DW_ATE_float; break;
490 }
491
492 switch (BT->getKind()) {
493 case BuiltinType::Long: BTName = "long int"; break;
494 case BuiltinType::LongLong: BTName = "long long int"; break;
495 case BuiltinType::ULong: BTName = "long unsigned int"; break;
496 case BuiltinType::ULongLong: BTName = "long long unsigned int"; break;
497 default:
498 BTName = BT->getName(CGM.getLangOpts());
499 break;
500 }
501 // Bit size, align and offset of the type.
502 uint64_t Size = CGM.getContext().getTypeSize(BT);
503 uint64_t Align = CGM.getContext().getTypeAlign(BT);
504 llvm::DIType DbgTy =
505 DBuilder.createBasicType(BTName, Size, Align, Encoding);
506 return DbgTy;
507}
508
509llvm::DIType CGDebugInfo::CreateType(const ComplexType *Ty) {
510 // Bit size, align and offset of the type.
511 llvm::dwarf::TypeKind Encoding = llvm::dwarf::DW_ATE_complex_float;
512 if (Ty->isComplexIntegerType())
513 Encoding = llvm::dwarf::DW_ATE_lo_user;
514
515 uint64_t Size = CGM.getContext().getTypeSize(Ty);
516 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
517 llvm::DIType DbgTy =
518 DBuilder.createBasicType("complex", Size, Align, Encoding);
519
520 return DbgTy;
521}
522
523/// CreateCVRType - Get the qualified type from the cache or create
524/// a new one if necessary.
525llvm::DIType CGDebugInfo::CreateQualifiedType(QualType Ty, llvm::DIFile Unit) {
526 QualifierCollector Qc;
527 const Type *T = Qc.strip(Ty);
528
529 // Ignore these qualifiers for now.
530 Qc.removeObjCGCAttr();
531 Qc.removeAddressSpace();
532 Qc.removeObjCLifetime();
533
534 // We will create one Derived type for one qualifier and recurse to handle any
535 // additional ones.
536 llvm::dwarf::Tag Tag;
537 if (Qc.hasConst()) {
538 Tag = llvm::dwarf::DW_TAG_const_type;
539 Qc.removeConst();
540 } else if (Qc.hasVolatile()) {
541 Tag = llvm::dwarf::DW_TAG_volatile_type;
542 Qc.removeVolatile();
543 } else if (Qc.hasRestrict()) {
544 Tag = llvm::dwarf::DW_TAG_restrict_type;
545 Qc.removeRestrict();
546 } else {
547 assert(Qc.empty() && "Unknown type qualifier for debug info")((Qc.empty() && "Unknown type qualifier for debug info"
) ? static_cast<void> (0) : __assert_fail ("Qc.empty() && \"Unknown type qualifier for debug info\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 547, __PRETTY_FUNCTION__));
548 return getOrCreateType(QualType(T, 0), Unit);
549 }
550
551 llvm::DIType FromTy = getOrCreateType(Qc.apply(CGM.getContext(), T), Unit);
552
553 // No need to fill in the Name, Line, Size, Alignment, Offset in case of
554 // CVR derived types.
555 llvm::DIType DbgTy = DBuilder.createQualifiedType(Tag, FromTy);
556
557 return DbgTy;
558}
559
560llvm::DIType CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty,
561 llvm::DIFile Unit) {
562
563 // The frontend treats 'id' as a typedef to an ObjCObjectType,
564 // whereas 'id<protocol>' is treated as an ObjCPointerType. For the
565 // debug info, we want to emit 'id' in both cases.
566 if (Ty->isObjCQualifiedIdType())
567 return getOrCreateType(CGM.getContext().getObjCIdType(), Unit);
568
569 llvm::DIType DbgTy =
570 CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
571 Ty->getPointeeType(), Unit);
572 return DbgTy;
573}
574
575llvm::DIType CGDebugInfo::CreateType(const PointerType *Ty,
576 llvm::DIFile Unit) {
577 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
578 Ty->getPointeeType(), Unit);
579}
580
581/// In C++ mode, types have linkage, so we can rely on the ODR and
582/// on their mangled names, if they're external.
583static SmallString<256>
584getUniqueTagTypeName(const TagType *Ty, CodeGenModule &CGM,
585 llvm::DICompileUnit TheCU) {
586 SmallString<256> FullName;
587 // FIXME: ODR should apply to ObjC++ exactly the same wasy it does to C++.
588 // For now, only apply ODR with C++.
589 const TagDecl *TD = Ty->getDecl();
590 if (TheCU.getLanguage() != llvm::dwarf::DW_LANG_C_plus_plus ||
591 !TD->isExternallyVisible())
592 return FullName;
593 // Microsoft Mangler does not have support for mangleCXXRTTIName yet.
594 if (CGM.getTarget().getCXXABI().isMicrosoft())
595 return FullName;
596
597 // TODO: This is using the RTTI name. Is there a better way to get
598 // a unique string for a type?
599 llvm::raw_svector_ostream Out(FullName);
600 CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(QualType(Ty, 0), Out);
601 Out.flush();
602 return FullName;
603}
604
605// Creates a forward declaration for a RecordDecl in the given context.
606llvm::DICompositeType
607CGDebugInfo::getOrCreateRecordFwdDecl(const RecordType *Ty,
608 llvm::DIDescriptor Ctx) {
609 const RecordDecl *RD = Ty->getDecl();
610 if (llvm::DIType T = getTypeOrNull(CGM.getContext().getRecordType(RD)))
611 return llvm::DICompositeType(T);
612 llvm::DIFile DefUnit = getOrCreateFile(RD->getLocation());
613 unsigned Line = getLineNumber(RD->getLocation());
614 StringRef RDName = getClassName(RD);
615
616 llvm::dwarf::Tag Tag;
617 if (RD->isStruct() || RD->isInterface())
618 Tag = llvm::dwarf::DW_TAG_structure_type;
619 else if (RD->isUnion())
620 Tag = llvm::dwarf::DW_TAG_union_type;
621 else {
622 assert(RD->isClass())((RD->isClass()) ? static_cast<void> (0) : __assert_fail
("RD->isClass()", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 622, __PRETTY_FUNCTION__));
623 Tag = llvm::dwarf::DW_TAG_class_type;
624 }
625
626 // Create the type.
627 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
628 llvm::DICompositeType RetTy = DBuilder.createReplaceableForwardDecl(
629 Tag, RDName, Ctx, DefUnit, Line, 0, 0, 0, FullName);
630 ReplaceMap.push_back(std::make_pair(Ty, static_cast<llvm::Value *>(RetTy)));
631 return RetTy;
632}
633
634llvm::DIType CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
635 const Type *Ty,
636 QualType PointeeTy,
637 llvm::DIFile Unit) {
638 if (Tag == llvm::dwarf::DW_TAG_reference_type ||
639 Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)
640 return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit));
641
642 // Bit size, align and offset of the type.
643 // Size is always the size of a pointer. We can't use getTypeSize here
644 // because that does not return the correct value for references.
645 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
646 uint64_t Size = CGM.getTarget().getPointerWidth(AS);
647 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
648
649 return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
650 Align);
651}
652
653llvm::DIType CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
654 llvm::DIType &Cache) {
655 if (Cache)
656 return Cache;
657 Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
658 TheCU, getOrCreateMainFile(), 0);
659 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
660 Cache = DBuilder.createPointerType(Cache, Size);
661 return Cache;
662}
663
664llvm::DIType CGDebugInfo::CreateType(const BlockPointerType *Ty,
665 llvm::DIFile Unit) {
666 if (BlockLiteralGeneric)
667 return BlockLiteralGeneric;
668
669 SmallVector<llvm::Value *, 8> EltTys;
670 llvm::DIType FieldTy;
671 QualType FType;
672 uint64_t FieldSize, FieldOffset;
673 unsigned FieldAlign;
674 llvm::DIArray Elements;
675 llvm::DIType EltTy, DescTy;
676
677 FieldOffset = 0;
678 FType = CGM.getContext().UnsignedLongTy;
679 EltTys.push_back(CreateMemberType(Unit, FType, "reserved", &FieldOffset));
680 EltTys.push_back(CreateMemberType(Unit, FType, "Size", &FieldOffset));
681
682 Elements = DBuilder.getOrCreateArray(EltTys);
683 EltTys.clear();
684
685 unsigned Flags = llvm::DIDescriptor::FlagAppleBlock;
686 unsigned LineNo = getLineNumber(CurLoc);
687
688 EltTy = DBuilder.createStructType(Unit, "__block_descriptor",
689 Unit, LineNo, FieldOffset, 0,
690 Flags, llvm::DIType(), Elements);
691
692 // Bit size, align and offset of the type.
693 uint64_t Size = CGM.getContext().getTypeSize(Ty);
694
695 DescTy = DBuilder.createPointerType(EltTy, Size);
696
697 FieldOffset = 0;
698 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
699 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
700 FType = CGM.getContext().IntTy;
701 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
702 EltTys.push_back(CreateMemberType(Unit, FType, "__reserved", &FieldOffset));
703 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
704 EltTys.push_back(CreateMemberType(Unit, FType, "__FuncPtr", &FieldOffset));
705
706 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
707 FieldTy = DescTy;
708 FieldSize = CGM.getContext().getTypeSize(Ty);
709 FieldAlign = CGM.getContext().getTypeAlign(Ty);
710 FieldTy = DBuilder.createMemberType(Unit, "__descriptor", Unit,
711 LineNo, FieldSize, FieldAlign,
712 FieldOffset, 0, FieldTy);
713 EltTys.push_back(FieldTy);
714
715 FieldOffset += FieldSize;
716 Elements = DBuilder.getOrCreateArray(EltTys);
717
718 EltTy = DBuilder.createStructType(Unit, "__block_literal_generic",
719 Unit, LineNo, FieldOffset, 0,
720 Flags, llvm::DIType(), Elements);
721
722 BlockLiteralGeneric = DBuilder.createPointerType(EltTy, Size);
723 return BlockLiteralGeneric;
724}
725
726llvm::DIType CGDebugInfo::CreateType(const TemplateSpecializationType *Ty, llvm::DIFile Unit) {
727 assert(Ty->isTypeAlias())((Ty->isTypeAlias()) ? static_cast<void> (0) : __assert_fail
("Ty->isTypeAlias()", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 727, __PRETTY_FUNCTION__));
728 llvm::DIType Src = getOrCreateType(Ty->getAliasedType(), Unit);
729
730 SmallString<128> NS;
731 llvm::raw_svector_ostream OS(NS);
732 Ty->getTemplateName().print(OS, CGM.getContext().getPrintingPolicy(), /*qualified*/ false);
733
734 TemplateSpecializationType::PrintTemplateArgumentList(
735 OS, Ty->getArgs(), Ty->getNumArgs(),
736 CGM.getContext().getPrintingPolicy());
737
738 TypeAliasDecl *AliasDecl =
739 cast<TypeAliasTemplateDecl>(Ty->getTemplateName().getAsTemplateDecl())
740 ->getTemplatedDecl();
741
742 SourceLocation Loc = AliasDecl->getLocation();
743 llvm::DIFile File = getOrCreateFile(Loc);
744 unsigned Line = getLineNumber(Loc);
745
746 llvm::DIDescriptor Ctxt = getContextDescriptor(cast<Decl>(AliasDecl->getDeclContext()));
747
748 return DBuilder.createTypedef(Src, internString(OS.str()), File, Line, Ctxt);
749}
750
751llvm::DIType CGDebugInfo::CreateType(const TypedefType *Ty, llvm::DIFile Unit) {
752 // Typedefs are derived from some other type. If we have a typedef of a
753 // typedef, make sure to emit the whole chain.
754 llvm::DIType Src = getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit);
755 // We don't set size information, but do specify where the typedef was
756 // declared.
757 SourceLocation Loc = Ty->getDecl()->getLocation();
758 llvm::DIFile File = getOrCreateFile(Loc);
759 unsigned Line = getLineNumber(Loc);
760 const TypedefNameDecl *TyDecl = Ty->getDecl();
761
762 llvm::DIDescriptor TypedefContext =
763 getContextDescriptor(cast<Decl>(Ty->getDecl()->getDeclContext()));
764
765 return
766 DBuilder.createTypedef(Src, TyDecl->getName(), File, Line, TypedefContext);
767}
768
769llvm::DIType CGDebugInfo::CreateType(const FunctionType *Ty,
770 llvm::DIFile Unit) {
771 SmallVector<llvm::Value *, 16> EltTys;
772
773 // Add the result type at least.
774 EltTys.push_back(getOrCreateType(Ty->getReturnType(), Unit));
775
776 // Set up remainder of arguments if there is a prototype.
777 // otherwise emit it as a variadic function.
778 if (isa<FunctionNoProtoType>(Ty))
779 EltTys.push_back(DBuilder.createUnspecifiedParameter());
780 else if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(Ty)) {
781 for (unsigned i = 0, e = FPT->getNumParams(); i != e; ++i)
782 EltTys.push_back(getOrCreateType(FPT->getParamType(i), Unit));
783 if (FPT->isVariadic())
784 EltTys.push_back(DBuilder.createUnspecifiedParameter());
785 }
786
787 llvm::DITypeArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
788 return DBuilder.createSubroutineType(Unit, EltTypeArray);
789}
790
791/// Convert an AccessSpecifier into the corresponding DIDescriptor flag.
792/// As an optimization, return 0 if the access specifier equals the
793/// default for the containing type.
794static unsigned getAccessFlag(AccessSpecifier Access, const RecordDecl *RD) {
795 AccessSpecifier Default = clang::AS_none;
796 if (RD && RD->isClass())
797 Default = clang::AS_private;
798 else if (RD && (RD->isStruct() || RD->isUnion()))
799 Default = clang::AS_public;
800
801 if (Access == Default)
802 return 0;
803
804 switch(Access) {
805 case clang::AS_private: return llvm::DIDescriptor::FlagPrivate;
806 case clang::AS_protected: return llvm::DIDescriptor::FlagProtected;
807 case clang::AS_public: return llvm::DIDescriptor::FlagPublic;
808 case clang::AS_none: return 0;
809 }
810 llvm_unreachable("unexpected access enumerator")::llvm::llvm_unreachable_internal("unexpected access enumerator"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 810);
811}
812
813llvm::DIType CGDebugInfo::createFieldType(StringRef name,
814 QualType type,
815 uint64_t sizeInBitsOverride,
816 SourceLocation loc,
817 AccessSpecifier AS,
818 uint64_t offsetInBits,
819 llvm::DIFile tunit,
820 llvm::DIScope scope,
821 const RecordDecl* RD) {
822 llvm::DIType debugType = getOrCreateType(type, tunit);
823
824 // Get the location for the field.
825 llvm::DIFile file = getOrCreateFile(loc);
826 unsigned line = getLineNumber(loc);
827
828 uint64_t SizeInBits = 0;
829 unsigned AlignInBits = 0;
830 if (!type->isIncompleteArrayType()) {
831 TypeInfo TI = CGM.getContext().getTypeInfo(type);
832 SizeInBits = TI.Width;
833 AlignInBits = TI.Align;
834
835 if (sizeInBitsOverride)
836 SizeInBits = sizeInBitsOverride;
837 }
838
839 unsigned flags = getAccessFlag(AS, RD);
840 return DBuilder.createMemberType(scope, name, file, line, SizeInBits,
841 AlignInBits, offsetInBits, flags, debugType);
842}
843
844/// CollectRecordLambdaFields - Helper for CollectRecordFields.
845void CGDebugInfo::
846CollectRecordLambdaFields(const CXXRecordDecl *CXXDecl,
847 SmallVectorImpl<llvm::Value *> &elements,
848 llvm::DIType RecordTy) {
849 // For C++11 Lambdas a Field will be the same as a Capture, but the Capture
850 // has the name and the location of the variable so we should iterate over
851 // both concurrently.
852 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(CXXDecl);
853 RecordDecl::field_iterator Field = CXXDecl->field_begin();
854 unsigned fieldno = 0;
855 for (CXXRecordDecl::capture_const_iterator I = CXXDecl->captures_begin(),
856 E = CXXDecl->captures_end(); I != E; ++I, ++Field, ++fieldno) {
857 const LambdaCapture &C = *I;
858 if (C.capturesVariable()) {
859 VarDecl *V = C.getCapturedVar();
860 llvm::DIFile VUnit = getOrCreateFile(C.getLocation());
861 StringRef VName = V->getName();
862 uint64_t SizeInBitsOverride = 0;
863 if (Field->isBitField()) {
864 SizeInBitsOverride = Field->getBitWidthValue(CGM.getContext());
865 assert(SizeInBitsOverride && "found named 0-width bitfield")((SizeInBitsOverride && "found named 0-width bitfield"
) ? static_cast<void> (0) : __assert_fail ("SizeInBitsOverride && \"found named 0-width bitfield\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 865, __PRETTY_FUNCTION__));
866 }
867 llvm::DIType fieldType
868 = createFieldType(VName, Field->getType(), SizeInBitsOverride,
869 C.getLocation(), Field->getAccess(),
870 layout.getFieldOffset(fieldno), VUnit, RecordTy,
871 CXXDecl);
872 elements.push_back(fieldType);
873 } else if (C.capturesThis()) {
874 // TODO: Need to handle 'this' in some way by probably renaming the
875 // this of the lambda class and having a field member of 'this' or
876 // by using AT_object_pointer for the function and having that be
877 // used as 'this' for semantic references.
878 FieldDecl *f = *Field;
879 llvm::DIFile VUnit = getOrCreateFile(f->getLocation());
880 QualType type = f->getType();
881 llvm::DIType fieldType
882 = createFieldType("this", type, 0, f->getLocation(), f->getAccess(),
883 layout.getFieldOffset(fieldno), VUnit, RecordTy,
884 CXXDecl);
885
886 elements.push_back(fieldType);
887 }
888 }
889}
890
891/// Helper for CollectRecordFields.
892llvm::DIDerivedType
893CGDebugInfo::CreateRecordStaticField(const VarDecl *Var,
894 llvm::DIType RecordTy,
895 const RecordDecl* RD) {
896 // Create the descriptor for the static variable, with or without
897 // constant initializers.
898 llvm::DIFile VUnit = getOrCreateFile(Var->getLocation());
899 llvm::DIType VTy = getOrCreateType(Var->getType(), VUnit);
900
901 unsigned LineNumber = getLineNumber(Var->getLocation());
902 StringRef VName = Var->getName();
903 llvm::Constant *C = nullptr;
904 if (Var->getInit()) {
905 const APValue *Value = Var->evaluateValue();
906 if (Value) {
907 if (Value->isInt())
908 C = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->getInt());
909 if (Value->isFloat())
910 C = llvm::ConstantFP::get(CGM.getLLVMContext(), Value->getFloat());
911 }
912 }
913
914 unsigned Flags = getAccessFlag(Var->getAccess(), RD);
915 llvm::DIDerivedType GV = DBuilder.createStaticMemberType(
916 RecordTy, VName, VUnit, LineNumber, VTy, Flags, C);
917 StaticDataMemberCache[Var->getCanonicalDecl()] = llvm::WeakVH(GV);
918 return GV;
919}
920
921/// CollectRecordNormalField - Helper for CollectRecordFields.
922void CGDebugInfo::
923CollectRecordNormalField(const FieldDecl *field, uint64_t OffsetInBits,
924 llvm::DIFile tunit,
925 SmallVectorImpl<llvm::Value *> &elements,
926 llvm::DIType RecordTy,
927 const RecordDecl* RD) {
928 StringRef name = field->getName();
929 QualType type = field->getType();
930
931 // Ignore unnamed fields unless they're anonymous structs/unions.
932 if (name.empty() && !type->isRecordType())
933 return;
934
935 uint64_t SizeInBitsOverride = 0;
936 if (field->isBitField()) {
937 SizeInBitsOverride = field->getBitWidthValue(CGM.getContext());
938 assert(SizeInBitsOverride && "found named 0-width bitfield")((SizeInBitsOverride && "found named 0-width bitfield"
) ? static_cast<void> (0) : __assert_fail ("SizeInBitsOverride && \"found named 0-width bitfield\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 938, __PRETTY_FUNCTION__));
939 }
940
941 llvm::DIType fieldType
942 = createFieldType(name, type, SizeInBitsOverride,
943 field->getLocation(), field->getAccess(),
944 OffsetInBits, tunit, RecordTy, RD);
945
946 elements.push_back(fieldType);
947}
948
949/// CollectRecordFields - A helper function to collect debug info for
950/// record fields. This is used while creating debug info entry for a Record.
951void CGDebugInfo::CollectRecordFields(const RecordDecl *record,
952 llvm::DIFile tunit,
953 SmallVectorImpl<llvm::Value *> &elements,
954 llvm::DICompositeType RecordTy) {
955 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(record);
956
957 if (CXXDecl && CXXDecl->isLambda())
958 CollectRecordLambdaFields(CXXDecl, elements, RecordTy);
959 else {
960 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(record);
961
962 // Field number for non-static fields.
963 unsigned fieldNo = 0;
964
965 // Static and non-static members should appear in the same order as
966 // the corresponding declarations in the source program.
967 for (const auto *I : record->decls())
968 if (const auto *V = dyn_cast<VarDecl>(I)) {
969 // Reuse the existing static member declaration if one exists
970 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator MI =
971 StaticDataMemberCache.find(V->getCanonicalDecl());
972 if (MI != StaticDataMemberCache.end()) {
973 assert(MI->second &&((MI->second && "Static data member declaration should still exist"
) ? static_cast<void> (0) : __assert_fail ("MI->second && \"Static data member declaration should still exist\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 974, __PRETTY_FUNCTION__))
974 "Static data member declaration should still exist")((MI->second && "Static data member declaration should still exist"
) ? static_cast<void> (0) : __assert_fail ("MI->second && \"Static data member declaration should still exist\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 974, __PRETTY_FUNCTION__));
975 elements.push_back(
976 llvm::DIDerivedType(cast<llvm::MDNode>(MI->second)));
977 } else {
978 auto Field = CreateRecordStaticField(V, RecordTy, record);
979 elements.push_back(Field);
980 }
981 } else if (const auto *field = dyn_cast<FieldDecl>(I)) {
982 CollectRecordNormalField(field, layout.getFieldOffset(fieldNo),
983 tunit, elements, RecordTy, record);
984
985 // Bump field number for next field.
986 ++fieldNo;
987 }
988 }
989}
990
991/// getOrCreateMethodType - CXXMethodDecl's type is a FunctionType. This
992/// function type is not updated to include implicit "this" pointer. Use this
993/// routine to get a method type which includes "this" pointer.
994llvm::DICompositeType
995CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method,
996 llvm::DIFile Unit) {
997 const FunctionProtoType *Func = Method->getType()->getAs<FunctionProtoType>();
998 if (Method->isStatic())
999 return llvm::DICompositeType(getOrCreateType(QualType(Func, 0), Unit));
1000 return getOrCreateInstanceMethodType(Method->getThisType(CGM.getContext()),
1001 Func, Unit);
1002}
1003
1004llvm::DICompositeType CGDebugInfo::getOrCreateInstanceMethodType(
1005 QualType ThisPtr, const FunctionProtoType *Func, llvm::DIFile Unit) {
1006 // Add "this" pointer.
1007 llvm::DITypeArray Args = llvm::DISubroutineType(
1008 getOrCreateType(QualType(Func, 0), Unit)).getTypeArray();
1009 assert (Args.getNumElements() && "Invalid number of arguments!")((Args.getNumElements() && "Invalid number of arguments!"
) ? static_cast<void> (0) : __assert_fail ("Args.getNumElements() && \"Invalid number of arguments!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1009, __PRETTY_FUNCTION__));
1010
1011 SmallVector<llvm::Value *, 16> Elts;
1012
1013 // First element is always return type. For 'void' functions it is NULL.
1014 Elts.push_back(Args.getElement(0));
1015
1016 // "this" pointer is always first argument.
1017 const CXXRecordDecl *RD = ThisPtr->getPointeeCXXRecordDecl();
1018 if (isa<ClassTemplateSpecializationDecl>(RD)) {
1019 // Create pointer type directly in this case.
1020 const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr);
1021 QualType PointeeTy = ThisPtrTy->getPointeeType();
1022 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
1023 uint64_t Size = CGM.getTarget().getPointerWidth(AS);
1024 uint64_t Align = CGM.getContext().getTypeAlign(ThisPtrTy);
1025 llvm::DIType PointeeType = getOrCreateType(PointeeTy, Unit);
1026 llvm::DIType ThisPtrType =
1027 DBuilder.createPointerType(PointeeType, Size, Align);
1028 TypeCache[ThisPtr.getAsOpaquePtr()] = ThisPtrType;
1029 // TODO: This and the artificial type below are misleading, the
1030 // types aren't artificial the argument is, but the current
1031 // metadata doesn't represent that.
1032 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1033 Elts.push_back(ThisPtrType);
1034 } else {
1035 llvm::DIType ThisPtrType = getOrCreateType(ThisPtr, Unit);
1036 TypeCache[ThisPtr.getAsOpaquePtr()] = ThisPtrType;
1037 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1038 Elts.push_back(ThisPtrType);
1039 }
1040
1041 // Copy rest of the arguments.
1042 for (unsigned i = 1, e = Args.getNumElements(); i != e; ++i)
1043 Elts.push_back(Args.getElement(i));
1044
1045 llvm::DITypeArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
1046
1047 unsigned Flags = 0;
1048 if (Func->getExtProtoInfo().RefQualifier == RQ_LValue)
1049 Flags |= llvm::DIDescriptor::FlagLValueReference;
1050 if (Func->getExtProtoInfo().RefQualifier == RQ_RValue)
1051 Flags |= llvm::DIDescriptor::FlagRValueReference;
1052
1053 return DBuilder.createSubroutineType(Unit, EltTypeArray, Flags);
1054}
1055
1056/// isFunctionLocalClass - Return true if CXXRecordDecl is defined
1057/// inside a function.
1058static bool isFunctionLocalClass(const CXXRecordDecl *RD) {
1059 if (const CXXRecordDecl *NRD = dyn_cast<CXXRecordDecl>(RD->getDeclContext()))
1060 return isFunctionLocalClass(NRD);
1061 if (isa<FunctionDecl>(RD->getDeclContext()))
1062 return true;
1063 return false;
1064}
1065
1066/// CreateCXXMemberFunction - A helper function to create a DISubprogram for
1067/// a single member function GlobalDecl.
1068llvm::DISubprogram
1069CGDebugInfo::CreateCXXMemberFunction(const CXXMethodDecl *Method,
1070 llvm::DIFile Unit,
1071 llvm::DIType RecordTy) {
1072 bool IsCtorOrDtor =
1073 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
1074
1075 StringRef MethodName = getFunctionName(Method);
1076 llvm::DICompositeType MethodTy = getOrCreateMethodType(Method, Unit);
1077
1078 // Since a single ctor/dtor corresponds to multiple functions, it doesn't
1079 // make sense to give a single ctor/dtor a linkage name.
1080 StringRef MethodLinkageName;
1081 if (!IsCtorOrDtor && !isFunctionLocalClass(Method->getParent()))
1082 MethodLinkageName = CGM.getMangledName(Method);
1083
1084 // Get the location for the method.
1085 llvm::DIFile MethodDefUnit;
1086 unsigned MethodLine = 0;
1087 if (!Method->isImplicit()) {
1088 MethodDefUnit = getOrCreateFile(Method->getLocation());
1089 MethodLine = getLineNumber(Method->getLocation());
1090 }
1091
1092 // Collect virtual method info.
1093 llvm::DIType ContainingType;
1094 unsigned Virtuality = 0;
1095 unsigned VIndex = 0;
1096
1097 if (Method->isVirtual()) {
1098 if (Method->isPure())
1099 Virtuality = llvm::dwarf::DW_VIRTUALITY_pure_virtual;
1100 else
1101 Virtuality = llvm::dwarf::DW_VIRTUALITY_virtual;
1102
1103 // It doesn't make sense to give a virtual destructor a vtable index,
1104 // since a single destructor has two entries in the vtable.
1105 // FIXME: Add proper support for debug info for virtual calls in
1106 // the Microsoft ABI, where we may use multiple vptrs to make a vftable
1107 // lookup if we have multiple or virtual inheritance.
1108 if (!isa<CXXDestructorDecl>(Method) &&
1109 !CGM.getTarget().getCXXABI().isMicrosoft())
1110 VIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(Method);
1111 ContainingType = RecordTy;
1112 }
1113
1114 unsigned Flags = 0;
1115 if (Method->isImplicit())
1116 Flags |= llvm::DIDescriptor::FlagArtificial;
1117 Flags |= getAccessFlag(Method->getAccess(), Method->getParent());
1118 if (const CXXConstructorDecl *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
1119 if (CXXC->isExplicit())
1120 Flags |= llvm::DIDescriptor::FlagExplicit;
1121 } else if (const CXXConversionDecl *CXXC =
1122 dyn_cast<CXXConversionDecl>(Method)) {
1123 if (CXXC->isExplicit())
1124 Flags |= llvm::DIDescriptor::FlagExplicit;
1125 }
1126 if (Method->hasPrototype())
1127 Flags |= llvm::DIDescriptor::FlagPrototyped;
1128 if (Method->getRefQualifier() == RQ_LValue)
1129 Flags |= llvm::DIDescriptor::FlagLValueReference;
1130 if (Method->getRefQualifier() == RQ_RValue)
1131 Flags |= llvm::DIDescriptor::FlagRValueReference;
1132
1133 llvm::DIArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
1134 llvm::DISubprogram SP =
1135 DBuilder.createMethod(RecordTy, MethodName, MethodLinkageName,
1136 MethodDefUnit, MethodLine,
1137 MethodTy, /*isLocalToUnit=*/false,
1138 /* isDefinition=*/ false,
1139 Virtuality, VIndex, ContainingType,
1140 Flags, CGM.getLangOpts().Optimize, nullptr,
1141 TParamsArray);
1142
1143 SPCache[Method->getCanonicalDecl()] = llvm::WeakVH(SP);
1144
1145 return SP;
1146}
1147
1148/// CollectCXXMemberFunctions - A helper function to collect debug info for
1149/// C++ member functions. This is used while creating debug info entry for
1150/// a Record.
1151void CGDebugInfo::
1152CollectCXXMemberFunctions(const CXXRecordDecl *RD, llvm::DIFile Unit,
1153 SmallVectorImpl<llvm::Value *> &EltTys,
1154 llvm::DIType RecordTy) {
1155
1156 // Since we want more than just the individual member decls if we
1157 // have templated functions iterate over every declaration to gather
1158 // the functions.
1159 for(const auto *I : RD->decls()) {
1160 const auto *Method = dyn_cast<CXXMethodDecl>(I);
1161 // If the member is implicit, don't add it to the member list. This avoids
1162 // the member being added to type units by LLVM, while still allowing it
1163 // to be emitted into the type declaration/reference inside the compile
1164 // unit.
1165 // FIXME: Handle Using(Shadow?)Decls here to create
1166 // DW_TAG_imported_declarations inside the class for base decls brought into
1167 // derived classes. GDB doesn't seem to notice/leverage these when I tried
1168 // it, so I'm not rushing to fix this. (GCC seems to produce them, if
1169 // referenced)
1170 if (!Method || Method->isImplicit())
1171 continue;
1172 // Reuse the existing member function declaration if it exists.
1173 // It may be associated with the declaration of the type & should be
1174 // reused as we're building the definition.
1175 //
1176 // This situation can arise in the vtable-based debug info reduction where
1177 // implicit members are emitted in a non-vtable TU.
1178 auto MI = SPCache.find(Method->getCanonicalDecl());
1179 EltTys.push_back(MI == SPCache.end()
1180 ? CreateCXXMemberFunction(Method, Unit, RecordTy)
1181 : static_cast<llvm::Value *>(MI->second));
1182 }
1183}
1184
1185/// CollectCXXBases - A helper function to collect debug info for
1186/// C++ base classes. This is used while creating debug info entry for
1187/// a Record.
1188void CGDebugInfo::
1189CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile Unit,
1190 SmallVectorImpl<llvm::Value *> &EltTys,
1191 llvm::DIType RecordTy) {
1192
1193 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1194 for (const auto &BI : RD->bases()) {
1195 unsigned BFlags = 0;
1196 uint64_t BaseOffset;
1197
1198 const CXXRecordDecl *Base =
1199 cast<CXXRecordDecl>(BI.getType()->getAs<RecordType>()->getDecl());
1200
1201 if (BI.isVirtual()) {
1202 if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1203 // virtual base offset offset is -ve. The code generator emits dwarf
1204 // expression where it expects +ve number.
1205 BaseOffset =
1206 0 - CGM.getItaniumVTableContext()
1207 .getVirtualBaseOffsetOffset(RD, Base).getQuantity();
1208 } else {
1209 // In the MS ABI, store the vbtable offset, which is analogous to the
1210 // vbase offset offset in Itanium.
1211 BaseOffset =
1212 4 * CGM.getMicrosoftVTableContext().getVBTableIndex(RD, Base);
1213 }
1214 BFlags = llvm::DIDescriptor::FlagVirtual;
1215 } else
1216 BaseOffset = CGM.getContext().toBits(RL.getBaseClassOffset(Base));
1217 // FIXME: Inconsistent units for BaseOffset. It is in bytes when
1218 // BI->isVirtual() and bits when not.
1219
1220 BFlags |= getAccessFlag(BI.getAccessSpecifier(), RD);
1221 llvm::DIType DTy =
1222 DBuilder.createInheritance(RecordTy,
1223 getOrCreateType(BI.getType(), Unit),
1224 BaseOffset, BFlags);
1225 EltTys.push_back(DTy);
1226 }
1227}
1228
1229/// CollectTemplateParams - A helper function to collect template parameters.
1230llvm::DIArray CGDebugInfo::
1231CollectTemplateParams(const TemplateParameterList *TPList,
1232 ArrayRef<TemplateArgument> TAList,
1233 llvm::DIFile Unit) {
1234 SmallVector<llvm::Value *, 16> TemplateParams;
1235 for (unsigned i = 0, e = TAList.size(); i != e; ++i) {
9
←
Assuming 'i' is not equal to 'e'
→
10
←
Loop condition is true. Entering loop body
→
15
←
Assuming 'i' is not equal to 'e'
→
16
←
Loop condition is true. Entering loop body
→
20
←
Assuming 'i' is not equal to 'e'
→
21
←
Loop condition is true. Entering loop body
→
25
←
Assuming 'i' is not equal to 'e'
→
26
←
Loop condition is true. Entering loop body
→
1236 const TemplateArgument &TA = TAList[i];
1237 StringRef Name;
1238 if (TPList)
11
←
Assuming 'TPList' is null
→
12
←
Taking false branch
→
17
←
Taking false branch
→
22
←
Taking false branch
→
27
←
Taking false branch
→
1239 Name = TPList->getParam(i)->getName();
1240 switch (TA.getKind()) {
13
←
Control jumps to 'case Expression:' at line 1329
→
18
←
Control jumps to 'case Expression:' at line 1329
→
23
←
Control jumps to 'case Expression:' at line 1329
→
28
←
Control jumps to 'case Declaration:' at line 1255
→
1241 case TemplateArgument::Type: {
1242 llvm::DIType TTy = getOrCreateType(TA.getAsType(), Unit);
1243 llvm::DITemplateTypeParameter TTP =
1244 DBuilder.createTemplateTypeParameter(TheCU, Name, TTy);
1245 TemplateParams.push_back(TTP);
1246 } break;
1247 case TemplateArgument::Integral: {
1248 llvm::DIType TTy = getOrCreateType(TA.getIntegralType(), Unit);
1249 llvm::DITemplateValueParameter TVP =
1250 DBuilder.createTemplateValueParameter(
1251 TheCU, Name, TTy,
1252 llvm::ConstantInt::get(CGM.getLLVMContext(), TA.getAsIntegral()));
1253 TemplateParams.push_back(TVP);
1254 } break;
1255 case TemplateArgument::Declaration: {
1256 const ValueDecl *D = TA.getAsDecl();
1257 bool InstanceMember = D->isCXXInstanceMember();
1258 QualType T = InstanceMember
29
←
Assuming 'InstanceMember' is 0
→
30
←
'?' condition is false
→
1259 ? CGM.getContext().getMemberPointerType(
1260 D->getType(), cast<RecordDecl>(D->getDeclContext())
1261 ->getTypeForDecl())
1262 : CGM.getContext().getPointerType(D->getType());
1263 llvm::DIType TTy = getOrCreateType(T, Unit);
1264 llvm::Value *V = nullptr;
31
←
'V' initialized to a null pointer value
→
1265 // Variable pointer template parameters have a value that is the address
1266 // of the variable.
1267 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
32
←
Taking false branch
→
1268 V = CGM.GetAddrOfGlobalVar(VD);
1269 // Member function pointers have special support for building them, though
1270 // this is currently unsupported in LLVM CodeGen.
1271 if (InstanceMember) {
33
←
Taking false branch
→
1272 if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(D))
1273 V = CGM.getCXXABI().EmitMemberPointer(method);
1274 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
34
←
Taking false branch
→
1275 V = CGM.GetAddrOfFunction(FD);
1276 // Member data pointers have special handling too to compute the fixed
1277 // offset within the object.
1278 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) {
35
←
Taking false branch
→
1279 // These five lines (& possibly the above member function pointer
1280 // handling) might be able to be refactored to use similar code in
1281 // CodeGenModule::getMemberPointerConstant
1282 uint64_t fieldOffset = CGM.getContext().getFieldOffset(D);
1283 CharUnits chars =
1284 CGM.getContext().toCharUnitsFromBits((int64_t) fieldOffset);
1285 V = CGM.getCXXABI().EmitMemberDataPointer(
1286 cast<MemberPointerType>(T.getTypePtr()), chars);
1287 }
1288 llvm::DITemplateValueParameter TVP =
1289 DBuilder.createTemplateValueParameter(TheCU, Name, TTy,
1290 V->stripPointerCasts());
36
←
Called C++ object pointer is null
1291 TemplateParams.push_back(TVP);
1292 } break;
1293 case TemplateArgument::NullPtr: {
1294 QualType T = TA.getNullPtrType();
1295 llvm::DIType TTy = getOrCreateType(T, Unit);
1296 llvm::Value *V = nullptr;
1297 // Special case member data pointer null values since they're actually -1
1298 // instead of zero.
1299 if (const MemberPointerType *MPT =
1300 dyn_cast<MemberPointerType>(T.getTypePtr()))
1301 // But treat member function pointers as simple zero integers because
1302 // it's easier than having a special case in LLVM's CodeGen. If LLVM
1303 // CodeGen grows handling for values of non-null member function
1304 // pointers then perhaps we could remove this special case and rely on
1305 // EmitNullMemberPointer for member function pointers.
1306 if (MPT->isMemberDataPointer())
1307 V = CGM.getCXXABI().EmitNullMemberPointer(MPT);
1308 if (!V)
1309 V = llvm::ConstantInt::get(CGM.Int8Ty, 0);
1310 llvm::DITemplateValueParameter TVP =
1311 DBuilder.createTemplateValueParameter(TheCU, Name, TTy, V);
1312 TemplateParams.push_back(TVP);
1313 } break;
1314 case TemplateArgument::Template: {
1315 llvm::DITemplateValueParameter TVP =
1316 DBuilder.createTemplateTemplateParameter(
1317 TheCU, Name, llvm::DIType(),
1318 TA.getAsTemplate().getAsTemplateDecl()
1319 ->getQualifiedNameAsString());
1320 TemplateParams.push_back(TVP);
1321 } break;
1322 case TemplateArgument::Pack: {
1323 llvm::DITemplateValueParameter TVP =
1324 DBuilder.createTemplateParameterPack(
1325 TheCU, Name, llvm::DIType(),
1326 CollectTemplateParams(nullptr, TA.getPackAsArray(), Unit));
1327 TemplateParams.push_back(TVP);
1328 } break;
1329 case TemplateArgument::Expression: {
1330 const Expr *E = TA.getAsExpr();
1331 QualType T = E->getType();
1332 llvm::Value *V = CGM.EmitConstantExpr(E, T);
1333 assert(V && "Expression in template argument isn't constant")((V && "Expression in template argument isn't constant"
) ? static_cast<void> (0) : __assert_fail ("V && \"Expression in template argument isn't constant\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1333, __PRETTY_FUNCTION__));
1334 llvm::DIType TTy = getOrCreateType(T, Unit);
1335 llvm::DITemplateValueParameter TVP =
1336 DBuilder.createTemplateValueParameter(TheCU, Name, TTy,
1337 V->stripPointerCasts());
1338 TemplateParams.push_back(TVP);
1339 } break;
14
←
 Execution continues on line 1235
→
19
←
 Execution continues on line 1235
→
24
←
 Execution continues on line 1235
→
1340 // And the following should never occur:
1341 case TemplateArgument::TemplateExpansion:
1342 case TemplateArgument::Null:
1343 llvm_unreachable(::llvm::llvm_unreachable_internal("These argument types shouldn't exist in concrete types"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1344)
1344 "These argument types shouldn't exist in concrete types")::llvm::llvm_unreachable_internal("These argument types shouldn't exist in concrete types"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1344);
1345 }
1346 }
1347 return DBuilder.getOrCreateArray(TemplateParams);
1348}
1349
1350/// CollectFunctionTemplateParams - A helper function to collect debug
1351/// info for function template parameters.
1352llvm::DIArray CGDebugInfo::
1353CollectFunctionTemplateParams(const FunctionDecl *FD, llvm::DIFile Unit) {
1354 if (FD->getTemplatedKind() ==
1355 FunctionDecl::TK_FunctionTemplateSpecialization) {
1356 const TemplateParameterList *TList =
1357 FD->getTemplateSpecializationInfo()->getTemplate()
1358 ->getTemplateParameters();
1359 return CollectTemplateParams(
1360 TList, FD->getTemplateSpecializationArgs()->asArray(), Unit);
1361 }
1362 return llvm::DIArray();
1363}
1364
1365/// CollectCXXTemplateParams - A helper function to collect debug info for
1366/// template parameters.
1367llvm::DIArray CGDebugInfo::
1368CollectCXXTemplateParams(const ClassTemplateSpecializationDecl *TSpecial,
1369 llvm::DIFile Unit) {
1370 // Always get the full list of parameters, not just the ones from
1371 // the specialization.
1372 TemplateParameterList *TPList =
1373 TSpecial->getSpecializedTemplate()->getTemplateParameters();
1374 const TemplateArgumentList &TAList = TSpecial->getTemplateArgs();
1375 return CollectTemplateParams(TPList, TAList.asArray(), Unit);
8
←
Calling 'CGDebugInfo::CollectTemplateParams'
→
1376}
1377
1378/// getOrCreateVTablePtrType - Return debug info descriptor for vtable.
1379llvm::DIType CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile Unit) {
1380 if (VTablePtrType.isValid())
1381 return VTablePtrType;
1382
1383 ASTContext &Context = CGM.getContext();
1384
1385 /* Function type */
1386 llvm::Value *STy = getOrCreateType(Context.IntTy, Unit);
1387 llvm::DITypeArray SElements = DBuilder.getOrCreateTypeArray(STy);
1388 llvm::DIType SubTy = DBuilder.createSubroutineType(Unit, SElements);
1389 unsigned Size = Context.getTypeSize(Context.VoidPtrTy);
1390 llvm::DIType vtbl_ptr_type = DBuilder.createPointerType(SubTy, Size, 0,
1391 "__vtbl_ptr_type");
1392 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
1393 return VTablePtrType;
1394}
1395
1396/// getVTableName - Get vtable name for the given Class.
1397StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) {
1398 // Copy the gdb compatible name on the side and use its reference.
1399 return internString("_vptr$", RD->getNameAsString());
1400}
1401
1402
1403/// CollectVTableInfo - If the C++ class has vtable info then insert appropriate
1404/// debug info entry in EltTys vector.
1405void CGDebugInfo::
1406CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile Unit,
1407 SmallVectorImpl<llvm::Value *> &EltTys) {
1408 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1409
1410 // If there is a primary base then it will hold vtable info.
1411 if (RL.getPrimaryBase())
1412 return;
1413
1414 // If this class is not dynamic then there is not any vtable info to collect.
1415 if (!RD->isDynamicClass())
1416 return;
1417
1418 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
1419 llvm::DIType VPTR
1420 = DBuilder.createMemberType(Unit, getVTableName(RD), Unit,
1421 0, Size, 0, 0,
1422 llvm::DIDescriptor::FlagArtificial,
1423 getOrCreateVTablePtrType(Unit));
1424 EltTys.push_back(VPTR);
1425}
1426
1427/// getOrCreateRecordType - Emit record type's standalone debug info.
1428llvm::DIType CGDebugInfo::getOrCreateRecordType(QualType RTy,
1429 SourceLocation Loc) {
1430 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo)((DebugKind >= CodeGenOptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= CodeGenOptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1430, __PRETTY_FUNCTION__));
1431 llvm::DIType T = getOrCreateType(RTy, getOrCreateFile(Loc));
1432 return T;
1433}
1434
1435/// getOrCreateInterfaceType - Emit an objective c interface type standalone
1436/// debug info.
1437llvm::DIType CGDebugInfo::getOrCreateInterfaceType(QualType D,
1438 SourceLocation Loc) {
1439 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo)((DebugKind >= CodeGenOptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= CodeGenOptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1439, __PRETTY_FUNCTION__));
1440 llvm::DIType T = getOrCreateType(D, getOrCreateFile(Loc));
1441 RetainedTypes.push_back(D.getAsOpaquePtr());
1442 return T;
1443}
1444
1445void CGDebugInfo::completeType(const EnumDecl *ED) {
1446 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
1447 return;
1448 QualType Ty = CGM.getContext().getEnumType(ED);
1449 void* TyPtr = Ty.getAsOpaquePtr();
1450 auto I = TypeCache.find(TyPtr);
1451 if (I == TypeCache.end() ||
1452 !llvm::DIType(cast<llvm::MDNode>(static_cast<llvm::Value *>(I->second)))
1453 .isForwardDecl())
1454 return;
1455 llvm::DIType Res = CreateTypeDefinition(Ty->castAs<EnumType>());
1456 assert(!Res.isForwardDecl())((!Res.isForwardDecl()) ? static_cast<void> (0) : __assert_fail
("!Res.isForwardDecl()", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1456, __PRETTY_FUNCTION__));
1457 TypeCache[TyPtr] = Res;
1458}
1459
1460void CGDebugInfo::completeType(const RecordDecl *RD) {
1461 if (DebugKind > CodeGenOptions::LimitedDebugInfo ||
1462 !CGM.getLangOpts().CPlusPlus)
1463 completeRequiredType(RD);
1464}
1465
1466void CGDebugInfo::completeRequiredType(const RecordDecl *RD) {
1467 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
1468 return;
1469
1470 if (const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
1471 if (CXXDecl->isDynamicClass())
1472 return;
1473
1474 QualType Ty = CGM.getContext().getRecordType(RD);
1475 llvm::DIType T = getTypeOrNull(Ty);
1476 if (T && T.isForwardDecl())
1477 completeClassData(RD);
1478}
1479
1480void CGDebugInfo::completeClassData(const RecordDecl *RD) {
1481 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
1482 return;
1483 QualType Ty = CGM.getContext().getRecordType(RD);
1484 void* TyPtr = Ty.getAsOpaquePtr();
1485 auto I = TypeCache.find(TyPtr);
1486 if (I != TypeCache.end() &&
1487 !llvm::DIType(cast<llvm::MDNode>(static_cast<llvm::Value *>(I->second)))
1488 .isForwardDecl())
1489 return;
1490 llvm::DIType Res = CreateTypeDefinition(Ty->castAs<RecordType>());
1491 assert(!Res.isForwardDecl())((!Res.isForwardDecl()) ? static_cast<void> (0) : __assert_fail
("!Res.isForwardDecl()", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1491, __PRETTY_FUNCTION__));
1492 TypeCache[TyPtr] = Res;
1493}
1494
1495static bool hasExplicitMemberDefinition(CXXRecordDecl::method_iterator I,
1496 CXXRecordDecl::method_iterator End) {
1497 for (; I != End; ++I)
1498 if (FunctionDecl *Tmpl = I->getInstantiatedFromMemberFunction())
1499 if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&
1500 !I->getMemberSpecializationInfo()->isExplicitSpecialization())
1501 return true;
1502 return false;
1503}
1504
1505static bool shouldOmitDefinition(CodeGenOptions::DebugInfoKind DebugKind,
1506 const RecordDecl *RD,
1507 const LangOptions &LangOpts) {
1508 if (DebugKind > CodeGenOptions::LimitedDebugInfo)
1509 return false;
1510
1511 if (!LangOpts.CPlusPlus)
1512 return false;
1513
1514 if (!RD->isCompleteDefinitionRequired())
1515 return true;
1516
1517 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
1518
1519 if (!CXXDecl)
1520 return false;
1521
1522 if (CXXDecl->hasDefinition() && CXXDecl->isDynamicClass())
1523 return true;
1524
1525 TemplateSpecializationKind Spec = TSK_Undeclared;
1526 if (const ClassTemplateSpecializationDecl *SD =
1527 dyn_cast<ClassTemplateSpecializationDecl>(RD))
1528 Spec = SD->getSpecializationKind();
1529
1530 if (Spec == TSK_ExplicitInstantiationDeclaration &&
1531 hasExplicitMemberDefinition(CXXDecl->method_begin(),
1532 CXXDecl->method_end()))
1533 return true;
1534
1535 return false;
1536}
1537
1538/// CreateType - get structure or union type.
1539llvm::DIType CGDebugInfo::CreateType(const RecordType *Ty) {
1540 RecordDecl *RD = Ty->getDecl();
1541 llvm::DICompositeType T(getTypeOrNull(QualType(Ty, 0)));
1542 if (T || shouldOmitDefinition(DebugKind, RD, CGM.getLangOpts())) {
1543 if (!T)
1544 T = getOrCreateRecordFwdDecl(
1545 Ty, getContextDescriptor(cast<Decl>(RD->getDeclContext())));
1546 return T;
1547 }
1548
1549 return CreateTypeDefinition(Ty);
1550}
1551
1552llvm::DIType CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) {
1553 RecordDecl *RD = Ty->getDecl();
1554
1555 // Get overall information about the record type for the debug info.
1556 llvm::DIFile DefUnit = getOrCreateFile(RD->getLocation());
1557
1558 // Records and classes and unions can all be recursive. To handle them, we
1559 // first generate a debug descriptor for the struct as a forward declaration.
1560 // Then (if it is a definition) we go through and get debug info for all of
1561 // its members. Finally, we create a descriptor for the complete type (which
1562 // may refer to the forward decl if the struct is recursive) and replace all
1563 // uses of the forward declaration with the final definition.
1564
1565 llvm::DICompositeType FwdDecl(getOrCreateLimitedType(Ty, DefUnit));
1566 assert(FwdDecl.isCompositeType() &&((FwdDecl.isCompositeType() && "The debug type of a RecordType should be a llvm::DICompositeType"
) ? static_cast<void> (0) : __assert_fail ("FwdDecl.isCompositeType() && \"The debug type of a RecordType should be a llvm::DICompositeType\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1567, __PRETTY_FUNCTION__))
1567 "The debug type of a RecordType should be a llvm::DICompositeType")((FwdDecl.isCompositeType() && "The debug type of a RecordType should be a llvm::DICompositeType"
) ? static_cast<void> (0) : __assert_fail ("FwdDecl.isCompositeType() && \"The debug type of a RecordType should be a llvm::DICompositeType\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1567, __PRETTY_FUNCTION__));
1568
1569 if (FwdDecl.isForwardDecl())
1570 return FwdDecl;
1571
1572 if (const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
1573 CollectContainingType(CXXDecl, FwdDecl);
1574
1575 // Push the struct on region stack.
1576 LexicalBlockStack.push_back(&*FwdDecl);
1577 RegionMap[Ty->getDecl()] = llvm::WeakVH(FwdDecl);
1578
1579 // Convert all the elements.
1580 SmallVector<llvm::Value *, 16> EltTys;
1581 // what about nested types?
1582
1583 // Note: The split of CXXDecl information here is intentional, the
1584 // gdb tests will depend on a certain ordering at printout. The debug
1585 // information offsets are still correct if we merge them all together
1586 // though.
1587 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
1588 if (CXXDecl) {
1589 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
1590 CollectVTableInfo(CXXDecl, DefUnit, EltTys);
1591 }
1592
1593 // Collect data fields (including static variables and any initializers).
1594 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
1595 if (CXXDecl)
1596 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
1597
1598 LexicalBlockStack.pop_back();
1599 RegionMap.erase(Ty->getDecl());
1600
1601 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys);
1602 FwdDecl.setArrays(Elements);
1603
1604 RegionMap[Ty->getDecl()] = llvm::WeakVH(FwdDecl);
1605 return FwdDecl;
1606}
1607
1608/// CreateType - get objective-c object type.
1609llvm::DIType CGDebugInfo::CreateType(const ObjCObjectType *Ty,
1610 llvm::DIFile Unit) {
1611 // Ignore protocols.
1612 return getOrCreateType(Ty->getBaseType(), Unit);
1613}
1614
1615
1616/// \return true if Getter has the default name for the property PD.
1617static bool hasDefaultGetterName(const ObjCPropertyDecl *PD,
1618 const ObjCMethodDecl *Getter) {
1619 assert(PD)((PD) ? static_cast<void> (0) : __assert_fail ("PD", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1619, __PRETTY_FUNCTION__));
1620 if (!Getter)
1621 return true;
1622
1623 assert(Getter->getDeclName().isObjCZeroArgSelector())((Getter->getDeclName().isObjCZeroArgSelector()) ? static_cast
<void> (0) : __assert_fail ("Getter->getDeclName().isObjCZeroArgSelector()"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1623, __PRETTY_FUNCTION__));
1624 return PD->getName() ==
1625 Getter->getDeclName().getObjCSelector().getNameForSlot(0);
1626}
1627
1628/// \return true if Setter has the default name for the property PD.
1629static bool hasDefaultSetterName(const ObjCPropertyDecl *PD,
1630 const ObjCMethodDecl *Setter) {
1631 assert(PD)((PD) ? static_cast<void> (0) : __assert_fail ("PD", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1631, __PRETTY_FUNCTION__));
1632 if (!Setter)
1633 return true;
1634
1635 assert(Setter->getDeclName().isObjCOneArgSelector())((Setter->getDeclName().isObjCOneArgSelector()) ? static_cast
<void> (0) : __assert_fail ("Setter->getDeclName().isObjCOneArgSelector()"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 1635, __PRETTY_FUNCTION__));
1636 return SelectorTable::constructSetterName(PD->getName()) ==
1637 Setter->getDeclName().getObjCSelector().getNameForSlot(0);
1638}
1639
1640/// CreateType - get objective-c interface type.
1641llvm::DIType CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
1642 llvm::DIFile Unit) {
1643 ObjCInterfaceDecl *ID = Ty->getDecl();
1644 if (!ID)
1645 return llvm::DIType();
1646
1647 // Get overall information about the record type for the debug info.
1648 llvm::DIFile DefUnit = getOrCreateFile(ID->getLocation());
1649 unsigned Line = getLineNumber(ID->getLocation());
1650 llvm::dwarf::SourceLanguage RuntimeLang = TheCU.getLanguage();
1651
1652 // If this is just a forward declaration return a special forward-declaration
1653 // debug type since we won't be able to lay out the entire type.
1654 ObjCInterfaceDecl *Def = ID->getDefinition();
1655 if (!Def || !Def->getImplementation()) {
1656 llvm::DIType FwdDecl = DBuilder.createReplaceableForwardDecl(
1657 llvm::dwarf::DW_TAG_structure_type, ID->getName(), TheCU, DefUnit, Line,
1658 RuntimeLang);
1659 ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit));
1660 return FwdDecl;
1661 }
1662
1663
1664 return CreateTypeDefinition(Ty, Unit);
1665}
1666
1667llvm::DIType CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty, llvm::DIFile Unit) {
1668 ObjCInterfaceDecl *ID = Ty->getDecl();
1669 llvm::DIFile DefUnit = getOrCreateFile(ID->getLocation());
1670 unsigned Line = getLineNumber(ID->getLocation());
1671 unsigned RuntimeLang = TheCU.getLanguage();
1672
1673 // Bit size, align and offset of the type.
1674 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1675 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1676
1677 unsigned Flags = 0;
1678 if (ID->getImplementation())
1679 Flags |= llvm::DIDescriptor::FlagObjcClassComplete;
1680
1681 llvm::DICompositeType RealDecl =
1682 DBuilder.createStructType(Unit, ID->getName(), DefUnit,
1683 Line, Size, Align, Flags,
1684 llvm::DIType(), llvm::DIArray(), RuntimeLang);
1685
1686 QualType QTy(Ty, 0);
1687 TypeCache[QTy.getAsOpaquePtr()] = RealDecl;
1688
1689 // Push the struct on region stack.
1690 LexicalBlockStack.push_back(static_cast<llvm::MDNode*>(RealDecl));
1691 RegionMap[Ty->getDecl()] = llvm::WeakVH(RealDecl);
1692
1693 // Convert all the elements.
1694 SmallVector<llvm::Value *, 16> EltTys;
1695
1696 ObjCInterfaceDecl *SClass = ID->getSuperClass();
1697 if (SClass) {
1698 llvm::DIType SClassTy =
1699 getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit);
1700 if (!SClassTy.isValid())
1701 return llvm::DIType();
1702
1703 llvm::DIType InhTag =
1704 DBuilder.createInheritance(RealDecl, SClassTy, 0, 0);
1705 EltTys.push_back(InhTag);
1706 }
1707
1708 // Create entries for all of the properties.
1709 for (const auto *PD : ID->properties()) {
1710 SourceLocation Loc = PD->getLocation();
1711 llvm::DIFile PUnit = getOrCreateFile(Loc);
1712 unsigned PLine = getLineNumber(Loc);
1713 ObjCMethodDecl *Getter = PD->getGetterMethodDecl();
1714 ObjCMethodDecl *Setter = PD->getSetterMethodDecl();
1715 llvm::MDNode *PropertyNode =
1716 DBuilder.createObjCProperty(PD->getName(),
1717 PUnit, PLine,
1718 hasDefaultGetterName(PD, Getter) ? "" :
1719 getSelectorName(PD->getGetterName()),
1720 hasDefaultSetterName(PD, Setter) ? "" :
1721 getSelectorName(PD->getSetterName()),
1722 PD->getPropertyAttributes(),
1723 getOrCreateType(PD->getType(), PUnit));
1724 EltTys.push_back(PropertyNode);
1725 }
1726
1727 const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(ID);
1728 unsigned FieldNo = 0;
1729 for (ObjCIvarDecl *Field = ID->all_declared_ivar_begin(); Field;
1730 Field = Field->getNextIvar(), ++FieldNo) {
1731 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
1732 if (!FieldTy.isValid())
1733 return llvm::DIType();
1734
1735 StringRef FieldName = Field->getName();
1736
1737 // Ignore unnamed fields.
1738 if (FieldName.empty())
1739 continue;
1740
1741 // Get the location for the field.
1742 llvm::DIFile FieldDefUnit = getOrCreateFile(Field->getLocation());
1743 unsigned FieldLine = getLineNumber(Field->getLocation());
1744 QualType FType = Field->getType();
1745 uint64_t FieldSize = 0;
1746 unsigned FieldAlign = 0;
1747
1748 if (!FType->isIncompleteArrayType()) {
1749
1750 // Bit size, align and offset of the type.
1751 FieldSize = Field->isBitField()
1752 ? Field->getBitWidthValue(CGM.getContext())
1753 : CGM.getContext().getTypeSize(FType);
1754 FieldAlign = CGM.getContext().getTypeAlign(FType);
1755 }
1756
1757 uint64_t FieldOffset;
1758 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
1759 // We don't know the runtime offset of an ivar if we're using the
1760 // non-fragile ABI. For bitfields, use the bit offset into the first
1761 // byte of storage of the bitfield. For other fields, use zero.
1762 if (Field->isBitField()) {
1763 FieldOffset = CGM.getObjCRuntime().ComputeBitfieldBitOffset(
1764 CGM, ID, Field);
1765 FieldOffset %= CGM.getContext().getCharWidth();
1766 } else {
1767 FieldOffset = 0;
1768 }
1769 } else {
1770 FieldOffset = RL.getFieldOffset(FieldNo);
1771 }
1772
1773 unsigned Flags = 0;
1774 if (Field->getAccessControl() == ObjCIvarDecl::Protected)
1775 Flags = llvm::DIDescriptor::FlagProtected;
1776 else if (Field->getAccessControl() == ObjCIvarDecl::Private)
1777 Flags = llvm::DIDescriptor::FlagPrivate;
1778 else if (Field->getAccessControl() == ObjCIvarDecl::Public)
1779 Flags = llvm::DIDescriptor::FlagPublic;
1780
1781 llvm::MDNode *PropertyNode = nullptr;
1782 if (ObjCImplementationDecl *ImpD = ID->getImplementation()) {
1783 if (ObjCPropertyImplDecl *PImpD =
1784 ImpD->FindPropertyImplIvarDecl(Field->getIdentifier())) {
1785 if (ObjCPropertyDecl *PD = PImpD->getPropertyDecl()) {
1786 SourceLocation Loc = PD->getLocation();
1787 llvm::DIFile PUnit = getOrCreateFile(Loc);
1788 unsigned PLine = getLineNumber(Loc);
1789 ObjCMethodDecl *Getter = PD->getGetterMethodDecl();
1790 ObjCMethodDecl *Setter = PD->getSetterMethodDecl();
1791 PropertyNode =
1792 DBuilder.createObjCProperty(PD->getName(),
1793 PUnit, PLine,
1794 hasDefaultGetterName(PD, Getter) ? "" :
1795 getSelectorName(PD->getGetterName()),
1796 hasDefaultSetterName(PD, Setter) ? "" :
1797 getSelectorName(PD->getSetterName()),
1798 PD->getPropertyAttributes(),
1799 getOrCreateType(PD->getType(), PUnit));
1800 }
1801 }
1802 }
1803 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit,
1804 FieldLine, FieldSize, FieldAlign,
1805 FieldOffset, Flags, FieldTy,
1806 PropertyNode);
1807 EltTys.push_back(FieldTy);
1808 }
1809
1810 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys);
1811 RealDecl.setArrays(Elements);
1812
1813 LexicalBlockStack.pop_back();
1814 return RealDecl;
1815}
1816
1817llvm::DIType CGDebugInfo::CreateType(const VectorType *Ty, llvm::DIFile Unit) {
1818 llvm::DIType ElementTy = getOrCreateType(Ty->getElementType(), Unit);
1819 int64_t Count = Ty->getNumElements();
1820 if (Count == 0)
1821 // If number of elements are not known then this is an unbounded array.
1822 // Use Count == -1 to express such arrays.
1823 Count = -1;
1824
1825 llvm::Value *Subscript = DBuilder.getOrCreateSubrange(0, Count);
1826 llvm::DIArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
1827
1828 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1829 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1830
1831 return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
1832}
1833
1834llvm::DIType CGDebugInfo::CreateType(const ArrayType *Ty,
1835 llvm::DIFile Unit) {
1836 uint64_t Size;
1837 uint64_t Align;
1838
1839 // FIXME: make getTypeAlign() aware of VLAs and incomplete array types
1840 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(Ty)) {
1841 Size = 0;
1842 Align =
1843 CGM.getContext().getTypeAlign(CGM.getContext().getBaseElementType(VAT));
1844 } else if (Ty->isIncompleteArrayType()) {
1845 Size = 0;
1846 if (Ty->getElementType()->isIncompleteType())
1847 Align = 0;
1848 else
1849 Align = CGM.getContext().getTypeAlign(Ty->getElementType());
1850 } else if (Ty->isIncompleteType()) {
1851 Size = 0;
1852 Align = 0;
1853 } else {
1854 // Size and align of the whole array, not the element type.
1855 Size = CGM.getContext().getTypeSize(Ty);
1856 Align = CGM.getContext().getTypeAlign(Ty);
1857 }
1858
1859 // Add the dimensions of the array. FIXME: This loses CV qualifiers from
1860 // interior arrays, do we care? Why aren't nested arrays represented the
1861 // obvious/recursive way?
1862 SmallVector<llvm::Value *, 8> Subscripts;
1863 QualType EltTy(Ty, 0);
1864 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
1865 // If the number of elements is known, then count is that number. Otherwise,
1866 // it's -1. This allows us to represent a subrange with an array of 0
1867 // elements, like this:
1868 //
1869 // struct foo {
1870 // int x[0];
1871 // };
1872 int64_t Count = -1; // Count == -1 is an unbounded array.
1873 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(Ty))
1874 Count = CAT->getSize().getZExtValue();
1875
1876 // FIXME: Verify this is right for VLAs.
1877 Subscripts.push_back(DBuilder.getOrCreateSubrange(0, Count));
1878 EltTy = Ty->getElementType();
1879 }
1880
1881 llvm::DIArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
1882
1883 llvm::DIType DbgTy =
1884 DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
1885 SubscriptArray);
1886 return DbgTy;
1887}
1888
1889llvm::DIType CGDebugInfo::CreateType(const LValueReferenceType *Ty,
1890 llvm::DIFile Unit) {
1891 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type,
1892 Ty, Ty->getPointeeType(), Unit);
1893}
1894
1895llvm::DIType CGDebugInfo::CreateType(const RValueReferenceType *Ty,
1896 llvm::DIFile Unit) {
1897 return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type,
1898 Ty, Ty->getPointeeType(), Unit);
1899}
1900
1901llvm::DIType CGDebugInfo::CreateType(const MemberPointerType *Ty,
1902 llvm::DIFile U) {
1903 llvm::DIType ClassType = getOrCreateType(QualType(Ty->getClass(), 0), U);
1904 if (!Ty->getPointeeType()->isFunctionType())
1905 return DBuilder.createMemberPointerType(
1906 getOrCreateType(Ty->getPointeeType(), U), ClassType);
1907
1908 const FunctionProtoType *FPT =
1909 Ty->getPointeeType()->getAs<FunctionProtoType>();
1910 return DBuilder.createMemberPointerType(getOrCreateInstanceMethodType(
1911 CGM.getContext().getPointerType(QualType(Ty->getClass(),
1912 FPT->getTypeQuals())),
1913 FPT, U), ClassType);
1914}
1915
1916llvm::DIType CGDebugInfo::CreateType(const AtomicType *Ty,
1917 llvm::DIFile U) {
1918 // Ignore the atomic wrapping
1919 // FIXME: What is the correct representation?
1920 return getOrCreateType(Ty->getValueType(), U);
1921}
1922
1923/// CreateEnumType - get enumeration type.
1924llvm::DIType CGDebugInfo::CreateEnumType(const EnumType *Ty) {
1925 const EnumDecl *ED = Ty->getDecl();
1926 uint64_t Size = 0;
1927 uint64_t Align = 0;
1928 if (!ED->getTypeForDecl()->isIncompleteType()) {
1929 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
1930 Align = CGM.getContext().getTypeAlign(ED->getTypeForDecl());
1931 }
1932
1933 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
1934
1935 // If this is just a forward declaration, construct an appropriately
1936 // marked node and just return it.
1937 if (!ED->getDefinition()) {
1938 llvm::DIDescriptor EDContext;
1939 EDContext = getContextDescriptor(cast<Decl>(ED->getDeclContext()));
1940 llvm::DIFile DefUnit = getOrCreateFile(ED->getLocation());
1941 unsigned Line = getLineNumber(ED->getLocation());
1942 StringRef EDName = ED->getName();
1943 llvm::DIType RetTy = DBuilder.createReplaceableForwardDecl(
1944 llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit, Line,
1945 0, Size, Align, FullName);
1946 ReplaceMap.push_back(std::make_pair(Ty, static_cast<llvm::Value *>(RetTy)));
1947 return RetTy;
1948 }
1949
1950 return CreateTypeDefinition(Ty);
1951}
1952
1953llvm::DIType CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) {
1954 const EnumDecl *ED = Ty->getDecl();
1955 uint64_t Size = 0;
1956 uint64_t Align = 0;
1957 if (!ED->getTypeForDecl()->isIncompleteType()) {
1958 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
1959 Align = CGM.getContext().getTypeAlign(ED->getTypeForDecl());
1960 }
1961
1962 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
1963
1964 // Create DIEnumerator elements for each enumerator.
1965 SmallVector<llvm::Value *, 16> Enumerators;
1966 ED = ED->getDefinition();
1967 for (const auto *Enum : ED->enumerators()) {
1968 Enumerators.push_back(
1969 DBuilder.createEnumerator(Enum->getName(),
1970 Enum->getInitVal().getSExtValue()));
1971 }
1972
1973 // Return a CompositeType for the enum itself.
1974 llvm::DIArray EltArray = DBuilder.getOrCreateArray(Enumerators);
1975
1976 llvm::DIFile DefUnit = getOrCreateFile(ED->getLocation());
1977 unsigned Line = getLineNumber(ED->getLocation());
1978 llvm::DIDescriptor EnumContext =
1979 getContextDescriptor(cast<Decl>(ED->getDeclContext()));
1980 llvm::DIType ClassTy = ED->isFixed() ?
1981 getOrCreateType(ED->getIntegerType(), DefUnit) : llvm::DIType();
1982 llvm::DIType DbgTy =
1983 DBuilder.createEnumerationType(EnumContext, ED->getName(), DefUnit, Line,
1984 Size, Align, EltArray,
1985 ClassTy, FullName);
1986 return DbgTy;
1987}
1988
1989static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C) {
1990 Qualifiers Quals;
1991 do {
1992 Qualifiers InnerQuals = T.getLocalQualifiers();
1993 // Qualifiers::operator+() doesn't like it if you add a Qualifier
1994 // that is already there.
1995 Quals += Qualifiers::removeCommonQualifiers(Quals, InnerQuals);
1996 Quals += InnerQuals;
1997 QualType LastT = T;
1998 switch (T->getTypeClass()) {
1999 default:
2000 return C.getQualifiedType(T.getTypePtr(), Quals);
2001 case Type::TemplateSpecialization: {
2002 const auto *Spec = cast<TemplateSpecializationType>(T);
2003 if (Spec->isTypeAlias())
2004 return C.getQualifiedType(T.getTypePtr(), Quals);
2005 T = Spec->desugar();
2006 break; }
2007 case Type::TypeOfExpr:
2008 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
2009 break;
2010 case Type::TypeOf:
2011 T = cast<TypeOfType>(T)->getUnderlyingType();
2012 break;
2013 case Type::Decltype:
2014 T = cast<DecltypeType>(T)->getUnderlyingType();
2015 break;
2016 case Type::UnaryTransform:
2017 T = cast<UnaryTransformType>(T)->getUnderlyingType();
2018 break;
2019 case Type::Attributed:
2020 T = cast<AttributedType>(T)->getEquivalentType();
2021 break;
2022 case Type::Elaborated:
2023 T = cast<ElaboratedType>(T)->getNamedType();
2024 break;
2025 case Type::Paren:
2026 T = cast<ParenType>(T)->getInnerType();
2027 break;
2028 case Type::SubstTemplateTypeParm:
2029 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
2030 break;
2031 case Type::Auto:
2032 QualType DT = cast<AutoType>(T)->getDeducedType();
2033 if (DT.isNull())
2034 return T;
2035 T = DT;
2036 break;
2037 }
2038
2039 assert(T != LastT && "Type unwrapping failed to unwrap!")((T != LastT && "Type unwrapping failed to unwrap!") ?
static_cast<void> (0) : __assert_fail ("T != LastT && \"Type unwrapping failed to unwrap!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2039, __PRETTY_FUNCTION__));
2040 (void)LastT;
2041 } while (true);
2042}
2043
2044/// getType - Get the type from the cache or return null type if it doesn't
2045/// exist.
2046llvm::DIType CGDebugInfo::getTypeOrNull(QualType Ty) {
2047
2048 // Unwrap the type as needed for debug information.
2049 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
2050
2051 auto it = TypeCache.find(Ty.getAsOpaquePtr());
2052 if (it != TypeCache.end()) {
2053 // Verify that the debug info still exists.
2054 if (llvm::Value *V = it->second)
2055 return llvm::DIType(cast<llvm::MDNode>(V));
2056 }
2057
2058 return llvm::DIType();
2059}
2060
2061void CGDebugInfo::completeTemplateDefinition(
2062 const ClassTemplateSpecializationDecl &SD) {
2063 if (DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2064 return;
2065
2066 completeClassData(&SD);
2067 // In case this type has no member function definitions being emitted, ensure
2068 // it is retained
2069 RetainedTypes.push_back(CGM.getContext().getRecordType(&SD).getAsOpaquePtr());
2070}
2071
2072/// getOrCreateType - Get the type from the cache or create a new
2073/// one if necessary.
2074llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile Unit) {
2075 if (Ty.isNull())
2076 return llvm::DIType();
2077
2078 // Unwrap the type as needed for debug information.
2079 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
2080
2081 if (llvm::DIType T = getTypeOrNull(Ty))
2082 return T;
2083
2084 // Otherwise create the type.
2085 llvm::DIType Res = CreateTypeNode(Ty, Unit);
2086 void* TyPtr = Ty.getAsOpaquePtr();
2087
2088 // And update the type cache.
2089 TypeCache[TyPtr] = Res;
2090
2091 return Res;
2092}
2093
2094/// Currently the checksum of an interface includes the number of
2095/// ivars and property accessors.
2096unsigned CGDebugInfo::Checksum(const ObjCInterfaceDecl *ID) {
2097 // The assumption is that the number of ivars can only increase
2098 // monotonically, so it is safe to just use their current number as
2099 // a checksum.
2100 unsigned Sum = 0;
2101 for (const ObjCIvarDecl *Ivar = ID->all_declared_ivar_begin();
2102 Ivar != nullptr; Ivar = Ivar->getNextIvar())
2103 ++Sum;
2104
2105 return Sum;
2106}
2107
2108ObjCInterfaceDecl *CGDebugInfo::getObjCInterfaceDecl(QualType Ty) {
2109 switch (Ty->getTypeClass()) {
2110 case Type::ObjCObjectPointer:
2111 return getObjCInterfaceDecl(cast<ObjCObjectPointerType>(Ty)
2112 ->getPointeeType());
2113 case Type::ObjCInterface:
2114 return cast<ObjCInterfaceType>(Ty)->getDecl();
2115 default:
2116 return nullptr;
2117 }
2118}
2119
2120/// CreateTypeNode - Create a new debug type node.
2121llvm::DIType CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile Unit) {
2122 // Handle qualifiers, which recursively handles what they refer to.
2123 if (Ty.hasLocalQualifiers())
2124 return CreateQualifiedType(Ty, Unit);
2125
2126 const char *Diag = nullptr;
2127
2128 // Work out details of type.
2129 switch (Ty->getTypeClass()) {
2130#define TYPE(Class, Base)
2131#define ABSTRACT_TYPE(Class, Base)
2132#define NON_CANONICAL_TYPE(Class, Base)
2133#define DEPENDENT_TYPE(Class, Base) case Type::Class:
2134#include "clang/AST/TypeNodes.def"
2135 llvm_unreachable("Dependent types cannot show up in debug information")::llvm::llvm_unreachable_internal("Dependent types cannot show up in debug information"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2135);
2136
2137 case Type::ExtVector:
2138 case Type::Vector:
2139 return CreateType(cast<VectorType>(Ty), Unit);
2140 case Type::ObjCObjectPointer:
2141 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
2142 case Type::ObjCObject:
2143 return CreateType(cast<ObjCObjectType>(Ty), Unit);
2144 case Type::ObjCInterface:
2145 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
2146 case Type::Builtin:
2147 return CreateType(cast<BuiltinType>(Ty));
2148 case Type::Complex:
2149 return CreateType(cast<ComplexType>(Ty));
2150 case Type::Pointer:
2151 return CreateType(cast<PointerType>(Ty), Unit);
2152 case Type::Adjusted:
2153 case Type::Decayed:
2154 // Decayed and adjusted types use the adjusted type in LLVM and DWARF.
2155 return CreateType(
2156 cast<PointerType>(cast<AdjustedType>(Ty)->getAdjustedType()), Unit);
2157 case Type::BlockPointer:
2158 return CreateType(cast<BlockPointerType>(Ty), Unit);
2159 case Type::Typedef:
2160 return CreateType(cast<TypedefType>(Ty), Unit);
2161 case Type::Record:
2162 return CreateType(cast<RecordType>(Ty));
2163 case Type::Enum:
2164 return CreateEnumType(cast<EnumType>(Ty));
2165 case Type::FunctionProto:
2166 case Type::FunctionNoProto:
2167 return CreateType(cast<FunctionType>(Ty), Unit);
2168 case Type::ConstantArray:
2169 case Type::VariableArray:
2170 case Type::IncompleteArray:
2171 return CreateType(cast<ArrayType>(Ty), Unit);
2172
2173 case Type::LValueReference:
2174 return CreateType(cast<LValueReferenceType>(Ty), Unit);
2175 case Type::RValueReference:
2176 return CreateType(cast<RValueReferenceType>(Ty), Unit);
2177
2178 case Type::MemberPointer:
2179 return CreateType(cast<MemberPointerType>(Ty), Unit);
2180
2181 case Type::Atomic:
2182 return CreateType(cast<AtomicType>(Ty), Unit);
2183
2184 case Type::TemplateSpecialization:
2185 return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
2186
2187 case Type::Attributed:
2188 case Type::Elaborated:
2189 case Type::Paren:
2190 case Type::SubstTemplateTypeParm:
2191 case Type::TypeOfExpr:
2192 case Type::TypeOf:
2193 case Type::Decltype:
2194 case Type::UnaryTransform:
2195 case Type::PackExpansion:
2196 llvm_unreachable("type should have been unwrapped!")::llvm::llvm_unreachable_internal("type should have been unwrapped!"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2196);
2197 case Type::Auto:
2198 Diag = "auto";
2199 break;
2200 }
2201
2202 assert(Diag && "Fall through without a diagnostic?")((Diag && "Fall through without a diagnostic?") ? static_cast
<void> (0) : __assert_fail ("Diag && \"Fall through without a diagnostic?\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2202, __PRETTY_FUNCTION__));
2203 unsigned DiagID = CGM.getDiags().getCustomDiagID(DiagnosticsEngine::Error,
2204 "debug information for %0 is not yet supported");
2205 CGM.getDiags().Report(DiagID)
2206 << Diag;
2207 return llvm::DIType();
2208}
2209
2210/// getOrCreateLimitedType - Get the type from the cache or create a new
2211/// limited type if necessary.
2212llvm::DIType CGDebugInfo::getOrCreateLimitedType(const RecordType *Ty,
2213 llvm::DIFile Unit) {
2214 QualType QTy(Ty, 0);
2215
2216 llvm::DICompositeType T(getTypeOrNull(QTy));
2217
2218 // We may have cached a forward decl when we could have created
2219 // a non-forward decl. Go ahead and create a non-forward decl
2220 // now.
2221 if (T && !T.isForwardDecl()) return T;
2222
2223 // Otherwise create the type.
2224 llvm::DICompositeType Res = CreateLimitedType(Ty);
2225
2226 // Propagate members from the declaration to the definition
2227 // CreateType(const RecordType*) will overwrite this with the members in the
2228 // correct order if the full type is needed.
2229 Res.setArrays(T.getElements());
2230
2231 // And update the type cache.
2232 TypeCache[QTy.getAsOpaquePtr()] = Res;
2233 return Res;
2234}
2235
2236// TODO: Currently used for context chains when limiting debug info.
2237llvm::DICompositeType CGDebugInfo::CreateLimitedType(const RecordType *Ty) {
2238 RecordDecl *RD = Ty->getDecl();
2239
2240 // Get overall information about the record type for the debug info.
2241 llvm::DIFile DefUnit = getOrCreateFile(RD->getLocation());
2242 unsigned Line = getLineNumber(RD->getLocation());
2243 StringRef RDName = getClassName(RD);
2244
2245 llvm::DIDescriptor RDContext =
2246 getContextDescriptor(cast<Decl>(RD->getDeclContext()));
2247
2248 // If we ended up creating the type during the context chain construction,
2249 // just return that.
2250 llvm::DICompositeType T(getTypeOrNull(CGM.getContext().getRecordType(RD)));
2251 if (T && (!T.isForwardDecl() || !RD->getDefinition()))
2252 return T;
2253
2254 // If this is just a forward or incomplete declaration, construct an
2255 // appropriately marked node and just return it.
2256 const RecordDecl *D = RD->getDefinition();
2257 if (!D || !D->isCompleteDefinition())
1
Assuming 'D' is non-null
→
2
←
Taking false branch
→
2258 return getOrCreateRecordFwdDecl(Ty, RDContext);
2259
2260 uint64_t Size = CGM.getContext().getTypeSize(Ty);
2261 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
2262 llvm::DICompositeType RealDecl;
2263
2264 SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
2265
2266 if (RD->isUnion())
3
←
Taking false branch
→
2267 RealDecl = DBuilder.createUnionType(RDContext, RDName, DefUnit, Line,
2268 Size, Align, 0, llvm::DIArray(), 0,
2269 FullName);
2270 else if (RD->isClass()) {
4
←
Taking false branch
→
2271 // FIXME: This could be a struct type giving a default visibility different
2272 // than C++ class type, but needs llvm metadata changes first.
2273 RealDecl = DBuilder.createClassType(RDContext, RDName, DefUnit, Line,
2274 Size, Align, 0, 0, llvm::DIType(),
2275 llvm::DIArray(), llvm::DIType(),
2276 llvm::DIArray(), FullName);
2277 } else
2278 RealDecl = DBuilder.createStructType(RDContext, RDName, DefUnit, Line,
2279 Size, Align, 0, llvm::DIType(),
2280 llvm::DIArray(), 0, llvm::DIType(),
2281 FullName);
2282
2283 RegionMap[Ty->getDecl()] = llvm::WeakVH(RealDecl);
2284 TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = RealDecl;
2285
2286 if (const ClassTemplateSpecializationDecl *TSpecial =
5
←
Assuming 'TSpecial' is non-null
→
6
←
Taking true branch
→
2287 dyn_cast<ClassTemplateSpecializationDecl>(RD))
2288 RealDecl.setArrays(llvm::DIArray(),
2289 CollectCXXTemplateParams(TSpecial, DefUnit));
7
←
Calling 'CGDebugInfo::CollectCXXTemplateParams'
→
2290 return RealDecl;
2291}
2292
2293void CGDebugInfo::CollectContainingType(const CXXRecordDecl *RD,
2294 llvm::DICompositeType RealDecl) {
2295 // A class's primary base or the class itself contains the vtable.
2296 llvm::DICompositeType ContainingType;
2297 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2298 if (const CXXRecordDecl *PBase = RL.getPrimaryBase()) {
2299 // Seek non-virtual primary base root.
2300 while (1) {
2301 const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase);
2302 const CXXRecordDecl *PBT = BRL.getPrimaryBase();
2303 if (PBT && !BRL.isPrimaryBaseVirtual())
2304 PBase = PBT;
2305 else
2306 break;
2307 }
2308 ContainingType = llvm::DICompositeType(
2309 getOrCreateType(QualType(PBase->getTypeForDecl(), 0),
2310 getOrCreateFile(RD->getLocation())));
2311 } else if (RD->isDynamicClass())
2312 ContainingType = RealDecl;
2313
2314 RealDecl.setContainingType(ContainingType);
2315}
2316
2317/// CreateMemberType - Create new member and increase Offset by FType's size.
2318llvm::DIType CGDebugInfo::CreateMemberType(llvm::DIFile Unit, QualType FType,
2319 StringRef Name,
2320 uint64_t *Offset) {
2321 llvm::DIType FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
2322 uint64_t FieldSize = CGM.getContext().getTypeSize(FType);
2323 unsigned FieldAlign = CGM.getContext().getTypeAlign(FType);
2324 llvm::DIType Ty = DBuilder.createMemberType(Unit, Name, Unit, 0,
2325 FieldSize, FieldAlign,
2326 *Offset, 0, FieldTy);
2327 *Offset += FieldSize;
2328 return Ty;
2329}
2330
2331llvm::DIScope CGDebugInfo::getDeclarationOrDefinition(const Decl *D) {
2332 // We only need a declaration (not a definition) of the type - so use whatever
2333 // we would otherwise do to get a type for a pointee. (forward declarations in
2334 // limited debug info, full definitions (if the type definition is available)
2335 // in unlimited debug info)
2336 if (const TypeDecl *TD = dyn_cast<TypeDecl>(D))
2337 return getOrCreateType(CGM.getContext().getTypeDeclType(TD),
2338 getOrCreateFile(TD->getLocation()));
2339 // Otherwise fall back to a fairly rudimentary cache of existing declarations.
2340 // This doesn't handle providing declarations (for functions or variables) for
2341 // entities without definitions in this TU, nor when the definition proceeds
2342 // the call to this function.
2343 // FIXME: This should be split out into more specific maps with support for
2344 // emitting forward declarations and merging definitions with declarations,
2345 // the same way as we do for types.
2346 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator I =
2347 DeclCache.find(D->getCanonicalDecl());
2348 if (I == DeclCache.end())
2349 return llvm::DIScope();
2350 llvm::Value *V = I->second;
2351 return llvm::DIScope(dyn_cast_or_null<llvm::MDNode>(V));
2352}
2353
2354/// getFunctionDeclaration - Return debug info descriptor to describe method
2355/// declaration for the given method definition.
2356llvm::DISubprogram CGDebugInfo::getFunctionDeclaration(const Decl *D) {
2357 if (!D || DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2358 return llvm::DISubprogram();
2359
2360 const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
2361 if (!FD) return llvm::DISubprogram();
2362
2363 // Setup context.
2364 llvm::DIScope S = getContextDescriptor(cast<Decl>(D->getDeclContext()));
2365
2366 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator
2367 MI = SPCache.find(FD->getCanonicalDecl());
2368 if (MI == SPCache.end()) {
2369 if (const CXXMethodDecl *MD =
2370 dyn_cast<CXXMethodDecl>(FD->getCanonicalDecl())) {
2371 llvm::DICompositeType T(S);
2372 llvm::DISubprogram SP =
2373 CreateCXXMemberFunction(MD, getOrCreateFile(MD->getLocation()), T);
2374 return SP;
2375 }
2376 }
2377 if (MI != SPCache.end()) {
2378 llvm::Value *V = MI->second;
2379 llvm::DISubprogram SP(dyn_cast_or_null<llvm::MDNode>(V));
2380 if (SP.isSubprogram() && !SP.isDefinition())
2381 return SP;
2382 }
2383
2384 for (auto NextFD : FD->redecls()) {
2385 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator
2386 MI = SPCache.find(NextFD->getCanonicalDecl());
2387 if (MI != SPCache.end()) {
2388 llvm::Value *V = MI->second;
2389 llvm::DISubprogram SP(dyn_cast_or_null<llvm::MDNode>(V));
2390 if (SP.isSubprogram() && !SP.isDefinition())
2391 return SP;
2392 }
2393 }
2394 return llvm::DISubprogram();
2395}
2396
2397// getOrCreateFunctionType - Construct DIType. If it is a c++ method, include
2398// implicit parameter "this".
2399llvm::DICompositeType CGDebugInfo::getOrCreateFunctionType(const Decl *D,
2400 QualType FnType,
2401 llvm::DIFile F) {
2402 if (!D || DebugKind <= CodeGenOptions::DebugLineTablesOnly)
2403 // Create fake but valid subroutine type. Otherwise
2404 // llvm::DISubprogram::Verify() would return false, and
2405 // subprogram DIE will miss DW_AT_decl_file and
2406 // DW_AT_decl_line fields.
2407 return DBuilder.createSubroutineType(F,
2408 DBuilder.getOrCreateTypeArray(None));
2409
2410 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
2411 return getOrCreateMethodType(Method, F);
2412 if (const ObjCMethodDecl *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
2413 // Add "self" and "_cmd"
2414 SmallVector<llvm::Value *, 16> Elts;
2415
2416 // First element is always return type. For 'void' functions it is NULL.
2417 QualType ResultTy = OMethod->getReturnType();
2418
2419 // Replace the instancetype keyword with the actual type.
2420 if (ResultTy == CGM.getContext().getObjCInstanceType())
2421 ResultTy = CGM.getContext().getPointerType(
2422 QualType(OMethod->getClassInterface()->getTypeForDecl(), 0));
2423
2424 Elts.push_back(getOrCreateType(ResultTy, F));
2425 // "self" pointer is always first argument.
2426 QualType SelfDeclTy = OMethod->getSelfDecl()->getType();
2427 llvm::DIType SelfTy = getOrCreateType(SelfDeclTy, F);
2428 Elts.push_back(CreateSelfType(SelfDeclTy, SelfTy));
2429 // "_cmd" pointer is always second argument.
2430 llvm::DIType CmdTy = getOrCreateType(OMethod->getCmdDecl()->getType(), F);
2431 Elts.push_back(DBuilder.createArtificialType(CmdTy));
2432 // Get rest of the arguments.
2433 for (const auto *PI : OMethod->params())
2434 Elts.push_back(getOrCreateType(PI->getType(), F));
2435 // Variadic methods need a special marker at the end of the type list.
2436 if (OMethod->isVariadic())
2437 Elts.push_back(DBuilder.createUnspecifiedParameter());
2438
2439 llvm::DITypeArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
2440 return DBuilder.createSubroutineType(F, EltTypeArray);
2441 }
2442
2443 // Handle variadic function types; they need an additional
2444 // unspecified parameter.
2445 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
2446 if (FD->isVariadic()) {
2447 SmallVector<llvm::Value *, 16> EltTys;
2448 EltTys.push_back(getOrCreateType(FD->getReturnType(), F));
2449 if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FnType))
2450 for (unsigned i = 0, e = FPT->getNumParams(); i != e; ++i)
2451 EltTys.push_back(getOrCreateType(FPT->getParamType(i), F));
2452 EltTys.push_back(DBuilder.createUnspecifiedParameter());
2453 llvm::DITypeArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
2454 return DBuilder.createSubroutineType(F, EltTypeArray);
2455 }
2456
2457 return llvm::DICompositeType(getOrCreateType(FnType, F));
2458}
2459
2460/// EmitFunctionStart - Constructs the debug code for entering a function.
2461void CGDebugInfo::EmitFunctionStart(GlobalDecl GD,
2462 SourceLocation Loc,
2463 SourceLocation ScopeLoc,
2464 QualType FnType,
2465 llvm::Function *Fn,
2466 CGBuilderTy &Builder) {
2467
2468 StringRef Name;
2469 StringRef LinkageName;
2470
2471 FnBeginRegionCount.push_back(LexicalBlockStack.size());
2472
2473 const Decl *D = GD.getDecl();
2474 bool HasDecl = (D != nullptr);
2475
2476 unsigned Flags = 0;
2477 llvm::DIFile Unit = getOrCreateFile(Loc);
2478 llvm::DIDescriptor FDContext(Unit);
2479 llvm::DIArray TParamsArray;
2480 if (!HasDecl) {
2481 // Use llvm function name.
2482 LinkageName = Fn->getName();
2483 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2484 // If there is a DISubprogram for this function available then use it.
2485 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator
2486 FI = SPCache.find(FD->getCanonicalDecl());
2487 if (FI != SPCache.end()) {
2488 llvm::Value *V = FI->second;
2489 llvm::DIDescriptor SP(dyn_cast_or_null<llvm::MDNode>(V));
2490 if (SP.isSubprogram() && llvm::DISubprogram(SP).isDefinition()) {
2491 llvm::MDNode *SPN = SP;
2492 LexicalBlockStack.push_back(SPN);
2493 RegionMap[D] = llvm::WeakVH(SP);
2494 return;
2495 }
2496 }
2497 Name = getFunctionName(FD);
2498 // Use mangled name as linkage name for C/C++ functions.
2499 if (FD->hasPrototype()) {
2500 LinkageName = CGM.getMangledName(GD);
2501 Flags |= llvm::DIDescriptor::FlagPrototyped;
2502 }
2503 // No need to replicate the linkage name if it isn't different from the
2504 // subprogram name, no need to have it at all unless coverage is enabled or
2505 // debug is set to more than just line tables.
2506 if (LinkageName == Name ||
2507 (!CGM.getCodeGenOpts().EmitGcovArcs &&
2508 !CGM.getCodeGenOpts().EmitGcovNotes &&
2509 DebugKind <= CodeGenOptions::DebugLineTablesOnly))
2510 LinkageName = StringRef();
2511
2512 if (DebugKind >= CodeGenOptions::LimitedDebugInfo) {
2513 if (const NamespaceDecl *NSDecl =
2514 dyn_cast_or_null<NamespaceDecl>(FD->getDeclContext()))
2515 FDContext = getOrCreateNameSpace(NSDecl);
2516 else if (const RecordDecl *RDecl =
2517 dyn_cast_or_null<RecordDecl>(FD->getDeclContext()))
2518 FDContext = getContextDescriptor(cast<Decl>(RDecl));
2519
2520 // Collect template parameters.
2521 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
2522 }
2523 } else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D)) {
2524 Name = getObjCMethodName(OMD);
2525 Flags |= llvm::DIDescriptor::FlagPrototyped;
2526 } else {
2527 // Use llvm function name.
2528 Name = Fn->getName();
2529 Flags |= llvm::DIDescriptor::FlagPrototyped;
2530 }
2531 if (!Name.empty() && Name[0] == '\01')
2532 Name = Name.substr(1);
2533
2534 if (!HasDecl || D->isImplicit()) {
2535 Flags |= llvm::DIDescriptor::FlagArtificial;
2536 // Artificial functions without a location should not silently reuse CurLoc.
2537 if (Loc.isInvalid())
2538 CurLoc = SourceLocation();
2539 }
2540 unsigned LineNo = getLineNumber(Loc);
2541 unsigned ScopeLine = getLineNumber(ScopeLoc);
2542
2543 // FIXME: The function declaration we're constructing here is mostly reusing
2544 // declarations from CXXMethodDecl and not constructing new ones for arbitrary
2545 // FunctionDecls. When/if we fix this we can have FDContext be TheCU/null for
2546 // all subprograms instead of the actual context since subprogram definitions
2547 // are emitted as CU level entities by the backend.
2548 llvm::DISubprogram SP =
2549 DBuilder.createFunction(FDContext, Name, LinkageName, Unit, LineNo,
2550 getOrCreateFunctionType(D, FnType, Unit),
2551 Fn->hasInternalLinkage(), true /*definition*/,
2552 ScopeLine, Flags,
2553 CGM.getLangOpts().Optimize, Fn, TParamsArray,
2554 getFunctionDeclaration(D));
2555 if (HasDecl)
2556 DeclCache.insert(std::make_pair(D->getCanonicalDecl(), llvm::WeakVH(SP)));
2557
2558 // Push the function onto the lexical block stack.
2559 llvm::MDNode *SPN = SP;
2560 LexicalBlockStack.push_back(SPN);
2561
2562 if (HasDecl)
2563 RegionMap[D] = llvm::WeakVH(SP);
2564}
2565
2566/// EmitLocation - Emit metadata to indicate a change in line/column
2567/// information in the source file. If the location is invalid, the
2568/// previous location will be reused.
2569void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc,
2570 bool ForceColumnInfo) {
2571 // Update our current location
2572 setLocation(Loc);
2573
2574 if (CurLoc.isInvalid() || CurLoc.isMacroID()) return;
2575
2576 // Don't bother if things are the same as last time.
2577 SourceManager &SM = CGM.getContext().getSourceManager();
2578 if (CurLoc == PrevLoc ||
2579 SM.getExpansionLoc(CurLoc) == SM.getExpansionLoc(PrevLoc))
2580 // New Builder may not be in sync with CGDebugInfo.
2581 if (!Builder.getCurrentDebugLocation().isUnknown() &&
2582 Builder.getCurrentDebugLocation().getScope(CGM.getLLVMContext()) ==
2583 LexicalBlockStack.back())
2584 return;
2585
2586 // Update last state.
2587 PrevLoc = CurLoc;
2588
2589 llvm::MDNode *Scope = LexicalBlockStack.back();
2590 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get
2591 (getLineNumber(CurLoc),
2592 getColumnNumber(CurLoc, ForceColumnInfo),
2593 Scope));
2594}
2595
2596/// CreateLexicalBlock - Creates a new lexical block node and pushes it on
2597/// the stack.
2598void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) {
2599 llvm::DIDescriptor D = DBuilder.createLexicalBlock(
2600 llvm::DIDescriptor(LexicalBlockStack.empty() ? nullptr
2601 : LexicalBlockStack.back()),
2602 getOrCreateFile(CurLoc), getLineNumber(CurLoc), getColumnNumber(CurLoc));
2603 llvm::MDNode *DN = D;
2604 LexicalBlockStack.push_back(DN);
2605}
2606
2607/// EmitLexicalBlockStart - Constructs the debug code for entering a declarative
2608/// region - beginning of a DW_TAG_lexical_block.
2609void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder,
2610 SourceLocation Loc) {
2611 // Set our current location.
2612 setLocation(Loc);
2613
2614 // Create a new lexical block and push it on the stack.
2615 CreateLexicalBlock(Loc);
2616
2617 // Emit a line table change for the current location inside the new scope.
2618 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(getLineNumber(Loc),
2619 getColumnNumber(Loc),
2620 LexicalBlockStack.back()));
2621}
2622
2623/// EmitLexicalBlockEnd - Constructs the debug code for exiting a declarative
2624/// region - end of a DW_TAG_lexical_block.
2625void CGDebugInfo::EmitLexicalBlockEnd(CGBuilderTy &Builder,
2626 SourceLocation Loc) {
2627 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!")((!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"
) ? static_cast<void> (0) : __assert_fail ("!LexicalBlockStack.empty() && \"Region stack mismatch, stack empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2627, __PRETTY_FUNCTION__));
2628
2629 // Provide an entry in the line table for the end of the block.
2630 EmitLocation(Builder, Loc);
2631
2632 LexicalBlockStack.pop_back();
2633}
2634
2635/// EmitFunctionEnd - Constructs the debug code for exiting a function.
2636void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder) {
2637 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!")((!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"
) ? static_cast<void> (0) : __assert_fail ("!LexicalBlockStack.empty() && \"Region stack mismatch, stack empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2637, __PRETTY_FUNCTION__));
2638 unsigned RCount = FnBeginRegionCount.back();
2639 assert(RCount <= LexicalBlockStack.size() && "Region stack mismatch")((RCount <= LexicalBlockStack.size() && "Region stack mismatch"
) ? static_cast<void> (0) : __assert_fail ("RCount <= LexicalBlockStack.size() && \"Region stack mismatch\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2639, __PRETTY_FUNCTION__));
2640
2641 // Pop all regions for this function.
2642 while (LexicalBlockStack.size() != RCount)
2643 EmitLexicalBlockEnd(Builder, CurLoc);
2644 FnBeginRegionCount.pop_back();
2645}
2646
2647// EmitTypeForVarWithBlocksAttr - Build up structure info for the byref.
2648// See BuildByRefType.
2649llvm::DIType CGDebugInfo::EmitTypeForVarWithBlocksAttr(const VarDecl *VD,
2650 uint64_t *XOffset) {
2651
2652 SmallVector<llvm::Value *, 5> EltTys;
2653 QualType FType;
2654 uint64_t FieldSize, FieldOffset;
2655 unsigned FieldAlign;
2656
2657 llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
2658 QualType Type = VD->getType();
2659
2660 FieldOffset = 0;
2661 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
2662 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
2663 EltTys.push_back(CreateMemberType(Unit, FType, "__forwarding", &FieldOffset));
2664 FType = CGM.getContext().IntTy;
2665 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
2666 EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset));
2667
2668 bool HasCopyAndDispose = CGM.getContext().BlockRequiresCopying(Type, VD);
2669 if (HasCopyAndDispose) {
2670 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
2671 EltTys.push_back(CreateMemberType(Unit, FType, "__copy_helper",
2672 &FieldOffset));
2673 EltTys.push_back(CreateMemberType(Unit, FType, "__destroy_helper",
2674 &FieldOffset));
2675 }
2676 bool HasByrefExtendedLayout;
2677 Qualifiers::ObjCLifetime Lifetime;
2678 if (CGM.getContext().getByrefLifetime(Type,
2679 Lifetime, HasByrefExtendedLayout)
2680 && HasByrefExtendedLayout) {
2681 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
2682 EltTys.push_back(CreateMemberType(Unit, FType,
2683 "__byref_variable_layout",
2684 &FieldOffset));
2685 }
2686
2687 CharUnits Align = CGM.getContext().getDeclAlign(VD);
2688 if (Align > CGM.getContext().toCharUnitsFromBits(
2689 CGM.getTarget().getPointerAlign(0))) {
2690 CharUnits FieldOffsetInBytes
2691 = CGM.getContext().toCharUnitsFromBits(FieldOffset);
2692 CharUnits AlignedOffsetInBytes
2693 = FieldOffsetInBytes.RoundUpToAlignment(Align);
2694 CharUnits NumPaddingBytes
2695 = AlignedOffsetInBytes - FieldOffsetInBytes;
2696
2697 if (NumPaddingBytes.isPositive()) {
2698 llvm::APInt pad(32, NumPaddingBytes.getQuantity());
2699 FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy,
2700 pad, ArrayType::Normal, 0);
2701 EltTys.push_back(CreateMemberType(Unit, FType, "", &FieldOffset));
2702 }
2703 }
2704
2705 FType = Type;
2706 llvm::DIType FieldTy = getOrCreateType(FType, Unit);
2707 FieldSize = CGM.getContext().getTypeSize(FType);
2708 FieldAlign = CGM.getContext().toBits(Align);
2709
2710 *XOffset = FieldOffset;
2711 FieldTy = DBuilder.createMemberType(Unit, VD->getName(), Unit,
2712 0, FieldSize, FieldAlign,
2713 FieldOffset, 0, FieldTy);
2714 EltTys.push_back(FieldTy);
2715 FieldOffset += FieldSize;
2716
2717 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys);
2718
2719 unsigned Flags = llvm::DIDescriptor::FlagBlockByrefStruct;
2720
2721 return DBuilder.createStructType(Unit, "", Unit, 0, FieldOffset, 0, Flags,
2722 llvm::DIType(), Elements);
2723}
2724
2725/// EmitDeclare - Emit local variable declaration debug info.
2726void CGDebugInfo::EmitDeclare(const VarDecl *VD, llvm::dwarf::LLVMConstants Tag,
2727 llvm::Value *Storage,
2728 unsigned ArgNo, CGBuilderTy &Builder) {
2729 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo)((DebugKind >= CodeGenOptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= CodeGenOptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2729, __PRETTY_FUNCTION__));
2730 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!")((!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"
) ? static_cast<void> (0) : __assert_fail ("!LexicalBlockStack.empty() && \"Region stack mismatch, stack empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2730, __PRETTY_FUNCTION__));
2731
2732 bool Unwritten =
2733 VD->isImplicit() || (isa<Decl>(VD->getDeclContext()) &&
2734 cast<Decl>(VD->getDeclContext())->isImplicit());
2735 llvm::DIFile Unit;
2736 if (!Unwritten)
2737 Unit = getOrCreateFile(VD->getLocation());
2738 llvm::DIType Ty;
2739 uint64_t XOffset = 0;
2740 if (VD->hasAttr<BlocksAttr>())
2741 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
2742 else
2743 Ty = getOrCreateType(VD->getType(), Unit);
2744
2745 // If there is no debug info for this type then do not emit debug info
2746 // for this variable.
2747 if (!Ty)
2748 return;
2749
2750 // Get location information.
2751 unsigned Line = 0;
2752 unsigned Column = 0;
2753 if (!Unwritten) {
2754 Line = getLineNumber(VD->getLocation());
2755 Column = getColumnNumber(VD->getLocation());
2756 }
2757 unsigned Flags = 0;
2758 if (VD->isImplicit())
2759 Flags |= llvm::DIDescriptor::FlagArtificial;
2760 // If this is the first argument and it is implicit then
2761 // give it an object pointer flag.
2762 // FIXME: There has to be a better way to do this, but for static
2763 // functions there won't be an implicit param at arg1 and
2764 // otherwise it is 'self' or 'this'.
2765 if (isa<ImplicitParamDecl>(VD) && ArgNo == 1)
2766 Flags |= llvm::DIDescriptor::FlagObjectPointer;
2767 if (llvm::Argument *Arg = dyn_cast<llvm::Argument>(Storage))
2768 if (Arg->getType()->isPointerTy() && !Arg->hasByValAttr() &&
2769 !VD->getType()->isPointerType())
2770 Flags |= llvm::DIDescriptor::FlagIndirectVariable;
2771
2772 llvm::MDNode *Scope = LexicalBlockStack.back();
2773
2774 StringRef Name = VD->getName();
2775 if (!Name.empty()) {
2776 if (VD->hasAttr<BlocksAttr>()) {
2777 CharUnits offset = CharUnits::fromQuantity(32);
2778 SmallVector<int64_t, 9> addr;
2779 addr.push_back(llvm::dwarf::DW_OP_plus);
2780 // offset of __forwarding field
2781 offset = CGM.getContext().toCharUnitsFromBits(
2782 CGM.getTarget().getPointerWidth(0));
2783 addr.push_back(offset.getQuantity());
2784 addr.push_back(llvm::dwarf::DW_OP_deref);
2785 addr.push_back(llvm::dwarf::DW_OP_plus);
2786 // offset of x field
2787 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
2788 addr.push_back(offset.getQuantity());
2789
2790 // Create the descriptor for the variable.
2791 llvm::DIVariable D =
2792 DBuilder.createLocalVariable(Tag, llvm::DIDescriptor(Scope),
2793 VD->getName(), Unit, Line, Ty, ArgNo);
2794
2795 // Insert an llvm.dbg.declare into the current block.
2796 llvm::Instruction *Call =
2797 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(addr),
2798 Builder.GetInsertBlock());
2799 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope));
2800 return;
2801 } else if (isa<VariableArrayType>(VD->getType()))
2802 Flags |= llvm::DIDescriptor::FlagIndirectVariable;
2803 } else if (const RecordType *RT = dyn_cast<RecordType>(VD->getType())) {
2804 // If VD is an anonymous union then Storage represents value for
2805 // all union fields.
2806 const RecordDecl *RD = cast<RecordDecl>(RT->getDecl());
2807 if (RD->isUnion() && RD->isAnonymousStructOrUnion()) {
2808 for (const auto *Field : RD->fields()) {
2809 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
2810 StringRef FieldName = Field->getName();
2811
2812 // Ignore unnamed fields. Do not ignore unnamed records.
2813 if (FieldName.empty() && !isa<RecordType>(Field->getType()))
2814 continue;
2815
2816 // Use VarDecl's Tag, Scope and Line number.
2817 llvm::DIVariable D =
2818 DBuilder.createLocalVariable(Tag, llvm::DIDescriptor(Scope),
2819 FieldName, Unit, Line, FieldTy,
2820 CGM.getLangOpts().Optimize, Flags,
2821 ArgNo);
2822
2823 // Insert an llvm.dbg.declare into the current block.
2824 llvm::Instruction *Call =
2825 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(),
2826 Builder.GetInsertBlock());
2827 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope));
2828 }
2829 return;
2830 }
2831 }
2832
2833 // Create the descriptor for the variable.
2834 llvm::DIVariable D =
2835 DBuilder.createLocalVariable(Tag, llvm::DIDescriptor(Scope),
2836 Name, Unit, Line, Ty,
2837 CGM.getLangOpts().Optimize, Flags, ArgNo);
2838
2839 // Insert an llvm.dbg.declare into the current block.
2840 llvm::Instruction *Call =
2841 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(),
2842 Builder.GetInsertBlock());
2843 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope));
2844}
2845
2846void CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD,
2847 llvm::Value *Storage,
2848 CGBuilderTy &Builder) {
2849 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo)((DebugKind >= CodeGenOptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= CodeGenOptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2849, __PRETTY_FUNCTION__));
2850 EmitDeclare(VD, llvm::dwarf::DW_TAG_auto_variable, Storage, 0, Builder);
2851}
2852
2853/// Look up the completed type for a self pointer in the TypeCache and
2854/// create a copy of it with the ObjectPointer and Artificial flags
2855/// set. If the type is not cached, a new one is created. This should
2856/// never happen though, since creating a type for the implicit self
2857/// argument implies that we already parsed the interface definition
2858/// and the ivar declarations in the implementation.
2859llvm::DIType CGDebugInfo::CreateSelfType(const QualType &QualTy,
2860 llvm::DIType Ty) {
2861 llvm::DIType CachedTy = getTypeOrNull(QualTy);
2862 if (CachedTy) Ty = CachedTy;
2863 return DBuilder.createObjectPointerType(Ty);
2864}
2865
2866void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(const VarDecl *VD,
2867 llvm::Value *Storage,
2868 CGBuilderTy &Builder,
2869 const CGBlockInfo &blockInfo) {
2870 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo)((DebugKind >= CodeGenOptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= CodeGenOptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2870, __PRETTY_FUNCTION__));
2871 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!")((!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"
) ? static_cast<void> (0) : __assert_fail ("!LexicalBlockStack.empty() && \"Region stack mismatch, stack empty!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2871, __PRETTY_FUNCTION__));
2872
2873 if (Builder.GetInsertBlock() == nullptr)
2874 return;
2875
2876 bool isByRef = VD->hasAttr<BlocksAttr>();
2877
2878 uint64_t XOffset = 0;
2879 llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
2880 llvm::DIType Ty;
2881 if (isByRef)
2882 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
2883 else
2884 Ty = getOrCreateType(VD->getType(), Unit);
2885
2886 // Self is passed along as an implicit non-arg variable in a
2887 // block. Mark it as the object pointer.
2888 if (isa<ImplicitParamDecl>(VD) && VD->getName() == "self")
2889 Ty = CreateSelfType(VD->getType(), Ty);
2890
2891 // Get location information.
2892 unsigned Line = getLineNumber(VD->getLocation());
2893 unsigned Column = getColumnNumber(VD->getLocation());
2894
2895 const llvm::DataLayout &target = CGM.getDataLayout();
2896
2897 CharUnits offset = CharUnits::fromQuantity(
2898 target.getStructLayout(blockInfo.StructureType)
2899 ->getElementOffset(blockInfo.getCapture(VD).getIndex()));
2900
2901 SmallVector<int64_t, 9> addr;
2902 if (isa<llvm::AllocaInst>(Storage))
2903 addr.push_back(llvm::dwarf::DW_OP_deref);
2904 addr.push_back(llvm::dwarf::DW_OP_plus);
2905 addr.push_back(offset.getQuantity());
2906 if (isByRef) {
2907 addr.push_back(llvm::dwarf::DW_OP_deref);
2908 addr.push_back(llvm::dwarf::DW_OP_plus);
2909 // offset of __forwarding field
2910 offset = CGM.getContext()
2911 .toCharUnitsFromBits(target.getPointerSizeInBits(0));
2912 addr.push_back(offset.getQuantity());
2913 addr.push_back(llvm::dwarf::DW_OP_deref);
2914 addr.push_back(llvm::dwarf::DW_OP_plus);
2915 // offset of x field
2916 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
2917 addr.push_back(offset.getQuantity());
2918 }
2919
2920 // Create the descriptor for the variable.
2921 llvm::DIVariable D =
2922 DBuilder.createLocalVariable(llvm::dwarf::DW_TAG_auto_variable,
2923 llvm::DIDescriptor(LexicalBlockStack.back()),
2924 VD->getName(), Unit, Line, Ty);
2925
2926 // Insert an llvm.dbg.declare into the current block.
2927 llvm::Instruction *Call =
2928 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(addr),
2929 Builder.GetInsertPoint());
2930 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column,
2931 LexicalBlockStack.back()));
2932}
2933
2934/// EmitDeclareOfArgVariable - Emit call to llvm.dbg.declare for an argument
2935/// variable declaration.
2936void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI,
2937 unsigned ArgNo,
2938 CGBuilderTy &Builder) {
2939 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo)((DebugKind >= CodeGenOptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= CodeGenOptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2939, __PRETTY_FUNCTION__));
2940 EmitDeclare(VD, llvm::dwarf::DW_TAG_arg_variable, AI, ArgNo, Builder);
2941}
2942
2943namespace {
2944 struct BlockLayoutChunk {
2945 uint64_t OffsetInBits;
2946 const BlockDecl::Capture *Capture;
2947 };
2948 bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) {
2949 return l.OffsetInBits < r.OffsetInBits;
2950 }
2951}
2952
2953void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
2954 llvm::Value *Arg,
2955 unsigned ArgNo,
2956 llvm::Value *LocalAddr,
2957 CGBuilderTy &Builder) {
2958 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo)((DebugKind >= CodeGenOptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= CodeGenOptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 2958, __PRETTY_FUNCTION__));
2959 ASTContext &C = CGM.getContext();
2960 const BlockDecl *blockDecl = block.getBlockDecl();
2961
2962 // Collect some general information about the block's location.
2963 SourceLocation loc = blockDecl->getCaretLocation();
2964 llvm::DIFile tunit = getOrCreateFile(loc);
2965 unsigned line = getLineNumber(loc);
2966 unsigned column = getColumnNumber(loc);
2967
2968 // Build the debug-info type for the block literal.
2969 getContextDescriptor(cast<Decl>(blockDecl->getDeclContext()));
2970
2971 const llvm::StructLayout *blockLayout =
2972 CGM.getDataLayout().getStructLayout(block.StructureType);
2973
2974 SmallVector<llvm::Value*, 16> fields;
2975 fields.push_back(createFieldType("__isa", C.VoidPtrTy, 0, loc, AS_public,
2976 blockLayout->getElementOffsetInBits(0),
2977 tunit, tunit));
2978 fields.push_back(createFieldType("__flags", C.IntTy, 0, loc, AS_public,
2979 blockLayout->getElementOffsetInBits(1),
2980 tunit, tunit));
2981 fields.push_back(createFieldType("__reserved", C.IntTy, 0, loc, AS_public,
2982 blockLayout->getElementOffsetInBits(2),
2983 tunit, tunit));
2984 fields.push_back(createFieldType("__FuncPtr", C.VoidPtrTy, 0, loc, AS_public,
2985 blockLayout->getElementOffsetInBits(3),
2986 tunit, tunit));
2987 fields.push_back(createFieldType("__descriptor",
2988 C.getPointerType(block.NeedsCopyDispose ?
2989 C.getBlockDescriptorExtendedType() :
2990 C.getBlockDescriptorType()),
2991 0, loc, AS_public,
2992 blockLayout->getElementOffsetInBits(4),
2993 tunit, tunit));
2994
2995 // We want to sort the captures by offset, not because DWARF
2996 // requires this, but because we're paranoid about debuggers.
2997 SmallVector<BlockLayoutChunk, 8> chunks;
2998
2999 // 'this' capture.
3000 if (blockDecl->capturesCXXThis()) {
3001 BlockLayoutChunk chunk;
3002 chunk.OffsetInBits =
3003 blockLayout->getElementOffsetInBits(block.CXXThisIndex);
3004 chunk.Capture = nullptr;
3005 chunks.push_back(chunk);
3006 }
3007
3008 // Variable captures.
3009 for (const auto &capture : blockDecl->captures()) {
3010 const VarDecl *variable = capture.getVariable();
3011 const CGBlockInfo::Capture &captureInfo = block.getCapture(variable);
3012
3013 // Ignore constant captures.
3014 if (captureInfo.isConstant())
3015 continue;
3016
3017 BlockLayoutChunk chunk;
3018 chunk.OffsetInBits =
3019 blockLayout->getElementOffsetInBits(captureInfo.getIndex());
3020 chunk.Capture = &capture;
3021 chunks.push_back(chunk);
3022 }
3023
3024 // Sort by offset.
3025 llvm::array_pod_sort(chunks.begin(), chunks.end());
3026
3027 for (SmallVectorImpl<BlockLayoutChunk>::iterator
3028 i = chunks.begin(), e = chunks.end(); i != e; ++i) {
3029 uint64_t offsetInBits = i->OffsetInBits;
3030 const BlockDecl::Capture *capture = i->Capture;
3031
3032 // If we have a null capture, this must be the C++ 'this' capture.
3033 if (!capture) {
3034 const CXXMethodDecl *method =
3035 cast<CXXMethodDecl>(blockDecl->getNonClosureContext());
3036 QualType type = method->getThisType(C);
3037
3038 fields.push_back(createFieldType("this", type, 0, loc, AS_public,
3039 offsetInBits, tunit, tunit));
3040 continue;
3041 }
3042
3043 const VarDecl *variable = capture->getVariable();
3044 StringRef name = variable->getName();
3045
3046 llvm::DIType fieldType;
3047 if (capture->isByRef()) {
3048 TypeInfo PtrInfo = C.getTypeInfo(C.VoidPtrTy);
3049
3050 // FIXME: this creates a second copy of this type!
3051 uint64_t xoffset;
3052 fieldType = EmitTypeForVarWithBlocksAttr(variable, &xoffset);
3053 fieldType = DBuilder.createPointerType(fieldType, PtrInfo.Width);
3054 fieldType =
3055 DBuilder.createMemberType(tunit, name, tunit, line, PtrInfo.Width,
3056 PtrInfo.Align, offsetInBits, 0, fieldType);
3057 } else {
3058 fieldType = createFieldType(name, variable->getType(), 0,
3059 loc, AS_public, offsetInBits, tunit, tunit);
3060 }
3061 fields.push_back(fieldType);
3062 }
3063
3064 SmallString<36> typeName;
3065 llvm::raw_svector_ostream(typeName)
3066 << "__block_literal_" << CGM.getUniqueBlockCount();
3067
3068 llvm::DIArray fieldsArray = DBuilder.getOrCreateArray(fields);
3069
3070 llvm::DIType type =
3071 DBuilder.createStructType(tunit, typeName.str(), tunit, line,
3072 CGM.getContext().toBits(block.BlockSize),
3073 CGM.getContext().toBits(block.BlockAlign),
3074 0, llvm::DIType(), fieldsArray);
3075 type = DBuilder.createPointerType(type, CGM.PointerWidthInBits);
3076
3077 // Get overall information about the block.
3078 unsigned flags = llvm::DIDescriptor::FlagArtificial;
3079 llvm::MDNode *scope = LexicalBlockStack.back();
3080
3081 // Create the descriptor for the parameter.
3082 llvm::DIVariable debugVar =
3083 DBuilder.createLocalVariable(llvm::dwarf::DW_TAG_arg_variable,
3084 llvm::DIDescriptor(scope),
3085 Arg->getName(), tunit, line, type,
3086 CGM.getLangOpts().Optimize, flags,
3087 ArgNo);
3088
3089 if (LocalAddr) {
3090 // Insert an llvm.dbg.value into the current block.
3091 llvm::Instruction *DbgVal =
3092 DBuilder.insertDbgValueIntrinsic(LocalAddr, 0, debugVar,
3093 DBuilder.createExpression(),
3094 Builder.GetInsertBlock());
3095 DbgVal->setDebugLoc(llvm::DebugLoc::get(line, column, scope));
3096 }
3097
3098 // Insert an llvm.dbg.declare into the current block.
3099 llvm::Instruction *DbgDecl =
3100 DBuilder.insertDeclare(Arg, debugVar, DBuilder.createExpression(),
3101 Builder.GetInsertBlock());
3102 DbgDecl->setDebugLoc(llvm::DebugLoc::get(line, column, scope));
3103}
3104
3105/// If D is an out-of-class definition of a static data member of a class, find
3106/// its corresponding in-class declaration.
3107llvm::DIDerivedType
3108CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(const VarDecl *D) {
3109 if (!D->isStaticDataMember())
3110 return llvm::DIDerivedType();
3111 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator MI =
3112 StaticDataMemberCache.find(D->getCanonicalDecl());
3113 if (MI != StaticDataMemberCache.end()) {
3114 assert(MI->second && "Static data member declaration should still exist")((MI->second && "Static data member declaration should still exist"
) ? static_cast<void> (0) : __assert_fail ("MI->second && \"Static data member declaration should still exist\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3114, __PRETTY_FUNCTION__));
3115 return llvm::DIDerivedType(cast<llvm::MDNode>(MI->second));
3116 }
3117
3118 // If the member wasn't found in the cache, lazily construct and add it to the
3119 // type (used when a limited form of the type is emitted).
3120 auto DC = D->getDeclContext();
3121 llvm::DICompositeType Ctxt(getContextDescriptor(cast<Decl>(DC)));
3122 return CreateRecordStaticField(D, Ctxt, cast<RecordDecl>(DC));
3123}
3124
3125/// Recursively collect all of the member fields of a global anonymous decl and
3126/// create static variables for them. The first time this is called it needs
3127/// to be on a union and then from there we can have additional unnamed fields.
3128llvm::DIGlobalVariable
3129CGDebugInfo::CollectAnonRecordDecls(const RecordDecl *RD, llvm::DIFile Unit,
3130 unsigned LineNo, StringRef LinkageName,
3131 llvm::GlobalVariable *Var,
3132 llvm::DIDescriptor DContext) {
3133 llvm::DIGlobalVariable GV;
3134
3135 for (const auto *Field : RD->fields()) {
3136 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
3137 StringRef FieldName = Field->getName();
3138
3139 // Ignore unnamed fields, but recurse into anonymous records.
3140 if (FieldName.empty()) {
3141 const RecordType *RT = dyn_cast<RecordType>(Field->getType());
3142 if (RT)
3143 GV = CollectAnonRecordDecls(RT->getDecl(), Unit, LineNo, LinkageName,
3144 Var, DContext);
3145 continue;
3146 }
3147 // Use VarDecl's Tag, Scope and Line number.
3148 GV = DBuilder.createGlobalVariable(DContext, FieldName, LinkageName, Unit,
3149 LineNo, FieldTy,
3150 Var->hasInternalLinkage(), Var,
3151 llvm::DIDerivedType());
3152 }
3153 return GV;
3154}
3155
3156/// EmitGlobalVariable - Emit information about a global variable.
3157void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
3158 const VarDecl *D) {
3159 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo)((DebugKind >= CodeGenOptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= CodeGenOptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3159, __PRETTY_FUNCTION__));
3160 // Create global variable debug descriptor.
3161 llvm::DIFile Unit = getOrCreateFile(D->getLocation());
3162 unsigned LineNo = getLineNumber(D->getLocation());
3163
3164 setLocation(D->getLocation());
3165
3166 QualType T = D->getType();
3167 if (T->isIncompleteArrayType()) {
3168
3169 // CodeGen turns int[] into int[1] so we'll do the same here.
3170 llvm::APInt ConstVal(32, 1);
3171 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
3172
3173 T = CGM.getContext().getConstantArrayType(ET, ConstVal,
3174 ArrayType::Normal, 0);
3175 }
3176
3177 StringRef DeclName = D->getName();
3178 StringRef LinkageName;
3179 if (D->getDeclContext() && !isa<FunctionDecl>(D->getDeclContext()) &&
3180 !isa<ObjCMethodDecl>(D->getDeclContext()))
3181 LinkageName = Var->getName();
3182 if (LinkageName == DeclName)
3183 LinkageName = StringRef();
3184
3185 llvm::DIDescriptor DContext =
3186 getContextDescriptor(dyn_cast<Decl>(D->getDeclContext()));
3187
3188 // Attempt to store one global variable for the declaration - even if we
3189 // emit a lot of fields.
3190 llvm::DIGlobalVariable GV;
3191
3192 // If this is an anonymous union then we'll want to emit a global
3193 // variable for each member of the anonymous union so that it's possible
3194 // to find the name of any field in the union.
3195 if (T->isUnionType() && DeclName.empty()) {
3196 const RecordDecl *RD = cast<RecordType>(T)->getDecl();
3197 assert(RD->isAnonymousStructOrUnion() && "unnamed non-anonymous struct or union?")((RD->isAnonymousStructOrUnion() && "unnamed non-anonymous struct or union?"
) ? static_cast<void> (0) : __assert_fail ("RD->isAnonymousStructOrUnion() && \"unnamed non-anonymous struct or union?\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3197, __PRETTY_FUNCTION__));
3198 GV = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
3199 } else {
3200 GV = DBuilder.createGlobalVariable(
3201 DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit),
3202 Var->hasInternalLinkage(), Var,
3203 getOrCreateStaticDataMemberDeclarationOrNull(D));
3204 }
3205 DeclCache.insert(std::make_pair(D->getCanonicalDecl(), llvm::WeakVH(GV)));
3206}
3207
3208/// EmitGlobalVariable - Emit global variable's debug info.
3209void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD,
3210 llvm::Constant *Init) {
3211 assert(DebugKind >= CodeGenOptions::LimitedDebugInfo)((DebugKind >= CodeGenOptions::LimitedDebugInfo) ? static_cast
<void> (0) : __assert_fail ("DebugKind >= CodeGenOptions::LimitedDebugInfo"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3211, __PRETTY_FUNCTION__));
3212 // Create the descriptor for the variable.
3213 llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
3214 StringRef Name = VD->getName();
3215 llvm::DIType Ty = getOrCreateType(VD->getType(), Unit);
3216 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(VD)) {
3217 const EnumDecl *ED = cast<EnumDecl>(ECD->getDeclContext());
3218 assert(isa<EnumType>(ED->getTypeForDecl()) && "Enum without EnumType?")((isa<EnumType>(ED->getTypeForDecl()) && "Enum without EnumType?"
) ? static_cast<void> (0) : __assert_fail ("isa<EnumType>(ED->getTypeForDecl()) && \"Enum without EnumType?\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3218, __PRETTY_FUNCTION__));
3219 Ty = getOrCreateType(QualType(ED->getTypeForDecl(), 0), Unit);
3220 }
3221 // Do not use DIGlobalVariable for enums.
3222 if (Ty.getTag() == llvm::dwarf::DW_TAG_enumeration_type)
3223 return;
3224 // Do not emit separate definitions for function local const/statics.
3225 if (isa<FunctionDecl>(VD->getDeclContext()))
3226 return;
3227 VD = cast<ValueDecl>(VD->getCanonicalDecl());
3228 auto pair = DeclCache.insert(std::make_pair(VD, llvm::WeakVH()));
3229 if (!pair.second)
3230 return;
3231 llvm::DIDescriptor DContext =
3232 getContextDescriptor(dyn_cast<Decl>(VD->getDeclContext()));
3233 llvm::DIGlobalVariable GV = DBuilder.createGlobalVariable(
3234 DContext, Name, StringRef(), Unit, getLineNumber(VD->getLocation()), Ty,
3235 true, Init,
3236 getOrCreateStaticDataMemberDeclarationOrNull(cast<VarDecl>(VD)));
3237 pair.first->second = llvm::WeakVH(GV);
3238}
3239
3240llvm::DIScope CGDebugInfo::getCurrentContextDescriptor(const Decl *D) {
3241 if (!LexicalBlockStack.empty())
3242 return llvm::DIScope(LexicalBlockStack.back());
3243 return getContextDescriptor(D);
3244}
3245
3246void CGDebugInfo::EmitUsingDirective(const UsingDirectiveDecl &UD) {
3247 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
3248 return;
3249 DBuilder.createImportedModule(
3250 getCurrentContextDescriptor(cast<Decl>(UD.getDeclContext())),
3251 getOrCreateNameSpace(UD.getNominatedNamespace()),
3252 getLineNumber(UD.getLocation()));
3253}
3254
3255void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) {
3256 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
3257 return;
3258 assert(UD.shadow_size() &&((UD.shadow_size() && "We shouldn't be codegening an invalid UsingDecl containing no decls"
) ? static_cast<void> (0) : __assert_fail ("UD.shadow_size() && \"We shouldn't be codegening an invalid UsingDecl containing no decls\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3259, __PRETTY_FUNCTION__))
3259 "We shouldn't be codegening an invalid UsingDecl containing no decls")((UD.shadow_size() && "We shouldn't be codegening an invalid UsingDecl containing no decls"
) ? static_cast<void> (0) : __assert_fail ("UD.shadow_size() && \"We shouldn't be codegening an invalid UsingDecl containing no decls\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3259, __PRETTY_FUNCTION__));
3260 // Emitting one decl is sufficient - debuggers can detect that this is an
3261 // overloaded name & provide lookup for all the overloads.
3262 const UsingShadowDecl &USD = **UD.shadow_begin();
3263 if (llvm::DIScope Target =
3264 getDeclarationOrDefinition(USD.getUnderlyingDecl()))
3265 DBuilder.createImportedDeclaration(
3266 getCurrentContextDescriptor(cast<Decl>(USD.getDeclContext())), Target,
3267 getLineNumber(USD.getLocation()));
3268}
3269
3270llvm::DIImportedEntity
3271CGDebugInfo::EmitNamespaceAlias(const NamespaceAliasDecl &NA) {
3272 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
3273 return llvm::DIImportedEntity(nullptr);
3274 llvm::WeakVH &VH = NamespaceAliasCache[&NA];
3275 if (VH)
3276 return llvm::DIImportedEntity(cast<llvm::MDNode>(VH));
3277 llvm::DIImportedEntity R(nullptr);
3278 if (const NamespaceAliasDecl *Underlying =
3279 dyn_cast<NamespaceAliasDecl>(NA.getAliasedNamespace()))
3280 // This could cache & dedup here rather than relying on metadata deduping.
3281 R = DBuilder.createImportedDeclaration(
3282 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
3283 EmitNamespaceAlias(*Underlying), getLineNumber(NA.getLocation()),
3284 NA.getName());
3285 else
3286 R = DBuilder.createImportedDeclaration(
3287 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
3288 getOrCreateNameSpace(cast<NamespaceDecl>(NA.getAliasedNamespace())),
3289 getLineNumber(NA.getLocation()), NA.getName());
3290 VH = R;
3291 return R;
3292}
3293
3294/// getOrCreateNamesSpace - Return namespace descriptor for the given
3295/// namespace decl.
3296llvm::DINameSpace
3297CGDebugInfo::getOrCreateNameSpace(const NamespaceDecl *NSDecl) {
3298 NSDecl = NSDecl->getCanonicalDecl();
3299 llvm::DenseMap<const NamespaceDecl *, llvm::WeakVH>::iterator I =
3300 NameSpaceCache.find(NSDecl);
3301 if (I != NameSpaceCache.end())
3302 return llvm::DINameSpace(cast<llvm::MDNode>(I->second));
3303
3304 unsigned LineNo = getLineNumber(NSDecl->getLocation());
3305 llvm::DIFile FileD = getOrCreateFile(NSDecl->getLocation());
3306 llvm::DIDescriptor Context =
3307 getContextDescriptor(dyn_cast<Decl>(NSDecl->getDeclContext()));
3308 llvm::DINameSpace NS =
3309 DBuilder.createNameSpace(Context, NSDecl->getName(), FileD, LineNo);
3310 NameSpaceCache[NSDecl] = llvm::WeakVH(NS);
3311 return NS;
3312}
3313
3314void CGDebugInfo::finalize() {
3315 // Creating types might create further types - invalidating the current
3316 // element and the size(), so don't cache/reference them.
3317 for (size_t i = 0; i != ObjCInterfaceCache.size(); ++i) {
3318 ObjCInterfaceCacheEntry E = ObjCInterfaceCache[i];
3319 E.Decl.replaceAllUsesWith(CGM.getLLVMContext(),
3320 E.Type->getDecl()->getDefinition()
3321 ? CreateTypeDefinition(E.Type, E.Unit)
3322 : E.Decl);
3323 }
3324
3325 for (auto p : ReplaceMap) {
3326 assert(p.second)((p.second) ? static_cast<void> (0) : __assert_fail ("p.second"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3326, __PRETTY_FUNCTION__));
3327 llvm::DIType Ty(cast<llvm::MDNode>(p.second));
3328 assert(Ty.isForwardDecl())((Ty.isForwardDecl()) ? static_cast<void> (0) : __assert_fail
("Ty.isForwardDecl()", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3328, __PRETTY_FUNCTION__));
3329
3330 auto it = TypeCache.find(p.first);
3331 assert(it != TypeCache.end())((it != TypeCache.end()) ? static_cast<void> (0) : __assert_fail
("it != TypeCache.end()", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3331, __PRETTY_FUNCTION__));
3332 assert(it->second)((it->second) ? static_cast<void> (0) : __assert_fail
("it->second", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/clang/lib/CodeGen/CGDebugInfo.cpp"
, 3332, __PRETTY_FUNCTION__));
3333
3334 llvm::DIType RepTy(cast<llvm::MDNode>(it->second));
3335 Ty.replaceAllUsesWith(CGM.getLLVMContext(), RepTy);
3336 }
3337
3338 // We keep our own list of retained types, because we need to look
3339 // up the final type in the type cache.
3340 for (std::vector<void *>::const_iterator RI = RetainedTypes.begin(),
3341 RE = RetainedTypes.end(); RI != RE; ++RI)
3342 DBuilder.retainType(llvm::DIType(cast<llvm::MDNode>(TypeCache[*RI])));
3343
3344 DBuilder.finalize();
3345}
3346
3347void CGDebugInfo::EmitExplicitCastType(QualType Ty) {
3348 if (CGM.getCodeGenOpts().getDebugInfo() < CodeGenOptions::LimitedDebugInfo)
3349 return;
3350 llvm::DIType DieTy = getOrCreateType(Ty, getOrCreateMainFile());
3351 // Don't ignore in case of explicit cast where it is referenced indirectly.
3352 DBuilder.retainType(DieTy);
3353}