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 "CodeGenFunction.h"
16 #include "CodeGenModule.h"
17 #include "CGBlocks.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/DeclFriend.h"
20 #include "clang/AST/DeclObjC.h"
21 #include "clang/AST/DeclTemplate.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/RecordLayout.h"
24 #include "clang/Basic/SourceManager.h"
25 #include "clang/Basic/FileManager.h"
26 #include "clang/Basic/Version.h"
27 #include "clang/Frontend/CodeGenOptions.h"
28 #include "llvm/Constants.h"
29 #include "llvm/DerivedTypes.h"
30 #include "llvm/Instructions.h"
31 #include "llvm/Intrinsics.h"
32 #include "llvm/Module.h"
33 #include "llvm/ADT/StringExtras.h"
34 #include "llvm/ADT/SmallVector.h"
35 #include "llvm/Support/Dwarf.h"
36 #include "llvm/Support/Path.h"
37 #include "llvm/Target/TargetData.h"
38 #include "llvm/Target/TargetMachine.h"
39 using namespace clang;
40 using namespace clang::CodeGen;
41
CGDebugInfo(CodeGenModule & CGM)42 CGDebugInfo::CGDebugInfo(CodeGenModule &CGM)
43 : CGM(CGM), DBuilder(CGM.getModule()),
44 BlockLiteralGenericSet(false) {
45 CreateCompileUnit();
46 }
47
~CGDebugInfo()48 CGDebugInfo::~CGDebugInfo() {
49 assert(RegionStack.empty() && "Region stack mismatch, stack not empty!");
50 }
51
setLocation(SourceLocation Loc)52 void CGDebugInfo::setLocation(SourceLocation Loc) {
53 if (Loc.isValid())
54 CurLoc = CGM.getContext().getSourceManager().getInstantiationLoc(Loc);
55 }
56
57 /// getContextDescriptor - Get context info for the decl.
getContextDescriptor(const Decl * Context)58 llvm::DIDescriptor CGDebugInfo::getContextDescriptor(const Decl *Context) {
59 if (!Context)
60 return TheCU;
61
62 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator
63 I = RegionMap.find(Context);
64 if (I != RegionMap.end())
65 return llvm::DIDescriptor(dyn_cast_or_null<llvm::MDNode>(&*I->second));
66
67 // Check namespace.
68 if (const NamespaceDecl *NSDecl = dyn_cast<NamespaceDecl>(Context))
69 return llvm::DIDescriptor(getOrCreateNameSpace(NSDecl));
70
71 if (const RecordDecl *RDecl = dyn_cast<RecordDecl>(Context)) {
72 if (!RDecl->isDependentType()) {
73 llvm::DIType Ty = getOrCreateType(CGM.getContext().getTypeDeclType(RDecl),
74 getOrCreateMainFile());
75 return llvm::DIDescriptor(Ty);
76 }
77 }
78 return TheCU;
79 }
80
81 /// getFunctionName - Get function name for the given FunctionDecl. If the
82 /// name is constructred on demand (e.g. C++ destructor) then the name
83 /// is stored on the side.
getFunctionName(const FunctionDecl * FD)84 llvm::StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) {
85 assert (FD && "Invalid FunctionDecl!");
86 IdentifierInfo *FII = FD->getIdentifier();
87 if (FII)
88 return FII->getName();
89
90 // Otherwise construct human readable name for debug info.
91 std::string NS = FD->getNameAsString();
92
93 // Copy this name on the side and use its reference.
94 char *StrPtr = DebugInfoNames.Allocate<char>(NS.length());
95 memcpy(StrPtr, NS.data(), NS.length());
96 return llvm::StringRef(StrPtr, NS.length());
97 }
98
getObjCMethodName(const ObjCMethodDecl * OMD)99 llvm::StringRef CGDebugInfo::getObjCMethodName(const ObjCMethodDecl *OMD) {
100 llvm::SmallString<256> MethodName;
101 llvm::raw_svector_ostream OS(MethodName);
102 OS << (OMD->isInstanceMethod() ? '-' : '+') << '[';
103 const DeclContext *DC = OMD->getDeclContext();
104 if (const ObjCImplementationDecl *OID =
105 dyn_cast<const ObjCImplementationDecl>(DC)) {
106 OS << OID->getName();
107 } else if (const ObjCInterfaceDecl *OID =
108 dyn_cast<const ObjCInterfaceDecl>(DC)) {
109 OS << OID->getName();
110 } else if (const ObjCCategoryImplDecl *OCD =
111 dyn_cast<const ObjCCategoryImplDecl>(DC)){
112 OS << ((NamedDecl *)OCD)->getIdentifier()->getNameStart() << '(' <<
113 OCD->getIdentifier()->getNameStart() << ')';
114 }
115 OS << ' ' << OMD->getSelector().getAsString() << ']';
116
117 char *StrPtr = DebugInfoNames.Allocate<char>(OS.tell());
118 memcpy(StrPtr, MethodName.begin(), OS.tell());
119 return llvm::StringRef(StrPtr, OS.tell());
120 }
121
122 /// getSelectorName - Return selector name. This is used for debugging
123 /// info.
getSelectorName(Selector S)124 llvm::StringRef CGDebugInfo::getSelectorName(Selector S) {
125 llvm::SmallString<256> SName;
126 llvm::raw_svector_ostream OS(SName);
127 OS << S.getAsString();
128 char *StrPtr = DebugInfoNames.Allocate<char>(OS.tell());
129 memcpy(StrPtr, SName.begin(), OS.tell());
130 return llvm::StringRef(StrPtr, OS.tell());
131 }
132
133 /// getClassName - Get class name including template argument list.
134 llvm::StringRef
getClassName(RecordDecl * RD)135 CGDebugInfo::getClassName(RecordDecl *RD) {
136 ClassTemplateSpecializationDecl *Spec
137 = dyn_cast<ClassTemplateSpecializationDecl>(RD);
138 if (!Spec)
139 return RD->getName();
140
141 const TemplateArgument *Args;
142 unsigned NumArgs;
143 std::string Buffer;
144 if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) {
145 const TemplateSpecializationType *TST =
146 cast<TemplateSpecializationType>(TAW->getType());
147 Args = TST->getArgs();
148 NumArgs = TST->getNumArgs();
149 } else {
150 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
151 Args = TemplateArgs.data();
152 NumArgs = TemplateArgs.size();
153 }
154 Buffer = RD->getIdentifier()->getNameStart();
155 PrintingPolicy Policy(CGM.getLangOptions());
156 Buffer += TemplateSpecializationType::PrintTemplateArgumentList(Args,
157 NumArgs,
158 Policy);
159
160 // Copy this name on the side and use its reference.
161 char *StrPtr = DebugInfoNames.Allocate<char>(Buffer.length());
162 memcpy(StrPtr, Buffer.data(), Buffer.length());
163 return llvm::StringRef(StrPtr, Buffer.length());
164 }
165
166 /// getOrCreateFile - Get the file debug info descriptor for the input location.
getOrCreateFile(SourceLocation Loc)167 llvm::DIFile CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
168 if (!Loc.isValid())
169 // If Location is not valid then use main input file.
170 return DBuilder.createFile(TheCU.getFilename(), TheCU.getDirectory());
171
172 SourceManager &SM = CGM.getContext().getSourceManager();
173 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
174
175 if (PLoc.isInvalid() || llvm::StringRef(PLoc.getFilename()).empty())
176 // If the location is not valid then use main input file.
177 return DBuilder.createFile(TheCU.getFilename(), TheCU.getDirectory());
178
179 // Cache the results.
180 const char *fname = PLoc.getFilename();
181 llvm::DenseMap<const char *, llvm::WeakVH>::iterator it =
182 DIFileCache.find(fname);
183
184 if (it != DIFileCache.end()) {
185 // Verify that the information still exists.
186 if (&*it->second)
187 return llvm::DIFile(cast<llvm::MDNode>(it->second));
188 }
189
190 llvm::DIFile F = DBuilder.createFile(PLoc.getFilename(), getCurrentDirname());
191
192 DIFileCache[fname] = F;
193 return F;
194
195 }
196
197 /// getOrCreateMainFile - Get the file info for main compile unit.
getOrCreateMainFile()198 llvm::DIFile CGDebugInfo::getOrCreateMainFile() {
199 return DBuilder.createFile(TheCU.getFilename(), TheCU.getDirectory());
200 }
201
202 /// getLineNumber - Get line number for the location. If location is invalid
203 /// then use current location.
getLineNumber(SourceLocation Loc)204 unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) {
205 assert (CurLoc.isValid() && "Invalid current location!");
206 SourceManager &SM = CGM.getContext().getSourceManager();
207 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
208 return PLoc.isValid()? PLoc.getLine() : 0;
209 }
210
211 /// getColumnNumber - Get column number for the location. If location is
212 /// invalid then use current location.
getColumnNumber(SourceLocation Loc)213 unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc) {
214 assert (CurLoc.isValid() && "Invalid current location!");
215 SourceManager &SM = CGM.getContext().getSourceManager();
216 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
217 return PLoc.isValid()? PLoc.getColumn() : 0;
218 }
219
getCurrentDirname()220 llvm::StringRef CGDebugInfo::getCurrentDirname() {
221 if (!CWDName.empty())
222 return CWDName;
223 char *CompDirnamePtr = NULL;
224 llvm::sys::Path CWD = llvm::sys::Path::GetCurrentDirectory();
225 CompDirnamePtr = DebugInfoNames.Allocate<char>(CWD.size());
226 memcpy(CompDirnamePtr, CWD.c_str(), CWD.size());
227 return CWDName = llvm::StringRef(CompDirnamePtr, CWD.size());
228 }
229
230 /// CreateCompileUnit - Create new compile unit.
CreateCompileUnit()231 void CGDebugInfo::CreateCompileUnit() {
232
233 // Get absolute path name.
234 SourceManager &SM = CGM.getContext().getSourceManager();
235 std::string MainFileName = CGM.getCodeGenOpts().MainFileName;
236 if (MainFileName.empty())
237 MainFileName = "<unknown>";
238
239 // The main file name provided via the "-main-file-name" option contains just
240 // the file name itself with no path information. This file name may have had
241 // a relative path, so we look into the actual file entry for the main
242 // file to determine the real absolute path for the file.
243 std::string MainFileDir;
244 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
245 MainFileDir = MainFile->getDir()->getName();
246 if (MainFileDir != ".")
247 MainFileName = MainFileDir + "/" + MainFileName;
248 }
249
250 // Save filename string.
251 char *FilenamePtr = DebugInfoNames.Allocate<char>(MainFileName.length());
252 memcpy(FilenamePtr, MainFileName.c_str(), MainFileName.length());
253 llvm::StringRef Filename(FilenamePtr, MainFileName.length());
254
255 unsigned LangTag;
256 const LangOptions &LO = CGM.getLangOptions();
257 if (LO.CPlusPlus) {
258 if (LO.ObjC1)
259 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
260 else
261 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
262 } else if (LO.ObjC1) {
263 LangTag = llvm::dwarf::DW_LANG_ObjC;
264 } else if (LO.C99) {
265 LangTag = llvm::dwarf::DW_LANG_C99;
266 } else {
267 LangTag = llvm::dwarf::DW_LANG_C89;
268 }
269
270 std::string Producer = getClangFullVersion();
271
272 // Figure out which version of the ObjC runtime we have.
273 unsigned RuntimeVers = 0;
274 if (LO.ObjC1)
275 RuntimeVers = LO.ObjCNonFragileABI ? 2 : 1;
276
277 // Create new compile unit.
278 DBuilder.createCompileUnit(
279 LangTag, Filename, getCurrentDirname(),
280 Producer,
281 LO.Optimize, CGM.getCodeGenOpts().DwarfDebugFlags, RuntimeVers);
282 // FIXME - Eliminate TheCU.
283 TheCU = llvm::DICompileUnit(DBuilder.getCU());
284 }
285
286 /// CreateType - Get the Basic type from the cache or create a new
287 /// one if necessary.
CreateType(const BuiltinType * BT)288 llvm::DIType CGDebugInfo::CreateType(const BuiltinType *BT) {
289 unsigned Encoding = 0;
290 const char *BTName = NULL;
291 switch (BT->getKind()) {
292 default:
293 case BuiltinType::Void:
294 return llvm::DIType();
295 case BuiltinType::ObjCClass:
296 return DBuilder.createStructType(TheCU, "objc_class",
297 getOrCreateMainFile(), 0, 0, 0,
298 llvm::DIDescriptor::FlagFwdDecl,
299 llvm::DIArray());
300 case BuiltinType::ObjCId: {
301 // typedef struct objc_class *Class;
302 // typedef struct objc_object {
303 // Class isa;
304 // } *id;
305
306 llvm::DIType OCTy =
307 DBuilder.createStructType(TheCU, "objc_class",
308 getOrCreateMainFile(), 0, 0, 0,
309 llvm::DIDescriptor::FlagFwdDecl,
310 llvm::DIArray());
311 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
312
313 llvm::DIType ISATy = DBuilder.createPointerType(OCTy, Size);
314
315 llvm::SmallVector<llvm::Value *, 16> EltTys;
316 llvm::DIType FieldTy =
317 DBuilder.createMemberType(getOrCreateMainFile(), "isa",
318 getOrCreateMainFile(), 0, Size,
319 0, 0, 0, ISATy);
320 EltTys.push_back(FieldTy);
321 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys);
322
323 return DBuilder.createStructType(TheCU, "objc_object",
324 getOrCreateMainFile(),
325 0, 0, 0, 0, Elements);
326 }
327 case BuiltinType::ObjCSel: {
328 return DBuilder.createStructType(TheCU, "objc_selector",
329 getOrCreateMainFile(), 0, 0, 0,
330 llvm::DIDescriptor::FlagFwdDecl,
331 llvm::DIArray());
332 }
333 case BuiltinType::UChar:
334 case BuiltinType::Char_U: Encoding = llvm::dwarf::DW_ATE_unsigned_char; break;
335 case BuiltinType::Char_S:
336 case BuiltinType::SChar: Encoding = llvm::dwarf::DW_ATE_signed_char; break;
337 case BuiltinType::UShort:
338 case BuiltinType::UInt:
339 case BuiltinType::UInt128:
340 case BuiltinType::ULong:
341 case BuiltinType::ULongLong: Encoding = llvm::dwarf::DW_ATE_unsigned; break;
342 case BuiltinType::Short:
343 case BuiltinType::Int:
344 case BuiltinType::Int128:
345 case BuiltinType::Long:
346 case BuiltinType::LongLong: Encoding = llvm::dwarf::DW_ATE_signed; break;
347 case BuiltinType::Bool: Encoding = llvm::dwarf::DW_ATE_boolean; break;
348 case BuiltinType::Float:
349 case BuiltinType::LongDouble:
350 case BuiltinType::Double: Encoding = llvm::dwarf::DW_ATE_float; break;
351 }
352
353 switch (BT->getKind()) {
354 case BuiltinType::Long: BTName = "long int"; break;
355 case BuiltinType::LongLong: BTName = "long long int"; break;
356 case BuiltinType::ULong: BTName = "long unsigned int"; break;
357 case BuiltinType::ULongLong: BTName = "long long unsigned int"; break;
358 default:
359 BTName = BT->getName(CGM.getContext().getLangOptions());
360 break;
361 }
362 // Bit size, align and offset of the type.
363 uint64_t Size = CGM.getContext().getTypeSize(BT);
364 uint64_t Align = CGM.getContext().getTypeAlign(BT);
365 llvm::DIType DbgTy =
366 DBuilder.createBasicType(BTName, Size, Align, Encoding);
367 return DbgTy;
368 }
369
CreateType(const ComplexType * Ty)370 llvm::DIType CGDebugInfo::CreateType(const ComplexType *Ty) {
371 // Bit size, align and offset of the type.
372 unsigned Encoding = llvm::dwarf::DW_ATE_complex_float;
373 if (Ty->isComplexIntegerType())
374 Encoding = llvm::dwarf::DW_ATE_lo_user;
375
376 uint64_t Size = CGM.getContext().getTypeSize(Ty);
377 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
378 llvm::DIType DbgTy =
379 DBuilder.createBasicType("complex", Size, Align, Encoding);
380
381 return DbgTy;
382 }
383
384 /// CreateCVRType - Get the qualified type from the cache or create
385 /// a new one if necessary.
CreateQualifiedType(QualType Ty,llvm::DIFile Unit)386 llvm::DIType CGDebugInfo::CreateQualifiedType(QualType Ty, llvm::DIFile Unit) {
387 QualifierCollector Qc;
388 const Type *T = Qc.strip(Ty);
389
390 // Ignore these qualifiers for now.
391 Qc.removeObjCGCAttr();
392 Qc.removeAddressSpace();
393 Qc.removeObjCLifetime();
394
395 // We will create one Derived type for one qualifier and recurse to handle any
396 // additional ones.
397 unsigned Tag;
398 if (Qc.hasConst()) {
399 Tag = llvm::dwarf::DW_TAG_const_type;
400 Qc.removeConst();
401 } else if (Qc.hasVolatile()) {
402 Tag = llvm::dwarf::DW_TAG_volatile_type;
403 Qc.removeVolatile();
404 } else if (Qc.hasRestrict()) {
405 Tag = llvm::dwarf::DW_TAG_restrict_type;
406 Qc.removeRestrict();
407 } else {
408 assert(Qc.empty() && "Unknown type qualifier for debug info");
409 return getOrCreateType(QualType(T, 0), Unit);
410 }
411
412 llvm::DIType FromTy = getOrCreateType(Qc.apply(CGM.getContext(), T), Unit);
413
414 // No need to fill in the Name, Line, Size, Alignment, Offset in case of
415 // CVR derived types.
416 llvm::DIType DbgTy = DBuilder.createQualifiedType(Tag, FromTy);
417
418 return DbgTy;
419 }
420
CreateType(const ObjCObjectPointerType * Ty,llvm::DIFile Unit)421 llvm::DIType CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty,
422 llvm::DIFile Unit) {
423 llvm::DIType DbgTy =
424 CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
425 Ty->getPointeeType(), Unit);
426 return DbgTy;
427 }
428
CreateType(const PointerType * Ty,llvm::DIFile Unit)429 llvm::DIType CGDebugInfo::CreateType(const PointerType *Ty,
430 llvm::DIFile Unit) {
431 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
432 Ty->getPointeeType(), Unit);
433 }
434
435 /// CreatePointeeType - Create PointTee type. If Pointee is a record
436 /// then emit record's fwd if debug info size reduction is enabled.
CreatePointeeType(QualType PointeeTy,llvm::DIFile Unit)437 llvm::DIType CGDebugInfo::CreatePointeeType(QualType PointeeTy,
438 llvm::DIFile Unit) {
439 if (!CGM.getCodeGenOpts().LimitDebugInfo)
440 return getOrCreateType(PointeeTy, Unit);
441
442 if (const RecordType *RTy = dyn_cast<RecordType>(PointeeTy)) {
443 RecordDecl *RD = RTy->getDecl();
444 llvm::DIFile DefUnit = getOrCreateFile(RD->getLocation());
445 unsigned Line = getLineNumber(RD->getLocation());
446 llvm::DIDescriptor FDContext =
447 getContextDescriptor(cast<Decl>(RD->getDeclContext()));
448
449 if (RD->isStruct())
450 return DBuilder.createStructType(FDContext, RD->getName(), DefUnit,
451 Line, 0, 0, llvm::DIType::FlagFwdDecl,
452 llvm::DIArray());
453 else if (RD->isUnion())
454 return DBuilder.createUnionType(FDContext, RD->getName(), DefUnit,
455 Line, 0, 0, llvm::DIType::FlagFwdDecl,
456 llvm::DIArray());
457 else {
458 assert(RD->isClass() && "Unknown RecordType!");
459 return DBuilder.createClassType(FDContext, RD->getName(), DefUnit,
460 Line, 0, 0, 0, llvm::DIType::FlagFwdDecl,
461 llvm::DIType(), llvm::DIArray());
462 }
463 }
464 return getOrCreateType(PointeeTy, Unit);
465
466 }
467
CreatePointerLikeType(unsigned Tag,const Type * Ty,QualType PointeeTy,llvm::DIFile Unit)468 llvm::DIType CGDebugInfo::CreatePointerLikeType(unsigned Tag,
469 const Type *Ty,
470 QualType PointeeTy,
471 llvm::DIFile Unit) {
472
473 if (Tag == llvm::dwarf::DW_TAG_reference_type)
474 return DBuilder.createReferenceType(CreatePointeeType(PointeeTy, Unit));
475
476 // Bit size, align and offset of the type.
477 // Size is always the size of a pointer. We can't use getTypeSize here
478 // because that does not return the correct value for references.
479 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
480 uint64_t Size = CGM.getContext().Target.getPointerWidth(AS);
481 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
482
483 return
484 DBuilder.createPointerType(CreatePointeeType(PointeeTy, Unit), Size, Align);
485 }
486
CreateType(const BlockPointerType * Ty,llvm::DIFile Unit)487 llvm::DIType CGDebugInfo::CreateType(const BlockPointerType *Ty,
488 llvm::DIFile Unit) {
489 if (BlockLiteralGenericSet)
490 return BlockLiteralGeneric;
491
492 llvm::SmallVector<llvm::Value *, 8> EltTys;
493 llvm::DIType FieldTy;
494 QualType FType;
495 uint64_t FieldSize, FieldOffset;
496 unsigned FieldAlign;
497 llvm::DIArray Elements;
498 llvm::DIType EltTy, DescTy;
499
500 FieldOffset = 0;
501 FType = CGM.getContext().UnsignedLongTy;
502 EltTys.push_back(CreateMemberType(Unit, FType, "reserved", &FieldOffset));
503 EltTys.push_back(CreateMemberType(Unit, FType, "Size", &FieldOffset));
504
505 Elements = DBuilder.getOrCreateArray(EltTys);
506 EltTys.clear();
507
508 unsigned Flags = llvm::DIDescriptor::FlagAppleBlock;
509 unsigned LineNo = getLineNumber(CurLoc);
510
511 EltTy = DBuilder.createStructType(Unit, "__block_descriptor",
512 Unit, LineNo, FieldOffset, 0,
513 Flags, Elements);
514
515 // Bit size, align and offset of the type.
516 uint64_t Size = CGM.getContext().getTypeSize(Ty);
517
518 DescTy = DBuilder.createPointerType(EltTy, Size);
519
520 FieldOffset = 0;
521 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
522 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
523 FType = CGM.getContext().IntTy;
524 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
525 EltTys.push_back(CreateMemberType(Unit, FType, "__reserved", &FieldOffset));
526 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
527 EltTys.push_back(CreateMemberType(Unit, FType, "__FuncPtr", &FieldOffset));
528
529 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
530 FieldTy = DescTy;
531 FieldSize = CGM.getContext().getTypeSize(Ty);
532 FieldAlign = CGM.getContext().getTypeAlign(Ty);
533 FieldTy = DBuilder.createMemberType(Unit, "__descriptor", Unit,
534 LineNo, FieldSize, FieldAlign,
535 FieldOffset, 0, FieldTy);
536 EltTys.push_back(FieldTy);
537
538 FieldOffset += FieldSize;
539 Elements = DBuilder.getOrCreateArray(EltTys);
540
541 EltTy = DBuilder.createStructType(Unit, "__block_literal_generic",
542 Unit, LineNo, FieldOffset, 0,
543 Flags, Elements);
544
545 BlockLiteralGenericSet = true;
546 BlockLiteralGeneric = DBuilder.createPointerType(EltTy, Size);
547 return BlockLiteralGeneric;
548 }
549
CreateType(const TypedefType * Ty,llvm::DIFile Unit)550 llvm::DIType CGDebugInfo::CreateType(const TypedefType *Ty,
551 llvm::DIFile Unit) {
552 // Typedefs are derived from some other type. If we have a typedef of a
553 // typedef, make sure to emit the whole chain.
554 llvm::DIType Src = getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit);
555 if (!Src.Verify())
556 return llvm::DIType();
557 // We don't set size information, but do specify where the typedef was
558 // declared.
559 unsigned Line = getLineNumber(Ty->getDecl()->getLocation());
560 const TypedefNameDecl *TyDecl = Ty->getDecl();
561 llvm::DIDescriptor TydefContext =
562 getContextDescriptor(cast<Decl>(Ty->getDecl()->getDeclContext()));
563
564 return
565 DBuilder.createTypedef(Src, TyDecl->getName(), Unit, Line, TydefContext);
566 }
567
CreateType(const FunctionType * Ty,llvm::DIFile Unit)568 llvm::DIType CGDebugInfo::CreateType(const FunctionType *Ty,
569 llvm::DIFile Unit) {
570 llvm::SmallVector<llvm::Value *, 16> EltTys;
571
572 // Add the result type at least.
573 EltTys.push_back(getOrCreateType(Ty->getResultType(), Unit));
574
575 // Set up remainder of arguments if there is a prototype.
576 // FIXME: IF NOT, HOW IS THIS REPRESENTED? llvm-gcc doesn't represent '...'!
577 if (isa<FunctionNoProtoType>(Ty))
578 EltTys.push_back(DBuilder.createUnspecifiedParameter());
579 else if (const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(Ty)) {
580 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
581 EltTys.push_back(getOrCreateType(FTP->getArgType(i), Unit));
582 }
583
584 llvm::DIArray EltTypeArray = DBuilder.getOrCreateArray(EltTys);
585
586 llvm::DIType DbgTy = DBuilder.createSubroutineType(Unit, EltTypeArray);
587 return DbgTy;
588 }
589
createFieldType(llvm::StringRef name,QualType type,Expr * bitWidth,SourceLocation loc,AccessSpecifier AS,uint64_t offsetInBits,llvm::DIFile tunit,llvm::DIDescriptor scope)590 llvm::DIType CGDebugInfo::createFieldType(llvm::StringRef name,
591 QualType type,
592 Expr *bitWidth,
593 SourceLocation loc,
594 AccessSpecifier AS,
595 uint64_t offsetInBits,
596 llvm::DIFile tunit,
597 llvm::DIDescriptor scope) {
598 llvm::DIType debugType = getOrCreateType(type, tunit);
599
600 // Get the location for the field.
601 llvm::DIFile file = getOrCreateFile(loc);
602 unsigned line = getLineNumber(loc);
603
604 uint64_t sizeInBits = 0;
605 unsigned alignInBits = 0;
606 if (!type->isIncompleteArrayType()) {
607 llvm::tie(sizeInBits, alignInBits) = CGM.getContext().getTypeInfo(type);
608
609 if (bitWidth)
610 sizeInBits = bitWidth->EvaluateAsInt(CGM.getContext()).getZExtValue();
611 }
612
613 unsigned flags = 0;
614 if (AS == clang::AS_private)
615 flags |= llvm::DIDescriptor::FlagPrivate;
616 else if (AS == clang::AS_protected)
617 flags |= llvm::DIDescriptor::FlagProtected;
618
619 return DBuilder.createMemberType(scope, name, file, line, sizeInBits,
620 alignInBits, offsetInBits, flags, debugType);
621 }
622
623 /// CollectRecordFields - A helper function to collect debug info for
624 /// record fields. This is used while creating debug info entry for a Record.
625 void CGDebugInfo::
CollectRecordFields(const RecordDecl * record,llvm::DIFile tunit,llvm::SmallVectorImpl<llvm::Value * > & elements,llvm::DIType RecordTy)626 CollectRecordFields(const RecordDecl *record, llvm::DIFile tunit,
627 llvm::SmallVectorImpl<llvm::Value *> &elements,
628 llvm::DIType RecordTy) {
629 unsigned fieldNo = 0;
630 const FieldDecl *LastFD = 0;
631 bool IsMsStruct = record->hasAttr<MsStructAttr>();
632
633 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(record);
634 for (RecordDecl::field_iterator I = record->field_begin(),
635 E = record->field_end();
636 I != E; ++I, ++fieldNo) {
637 FieldDecl *field = *I;
638 if (IsMsStruct) {
639 // Zero-length bitfields following non-bitfield members are ignored
640 if (CGM.getContext().ZeroBitfieldFollowsNonBitfield((field), LastFD)) {
641 --fieldNo;
642 continue;
643 }
644 LastFD = field;
645 }
646
647 llvm::StringRef name = field->getName();
648 QualType type = field->getType();
649
650 // Ignore unnamed fields unless they're anonymous structs/unions.
651 if (name.empty() && !type->isRecordType()) {
652 LastFD = field;
653 continue;
654 }
655
656 llvm::DIType fieldType
657 = createFieldType(name, type, field->getBitWidth(),
658 field->getLocation(), field->getAccess(),
659 layout.getFieldOffset(fieldNo), tunit, RecordTy);
660
661 elements.push_back(fieldType);
662 }
663 }
664
665 /// getOrCreateMethodType - CXXMethodDecl's type is a FunctionType. This
666 /// function type is not updated to include implicit "this" pointer. Use this
667 /// routine to get a method type which includes "this" pointer.
668 llvm::DIType
getOrCreateMethodType(const CXXMethodDecl * Method,llvm::DIFile Unit)669 CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method,
670 llvm::DIFile Unit) {
671 llvm::DIType FnTy
672 = getOrCreateType(QualType(Method->getType()->getAs<FunctionProtoType>(),
673 0),
674 Unit);
675
676 // Add "this" pointer.
677
678 llvm::DIArray Args = llvm::DICompositeType(FnTy).getTypeArray();
679 assert (Args.getNumElements() && "Invalid number of arguments!");
680
681 llvm::SmallVector<llvm::Value *, 16> Elts;
682
683 // First element is always return type. For 'void' functions it is NULL.
684 Elts.push_back(Args.getElement(0));
685
686 if (!Method->isStatic())
687 {
688 // "this" pointer is always first argument.
689 QualType ThisPtr = Method->getThisType(CGM.getContext());
690 llvm::DIType ThisPtrType =
691 DBuilder.createArtificialType(getOrCreateType(ThisPtr, Unit));
692
693 TypeCache[ThisPtr.getAsOpaquePtr()] = ThisPtrType;
694 Elts.push_back(ThisPtrType);
695 }
696
697 // Copy rest of the arguments.
698 for (unsigned i = 1, e = Args.getNumElements(); i != e; ++i)
699 Elts.push_back(Args.getElement(i));
700
701 llvm::DIArray EltTypeArray = DBuilder.getOrCreateArray(Elts);
702
703 return DBuilder.createSubroutineType(Unit, EltTypeArray);
704 }
705
706 /// isFunctionLocalClass - Return true if CXXRecordDecl is defined
707 /// inside a function.
isFunctionLocalClass(const CXXRecordDecl * RD)708 static bool isFunctionLocalClass(const CXXRecordDecl *RD) {
709 if (const CXXRecordDecl *NRD =
710 dyn_cast<CXXRecordDecl>(RD->getDeclContext()))
711 return isFunctionLocalClass(NRD);
712 else if (isa<FunctionDecl>(RD->getDeclContext()))
713 return true;
714 return false;
715
716 }
717 /// CreateCXXMemberFunction - A helper function to create a DISubprogram for
718 /// a single member function GlobalDecl.
719 llvm::DISubprogram
CreateCXXMemberFunction(const CXXMethodDecl * Method,llvm::DIFile Unit,llvm::DIType RecordTy)720 CGDebugInfo::CreateCXXMemberFunction(const CXXMethodDecl *Method,
721 llvm::DIFile Unit,
722 llvm::DIType RecordTy) {
723 bool IsCtorOrDtor =
724 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
725
726 llvm::StringRef MethodName = getFunctionName(Method);
727 llvm::DIType MethodTy = getOrCreateMethodType(Method, Unit);
728
729 // Since a single ctor/dtor corresponds to multiple functions, it doesn't
730 // make sense to give a single ctor/dtor a linkage name.
731 llvm::StringRef MethodLinkageName;
732 if (!IsCtorOrDtor && !isFunctionLocalClass(Method->getParent()))
733 MethodLinkageName = CGM.getMangledName(Method);
734
735 // Get the location for the method.
736 llvm::DIFile MethodDefUnit = getOrCreateFile(Method->getLocation());
737 unsigned MethodLine = getLineNumber(Method->getLocation());
738
739 // Collect virtual method info.
740 llvm::DIType ContainingType;
741 unsigned Virtuality = 0;
742 unsigned VIndex = 0;
743
744 if (Method->isVirtual()) {
745 if (Method->isPure())
746 Virtuality = llvm::dwarf::DW_VIRTUALITY_pure_virtual;
747 else
748 Virtuality = llvm::dwarf::DW_VIRTUALITY_virtual;
749
750 // It doesn't make sense to give a virtual destructor a vtable index,
751 // since a single destructor has two entries in the vtable.
752 if (!isa<CXXDestructorDecl>(Method))
753 VIndex = CGM.getVTables().getMethodVTableIndex(Method);
754 ContainingType = RecordTy;
755 }
756
757 unsigned Flags = 0;
758 if (Method->isImplicit())
759 Flags |= llvm::DIDescriptor::FlagArtificial;
760 AccessSpecifier Access = Method->getAccess();
761 if (Access == clang::AS_private)
762 Flags |= llvm::DIDescriptor::FlagPrivate;
763 else if (Access == clang::AS_protected)
764 Flags |= llvm::DIDescriptor::FlagProtected;
765 if (const CXXConstructorDecl *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
766 if (CXXC->isExplicit())
767 Flags |= llvm::DIDescriptor::FlagExplicit;
768 } else if (const CXXConversionDecl *CXXC =
769 dyn_cast<CXXConversionDecl>(Method)) {
770 if (CXXC->isExplicit())
771 Flags |= llvm::DIDescriptor::FlagExplicit;
772 }
773 if (Method->hasPrototype())
774 Flags |= llvm::DIDescriptor::FlagPrototyped;
775
776 llvm::DISubprogram SP =
777 DBuilder.createMethod(RecordTy , MethodName, MethodLinkageName,
778 MethodDefUnit, MethodLine,
779 MethodTy, /*isLocalToUnit=*/false,
780 /* isDefinition=*/ false,
781 Virtuality, VIndex, ContainingType,
782 Flags, CGM.getLangOptions().Optimize);
783
784 SPCache[Method] = llvm::WeakVH(SP);
785
786 return SP;
787 }
788
789 /// CollectCXXMemberFunctions - A helper function to collect debug info for
790 /// C++ member functions.This is used while creating debug info entry for
791 /// a Record.
792 void CGDebugInfo::
CollectCXXMemberFunctions(const CXXRecordDecl * RD,llvm::DIFile Unit,llvm::SmallVectorImpl<llvm::Value * > & EltTys,llvm::DIType RecordTy)793 CollectCXXMemberFunctions(const CXXRecordDecl *RD, llvm::DIFile Unit,
794 llvm::SmallVectorImpl<llvm::Value *> &EltTys,
795 llvm::DIType RecordTy) {
796 for(CXXRecordDecl::method_iterator I = RD->method_begin(),
797 E = RD->method_end(); I != E; ++I) {
798 const CXXMethodDecl *Method = *I;
799
800 if (Method->isImplicit() && !Method->isUsed())
801 continue;
802
803 EltTys.push_back(CreateCXXMemberFunction(Method, Unit, RecordTy));
804 }
805 }
806
807 /// CollectCXXFriends - A helper function to collect debug info for
808 /// C++ base classes. This is used while creating debug info entry for
809 /// a Record.
810 void CGDebugInfo::
CollectCXXFriends(const CXXRecordDecl * RD,llvm::DIFile Unit,llvm::SmallVectorImpl<llvm::Value * > & EltTys,llvm::DIType RecordTy)811 CollectCXXFriends(const CXXRecordDecl *RD, llvm::DIFile Unit,
812 llvm::SmallVectorImpl<llvm::Value *> &EltTys,
813 llvm::DIType RecordTy) {
814
815 for (CXXRecordDecl::friend_iterator BI = RD->friend_begin(),
816 BE = RD->friend_end(); BI != BE; ++BI) {
817 if (TypeSourceInfo *TInfo = (*BI)->getFriendType())
818 EltTys.push_back(DBuilder.createFriend(RecordTy,
819 getOrCreateType(TInfo->getType(),
820 Unit)));
821 }
822 }
823
824 /// CollectCXXBases - A helper function to collect debug info for
825 /// C++ base classes. This is used while creating debug info entry for
826 /// a Record.
827 void CGDebugInfo::
CollectCXXBases(const CXXRecordDecl * RD,llvm::DIFile Unit,llvm::SmallVectorImpl<llvm::Value * > & EltTys,llvm::DIType RecordTy)828 CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile Unit,
829 llvm::SmallVectorImpl<llvm::Value *> &EltTys,
830 llvm::DIType RecordTy) {
831
832 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
833 for (CXXRecordDecl::base_class_const_iterator BI = RD->bases_begin(),
834 BE = RD->bases_end(); BI != BE; ++BI) {
835 unsigned BFlags = 0;
836 uint64_t BaseOffset;
837
838 const CXXRecordDecl *Base =
839 cast<CXXRecordDecl>(BI->getType()->getAs<RecordType>()->getDecl());
840
841 if (BI->isVirtual()) {
842 // virtual base offset offset is -ve. The code generator emits dwarf
843 // expression where it expects +ve number.
844 BaseOffset =
845 0 - CGM.getVTables().getVirtualBaseOffsetOffset(RD, Base).getQuantity();
846 BFlags = llvm::DIDescriptor::FlagVirtual;
847 } else
848 BaseOffset = RL.getBaseClassOffsetInBits(Base);
849 // FIXME: Inconsistent units for BaseOffset. It is in bytes when
850 // BI->isVirtual() and bits when not.
851
852 AccessSpecifier Access = BI->getAccessSpecifier();
853 if (Access == clang::AS_private)
854 BFlags |= llvm::DIDescriptor::FlagPrivate;
855 else if (Access == clang::AS_protected)
856 BFlags |= llvm::DIDescriptor::FlagProtected;
857
858 llvm::DIType DTy =
859 DBuilder.createInheritance(RecordTy,
860 getOrCreateType(BI->getType(), Unit),
861 BaseOffset, BFlags);
862 EltTys.push_back(DTy);
863 }
864 }
865
866 /// CollectTemplateParams - A helper function to collect template parameters.
867 llvm::DIArray CGDebugInfo::
CollectTemplateParams(const TemplateParameterList * TPList,const TemplateArgumentList & TAList,llvm::DIFile Unit)868 CollectTemplateParams(const TemplateParameterList *TPList,
869 const TemplateArgumentList &TAList,
870 llvm::DIFile Unit) {
871 llvm::SmallVector<llvm::Value *, 16> TemplateParams;
872 for (unsigned i = 0, e = TAList.size(); i != e; ++i) {
873 const TemplateArgument &TA = TAList[i];
874 const NamedDecl *ND = TPList->getParam(i);
875 if (TA.getKind() == TemplateArgument::Type) {
876 llvm::DIType TTy = getOrCreateType(TA.getAsType(), Unit);
877 llvm::DITemplateTypeParameter TTP =
878 DBuilder.createTemplateTypeParameter(TheCU, ND->getName(), TTy);
879 TemplateParams.push_back(TTP);
880 } else if (TA.getKind() == TemplateArgument::Integral) {
881 llvm::DIType TTy = getOrCreateType(TA.getIntegralType(), Unit);
882 llvm::DITemplateValueParameter TVP =
883 DBuilder.createTemplateValueParameter(TheCU, ND->getName(), TTy,
884 TA.getAsIntegral()->getZExtValue());
885 TemplateParams.push_back(TVP);
886 }
887 }
888 return DBuilder.getOrCreateArray(TemplateParams);
889 }
890
891 /// CollectFunctionTemplateParams - A helper function to collect debug
892 /// info for function template parameters.
893 llvm::DIArray CGDebugInfo::
CollectFunctionTemplateParams(const FunctionDecl * FD,llvm::DIFile Unit)894 CollectFunctionTemplateParams(const FunctionDecl *FD, llvm::DIFile Unit) {
895 if (FD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplateSpecialization){
896 const TemplateParameterList *TList =
897 FD->getTemplateSpecializationInfo()->getTemplate()->getTemplateParameters();
898 return
899 CollectTemplateParams(TList, *FD->getTemplateSpecializationArgs(), Unit);
900 }
901 return llvm::DIArray();
902 }
903
904 /// CollectCXXTemplateParams - A helper function to collect debug info for
905 /// template parameters.
906 llvm::DIArray CGDebugInfo::
CollectCXXTemplateParams(const ClassTemplateSpecializationDecl * TSpecial,llvm::DIFile Unit)907 CollectCXXTemplateParams(const ClassTemplateSpecializationDecl *TSpecial,
908 llvm::DIFile Unit) {
909 llvm::PointerUnion<ClassTemplateDecl *,
910 ClassTemplatePartialSpecializationDecl *>
911 PU = TSpecial->getSpecializedTemplateOrPartial();
912
913 TemplateParameterList *TPList = PU.is<ClassTemplateDecl *>() ?
914 PU.get<ClassTemplateDecl *>()->getTemplateParameters() :
915 PU.get<ClassTemplatePartialSpecializationDecl *>()->getTemplateParameters();
916 const TemplateArgumentList &TAList = TSpecial->getTemplateInstantiationArgs();
917 return CollectTemplateParams(TPList, TAList, Unit);
918 }
919
920 /// getOrCreateVTablePtrType - Return debug info descriptor for vtable.
getOrCreateVTablePtrType(llvm::DIFile Unit)921 llvm::DIType CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile Unit) {
922 if (VTablePtrType.isValid())
923 return VTablePtrType;
924
925 ASTContext &Context = CGM.getContext();
926
927 /* Function type */
928 llvm::Value *STy = getOrCreateType(Context.IntTy, Unit);
929 llvm::DIArray SElements = DBuilder.getOrCreateArray(STy);
930 llvm::DIType SubTy = DBuilder.createSubroutineType(Unit, SElements);
931 unsigned Size = Context.getTypeSize(Context.VoidPtrTy);
932 llvm::DIType vtbl_ptr_type = DBuilder.createPointerType(SubTy, Size, 0,
933 "__vtbl_ptr_type");
934 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
935 return VTablePtrType;
936 }
937
938 /// getVTableName - Get vtable name for the given Class.
getVTableName(const CXXRecordDecl * RD)939 llvm::StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) {
940 // Otherwise construct gdb compatible name name.
941 std::string Name = "_vptr$" + RD->getNameAsString();
942
943 // Copy this name on the side and use its reference.
944 char *StrPtr = DebugInfoNames.Allocate<char>(Name.length());
945 memcpy(StrPtr, Name.data(), Name.length());
946 return llvm::StringRef(StrPtr, Name.length());
947 }
948
949
950 /// CollectVTableInfo - If the C++ class has vtable info then insert appropriate
951 /// debug info entry in EltTys vector.
952 void CGDebugInfo::
CollectVTableInfo(const CXXRecordDecl * RD,llvm::DIFile Unit,llvm::SmallVectorImpl<llvm::Value * > & EltTys)953 CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile Unit,
954 llvm::SmallVectorImpl<llvm::Value *> &EltTys) {
955 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
956
957 // If there is a primary base then it will hold vtable info.
958 if (RL.getPrimaryBase())
959 return;
960
961 // If this class is not dynamic then there is not any vtable info to collect.
962 if (!RD->isDynamicClass())
963 return;
964
965 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
966 llvm::DIType VPTR
967 = DBuilder.createMemberType(Unit, getVTableName(RD), Unit,
968 0, Size, 0, 0, 0,
969 getOrCreateVTablePtrType(Unit));
970 EltTys.push_back(VPTR);
971 }
972
973 /// getOrCreateRecordType - Emit record type's standalone debug info.
getOrCreateRecordType(QualType RTy,SourceLocation Loc)974 llvm::DIType CGDebugInfo::getOrCreateRecordType(QualType RTy,
975 SourceLocation Loc) {
976 llvm::DIType T = getOrCreateType(RTy, getOrCreateFile(Loc));
977 DBuilder.retainType(T);
978 return T;
979 }
980
981 /// CreateType - get structure or union type.
CreateType(const RecordType * Ty)982 llvm::DIType CGDebugInfo::CreateType(const RecordType *Ty) {
983 RecordDecl *RD = Ty->getDecl();
984 llvm::DIFile Unit = getOrCreateFile(RD->getLocation());
985
986 // Get overall information about the record type for the debug info.
987 llvm::DIFile DefUnit = getOrCreateFile(RD->getLocation());
988 unsigned Line = getLineNumber(RD->getLocation());
989
990 // Records and classes and unions can all be recursive. To handle them, we
991 // first generate a debug descriptor for the struct as a forward declaration.
992 // Then (if it is a definition) we go through and get debug info for all of
993 // its members. Finally, we create a descriptor for the complete type (which
994 // may refer to the forward decl if the struct is recursive) and replace all
995 // uses of the forward declaration with the final definition.
996 llvm::DIDescriptor FDContext =
997 getContextDescriptor(cast<Decl>(RD->getDeclContext()));
998
999 // If this is just a forward declaration, construct an appropriately
1000 // marked node and just return it.
1001 if (!RD->getDefinition()) {
1002 llvm::DIType FwdDecl =
1003 DBuilder.createStructType(FDContext, RD->getName(),
1004 DefUnit, Line, 0, 0,
1005 llvm::DIDescriptor::FlagFwdDecl,
1006 llvm::DIArray());
1007
1008 return FwdDecl;
1009 }
1010
1011 llvm::DIType FwdDecl = DBuilder.createTemporaryType(DefUnit);
1012
1013 llvm::MDNode *MN = FwdDecl;
1014 llvm::TrackingVH<llvm::MDNode> FwdDeclNode = MN;
1015 // Otherwise, insert it into the TypeCache so that recursive uses will find
1016 // it.
1017 TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl;
1018 // Push the struct on region stack.
1019 RegionStack.push_back(FwdDeclNode);
1020 RegionMap[Ty->getDecl()] = llvm::WeakVH(FwdDecl);
1021
1022 // Convert all the elements.
1023 llvm::SmallVector<llvm::Value *, 16> EltTys;
1024
1025 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
1026 if (CXXDecl) {
1027 CollectCXXBases(CXXDecl, Unit, EltTys, FwdDecl);
1028 CollectVTableInfo(CXXDecl, Unit, EltTys);
1029 }
1030
1031 // Collect static variables with initializers.
1032 for (RecordDecl::decl_iterator I = RD->decls_begin(), E = RD->decls_end();
1033 I != E; ++I)
1034 if (const VarDecl *V = dyn_cast<VarDecl>(*I)) {
1035 if (const Expr *Init = V->getInit()) {
1036 Expr::EvalResult Result;
1037 if (Init->Evaluate(Result, CGM.getContext()) && Result.Val.isInt()) {
1038 llvm::ConstantInt *CI
1039 = llvm::ConstantInt::get(CGM.getLLVMContext(), Result.Val.getInt());
1040
1041 // Create the descriptor for static variable.
1042 llvm::DIFile VUnit = getOrCreateFile(V->getLocation());
1043 llvm::StringRef VName = V->getName();
1044 llvm::DIType VTy = getOrCreateType(V->getType(), VUnit);
1045 // Do not use DIGlobalVariable for enums.
1046 if (VTy.getTag() != llvm::dwarf::DW_TAG_enumeration_type) {
1047 DBuilder.createStaticVariable(FwdDecl, VName, VName, VUnit,
1048 getLineNumber(V->getLocation()),
1049 VTy, true, CI);
1050 }
1051 }
1052 }
1053 }
1054
1055 CollectRecordFields(RD, Unit, EltTys, FwdDecl);
1056 llvm::DIArray TParamsArray;
1057 if (CXXDecl) {
1058 CollectCXXMemberFunctions(CXXDecl, Unit, EltTys, FwdDecl);
1059 CollectCXXFriends(CXXDecl, Unit, EltTys, FwdDecl);
1060 if (const ClassTemplateSpecializationDecl *TSpecial
1061 = dyn_cast<ClassTemplateSpecializationDecl>(RD))
1062 TParamsArray = CollectCXXTemplateParams(TSpecial, Unit);
1063 }
1064
1065 RegionStack.pop_back();
1066 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator RI =
1067 RegionMap.find(Ty->getDecl());
1068 if (RI != RegionMap.end())
1069 RegionMap.erase(RI);
1070
1071 llvm::DIDescriptor RDContext =
1072 getContextDescriptor(cast<Decl>(RD->getDeclContext()));
1073 llvm::StringRef RDName = RD->getName();
1074 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1075 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1076 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys);
1077 llvm::MDNode *RealDecl = NULL;
1078
1079 if (RD->isUnion())
1080 RealDecl = DBuilder.createUnionType(RDContext, RDName, DefUnit, Line,
1081 Size, Align, 0, Elements);
1082 else if (CXXDecl) {
1083 RDName = getClassName(RD);
1084 // A class's primary base or the class itself contains the vtable.
1085 llvm::MDNode *ContainingType = NULL;
1086 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1087 if (const CXXRecordDecl *PBase = RL.getPrimaryBase()) {
1088 // Seek non virtual primary base root.
1089 while (1) {
1090 const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase);
1091 const CXXRecordDecl *PBT = BRL.getPrimaryBase();
1092 if (PBT && !BRL.isPrimaryBaseVirtual())
1093 PBase = PBT;
1094 else
1095 break;
1096 }
1097 ContainingType =
1098 getOrCreateType(QualType(PBase->getTypeForDecl(), 0), Unit);
1099 }
1100 else if (CXXDecl->isDynamicClass())
1101 ContainingType = FwdDecl;
1102
1103 RealDecl = DBuilder.createClassType(RDContext, RDName, DefUnit, Line,
1104 Size, Align, 0, 0, llvm::DIType(),
1105 Elements, ContainingType,
1106 TParamsArray);
1107 } else
1108 RealDecl = DBuilder.createStructType(RDContext, RDName, DefUnit, Line,
1109 Size, Align, 0, Elements);
1110
1111 // Now that we have a real decl for the struct, replace anything using the
1112 // old decl with the new one. This will recursively update the debug info.
1113 llvm::DIType(FwdDeclNode).replaceAllUsesWith(RealDecl);
1114 RegionMap[RD] = llvm::WeakVH(RealDecl);
1115 return llvm::DIType(RealDecl);
1116 }
1117
1118 /// CreateType - get objective-c object type.
CreateType(const ObjCObjectType * Ty,llvm::DIFile Unit)1119 llvm::DIType CGDebugInfo::CreateType(const ObjCObjectType *Ty,
1120 llvm::DIFile Unit) {
1121 // Ignore protocols.
1122 return getOrCreateType(Ty->getBaseType(), Unit);
1123 }
1124
1125 /// CreateType - get objective-c interface type.
CreateType(const ObjCInterfaceType * Ty,llvm::DIFile Unit)1126 llvm::DIType CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
1127 llvm::DIFile Unit) {
1128 ObjCInterfaceDecl *ID = Ty->getDecl();
1129 if (!ID)
1130 return llvm::DIType();
1131
1132 // Get overall information about the record type for the debug info.
1133 llvm::DIFile DefUnit = getOrCreateFile(ID->getLocation());
1134 unsigned Line = getLineNumber(ID->getLocation());
1135 unsigned RuntimeLang = TheCU.getLanguage();
1136
1137 // If this is just a forward declaration, return a special forward-declaration
1138 // debug type.
1139 if (ID->isForwardDecl()) {
1140 llvm::DIType FwdDecl =
1141 DBuilder.createStructType(Unit, ID->getName(),
1142 DefUnit, Line, 0, 0, 0,
1143 llvm::DIArray(), RuntimeLang);
1144 return FwdDecl;
1145 }
1146
1147 // To handle recursive interface, we
1148 // first generate a debug descriptor for the struct as a forward declaration.
1149 // Then (if it is a definition) we go through and get debug info for all of
1150 // its members. Finally, we create a descriptor for the complete type (which
1151 // may refer to the forward decl if the struct is recursive) and replace all
1152 // uses of the forward declaration with the final definition.
1153 llvm::DIType FwdDecl = DBuilder.createTemporaryType(DefUnit);
1154
1155 llvm::MDNode *MN = FwdDecl;
1156 llvm::TrackingVH<llvm::MDNode> FwdDeclNode = MN;
1157 // Otherwise, insert it into the TypeCache so that recursive uses will find
1158 // it.
1159 TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl;
1160 // Push the struct on region stack.
1161 RegionStack.push_back(FwdDeclNode);
1162 RegionMap[Ty->getDecl()] = llvm::WeakVH(FwdDecl);
1163
1164 // Convert all the elements.
1165 llvm::SmallVector<llvm::Value *, 16> EltTys;
1166
1167 ObjCInterfaceDecl *SClass = ID->getSuperClass();
1168 if (SClass) {
1169 llvm::DIType SClassTy =
1170 getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit);
1171 if (!SClassTy.isValid())
1172 return llvm::DIType();
1173
1174 llvm::DIType InhTag =
1175 DBuilder.createInheritance(FwdDecl, SClassTy, 0, 0);
1176 EltTys.push_back(InhTag);
1177 }
1178
1179 const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(ID);
1180
1181 unsigned FieldNo = 0;
1182 for (ObjCIvarDecl *Field = ID->all_declared_ivar_begin(); Field;
1183 Field = Field->getNextIvar(), ++FieldNo) {
1184 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
1185 if (!FieldTy.isValid())
1186 return llvm::DIType();
1187
1188 llvm::StringRef FieldName = Field->getName();
1189
1190 // Ignore unnamed fields.
1191 if (FieldName.empty())
1192 continue;
1193
1194 // Get the location for the field.
1195 llvm::DIFile FieldDefUnit = getOrCreateFile(Field->getLocation());
1196 unsigned FieldLine = getLineNumber(Field->getLocation());
1197 QualType FType = Field->getType();
1198 uint64_t FieldSize = 0;
1199 unsigned FieldAlign = 0;
1200
1201 if (!FType->isIncompleteArrayType()) {
1202
1203 // Bit size, align and offset of the type.
1204 FieldSize = CGM.getContext().getTypeSize(FType);
1205 Expr *BitWidth = Field->getBitWidth();
1206 if (BitWidth)
1207 FieldSize = BitWidth->EvaluateAsInt(CGM.getContext()).getZExtValue();
1208
1209 FieldAlign = CGM.getContext().getTypeAlign(FType);
1210 }
1211
1212 uint64_t FieldOffset = RL.getFieldOffset(FieldNo);
1213
1214 unsigned Flags = 0;
1215 if (Field->getAccessControl() == ObjCIvarDecl::Protected)
1216 Flags = llvm::DIDescriptor::FlagProtected;
1217 else if (Field->getAccessControl() == ObjCIvarDecl::Private)
1218 Flags = llvm::DIDescriptor::FlagPrivate;
1219
1220 llvm::StringRef PropertyName;
1221 llvm::StringRef PropertyGetter;
1222 llvm::StringRef PropertySetter;
1223 unsigned PropertyAttributes = 0;
1224 if (ObjCPropertyDecl *PD =
1225 ID->FindPropertyVisibleInPrimaryClass(Field->getIdentifier())) {
1226 PropertyName = PD->getName();
1227 PropertyGetter = getSelectorName(PD->getGetterName());
1228 PropertySetter = getSelectorName(PD->getSetterName());
1229 PropertyAttributes = PD->getPropertyAttributes();
1230 }
1231 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit,
1232 FieldLine, FieldSize, FieldAlign,
1233 FieldOffset, Flags, FieldTy,
1234 PropertyName, PropertyGetter,
1235 PropertySetter, PropertyAttributes);
1236 EltTys.push_back(FieldTy);
1237 }
1238
1239 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys);
1240
1241 RegionStack.pop_back();
1242 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator RI =
1243 RegionMap.find(Ty->getDecl());
1244 if (RI != RegionMap.end())
1245 RegionMap.erase(RI);
1246
1247 // Bit size, align and offset of the type.
1248 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1249 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1250
1251 unsigned Flags = 0;
1252 if (ID->getImplementation())
1253 Flags |= llvm::DIDescriptor::FlagObjcClassComplete;
1254
1255 llvm::DIType RealDecl =
1256 DBuilder.createStructType(Unit, ID->getName(), DefUnit,
1257 Line, Size, Align, Flags,
1258 Elements, RuntimeLang);
1259
1260 // Now that we have a real decl for the struct, replace anything using the
1261 // old decl with the new one. This will recursively update the debug info.
1262 llvm::DIType(FwdDeclNode).replaceAllUsesWith(RealDecl);
1263 RegionMap[ID] = llvm::WeakVH(RealDecl);
1264
1265 return RealDecl;
1266 }
1267
CreateType(const TagType * Ty)1268 llvm::DIType CGDebugInfo::CreateType(const TagType *Ty) {
1269 if (const RecordType *RT = dyn_cast<RecordType>(Ty))
1270 return CreateType(RT);
1271 else if (const EnumType *ET = dyn_cast<EnumType>(Ty))
1272 return CreateEnumType(ET->getDecl());
1273
1274 return llvm::DIType();
1275 }
1276
CreateType(const VectorType * Ty,llvm::DIFile Unit)1277 llvm::DIType CGDebugInfo::CreateType(const VectorType *Ty,
1278 llvm::DIFile Unit) {
1279 llvm::DIType ElementTy = getOrCreateType(Ty->getElementType(), Unit);
1280 int64_t NumElems = Ty->getNumElements();
1281 int64_t LowerBound = 0;
1282 if (NumElems == 0)
1283 // If number of elements are not known then this is an unbounded array.
1284 // Use Low = 1, Hi = 0 to express such arrays.
1285 LowerBound = 1;
1286 else
1287 --NumElems;
1288
1289 llvm::Value *Subscript = DBuilder.getOrCreateSubrange(LowerBound, NumElems);
1290 llvm::DIArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
1291
1292 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1293 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1294
1295 return
1296 DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
1297 }
1298
CreateType(const ArrayType * Ty,llvm::DIFile Unit)1299 llvm::DIType CGDebugInfo::CreateType(const ArrayType *Ty,
1300 llvm::DIFile Unit) {
1301 uint64_t Size;
1302 uint64_t Align;
1303
1304
1305 // FIXME: make getTypeAlign() aware of VLAs and incomplete array types
1306 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(Ty)) {
1307 Size = 0;
1308 Align =
1309 CGM.getContext().getTypeAlign(CGM.getContext().getBaseElementType(VAT));
1310 } else if (Ty->isIncompleteArrayType()) {
1311 Size = 0;
1312 Align = CGM.getContext().getTypeAlign(Ty->getElementType());
1313 } else if (Ty->isDependentSizedArrayType() || Ty->isIncompleteType()) {
1314 Size = 0;
1315 Align = 0;
1316 } else {
1317 // Size and align of the whole array, not the element type.
1318 Size = CGM.getContext().getTypeSize(Ty);
1319 Align = CGM.getContext().getTypeAlign(Ty);
1320 }
1321
1322 // Add the dimensions of the array. FIXME: This loses CV qualifiers from
1323 // interior arrays, do we care? Why aren't nested arrays represented the
1324 // obvious/recursive way?
1325 llvm::SmallVector<llvm::Value *, 8> Subscripts;
1326 QualType EltTy(Ty, 0);
1327 if (Ty->isIncompleteArrayType())
1328 EltTy = Ty->getElementType();
1329 else {
1330 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
1331 int64_t UpperBound = 0;
1332 int64_t LowerBound = 0;
1333 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(Ty)) {
1334 if (CAT->getSize().getZExtValue())
1335 UpperBound = CAT->getSize().getZExtValue() - 1;
1336 } else
1337 // This is an unbounded array. Use Low = 1, Hi = 0 to express such
1338 // arrays.
1339 LowerBound = 1;
1340
1341 // FIXME: Verify this is right for VLAs.
1342 Subscripts.push_back(DBuilder.getOrCreateSubrange(LowerBound, UpperBound));
1343 EltTy = Ty->getElementType();
1344 }
1345 }
1346
1347 llvm::DIArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
1348
1349 llvm::DIType DbgTy =
1350 DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
1351 SubscriptArray);
1352 return DbgTy;
1353 }
1354
CreateType(const LValueReferenceType * Ty,llvm::DIFile Unit)1355 llvm::DIType CGDebugInfo::CreateType(const LValueReferenceType *Ty,
1356 llvm::DIFile Unit) {
1357 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type,
1358 Ty, Ty->getPointeeType(), Unit);
1359 }
1360
CreateType(const RValueReferenceType * Ty,llvm::DIFile Unit)1361 llvm::DIType CGDebugInfo::CreateType(const RValueReferenceType *Ty,
1362 llvm::DIFile Unit) {
1363 return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type,
1364 Ty, Ty->getPointeeType(), Unit);
1365 }
1366
CreateType(const MemberPointerType * Ty,llvm::DIFile U)1367 llvm::DIType CGDebugInfo::CreateType(const MemberPointerType *Ty,
1368 llvm::DIFile U) {
1369 QualType PointerDiffTy = CGM.getContext().getPointerDiffType();
1370 llvm::DIType PointerDiffDITy = getOrCreateType(PointerDiffTy, U);
1371
1372 if (!Ty->getPointeeType()->isFunctionType()) {
1373 // We have a data member pointer type.
1374 return PointerDiffDITy;
1375 }
1376
1377 // We have a member function pointer type. Treat it as a struct with two
1378 // ptrdiff_t members.
1379 std::pair<uint64_t, unsigned> Info = CGM.getContext().getTypeInfo(Ty);
1380
1381 uint64_t FieldOffset = 0;
1382 llvm::Value *ElementTypes[2];
1383
1384 // FIXME: This should probably be a function type instead.
1385 ElementTypes[0] =
1386 DBuilder.createMemberType(U, "ptr", U, 0,
1387 Info.first, Info.second, FieldOffset, 0,
1388 PointerDiffDITy);
1389 FieldOffset += Info.first;
1390
1391 ElementTypes[1] =
1392 DBuilder.createMemberType(U, "ptr", U, 0,
1393 Info.first, Info.second, FieldOffset, 0,
1394 PointerDiffDITy);
1395
1396 llvm::DIArray Elements = DBuilder.getOrCreateArray(ElementTypes);
1397
1398 return DBuilder.createStructType(U, llvm::StringRef("test"),
1399 U, 0, FieldOffset,
1400 0, 0, Elements);
1401 }
1402
1403 /// CreateEnumType - get enumeration type.
CreateEnumType(const EnumDecl * ED)1404 llvm::DIType CGDebugInfo::CreateEnumType(const EnumDecl *ED) {
1405 llvm::DIFile Unit = getOrCreateFile(ED->getLocation());
1406 llvm::SmallVector<llvm::Value *, 16> Enumerators;
1407
1408 // Create DIEnumerator elements for each enumerator.
1409 for (EnumDecl::enumerator_iterator
1410 Enum = ED->enumerator_begin(), EnumEnd = ED->enumerator_end();
1411 Enum != EnumEnd; ++Enum) {
1412 Enumerators.push_back(
1413 DBuilder.createEnumerator(Enum->getName(),
1414 Enum->getInitVal().getZExtValue()));
1415 }
1416
1417 // Return a CompositeType for the enum itself.
1418 llvm::DIArray EltArray = DBuilder.getOrCreateArray(Enumerators);
1419
1420 llvm::DIFile DefUnit = getOrCreateFile(ED->getLocation());
1421 unsigned Line = getLineNumber(ED->getLocation());
1422 uint64_t Size = 0;
1423 uint64_t Align = 0;
1424 if (!ED->getTypeForDecl()->isIncompleteType()) {
1425 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
1426 Align = CGM.getContext().getTypeAlign(ED->getTypeForDecl());
1427 }
1428 llvm::DIDescriptor EnumContext =
1429 getContextDescriptor(cast<Decl>(ED->getDeclContext()));
1430 llvm::DIType DbgTy =
1431 DBuilder.createEnumerationType(EnumContext, ED->getName(), DefUnit, Line,
1432 Size, Align, EltArray);
1433 return DbgTy;
1434 }
1435
UnwrapTypeForDebugInfo(QualType T)1436 static QualType UnwrapTypeForDebugInfo(QualType T) {
1437 do {
1438 QualType LastT = T;
1439 switch (T->getTypeClass()) {
1440 default:
1441 return T;
1442 case Type::TemplateSpecialization:
1443 T = cast<TemplateSpecializationType>(T)->desugar();
1444 break;
1445 case Type::TypeOfExpr:
1446 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
1447 break;
1448 case Type::TypeOf:
1449 T = cast<TypeOfType>(T)->getUnderlyingType();
1450 break;
1451 case Type::Decltype:
1452 T = cast<DecltypeType>(T)->getUnderlyingType();
1453 break;
1454 case Type::UnaryTransform:
1455 T = cast<UnaryTransformType>(T)->getUnderlyingType();
1456 break;
1457 case Type::Attributed:
1458 T = cast<AttributedType>(T)->getEquivalentType();
1459 break;
1460 case Type::Elaborated:
1461 T = cast<ElaboratedType>(T)->getNamedType();
1462 break;
1463 case Type::Paren:
1464 T = cast<ParenType>(T)->getInnerType();
1465 break;
1466 case Type::SubstTemplateTypeParm:
1467 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
1468 break;
1469 case Type::Auto:
1470 T = cast<AutoType>(T)->getDeducedType();
1471 break;
1472 }
1473
1474 assert(T != LastT && "Type unwrapping failed to unwrap!");
1475 if (T == LastT)
1476 return T;
1477 } while (true);
1478
1479 return T;
1480 }
1481
1482 /// getOrCreateType - Get the type from the cache or create a new
1483 /// one if necessary.
getOrCreateType(QualType Ty,llvm::DIFile Unit)1484 llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty,
1485 llvm::DIFile Unit) {
1486 if (Ty.isNull())
1487 return llvm::DIType();
1488
1489 // Unwrap the type as needed for debug information.
1490 Ty = UnwrapTypeForDebugInfo(Ty);
1491
1492 // Check for existing entry.
1493 llvm::DenseMap<void *, llvm::WeakVH>::iterator it =
1494 TypeCache.find(Ty.getAsOpaquePtr());
1495 if (it != TypeCache.end()) {
1496 // Verify that the debug info still exists.
1497 if (&*it->second)
1498 return llvm::DIType(cast<llvm::MDNode>(it->second));
1499 }
1500
1501 // Otherwise create the type.
1502 llvm::DIType Res = CreateTypeNode(Ty, Unit);
1503
1504 // And update the type cache.
1505 TypeCache[Ty.getAsOpaquePtr()] = Res;
1506 return Res;
1507 }
1508
1509 /// CreateTypeNode - Create a new debug type node.
CreateTypeNode(QualType Ty,llvm::DIFile Unit)1510 llvm::DIType CGDebugInfo::CreateTypeNode(QualType Ty,
1511 llvm::DIFile Unit) {
1512 // Handle qualifiers, which recursively handles what they refer to.
1513 if (Ty.hasLocalQualifiers())
1514 return CreateQualifiedType(Ty, Unit);
1515
1516 const char *Diag = 0;
1517
1518 // Work out details of type.
1519 switch (Ty->getTypeClass()) {
1520 #define TYPE(Class, Base)
1521 #define ABSTRACT_TYPE(Class, Base)
1522 #define NON_CANONICAL_TYPE(Class, Base)
1523 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
1524 #include "clang/AST/TypeNodes.def"
1525 assert(false && "Dependent types cannot show up in debug information");
1526
1527 case Type::ExtVector:
1528 case Type::Vector:
1529 return CreateType(cast<VectorType>(Ty), Unit);
1530 case Type::ObjCObjectPointer:
1531 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
1532 case Type::ObjCObject:
1533 return CreateType(cast<ObjCObjectType>(Ty), Unit);
1534 case Type::ObjCInterface:
1535 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
1536 case Type::Builtin: return CreateType(cast<BuiltinType>(Ty));
1537 case Type::Complex: return CreateType(cast<ComplexType>(Ty));
1538 case Type::Pointer: return CreateType(cast<PointerType>(Ty), Unit);
1539 case Type::BlockPointer:
1540 return CreateType(cast<BlockPointerType>(Ty), Unit);
1541 case Type::Typedef: return CreateType(cast<TypedefType>(Ty), Unit);
1542 case Type::Record:
1543 case Type::Enum:
1544 return CreateType(cast<TagType>(Ty));
1545 case Type::FunctionProto:
1546 case Type::FunctionNoProto:
1547 return CreateType(cast<FunctionType>(Ty), Unit);
1548 case Type::ConstantArray:
1549 case Type::VariableArray:
1550 case Type::IncompleteArray:
1551 return CreateType(cast<ArrayType>(Ty), Unit);
1552
1553 case Type::LValueReference:
1554 return CreateType(cast<LValueReferenceType>(Ty), Unit);
1555 case Type::RValueReference:
1556 return CreateType(cast<RValueReferenceType>(Ty), Unit);
1557
1558 case Type::MemberPointer:
1559 return CreateType(cast<MemberPointerType>(Ty), Unit);
1560
1561 case Type::Attributed:
1562 case Type::TemplateSpecialization:
1563 case Type::Elaborated:
1564 case Type::Paren:
1565 case Type::SubstTemplateTypeParm:
1566 case Type::TypeOfExpr:
1567 case Type::TypeOf:
1568 case Type::Decltype:
1569 case Type::UnaryTransform:
1570 case Type::Auto:
1571 llvm_unreachable("type should have been unwrapped!");
1572 return llvm::DIType();
1573 }
1574
1575 assert(Diag && "Fall through without a diagnostic?");
1576 unsigned DiagID = CGM.getDiags().getCustomDiagID(Diagnostic::Error,
1577 "debug information for %0 is not yet supported");
1578 CGM.getDiags().Report(DiagID)
1579 << Diag;
1580 return llvm::DIType();
1581 }
1582
1583 /// CreateMemberType - Create new member and increase Offset by FType's size.
CreateMemberType(llvm::DIFile Unit,QualType FType,llvm::StringRef Name,uint64_t * Offset)1584 llvm::DIType CGDebugInfo::CreateMemberType(llvm::DIFile Unit, QualType FType,
1585 llvm::StringRef Name,
1586 uint64_t *Offset) {
1587 llvm::DIType FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
1588 uint64_t FieldSize = CGM.getContext().getTypeSize(FType);
1589 unsigned FieldAlign = CGM.getContext().getTypeAlign(FType);
1590 llvm::DIType Ty = DBuilder.createMemberType(Unit, Name, Unit, 0,
1591 FieldSize, FieldAlign,
1592 *Offset, 0, FieldTy);
1593 *Offset += FieldSize;
1594 return Ty;
1595 }
1596
1597 /// getFunctionDeclaration - Return debug info descriptor to describe method
1598 /// declaration for the given method definition.
getFunctionDeclaration(const Decl * D)1599 llvm::DISubprogram CGDebugInfo::getFunctionDeclaration(const Decl *D) {
1600 const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
1601 if (!FD) return llvm::DISubprogram();
1602
1603 // Setup context.
1604 getContextDescriptor(cast<Decl>(D->getDeclContext()));
1605
1606 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator
1607 MI = SPCache.find(FD);
1608 if (MI != SPCache.end()) {
1609 llvm::DISubprogram SP(dyn_cast_or_null<llvm::MDNode>(&*MI->second));
1610 if (SP.isSubprogram() && !llvm::DISubprogram(SP).isDefinition())
1611 return SP;
1612 }
1613
1614 for (FunctionDecl::redecl_iterator I = FD->redecls_begin(),
1615 E = FD->redecls_end(); I != E; ++I) {
1616 const FunctionDecl *NextFD = *I;
1617 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator
1618 MI = SPCache.find(NextFD);
1619 if (MI != SPCache.end()) {
1620 llvm::DISubprogram SP(dyn_cast_or_null<llvm::MDNode>(&*MI->second));
1621 if (SP.isSubprogram() && !llvm::DISubprogram(SP).isDefinition())
1622 return SP;
1623 }
1624 }
1625 return llvm::DISubprogram();
1626 }
1627
1628 // getOrCreateFunctionType - Construct DIType. If it is a c++ method, include
1629 // implicit parameter "this".
getOrCreateFunctionType(const Decl * D,QualType FnType,llvm::DIFile F)1630 llvm::DIType CGDebugInfo::getOrCreateFunctionType(const Decl * D, QualType FnType,
1631 llvm::DIFile F) {
1632 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
1633 return getOrCreateMethodType(Method, F);
1634 else if (const ObjCMethodDecl *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
1635 // Add "self" and "_cmd"
1636 llvm::SmallVector<llvm::Value *, 16> Elts;
1637
1638 // First element is always return type. For 'void' functions it is NULL.
1639 Elts.push_back(getOrCreateType(OMethod->getResultType(), F));
1640 // "self" pointer is always first argument.
1641 Elts.push_back(getOrCreateType(OMethod->getSelfDecl()->getType(), F));
1642 // "cmd" pointer is always second argument.
1643 Elts.push_back(getOrCreateType(OMethod->getCmdDecl()->getType(), F));
1644 // Get rest of the arguments.
1645 for (ObjCMethodDecl::param_iterator PI = OMethod->param_begin(),
1646 PE = OMethod->param_end(); PI != PE; ++PI)
1647 Elts.push_back(getOrCreateType((*PI)->getType(), F));
1648
1649 llvm::DIArray EltTypeArray = DBuilder.getOrCreateArray(Elts);
1650 return DBuilder.createSubroutineType(F, EltTypeArray);
1651 }
1652 return getOrCreateType(FnType, F);
1653 }
1654
1655 /// EmitFunctionStart - Constructs the debug code for entering a function -
1656 /// "llvm.dbg.func.start.".
EmitFunctionStart(GlobalDecl GD,QualType FnType,llvm::Function * Fn,CGBuilderTy & Builder)1657 void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, QualType FnType,
1658 llvm::Function *Fn,
1659 CGBuilderTy &Builder) {
1660
1661 llvm::StringRef Name;
1662 llvm::StringRef LinkageName;
1663
1664 FnBeginRegionCount.push_back(RegionStack.size());
1665
1666 const Decl *D = GD.getDecl();
1667
1668 unsigned Flags = 0;
1669 llvm::DIFile Unit = getOrCreateFile(CurLoc);
1670 llvm::DIDescriptor FDContext(Unit);
1671 llvm::DIArray TParamsArray;
1672 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1673 // If there is a DISubprogram for this function available then use it.
1674 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator
1675 FI = SPCache.find(FD);
1676 if (FI != SPCache.end()) {
1677 llvm::DIDescriptor SP(dyn_cast_or_null<llvm::MDNode>(&*FI->second));
1678 if (SP.isSubprogram() && llvm::DISubprogram(SP).isDefinition()) {
1679 llvm::MDNode *SPN = SP;
1680 RegionStack.push_back(SPN);
1681 RegionMap[D] = llvm::WeakVH(SP);
1682 return;
1683 }
1684 }
1685 Name = getFunctionName(FD);
1686 // Use mangled name as linkage name for c/c++ functions.
1687 if (!Fn->hasInternalLinkage())
1688 LinkageName = CGM.getMangledName(GD);
1689 if (LinkageName == Name)
1690 LinkageName = llvm::StringRef();
1691 if (FD->hasPrototype())
1692 Flags |= llvm::DIDescriptor::FlagPrototyped;
1693 if (const NamespaceDecl *NSDecl =
1694 dyn_cast_or_null<NamespaceDecl>(FD->getDeclContext()))
1695 FDContext = getOrCreateNameSpace(NSDecl);
1696 else if (const RecordDecl *RDecl =
1697 dyn_cast_or_null<RecordDecl>(FD->getDeclContext()))
1698 FDContext = getContextDescriptor(cast<Decl>(RDecl->getDeclContext()));
1699
1700 // Collect template parameters.
1701 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
1702 } else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D)) {
1703 Name = getObjCMethodName(OMD);
1704 Flags |= llvm::DIDescriptor::FlagPrototyped;
1705 } else {
1706 // Use llvm function name.
1707 Name = Fn->getName();
1708 Flags |= llvm::DIDescriptor::FlagPrototyped;
1709 }
1710 if (!Name.empty() && Name[0] == '\01')
1711 Name = Name.substr(1);
1712
1713 // It is expected that CurLoc is set before using EmitFunctionStart.
1714 // Usually, CurLoc points to the left bracket location of compound
1715 // statement representing function body.
1716 unsigned LineNo = getLineNumber(CurLoc);
1717 if (D->isImplicit())
1718 Flags |= llvm::DIDescriptor::FlagArtificial;
1719 llvm::DISubprogram SPDecl = getFunctionDeclaration(D);
1720 llvm::DISubprogram SP =
1721 DBuilder.createFunction(FDContext, Name, LinkageName, Unit,
1722 LineNo, getOrCreateFunctionType(D, FnType, Unit),
1723 Fn->hasInternalLinkage(), true/*definition*/,
1724 Flags, CGM.getLangOptions().Optimize, Fn,
1725 TParamsArray, SPDecl);
1726
1727 // Push function on region stack.
1728 llvm::MDNode *SPN = SP;
1729 RegionStack.push_back(SPN);
1730 RegionMap[D] = llvm::WeakVH(SP);
1731
1732 // Clear stack used to keep track of #line directives.
1733 LineDirectiveFiles.clear();
1734 }
1735
1736
EmitStopPoint(CGBuilderTy & Builder)1737 void CGDebugInfo::EmitStopPoint(CGBuilderTy &Builder) {
1738 if (CurLoc.isInvalid() || CurLoc.isMacroID()) return;
1739
1740 // Don't bother if things are the same as last time.
1741 SourceManager &SM = CGM.getContext().getSourceManager();
1742 if (CurLoc == PrevLoc ||
1743 SM.getInstantiationLoc(CurLoc) == SM.getInstantiationLoc(PrevLoc))
1744 // New Builder may not be in sync with CGDebugInfo.
1745 if (!Builder.getCurrentDebugLocation().isUnknown())
1746 return;
1747
1748 // Update last state.
1749 PrevLoc = CurLoc;
1750
1751 llvm::MDNode *Scope = RegionStack.back();
1752 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(getLineNumber(CurLoc),
1753 getColumnNumber(CurLoc),
1754 Scope));
1755 }
1756
1757 /// UpdateLineDirectiveRegion - Update region stack only if #line directive
1758 /// has introduced scope change.
UpdateLineDirectiveRegion(CGBuilderTy & Builder)1759 void CGDebugInfo::UpdateLineDirectiveRegion(CGBuilderTy &Builder) {
1760 if (CurLoc.isInvalid() || CurLoc.isMacroID() ||
1761 PrevLoc.isInvalid() || PrevLoc.isMacroID())
1762 return;
1763 SourceManager &SM = CGM.getContext().getSourceManager();
1764 PresumedLoc PCLoc = SM.getPresumedLoc(CurLoc);
1765 PresumedLoc PPLoc = SM.getPresumedLoc(PrevLoc);
1766
1767 if (PCLoc.isInvalid() || PPLoc.isInvalid() ||
1768 !strcmp(PPLoc.getFilename(), PCLoc.getFilename()))
1769 return;
1770
1771 // If #line directive stack is empty then we are entering a new scope.
1772 if (LineDirectiveFiles.empty()) {
1773 EmitRegionStart(Builder);
1774 LineDirectiveFiles.push_back(PCLoc.getFilename());
1775 return;
1776 }
1777
1778 assert (RegionStack.size() >= LineDirectiveFiles.size()
1779 && "error handling #line regions!");
1780
1781 bool SeenThisFile = false;
1782 // Chek if current file is already seen earlier.
1783 for(std::vector<const char *>::iterator I = LineDirectiveFiles.begin(),
1784 E = LineDirectiveFiles.end(); I != E; ++I)
1785 if (!strcmp(PCLoc.getFilename(), *I)) {
1786 SeenThisFile = true;
1787 break;
1788 }
1789
1790 // If #line for this file is seen earlier then pop out #line regions.
1791 if (SeenThisFile) {
1792 while (!LineDirectiveFiles.empty()) {
1793 const char *LastFile = LineDirectiveFiles.back();
1794 RegionStack.pop_back();
1795 LineDirectiveFiles.pop_back();
1796 if (!strcmp(PPLoc.getFilename(), LastFile))
1797 break;
1798 }
1799 return;
1800 }
1801
1802 // .. otherwise insert new #line region.
1803 EmitRegionStart(Builder);
1804 LineDirectiveFiles.push_back(PCLoc.getFilename());
1805
1806 return;
1807 }
1808 /// EmitRegionStart- Constructs the debug code for entering a declarative
1809 /// region - "llvm.dbg.region.start.".
EmitRegionStart(CGBuilderTy & Builder)1810 void CGDebugInfo::EmitRegionStart(CGBuilderTy &Builder) {
1811 llvm::DIDescriptor D =
1812 DBuilder.createLexicalBlock(RegionStack.empty() ?
1813 llvm::DIDescriptor() :
1814 llvm::DIDescriptor(RegionStack.back()),
1815 getOrCreateFile(CurLoc),
1816 getLineNumber(CurLoc),
1817 getColumnNumber(CurLoc));
1818 llvm::MDNode *DN = D;
1819 RegionStack.push_back(DN);
1820 }
1821
1822 /// EmitRegionEnd - Constructs the debug code for exiting a declarative
1823 /// region - "llvm.dbg.region.end."
EmitRegionEnd(CGBuilderTy & Builder)1824 void CGDebugInfo::EmitRegionEnd(CGBuilderTy &Builder) {
1825 assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
1826
1827 // Provide an region stop point.
1828 EmitStopPoint(Builder);
1829
1830 RegionStack.pop_back();
1831 }
1832
1833 /// EmitFunctionEnd - Constructs the debug code for exiting a function.
EmitFunctionEnd(CGBuilderTy & Builder)1834 void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder) {
1835 assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
1836 unsigned RCount = FnBeginRegionCount.back();
1837 assert(RCount <= RegionStack.size() && "Region stack mismatch");
1838
1839 // Pop all regions for this function.
1840 while (RegionStack.size() != RCount)
1841 EmitRegionEnd(Builder);
1842 FnBeginRegionCount.pop_back();
1843 }
1844
1845 // EmitTypeForVarWithBlocksAttr - Build up structure info for the byref.
1846 // See BuildByRefType.
EmitTypeForVarWithBlocksAttr(const ValueDecl * VD,uint64_t * XOffset)1847 llvm::DIType CGDebugInfo::EmitTypeForVarWithBlocksAttr(const ValueDecl *VD,
1848 uint64_t *XOffset) {
1849
1850 llvm::SmallVector<llvm::Value *, 5> EltTys;
1851 QualType FType;
1852 uint64_t FieldSize, FieldOffset;
1853 unsigned FieldAlign;
1854
1855 llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
1856 QualType Type = VD->getType();
1857
1858 FieldOffset = 0;
1859 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
1860 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
1861 EltTys.push_back(CreateMemberType(Unit, FType, "__forwarding", &FieldOffset));
1862 FType = CGM.getContext().IntTy;
1863 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
1864 EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset));
1865
1866 bool HasCopyAndDispose = CGM.getContext().BlockRequiresCopying(Type);
1867 if (HasCopyAndDispose) {
1868 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
1869 EltTys.push_back(CreateMemberType(Unit, FType, "__copy_helper",
1870 &FieldOffset));
1871 EltTys.push_back(CreateMemberType(Unit, FType, "__destroy_helper",
1872 &FieldOffset));
1873 }
1874
1875 CharUnits Align = CGM.getContext().getDeclAlign(VD);
1876 if (Align > CGM.getContext().toCharUnitsFromBits(
1877 CGM.getContext().Target.getPointerAlign(0))) {
1878 CharUnits FieldOffsetInBytes
1879 = CGM.getContext().toCharUnitsFromBits(FieldOffset);
1880 CharUnits AlignedOffsetInBytes
1881 = FieldOffsetInBytes.RoundUpToAlignment(Align);
1882 CharUnits NumPaddingBytes
1883 = AlignedOffsetInBytes - FieldOffsetInBytes;
1884
1885 if (NumPaddingBytes.isPositive()) {
1886 llvm::APInt pad(32, NumPaddingBytes.getQuantity());
1887 FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy,
1888 pad, ArrayType::Normal, 0);
1889 EltTys.push_back(CreateMemberType(Unit, FType, "", &FieldOffset));
1890 }
1891 }
1892
1893 FType = Type;
1894 llvm::DIType FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
1895 FieldSize = CGM.getContext().getTypeSize(FType);
1896 FieldAlign = CGM.getContext().toBits(Align);
1897
1898 *XOffset = FieldOffset;
1899 FieldTy = DBuilder.createMemberType(Unit, VD->getName(), Unit,
1900 0, FieldSize, FieldAlign,
1901 FieldOffset, 0, FieldTy);
1902 EltTys.push_back(FieldTy);
1903 FieldOffset += FieldSize;
1904
1905 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys);
1906
1907 unsigned Flags = llvm::DIDescriptor::FlagBlockByrefStruct;
1908
1909 return DBuilder.createStructType(Unit, "", Unit, 0, FieldOffset, 0, Flags,
1910 Elements);
1911 }
1912
1913 /// EmitDeclare - Emit local variable declaration debug info.
EmitDeclare(const VarDecl * VD,unsigned Tag,llvm::Value * Storage,unsigned ArgNo,CGBuilderTy & Builder)1914 void CGDebugInfo::EmitDeclare(const VarDecl *VD, unsigned Tag,
1915 llvm::Value *Storage,
1916 unsigned ArgNo, CGBuilderTy &Builder) {
1917 assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
1918
1919 llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
1920 llvm::DIType Ty;
1921 uint64_t XOffset = 0;
1922 if (VD->hasAttr<BlocksAttr>())
1923 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
1924 else
1925 Ty = getOrCreateType(VD->getType(), Unit);
1926
1927 // If there is not any debug info for type then do not emit debug info
1928 // for this variable.
1929 if (!Ty)
1930 return;
1931
1932 if (llvm::Argument *Arg = dyn_cast<llvm::Argument>(Storage)) {
1933 // If Storage is an aggregate returned as 'sret' then let debugger know
1934 // about this.
1935 if (Arg->hasStructRetAttr())
1936 Ty = DBuilder.createReferenceType(Ty);
1937 else if (CXXRecordDecl *Record = VD->getType()->getAsCXXRecordDecl()) {
1938 // If an aggregate variable has non trivial destructor or non trivial copy
1939 // constructor than it is pass indirectly. Let debug info know about this
1940 // by using reference of the aggregate type as a argument type.
1941 if (!Record->hasTrivialCopyConstructor() || !Record->hasTrivialDestructor())
1942 Ty = DBuilder.createReferenceType(Ty);
1943 }
1944 }
1945
1946 // Get location information.
1947 unsigned Line = getLineNumber(VD->getLocation());
1948 unsigned Column = getColumnNumber(VD->getLocation());
1949 unsigned Flags = 0;
1950 if (VD->isImplicit())
1951 Flags |= llvm::DIDescriptor::FlagArtificial;
1952 llvm::MDNode *Scope = RegionStack.back();
1953
1954 llvm::StringRef Name = VD->getName();
1955 if (!Name.empty()) {
1956 if (VD->hasAttr<BlocksAttr>()) {
1957 CharUnits offset = CharUnits::fromQuantity(32);
1958 llvm::SmallVector<llvm::Value *, 9> addr;
1959 llvm::Type *Int64Ty = llvm::Type::getInt64Ty(CGM.getLLVMContext());
1960 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus));
1961 // offset of __forwarding field
1962 offset = CGM.getContext().toCharUnitsFromBits(
1963 CGM.getContext().Target.getPointerWidth(0));
1964 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
1965 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpDeref));
1966 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus));
1967 // offset of x field
1968 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
1969 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
1970
1971 // Create the descriptor for the variable.
1972 llvm::DIVariable D =
1973 DBuilder.createComplexVariable(Tag,
1974 llvm::DIDescriptor(RegionStack.back()),
1975 VD->getName(), Unit, Line, Ty,
1976 addr, ArgNo);
1977
1978 // Insert an llvm.dbg.declare into the current block.
1979 llvm::Instruction *Call =
1980 DBuilder.insertDeclare(Storage, D, Builder.GetInsertBlock());
1981
1982 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope));
1983 return;
1984 }
1985 // Create the descriptor for the variable.
1986 llvm::DIVariable D =
1987 DBuilder.createLocalVariable(Tag, llvm::DIDescriptor(Scope),
1988 Name, Unit, Line, Ty,
1989 CGM.getLangOptions().Optimize, Flags, ArgNo);
1990
1991 // Insert an llvm.dbg.declare into the current block.
1992 llvm::Instruction *Call =
1993 DBuilder.insertDeclare(Storage, D, Builder.GetInsertBlock());
1994
1995 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope));
1996 return;
1997 }
1998
1999 // If VD is an anonymous union then Storage represents value for
2000 // all union fields.
2001 if (const RecordType *RT = dyn_cast<RecordType>(VD->getType())) {
2002 const RecordDecl *RD = cast<RecordDecl>(RT->getDecl());
2003 if (RD->isUnion()) {
2004 for (RecordDecl::field_iterator I = RD->field_begin(),
2005 E = RD->field_end();
2006 I != E; ++I) {
2007 FieldDecl *Field = *I;
2008 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
2009 llvm::StringRef FieldName = Field->getName();
2010
2011 // Ignore unnamed fields. Do not ignore unnamed records.
2012 if (FieldName.empty() && !isa<RecordType>(Field->getType()))
2013 continue;
2014
2015 // Use VarDecl's Tag, Scope and Line number.
2016 llvm::DIVariable D =
2017 DBuilder.createLocalVariable(Tag, llvm::DIDescriptor(Scope),
2018 FieldName, Unit, Line, FieldTy,
2019 CGM.getLangOptions().Optimize, Flags,
2020 ArgNo);
2021
2022 // Insert an llvm.dbg.declare into the current block.
2023 llvm::Instruction *Call =
2024 DBuilder.insertDeclare(Storage, D, Builder.GetInsertBlock());
2025
2026 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope));
2027 }
2028 }
2029 }
2030 }
2031
EmitDeclareOfAutoVariable(const VarDecl * VD,llvm::Value * Storage,CGBuilderTy & Builder)2032 void CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD,
2033 llvm::Value *Storage,
2034 CGBuilderTy &Builder) {
2035 EmitDeclare(VD, llvm::dwarf::DW_TAG_auto_variable, Storage, 0, Builder);
2036 }
2037
EmitDeclareOfBlockDeclRefVariable(const VarDecl * VD,llvm::Value * Storage,CGBuilderTy & Builder,const CGBlockInfo & blockInfo)2038 void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
2039 const VarDecl *VD, llvm::Value *Storage, CGBuilderTy &Builder,
2040 const CGBlockInfo &blockInfo) {
2041 assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
2042
2043 if (Builder.GetInsertBlock() == 0)
2044 return;
2045
2046 bool isByRef = VD->hasAttr<BlocksAttr>();
2047
2048 uint64_t XOffset = 0;
2049 llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
2050 llvm::DIType Ty;
2051 if (isByRef)
2052 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
2053 else
2054 Ty = getOrCreateType(VD->getType(), Unit);
2055
2056 // Get location information.
2057 unsigned Line = getLineNumber(VD->getLocation());
2058 unsigned Column = getColumnNumber(VD->getLocation());
2059
2060 const llvm::TargetData &target = CGM.getTargetData();
2061
2062 CharUnits offset = CharUnits::fromQuantity(
2063 target.getStructLayout(blockInfo.StructureType)
2064 ->getElementOffset(blockInfo.getCapture(VD).getIndex()));
2065
2066 llvm::SmallVector<llvm::Value *, 9> addr;
2067 llvm::Type *Int64Ty = llvm::Type::getInt64Ty(CGM.getLLVMContext());
2068 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus));
2069 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
2070 if (isByRef) {
2071 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpDeref));
2072 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus));
2073 // offset of __forwarding field
2074 offset = CGM.getContext().toCharUnitsFromBits(target.getPointerSizeInBits());
2075 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
2076 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpDeref));
2077 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus));
2078 // offset of x field
2079 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
2080 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
2081 }
2082
2083 // Create the descriptor for the variable.
2084 llvm::DIVariable D =
2085 DBuilder.createComplexVariable(llvm::dwarf::DW_TAG_auto_variable,
2086 llvm::DIDescriptor(RegionStack.back()),
2087 VD->getName(), Unit, Line, Ty, addr);
2088 // Insert an llvm.dbg.declare into the current block.
2089 llvm::Instruction *Call =
2090 DBuilder.insertDeclare(Storage, D, Builder.GetInsertPoint());
2091
2092 llvm::MDNode *Scope = RegionStack.back();
2093 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope));
2094 }
2095
2096 /// EmitDeclareOfArgVariable - Emit call to llvm.dbg.declare for an argument
2097 /// variable declaration.
EmitDeclareOfArgVariable(const VarDecl * VD,llvm::Value * AI,unsigned ArgNo,CGBuilderTy & Builder)2098 void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI,
2099 unsigned ArgNo,
2100 CGBuilderTy &Builder) {
2101 EmitDeclare(VD, llvm::dwarf::DW_TAG_arg_variable, AI, ArgNo, Builder);
2102 }
2103
2104 namespace {
2105 struct BlockLayoutChunk {
2106 uint64_t OffsetInBits;
2107 const BlockDecl::Capture *Capture;
2108 };
operator <(const BlockLayoutChunk & l,const BlockLayoutChunk & r)2109 bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) {
2110 return l.OffsetInBits < r.OffsetInBits;
2111 }
2112 }
2113
EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo & block,llvm::Value * addr,CGBuilderTy & Builder)2114 void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
2115 llvm::Value *addr,
2116 CGBuilderTy &Builder) {
2117 ASTContext &C = CGM.getContext();
2118 const BlockDecl *blockDecl = block.getBlockDecl();
2119
2120 // Collect some general information about the block's location.
2121 SourceLocation loc = blockDecl->getCaretLocation();
2122 llvm::DIFile tunit = getOrCreateFile(loc);
2123 unsigned line = getLineNumber(loc);
2124 unsigned column = getColumnNumber(loc);
2125
2126 // Build the debug-info type for the block literal.
2127 getContextDescriptor(cast<Decl>(blockDecl->getDeclContext()));
2128
2129 const llvm::StructLayout *blockLayout =
2130 CGM.getTargetData().getStructLayout(block.StructureType);
2131
2132 llvm::SmallVector<llvm::Value*, 16> fields;
2133 fields.push_back(createFieldType("__isa", C.VoidPtrTy, 0, loc, AS_public,
2134 blockLayout->getElementOffsetInBits(0),
2135 tunit, tunit));
2136 fields.push_back(createFieldType("__flags", C.IntTy, 0, loc, AS_public,
2137 blockLayout->getElementOffsetInBits(1),
2138 tunit, tunit));
2139 fields.push_back(createFieldType("__reserved", C.IntTy, 0, loc, AS_public,
2140 blockLayout->getElementOffsetInBits(2),
2141 tunit, tunit));
2142 fields.push_back(createFieldType("__FuncPtr", C.VoidPtrTy, 0, loc, AS_public,
2143 blockLayout->getElementOffsetInBits(3),
2144 tunit, tunit));
2145 fields.push_back(createFieldType("__descriptor",
2146 C.getPointerType(block.NeedsCopyDispose ?
2147 C.getBlockDescriptorExtendedType() :
2148 C.getBlockDescriptorType()),
2149 0, loc, AS_public,
2150 blockLayout->getElementOffsetInBits(4),
2151 tunit, tunit));
2152
2153 // We want to sort the captures by offset, not because DWARF
2154 // requires this, but because we're paranoid about debuggers.
2155 llvm::SmallVector<BlockLayoutChunk, 8> chunks;
2156
2157 // 'this' capture.
2158 if (blockDecl->capturesCXXThis()) {
2159 BlockLayoutChunk chunk;
2160 chunk.OffsetInBits =
2161 blockLayout->getElementOffsetInBits(block.CXXThisIndex);
2162 chunk.Capture = 0;
2163 chunks.push_back(chunk);
2164 }
2165
2166 // Variable captures.
2167 for (BlockDecl::capture_const_iterator
2168 i = blockDecl->capture_begin(), e = blockDecl->capture_end();
2169 i != e; ++i) {
2170 const BlockDecl::Capture &capture = *i;
2171 const VarDecl *variable = capture.getVariable();
2172 const CGBlockInfo::Capture &captureInfo = block.getCapture(variable);
2173
2174 // Ignore constant captures.
2175 if (captureInfo.isConstant())
2176 continue;
2177
2178 BlockLayoutChunk chunk;
2179 chunk.OffsetInBits =
2180 blockLayout->getElementOffsetInBits(captureInfo.getIndex());
2181 chunk.Capture = &capture;
2182 chunks.push_back(chunk);
2183 }
2184
2185 // Sort by offset.
2186 llvm::array_pod_sort(chunks.begin(), chunks.end());
2187
2188 for (llvm::SmallVectorImpl<BlockLayoutChunk>::iterator
2189 i = chunks.begin(), e = chunks.end(); i != e; ++i) {
2190 uint64_t offsetInBits = i->OffsetInBits;
2191 const BlockDecl::Capture *capture = i->Capture;
2192
2193 // If we have a null capture, this must be the C++ 'this' capture.
2194 if (!capture) {
2195 const CXXMethodDecl *method =
2196 cast<CXXMethodDecl>(blockDecl->getNonClosureContext());
2197 QualType type = method->getThisType(C);
2198
2199 fields.push_back(createFieldType("this", type, 0, loc, AS_public,
2200 offsetInBits, tunit, tunit));
2201 continue;
2202 }
2203
2204 const VarDecl *variable = capture->getVariable();
2205 llvm::StringRef name = variable->getName();
2206
2207 llvm::DIType fieldType;
2208 if (capture->isByRef()) {
2209 std::pair<uint64_t,unsigned> ptrInfo = C.getTypeInfo(C.VoidPtrTy);
2210
2211 // FIXME: this creates a second copy of this type!
2212 uint64_t xoffset;
2213 fieldType = EmitTypeForVarWithBlocksAttr(variable, &xoffset);
2214 fieldType = DBuilder.createPointerType(fieldType, ptrInfo.first);
2215 fieldType = DBuilder.createMemberType(tunit, name, tunit, line,
2216 ptrInfo.first, ptrInfo.second,
2217 offsetInBits, 0, fieldType);
2218 } else {
2219 fieldType = createFieldType(name, variable->getType(), 0,
2220 loc, AS_public, offsetInBits, tunit, tunit);
2221 }
2222 fields.push_back(fieldType);
2223 }
2224
2225 llvm::SmallString<36> typeName;
2226 llvm::raw_svector_ostream(typeName)
2227 << "__block_literal_" << CGM.getUniqueBlockCount();
2228
2229 llvm::DIArray fieldsArray = DBuilder.getOrCreateArray(fields);
2230
2231 llvm::DIType type =
2232 DBuilder.createStructType(tunit, typeName.str(), tunit, line,
2233 CGM.getContext().toBits(block.BlockSize),
2234 CGM.getContext().toBits(block.BlockAlign),
2235 0, fieldsArray);
2236 type = DBuilder.createPointerType(type, CGM.PointerWidthInBits);
2237
2238 // Get overall information about the block.
2239 unsigned flags = llvm::DIDescriptor::FlagArtificial;
2240 llvm::MDNode *scope = RegionStack.back();
2241 llvm::StringRef name = ".block_descriptor";
2242
2243 // Create the descriptor for the parameter.
2244 llvm::DIVariable debugVar =
2245 DBuilder.createLocalVariable(llvm::dwarf::DW_TAG_arg_variable,
2246 llvm::DIDescriptor(scope),
2247 name, tunit, line, type,
2248 CGM.getLangOptions().Optimize, flags,
2249 cast<llvm::Argument>(addr)->getArgNo() + 1);
2250
2251 // Insert an llvm.dbg.value into the current block.
2252 llvm::Instruction *declare =
2253 DBuilder.insertDbgValueIntrinsic(addr, 0, debugVar,
2254 Builder.GetInsertBlock());
2255 declare->setDebugLoc(llvm::DebugLoc::get(line, column, scope));
2256 }
2257
2258 /// EmitGlobalVariable - Emit information about a global variable.
EmitGlobalVariable(llvm::GlobalVariable * Var,const VarDecl * D)2259 void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
2260 const VarDecl *D) {
2261
2262 // Create global variable debug descriptor.
2263 llvm::DIFile Unit = getOrCreateFile(D->getLocation());
2264 unsigned LineNo = getLineNumber(D->getLocation());
2265
2266 QualType T = D->getType();
2267 if (T->isIncompleteArrayType()) {
2268
2269 // CodeGen turns int[] into int[1] so we'll do the same here.
2270 llvm::APSInt ConstVal(32);
2271
2272 ConstVal = 1;
2273 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
2274
2275 T = CGM.getContext().getConstantArrayType(ET, ConstVal,
2276 ArrayType::Normal, 0);
2277 }
2278 llvm::StringRef DeclName = D->getName();
2279 llvm::StringRef LinkageName;
2280 if (D->getDeclContext() && !isa<FunctionDecl>(D->getDeclContext())
2281 && !isa<ObjCMethodDecl>(D->getDeclContext()))
2282 LinkageName = Var->getName();
2283 if (LinkageName == DeclName)
2284 LinkageName = llvm::StringRef();
2285 llvm::DIDescriptor DContext =
2286 getContextDescriptor(dyn_cast<Decl>(D->getDeclContext()));
2287 DBuilder.createStaticVariable(DContext, DeclName, LinkageName,
2288 Unit, LineNo, getOrCreateType(T, Unit),
2289 Var->hasInternalLinkage(), Var);
2290 }
2291
2292 /// EmitGlobalVariable - Emit information about an objective-c interface.
EmitGlobalVariable(llvm::GlobalVariable * Var,ObjCInterfaceDecl * ID)2293 void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
2294 ObjCInterfaceDecl *ID) {
2295 // Create global variable debug descriptor.
2296 llvm::DIFile Unit = getOrCreateFile(ID->getLocation());
2297 unsigned LineNo = getLineNumber(ID->getLocation());
2298
2299 llvm::StringRef Name = ID->getName();
2300
2301 QualType T = CGM.getContext().getObjCInterfaceType(ID);
2302 if (T->isIncompleteArrayType()) {
2303
2304 // CodeGen turns int[] into int[1] so we'll do the same here.
2305 llvm::APSInt ConstVal(32);
2306
2307 ConstVal = 1;
2308 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
2309
2310 T = CGM.getContext().getConstantArrayType(ET, ConstVal,
2311 ArrayType::Normal, 0);
2312 }
2313
2314 DBuilder.createGlobalVariable(Name, Unit, LineNo,
2315 getOrCreateType(T, Unit),
2316 Var->hasInternalLinkage(), Var);
2317 }
2318
2319 /// EmitGlobalVariable - Emit global variable's debug info.
EmitGlobalVariable(const ValueDecl * VD,llvm::Constant * Init)2320 void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD,
2321 llvm::Constant *Init) {
2322 // Create the descriptor for the variable.
2323 llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
2324 llvm::StringRef Name = VD->getName();
2325 llvm::DIType Ty = getOrCreateType(VD->getType(), Unit);
2326 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(VD)) {
2327 if (const EnumDecl *ED = dyn_cast<EnumDecl>(ECD->getDeclContext()))
2328 Ty = CreateEnumType(ED);
2329 }
2330 // Do not use DIGlobalVariable for enums.
2331 if (Ty.getTag() == llvm::dwarf::DW_TAG_enumeration_type)
2332 return;
2333 DBuilder.createStaticVariable(Unit, Name, Name, Unit,
2334 getLineNumber(VD->getLocation()),
2335 Ty, true, Init);
2336 }
2337
2338 /// getOrCreateNamesSpace - Return namespace descriptor for the given
2339 /// namespace decl.
2340 llvm::DINameSpace
getOrCreateNameSpace(const NamespaceDecl * NSDecl)2341 CGDebugInfo::getOrCreateNameSpace(const NamespaceDecl *NSDecl) {
2342 llvm::DenseMap<const NamespaceDecl *, llvm::WeakVH>::iterator I =
2343 NameSpaceCache.find(NSDecl);
2344 if (I != NameSpaceCache.end())
2345 return llvm::DINameSpace(cast<llvm::MDNode>(I->second));
2346
2347 unsigned LineNo = getLineNumber(NSDecl->getLocation());
2348 llvm::DIFile FileD = getOrCreateFile(NSDecl->getLocation());
2349 llvm::DIDescriptor Context =
2350 getContextDescriptor(dyn_cast<Decl>(NSDecl->getDeclContext()));
2351 llvm::DINameSpace NS =
2352 DBuilder.createNameSpace(Context, NSDecl->getName(), FileD, LineNo);
2353 NameSpaceCache[NSDecl] = llvm::WeakVH(NS);
2354 return NS;
2355 }
2356
2357 /// UpdateCompletedType - Update type cache because the type is now
2358 /// translated.
UpdateCompletedType(const TagDecl * TD)2359 void CGDebugInfo::UpdateCompletedType(const TagDecl *TD) {
2360 QualType Ty = CGM.getContext().getTagDeclType(TD);
2361
2362 // If the type exist in type cache then remove it from the cache.
2363 // There is no need to prepare debug info for the completed type
2364 // right now. It will be generated on demand lazily.
2365 llvm::DenseMap<void *, llvm::WeakVH>::iterator it =
2366 TypeCache.find(Ty.getAsOpaquePtr());
2367 if (it != TypeCache.end())
2368 TypeCache.erase(it);
2369 }
2370