blob: 2b03d2c603cc84d908ede84a05d1204dae2907f1 [file] [log] [blame]
Sanjiv Gupta15cb6692008-05-08 08:54:20 +00001//===--- 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"
Mike Stump2e722b92009-09-30 02:43:10 +000015#include "CodeGenFunction.h"
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000016#include "CodeGenModule.h"
Sanjiv Gupta98070572008-05-25 05:15:42 +000017#include "clang/AST/ASTContext.h"
Devang Patelf4c205b2009-02-26 21:10:26 +000018#include "clang/AST/DeclObjC.h"
Chris Lattnercd2523b2008-11-11 07:01:36 +000019#include "clang/AST/Expr.h"
Anders Carlsson15b73de2009-07-18 19:43:29 +000020#include "clang/AST/RecordLayout.h"
Sanjiv Gupta98070572008-05-25 05:15:42 +000021#include "clang/Basic/SourceManager.h"
22#include "clang/Basic/FileManager.h"
Mike Stumpc3844be2009-09-15 21:48:34 +000023#include "clang/Basic/Version.h"
Chandler Carruthbc55fe22009-11-12 17:24:48 +000024#include "clang/CodeGen/CodeGenOptions.h"
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000025#include "llvm/Constants.h"
26#include "llvm/DerivedTypes.h"
27#include "llvm/Instructions.h"
28#include "llvm/Intrinsics.h"
29#include "llvm/Module.h"
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000030#include "llvm/ADT/StringExtras.h"
31#include "llvm/ADT/SmallVector.h"
Sanjiv Gupta98070572008-05-25 05:15:42 +000032#include "llvm/Support/Dwarf.h"
Devang Patel75009452009-04-17 21:06:59 +000033#include "llvm/System/Path.h"
Sanjiv Gupta98070572008-05-25 05:15:42 +000034#include "llvm/Target/TargetMachine.h"
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000035using namespace clang;
36using namespace clang::CodeGen;
37
Anders Carlsson3efc6e62009-12-06 18:00:51 +000038CGDebugInfo::CGDebugInfo(CodeGenModule &CGM)
39 : CGM(CGM), isMainCompileUnitCreated(false), DebugFactory(CGM.getModule()),
Mike Stump31f099c2009-05-14 02:03:51 +000040 BlockLiteralGenericSet(false) {
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000041}
42
Chris Lattneraffb3732008-11-10 06:08:34 +000043CGDebugInfo::~CGDebugInfo() {
Daniel Dunbarb9fd9022008-10-17 16:15:48 +000044 assert(RegionStack.empty() && "Region stack mismatch, stack not empty!");
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000045}
46
Chris Lattneraffb3732008-11-10 06:08:34 +000047void CGDebugInfo::setLocation(SourceLocation Loc) {
48 if (Loc.isValid())
Anders Carlsson3efc6e62009-12-06 18:00:51 +000049 CurLoc = CGM.getContext().getSourceManager().getInstantiationLoc(Loc);
Sanjiv Gupta98070572008-05-25 05:15:42 +000050}
51
Devang Patelfaf7e9a2009-10-06 00:35:31 +000052/// getContext - Get context info for the decl.
53llvm::DIDescriptor CGDebugInfo::getContext(const VarDecl *Decl,
54 llvm::DIDescriptor &CompileUnit) {
55 if (Decl->isFileVarDecl())
56 return CompileUnit;
57 if (Decl->getDeclContext()->isFunctionOrMethod()) {
58 // Find the last subprogram in region stack.
59 for (unsigned RI = RegionStack.size(), RE = 0; RI != RE; --RI) {
Devang Patelb40f2952009-11-13 19:10:24 +000060 llvm::DIDescriptor R(RegionStack[RI - 1]);
Devang Patelfaf7e9a2009-10-06 00:35:31 +000061 if (R.isSubprogram())
62 return R;
63 }
64 }
65 return CompileUnit;
66}
67
Devang Patel934661e2010-01-14 00:36:21 +000068/// getFunctionName - Get function name for the given FunctionDecl. If the
69/// name is constructred on demand (e.g. C++ destructor) then the name
70/// is stored on the side.
71llvm::StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) {
72 assert (FD && "Invalid FunctionDecl!");
73 IdentifierInfo *FII = FD->getIdentifier();
74 if (FII)
75 return FII->getName();
76
77 // Otherwise construct human readable name for debug info.
78 std::string NS = FD->getNameAsString();
79
80 // Copy this name on the side and use its reference.
Benjamin Kramer8f8f4052010-01-23 18:16:07 +000081 char *StrPtr = FunctionNames.Allocate<char>(NS.length());
82 memcpy(StrPtr, NS.data(), NS.length());
83 return llvm::StringRef(StrPtr, NS.length());
Devang Patel934661e2010-01-14 00:36:21 +000084}
85
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000086/// getOrCreateCompileUnit - Get the compile unit from the cache or create a new
Daniel Dunbardec8a892008-10-24 08:38:36 +000087/// one if necessary. This returns null for invalid source locations.
Chris Lattneraffb3732008-11-10 06:08:34 +000088llvm::DICompileUnit CGDebugInfo::getOrCreateCompileUnit(SourceLocation Loc) {
Devang Patel75009452009-04-17 21:06:59 +000089 // Get source file information.
90 const char *FileName = "<unknown>";
Anders Carlsson3efc6e62009-12-06 18:00:51 +000091 SourceManager &SM = CGM.getContext().getSourceManager();
Chris Lattner96adcd52009-04-19 06:50:29 +000092 unsigned FID = 0;
Daniel Dunbar56493b02009-01-22 00:09:25 +000093 if (Loc.isValid()) {
Devang Patel75009452009-04-17 21:06:59 +000094 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
95 FileName = PLoc.getFilename();
96 FID = PLoc.getIncludeLoc().getRawEncoding();
Daniel Dunbar56493b02009-01-22 00:09:25 +000097 }
Mike Stump11289f42009-09-09 15:08:12 +000098
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000099 // See if this compile unit has been used before.
Devang Patel75009452009-04-17 21:06:59 +0000100 llvm::DICompileUnit &Unit = CompileUnitCache[FID];
Chris Lattneraffb3732008-11-10 06:08:34 +0000101 if (!Unit.isNull()) return Unit;
Daniel Dunbar3b358a32009-04-08 05:11:16 +0000102
Devang Patel75009452009-04-17 21:06:59 +0000103 // Get absolute path name.
104 llvm::sys::Path AbsFileName(FileName);
Benjamin Kramer1d205642009-12-08 11:02:29 +0000105 AbsFileName.makeAbsolute();
Devang Patel75009452009-04-17 21:06:59 +0000106
Devang Patel0d425352009-06-26 18:32:22 +0000107 // See if thie compile unit is representing main source file. Each source
108 // file has corresponding compile unit. There is only one main source
109 // file at a time.
110 bool isMain = false;
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000111 const LangOptions &LO = CGM.getLangOptions();
112 const CodeGenOptions &CGO = CGM.getCodeGenOpts();
Devang Patel0d425352009-06-26 18:32:22 +0000113 if (isMainCompileUnitCreated == false) {
Daniel Dunbar9eac0652009-11-29 02:38:34 +0000114 if (!CGO.MainFileName.empty()) {
115 if (AbsFileName.getLast() == CGO.MainFileName)
Devang Patel0d425352009-06-26 18:32:22 +0000116 isMain = true;
117 } else {
118 if (Loc.isValid() && SM.isFromMainFile(Loc))
119 isMain = true;
120 }
121 if (isMain)
122 isMainCompileUnitCreated = true;
Devang Patel75009452009-04-17 21:06:59 +0000123 }
Daniel Dunbar3b358a32009-04-08 05:11:16 +0000124
Chris Lattner8c37df42009-03-25 03:28:08 +0000125 unsigned LangTag;
126 if (LO.CPlusPlus) {
127 if (LO.ObjC1)
128 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
129 else
130 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
131 } else if (LO.ObjC1) {
Devang Patel94406c92009-03-24 20:35:51 +0000132 LangTag = llvm::dwarf::DW_LANG_ObjC;
Chris Lattner8c37df42009-03-25 03:28:08 +0000133 } else if (LO.C99) {
Devang Patel94406c92009-03-24 20:35:51 +0000134 LangTag = llvm::dwarf::DW_LANG_C99;
Chris Lattner8c37df42009-03-25 03:28:08 +0000135 } else {
136 LangTag = llvm::dwarf::DW_LANG_C89;
137 }
Devang Patel75009452009-04-17 21:06:59 +0000138
Benjamin Kramer1d205642009-12-08 11:02:29 +0000139 const char *Producer =
Mike Stumpfc8ff632009-10-09 18:38:12 +0000140#ifdef CLANG_VENDOR
141 CLANG_VENDOR
142#endif
143 "clang " CLANG_VERSION_STRING;
Chris Lattner5912de12009-05-02 01:00:04 +0000144
145 // Figure out which version of the ObjC runtime we have.
146 unsigned RuntimeVers = 0;
147 if (LO.ObjC1)
148 RuntimeVers = LO.ObjCNonFragileABI ? 2 : 1;
Mike Stump11289f42009-09-09 15:08:12 +0000149
Sanjiv Gupta15cb6692008-05-08 08:54:20 +0000150 // Create new compile unit.
Daniel Dunbar24c7f5e2009-12-18 02:43:17 +0000151 return Unit = DebugFactory.CreateCompileUnit(
152 LangTag, AbsFileName.getLast(), AbsFileName.getDirname(), Producer, isMain,
153 LO.Optimize, CGM.getCodeGenOpts().DwarfDebugFlags, RuntimeVers);
Sanjiv Gupta15cb6692008-05-08 08:54:20 +0000154}
155
Devang Patel410dc002009-02-25 01:36:11 +0000156/// CreateType - Get the Basic type from the cache or create a new
Chris Lattneraffb3732008-11-10 06:08:34 +0000157/// one if necessary.
158llvm::DIType CGDebugInfo::CreateType(const BuiltinType *BT,
Devang Patel410dc002009-02-25 01:36:11 +0000159 llvm::DICompileUnit Unit) {
Chris Lattneraffb3732008-11-10 06:08:34 +0000160 unsigned Encoding = 0;
161 switch (BT->getKind()) {
162 default:
163 case BuiltinType::Void:
164 return llvm::DIType();
165 case BuiltinType::UChar:
166 case BuiltinType::Char_U: Encoding = llvm::dwarf::DW_ATE_unsigned_char; break;
167 case BuiltinType::Char_S:
168 case BuiltinType::SChar: Encoding = llvm::dwarf::DW_ATE_signed_char; break;
169 case BuiltinType::UShort:
170 case BuiltinType::UInt:
171 case BuiltinType::ULong:
172 case BuiltinType::ULongLong: Encoding = llvm::dwarf::DW_ATE_unsigned; break;
173 case BuiltinType::Short:
174 case BuiltinType::Int:
175 case BuiltinType::Long:
176 case BuiltinType::LongLong: Encoding = llvm::dwarf::DW_ATE_signed; break;
177 case BuiltinType::Bool: Encoding = llvm::dwarf::DW_ATE_boolean; break;
178 case BuiltinType::Float:
Devang Patel551e1122009-10-12 22:28:31 +0000179 case BuiltinType::LongDouble:
Chris Lattneraffb3732008-11-10 06:08:34 +0000180 case BuiltinType::Double: Encoding = llvm::dwarf::DW_ATE_float; break;
Mike Stump11289f42009-09-09 15:08:12 +0000181 }
Chris Lattneraffb3732008-11-10 06:08:34 +0000182 // Bit size, align and offset of the type.
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000183 uint64_t Size = CGM.getContext().getTypeSize(BT);
184 uint64_t Align = CGM.getContext().getTypeAlign(BT);
Chris Lattneraffb3732008-11-10 06:08:34 +0000185 uint64_t Offset = 0;
Mike Stump11289f42009-09-09 15:08:12 +0000186
Devang Patele21912d2009-10-20 19:55:01 +0000187 llvm::DIType DbgTy =
188 DebugFactory.CreateBasicType(Unit,
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000189 BT->getName(CGM.getContext().getLangOptions()),
Devang Patele21912d2009-10-20 19:55:01 +0000190 Unit, 0, Size, Align,
191 Offset, /*flags*/ 0, Encoding);
Devang Patele21912d2009-10-20 19:55:01 +0000192 return DbgTy;
Chris Lattneraffb3732008-11-10 06:08:34 +0000193}
Sanjiv Gupta15cb6692008-05-08 08:54:20 +0000194
Chris Lattner7b0344f2009-04-23 06:13:01 +0000195llvm::DIType CGDebugInfo::CreateType(const ComplexType *Ty,
196 llvm::DICompileUnit Unit) {
197 // Bit size, align and offset of the type.
198 unsigned Encoding = llvm::dwarf::DW_ATE_complex_float;
199 if (Ty->isComplexIntegerType())
200 Encoding = llvm::dwarf::DW_ATE_lo_user;
Mike Stump11289f42009-09-09 15:08:12 +0000201
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000202 uint64_t Size = CGM.getContext().getTypeSize(Ty);
203 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
Chris Lattner7b0344f2009-04-23 06:13:01 +0000204 uint64_t Offset = 0;
Mike Stump11289f42009-09-09 15:08:12 +0000205
Devang Patele21912d2009-10-20 19:55:01 +0000206 llvm::DIType DbgTy =
207 DebugFactory.CreateBasicType(Unit, "complex",
208 Unit, 0, Size, Align,
209 Offset, /*flags*/ 0, Encoding);
Devang Patele21912d2009-10-20 19:55:01 +0000210 return DbgTy;
Chris Lattner7b0344f2009-04-23 06:13:01 +0000211}
212
John McCall0cf15512009-09-25 01:40:47 +0000213/// CreateCVRType - Get the qualified type from the cache or create
Sanjiv Gupta19292422008-06-07 04:46:53 +0000214/// a new one if necessary.
John McCall0cf15512009-09-25 01:40:47 +0000215llvm::DIType CGDebugInfo::CreateQualifiedType(QualType Ty, llvm::DICompileUnit Unit) {
216 QualifierCollector Qc;
217 const Type *T = Qc.strip(Ty);
218
219 // Ignore these qualifiers for now.
220 Qc.removeObjCGCAttr();
221 Qc.removeAddressSpace();
222
Chris Lattneraffb3732008-11-10 06:08:34 +0000223 // We will create one Derived type for one qualifier and recurse to handle any
224 // additional ones.
Chris Lattneraffb3732008-11-10 06:08:34 +0000225 unsigned Tag;
John McCall0cf15512009-09-25 01:40:47 +0000226 if (Qc.hasConst()) {
Chris Lattneraffb3732008-11-10 06:08:34 +0000227 Tag = llvm::dwarf::DW_TAG_const_type;
John McCall0cf15512009-09-25 01:40:47 +0000228 Qc.removeConst();
229 } else if (Qc.hasVolatile()) {
Chris Lattneraffb3732008-11-10 06:08:34 +0000230 Tag = llvm::dwarf::DW_TAG_volatile_type;
John McCall0cf15512009-09-25 01:40:47 +0000231 Qc.removeVolatile();
232 } else if (Qc.hasRestrict()) {
Chris Lattneraffb3732008-11-10 06:08:34 +0000233 Tag = llvm::dwarf::DW_TAG_restrict_type;
John McCall0cf15512009-09-25 01:40:47 +0000234 Qc.removeRestrict();
235 } else {
236 assert(Qc.empty() && "Unknown type qualifier for debug info");
237 return getOrCreateType(QualType(T, 0), Unit);
Sanjiv Gupta98070572008-05-25 05:15:42 +0000238 }
Mike Stump11289f42009-09-09 15:08:12 +0000239
John McCall0cf15512009-09-25 01:40:47 +0000240 llvm::DIType FromTy = getOrCreateType(Qc.apply(T), Unit);
241
Daniel Dunbara290ded2008-10-31 03:54:29 +0000242 // No need to fill in the Name, Line, Size, Alignment, Offset in case of
243 // CVR derived types.
Devang Patele21912d2009-10-20 19:55:01 +0000244 llvm::DIType DbgTy =
245 DebugFactory.CreateDerivedType(Tag, Unit, "", llvm::DICompileUnit(),
246 0, 0, 0, 0, 0, FromTy);
Devang Patele21912d2009-10-20 19:55:01 +0000247 return DbgTy;
Sanjiv Gupta98070572008-05-25 05:15:42 +0000248}
249
Daniel Dunbarf5c79702009-07-14 01:20:56 +0000250llvm::DIType CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty,
251 llvm::DICompileUnit Unit) {
Devang Patele21912d2009-10-20 19:55:01 +0000252 llvm::DIType DbgTy =
Anders Carlsson443f6772009-11-06 19:19:55 +0000253 CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
254 Ty->getPointeeType(), Unit);
Devang Patele21912d2009-10-20 19:55:01 +0000255 return DbgTy;
Daniel Dunbarf5c79702009-07-14 01:20:56 +0000256}
257
Chris Lattneraffb3732008-11-10 06:08:34 +0000258llvm::DIType CGDebugInfo::CreateType(const PointerType *Ty,
259 llvm::DICompileUnit Unit) {
Anders Carlsson443f6772009-11-06 19:19:55 +0000260 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
261 Ty->getPointeeType(), Unit);
262}
263
264llvm::DIType CGDebugInfo::CreatePointerLikeType(unsigned Tag,
265 const Type *Ty,
266 QualType PointeeTy,
267 llvm::DICompileUnit Unit) {
268 llvm::DIType EltTy = getOrCreateType(PointeeTy, Unit);
Mike Stump11289f42009-09-09 15:08:12 +0000269
Sanjiv Gupta98070572008-05-25 05:15:42 +0000270 // Bit size, align and offset of the type.
Anders Carlsson443f6772009-11-06 19:19:55 +0000271
272 // Size is always the size of a pointer. We can't use getTypeSize here
273 // because that does not return the correct value for references.
274 uint64_t Size =
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000275 CGM.getContext().Target.getPointerWidth(PointeeTy.getAddressSpace());
276 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
Mike Stump11289f42009-09-09 15:08:12 +0000277
Devang Patele21912d2009-10-20 19:55:01 +0000278 return
Anders Carlsson443f6772009-11-06 19:19:55 +0000279 DebugFactory.CreateDerivedType(Tag, Unit, "", llvm::DICompileUnit(),
Devang Patele21912d2009-10-20 19:55:01 +0000280 0, Size, Align, 0, 0, EltTy);
Anders Carlsson443f6772009-11-06 19:19:55 +0000281
Sanjiv Gupta98070572008-05-25 05:15:42 +0000282}
283
Mike Stump31f099c2009-05-14 02:03:51 +0000284llvm::DIType CGDebugInfo::CreateType(const BlockPointerType *Ty,
285 llvm::DICompileUnit Unit) {
286 if (BlockLiteralGenericSet)
287 return BlockLiteralGeneric;
288
289 llvm::DICompileUnit DefUnit;
290 unsigned Tag = llvm::dwarf::DW_TAG_structure_type;
291
292 llvm::SmallVector<llvm::DIDescriptor, 5> EltTys;
293
294 llvm::DIType FieldTy;
295
296 QualType FType;
297 uint64_t FieldSize, FieldOffset;
298 unsigned FieldAlign;
299
300 llvm::DIArray Elements;
301 llvm::DIType EltTy, DescTy;
302
303 FieldOffset = 0;
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000304 FType = CGM.getContext().UnsignedLongTy;
Mike Stump31f099c2009-05-14 02:03:51 +0000305 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000306 FieldSize = CGM.getContext().getTypeSize(FType);
307 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump31f099c2009-05-14 02:03:51 +0000308 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
309 "reserved", DefUnit,
310 0, FieldSize, FieldAlign,
311 FieldOffset, 0, FieldTy);
312 EltTys.push_back(FieldTy);
313
314 FieldOffset += FieldSize;
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000315 FType = CGM.getContext().UnsignedLongTy;
Mike Stump31f099c2009-05-14 02:03:51 +0000316 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000317 FieldSize = CGM.getContext().getTypeSize(FType);
318 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump31f099c2009-05-14 02:03:51 +0000319 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
320 "Size", DefUnit,
321 0, FieldSize, FieldAlign,
322 FieldOffset, 0, FieldTy);
323 EltTys.push_back(FieldTy);
324
325 FieldOffset += FieldSize;
Daniel Dunbarbee70bd2009-05-26 19:40:20 +0000326 Elements = DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
Mike Stump31f099c2009-05-14 02:03:51 +0000327 EltTys.clear();
328
Mike Stump581b9ad2009-10-02 02:30:50 +0000329 unsigned Flags = llvm::DIType::FlagAppleBlock;
330
Mike Stump31f099c2009-05-14 02:03:51 +0000331 EltTy = DebugFactory.CreateCompositeType(Tag, Unit, "__block_descriptor",
Mike Stump581b9ad2009-10-02 02:30:50 +0000332 DefUnit, 0, FieldOffset, 0, 0, Flags,
Mike Stump31f099c2009-05-14 02:03:51 +0000333 llvm::DIType(), Elements);
Mike Stump11289f42009-09-09 15:08:12 +0000334
Mike Stump31f099c2009-05-14 02:03:51 +0000335 // Bit size, align and offset of the type.
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000336 uint64_t Size = CGM.getContext().getTypeSize(Ty);
337 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
Mike Stump11289f42009-09-09 15:08:12 +0000338
Mike Stump31f099c2009-05-14 02:03:51 +0000339 DescTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_pointer_type,
340 Unit, "", llvm::DICompileUnit(),
341 0, Size, Align, 0, 0, EltTy);
342
343 FieldOffset = 0;
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000344 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Mike Stump31f099c2009-05-14 02:03:51 +0000345 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000346 FieldSize = CGM.getContext().getTypeSize(FType);
347 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump31f099c2009-05-14 02:03:51 +0000348 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
349 "__isa", DefUnit,
350 0, FieldSize, FieldAlign,
351 FieldOffset, 0, FieldTy);
352 EltTys.push_back(FieldTy);
353
354 FieldOffset += FieldSize;
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000355 FType = CGM.getContext().IntTy;
Mike Stump31f099c2009-05-14 02:03:51 +0000356 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000357 FieldSize = CGM.getContext().getTypeSize(FType);
358 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump31f099c2009-05-14 02:03:51 +0000359 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
360 "__flags", DefUnit,
361 0, FieldSize, FieldAlign,
362 FieldOffset, 0, FieldTy);
363 EltTys.push_back(FieldTy);
364
365 FieldOffset += FieldSize;
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000366 FType = CGM.getContext().IntTy;
Mike Stump31f099c2009-05-14 02:03:51 +0000367 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000368 FieldSize = CGM.getContext().getTypeSize(FType);
369 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump31f099c2009-05-14 02:03:51 +0000370 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
371 "__reserved", DefUnit,
372 0, FieldSize, FieldAlign,
373 FieldOffset, 0, FieldTy);
374 EltTys.push_back(FieldTy);
375
376 FieldOffset += FieldSize;
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000377 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Mike Stump31f099c2009-05-14 02:03:51 +0000378 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000379 FieldSize = CGM.getContext().getTypeSize(FType);
380 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump31f099c2009-05-14 02:03:51 +0000381 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
382 "__FuncPtr", DefUnit,
383 0, FieldSize, FieldAlign,
384 FieldOffset, 0, FieldTy);
385 EltTys.push_back(FieldTy);
386
387 FieldOffset += FieldSize;
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000388 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Mike Stump31f099c2009-05-14 02:03:51 +0000389 FieldTy = DescTy;
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000390 FieldSize = CGM.getContext().getTypeSize(Ty);
391 FieldAlign = CGM.getContext().getTypeAlign(Ty);
Mike Stump31f099c2009-05-14 02:03:51 +0000392 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
393 "__descriptor", DefUnit,
394 0, FieldSize, FieldAlign,
395 FieldOffset, 0, FieldTy);
396 EltTys.push_back(FieldTy);
397
398 FieldOffset += FieldSize;
Daniel Dunbarbee70bd2009-05-26 19:40:20 +0000399 Elements = DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
Mike Stump31f099c2009-05-14 02:03:51 +0000400
401 EltTy = DebugFactory.CreateCompositeType(Tag, Unit, "__block_literal_generic",
Mike Stump440af3d2009-10-02 02:23:37 +0000402 DefUnit, 0, FieldOffset, 0, 0, Flags,
Mike Stump31f099c2009-05-14 02:03:51 +0000403 llvm::DIType(), Elements);
Mike Stump11289f42009-09-09 15:08:12 +0000404
Mike Stump31f099c2009-05-14 02:03:51 +0000405 BlockLiteralGenericSet = true;
406 BlockLiteralGeneric
407 = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_pointer_type, Unit,
408 "", llvm::DICompileUnit(),
409 0, Size, Align, 0, 0, EltTy);
410 return BlockLiteralGeneric;
411}
412
Chris Lattneraffb3732008-11-10 06:08:34 +0000413llvm::DIType CGDebugInfo::CreateType(const TypedefType *Ty,
414 llvm::DICompileUnit Unit) {
415 // Typedefs are derived from some other type. If we have a typedef of a
416 // typedef, make sure to emit the whole chain.
417 llvm::DIType Src = getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit);
Mike Stump11289f42009-09-09 15:08:12 +0000418
Chris Lattneraffb3732008-11-10 06:08:34 +0000419 // We don't set size information, but do specify where the typedef was
420 // declared.
Chris Lattneraffb3732008-11-10 06:08:34 +0000421 SourceLocation DefLoc = Ty->getDecl()->getLocation();
422 llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(DefLoc);
Sanjiv Gupta98070572008-05-25 05:15:42 +0000423
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000424 SourceManager &SM = CGM.getContext().getSourceManager();
Devang Patel12f0dea2009-04-17 21:35:15 +0000425 PresumedLoc PLoc = SM.getPresumedLoc(DefLoc);
426 unsigned Line = PLoc.isInvalid() ? 0 : PLoc.getLine();
Sanjiv Gupta98070572008-05-25 05:15:42 +0000427
Devang Patele21912d2009-10-20 19:55:01 +0000428 llvm::DIType DbgTy =
429 DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_typedef, Unit,
Devang Patel58bf6e12009-11-25 17:37:31 +0000430 Ty->getDecl()->getName(),
Devang Patel7bdf0962009-11-12 00:51:46 +0000431 DefUnit, Line, 0, 0, 0, 0, Src);
Devang Patele21912d2009-10-20 19:55:01 +0000432 return DbgTy;
Sanjiv Gupta98070572008-05-25 05:15:42 +0000433}
434
Chris Lattneraffb3732008-11-10 06:08:34 +0000435llvm::DIType CGDebugInfo::CreateType(const FunctionType *Ty,
436 llvm::DICompileUnit Unit) {
437 llvm::SmallVector<llvm::DIDescriptor, 16> EltTys;
Sanjiv Gupta98070572008-05-25 05:15:42 +0000438
Chris Lattneraffb3732008-11-10 06:08:34 +0000439 // Add the result type at least.
440 EltTys.push_back(getOrCreateType(Ty->getResultType(), Unit));
Mike Stump11289f42009-09-09 15:08:12 +0000441
Chris Lattneraffb3732008-11-10 06:08:34 +0000442 // Set up remainder of arguments if there is a prototype.
443 // FIXME: IF NOT, HOW IS THIS REPRESENTED? llvm-gcc doesn't represent '...'!
Douglas Gregordeaad8c2009-02-26 23:50:07 +0000444 if (const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(Ty)) {
Chris Lattneraffb3732008-11-10 06:08:34 +0000445 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
446 EltTys.push_back(getOrCreateType(FTP->getArgType(i), Unit));
447 } else {
448 // FIXME: Handle () case in C. llvm-gcc doesn't do it either.
Sanjiv Gupta98070572008-05-25 05:15:42 +0000449 }
450
Chris Lattneraffb3732008-11-10 06:08:34 +0000451 llvm::DIArray EltTypeArray =
Daniel Dunbarbee70bd2009-05-26 19:40:20 +0000452 DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
Mike Stump11289f42009-09-09 15:08:12 +0000453
Devang Patele21912d2009-10-20 19:55:01 +0000454 llvm::DIType DbgTy =
455 DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_subroutine_type,
456 Unit, "", llvm::DICompileUnit(),
457 0, 0, 0, 0, 0,
458 llvm::DIType(), EltTypeArray);
Devang Patele21912d2009-10-20 19:55:01 +0000459 return DbgTy;
Sanjiv Gupta98070572008-05-25 05:15:42 +0000460}
461
Devang Patel889ce762010-01-19 00:00:59 +0000462/// CollectRecordFields - A helper function to collect debug info for
463/// record fields. This is used while creating debug info entry for a Record.
464void CGDebugInfo::
465CollectRecordFields(const RecordDecl *Decl,
466 llvm::DICompileUnit Unit,
467 llvm::SmallVectorImpl<llvm::DIDescriptor> &EltTys) {
468 unsigned FieldNo = 0;
469 SourceManager &SM = CGM.getContext().getSourceManager();
470 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(Decl);
471 for (RecordDecl::field_iterator I = Decl->field_begin(),
472 E = Decl->field_end();
473 I != E; ++I, ++FieldNo) {
474 FieldDecl *Field = *I;
475 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
476
477 llvm::StringRef FieldName = Field->getName();
478
479 // Ignore unnamed fields.
480 if (FieldName.empty())
481 continue;
482
483 // Get the location for the field.
484 SourceLocation FieldDefLoc = Field->getLocation();
485 PresumedLoc PLoc = SM.getPresumedLoc(FieldDefLoc);
486 llvm::DICompileUnit FieldDefUnit;
487 unsigned FieldLine = 0;
488
489 if (!PLoc.isInvalid()) {
490 FieldDefUnit = getOrCreateCompileUnit(FieldDefLoc);
491 FieldLine = PLoc.getLine();
492 }
493
494 QualType FType = Field->getType();
495 uint64_t FieldSize = 0;
496 unsigned FieldAlign = 0;
497 if (!FType->isIncompleteArrayType()) {
498
499 // Bit size, align and offset of the type.
500 FieldSize = CGM.getContext().getTypeSize(FType);
501 Expr *BitWidth = Field->getBitWidth();
502 if (BitWidth)
503 FieldSize = BitWidth->EvaluateAsInt(CGM.getContext()).getZExtValue();
504
505 FieldAlign = CGM.getContext().getTypeAlign(FType);
506 }
507
508 uint64_t FieldOffset = RL.getFieldOffset(FieldNo);
509
510 // Create a DW_TAG_member node to remember the offset of this field in the
511 // struct. FIXME: This is an absolutely insane way to capture this
512 // information. When we gut debug info, this should be fixed.
513 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
514 FieldName, FieldDefUnit,
515 FieldLine, FieldSize, FieldAlign,
516 FieldOffset, 0, FieldTy);
517 EltTys.push_back(FieldTy);
518 }
519}
520
Devang Patel7a12ad02010-01-19 01:54:44 +0000521/// CollectCXXMemberFunctions - A helper function to collect debug info for
522/// C++ member functions.This is used while creating debug info entry for
523/// a Record.
524void CGDebugInfo::
525CollectCXXMemberFunctions(const CXXRecordDecl *Decl,
526 llvm::DICompileUnit Unit,
527 llvm::SmallVectorImpl<llvm::DIDescriptor> &EltTys,
528 llvm::DICompositeType &RecordTy) {
529 SourceManager &SM = CGM.getContext().getSourceManager();
530 for(CXXRecordDecl::method_iterator I = Decl->method_begin(),
531 E = Decl->method_end(); I != E; ++I) {
532 CXXMethodDecl *Method = *I;
533 llvm::StringRef MethodName;
534 llvm::StringRef MethodLinkageName;
535 llvm::DIType MethodTy = getOrCreateType(Method->getType(), Unit);
536 if (CXXConstructorDecl *CDecl = dyn_cast<CXXConstructorDecl>(Method)) {
537 if (CDecl->isImplicit())
538 continue;
539 MethodName = Decl->getName();
540 // FIXME : Find linkage name.
541 } else if (CXXDestructorDecl *DDecl = dyn_cast<CXXDestructorDecl>(Method)) {
542 if (DDecl->isImplicit())
543 continue;
544 MethodName = getFunctionName(Method);
545 // FIXME : Find linkage name.
546 } else {
Devang Patel5e1a83c2010-01-19 02:02:11 +0000547 if (Method->isImplicit())
Devang Patel7a12ad02010-01-19 01:54:44 +0000548 continue;
Devang Patel5e1a83c2010-01-19 02:02:11 +0000549 // regular method
550 MethodName = getFunctionName(Method);
Devang Patel7a12ad02010-01-19 01:54:44 +0000551 MethodLinkageName = CGM.getMangledName(Method);
552 }
553
554 // Get the location for the method.
555 SourceLocation MethodDefLoc = Method->getLocation();
556 PresumedLoc PLoc = SM.getPresumedLoc(MethodDefLoc);
557 llvm::DICompileUnit MethodDefUnit;
558 unsigned MethodLine = 0;
559
560 if (!PLoc.isInvalid()) {
561 MethodDefUnit = getOrCreateCompileUnit(MethodDefLoc);
562 MethodLine = PLoc.getLine();
563 }
564
Devang Patel7af03fb2010-01-25 23:17:15 +0000565 // Collect virtual method info.
566 llvm::DIType ContainingType;
567 unsigned Virtuality = 0;
568 unsigned VIndex = 0;
569 if (Method->isVirtual()) {
570 // FIXME: Identify pure virtual functions.
571 Virtuality = llvm::dwarf::DW_VIRTUALITY_virtual;
572 VIndex = CGM.getVtableInfo().getMethodVtableIndex(Method);
573 ContainingType = RecordTy;
574 }
575
Devang Patel7a12ad02010-01-19 01:54:44 +0000576 llvm::DISubprogram SP =
577 DebugFactory.CreateSubprogram(RecordTy , MethodName, MethodName,
578 MethodLinkageName,
579 MethodDefUnit, MethodLine,
580 MethodTy, false,
581 Method->isThisDeclarationADefinition(),
Devang Patel7af03fb2010-01-25 23:17:15 +0000582 Virtuality, VIndex, ContainingType);
Devang Patel7a12ad02010-01-19 01:54:44 +0000583 if (Method->isThisDeclarationADefinition())
584 SPCache[cast<FunctionDecl>(Method)] = llvm::WeakVH(SP.getNode());
585 EltTys.push_back(SP);
586 }
587}
588
Devang Patel410dc002009-02-25 01:36:11 +0000589/// CreateType - get structure or union type.
Chris Lattneraffb3732008-11-10 06:08:34 +0000590llvm::DIType CGDebugInfo::CreateType(const RecordType *Ty,
591 llvm::DICompileUnit Unit) {
Douglas Gregore0295612008-12-11 17:59:21 +0000592 RecordDecl *Decl = Ty->getDecl();
Mike Stump11289f42009-09-09 15:08:12 +0000593
Chris Lattneraffb3732008-11-10 06:08:34 +0000594 unsigned Tag;
595 if (Decl->isStruct())
596 Tag = llvm::dwarf::DW_TAG_structure_type;
597 else if (Decl->isUnion())
598 Tag = llvm::dwarf::DW_TAG_union_type;
599 else {
600 assert(Decl->isClass() && "Unknown RecordType!");
601 Tag = llvm::dwarf::DW_TAG_class_type;
Sanjiv Gupta19292422008-06-07 04:46:53 +0000602 }
603
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000604 SourceManager &SM = CGM.getContext().getSourceManager();
Sanjiv Gupta224e8ea2008-06-09 10:47:41 +0000605
Chris Lattneraffb3732008-11-10 06:08:34 +0000606 // Get overall information about the record type for the debug info.
Devang Patel12f0dea2009-04-17 21:35:15 +0000607 PresumedLoc PLoc = SM.getPresumedLoc(Decl->getLocation());
Chris Lattner448a2282009-05-05 05:16:17 +0000608 llvm::DICompileUnit DefUnit;
609 unsigned Line = 0;
610 if (!PLoc.isInvalid()) {
611 DefUnit = getOrCreateCompileUnit(Decl->getLocation());
612 Line = PLoc.getLine();
613 }
Mike Stump11289f42009-09-09 15:08:12 +0000614
Chris Lattneraffb3732008-11-10 06:08:34 +0000615 // Records and classes and unions can all be recursive. To handle them, we
616 // first generate a debug descriptor for the struct as a forward declaration.
617 // Then (if it is a definition) we go through and get debug info for all of
618 // its members. Finally, we create a descriptor for the complete type (which
619 // may refer to the forward decl if the struct is recursive) and replace all
620 // uses of the forward declaration with the final definition.
Devang Patel3f4a77e2010-01-20 23:56:40 +0000621
622 // A Decl->getName() is not unique. However, the debug info descriptors
623 // are uniqued. The debug info descriptor describing record's context is
624 // necessary to keep two Decl's descriptor unique if their name match.
625 // FIXME : Use RecordDecl's DeclContext's descriptor. As a temp. step
626 // use type's name in FwdDecl.
627 std::string STy = QualType(Ty, 0).getAsString();
Devang Patel06cceef2009-07-22 18:57:00 +0000628 llvm::DICompositeType FwdDecl =
Devang Patel3f4a77e2010-01-20 23:56:40 +0000629 DebugFactory.CreateCompositeType(Tag, Unit, STy.c_str(),
Devang Patel7bdf0962009-11-12 00:51:46 +0000630 DefUnit, Line, 0, 0, 0, 0,
Chris Lattneraffb3732008-11-10 06:08:34 +0000631 llvm::DIType(), llvm::DIArray());
Mike Stump11289f42009-09-09 15:08:12 +0000632
Chris Lattneraffb3732008-11-10 06:08:34 +0000633 // If this is just a forward declaration, return it.
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000634 if (!Decl->getDefinition(CGM.getContext()))
Chris Lattneraffb3732008-11-10 06:08:34 +0000635 return FwdDecl;
Sanjiv Gupta224e8ea2008-06-09 10:47:41 +0000636
Eli Friedman00dbf4c2009-11-16 21:04:30 +0000637 llvm::TrackingVH<llvm::MDNode> FwdDeclNode = FwdDecl.getNode();
Chris Lattneraffb3732008-11-10 06:08:34 +0000638 // Otherwise, insert it into the TypeCache so that recursive uses will find
639 // it.
Daniel Dunbar1cbaae52009-09-19 19:27:24 +0000640 TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl.getNode();
Chris Lattneraffb3732008-11-10 06:08:34 +0000641
642 // Convert all the elements.
643 llvm::SmallVector<llvm::DIDescriptor, 16> EltTys;
644
Devang Patel889ce762010-01-19 00:00:59 +0000645 CollectRecordFields(Decl, Unit, EltTys);
Devang Patel7a12ad02010-01-19 01:54:44 +0000646 if (CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(Decl))
647 CollectCXXMemberFunctions(CXXDecl, Unit, EltTys, FwdDecl);
Mike Stump11289f42009-09-09 15:08:12 +0000648
Chris Lattneraffb3732008-11-10 06:08:34 +0000649 llvm::DIArray Elements =
Daniel Dunbarbee70bd2009-05-26 19:40:20 +0000650 DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
Chris Lattneraffb3732008-11-10 06:08:34 +0000651
652 // Bit size, align and offset of the type.
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000653 uint64_t Size = CGM.getContext().getTypeSize(Ty);
654 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
Mike Stump11289f42009-09-09 15:08:12 +0000655
Devang Patel06cceef2009-07-22 18:57:00 +0000656 llvm::DICompositeType RealDecl =
Devang Patel58bf6e12009-11-25 17:37:31 +0000657 DebugFactory.CreateCompositeType(Tag, Unit, Decl->getName(),
Devang Patel7bdf0962009-11-12 00:51:46 +0000658 DefUnit, Line, Size, Align, 0, 0,
659 llvm::DIType(), Elements);
Chris Lattneraffb3732008-11-10 06:08:34 +0000660
661 // Now that we have a real decl for the struct, replace anything using the
662 // old decl with the new one. This will recursively update the debug info.
Eli Friedman00dbf4c2009-11-16 21:04:30 +0000663 llvm::DIDerivedType(FwdDeclNode).replaceAllUsesWith(RealDecl);
Devang Patel9c3a0182009-07-13 17:03:14 +0000664
Chris Lattneraffb3732008-11-10 06:08:34 +0000665 return RealDecl;
666}
667
Devang Patelf4c205b2009-02-26 21:10:26 +0000668/// CreateType - get objective-c interface type.
669llvm::DIType CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
670 llvm::DICompileUnit Unit) {
671 ObjCInterfaceDecl *Decl = Ty->getDecl();
Mike Stump11289f42009-09-09 15:08:12 +0000672
Devang Patelf4c205b2009-02-26 21:10:26 +0000673 unsigned Tag = llvm::dwarf::DW_TAG_structure_type;
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000674 SourceManager &SM = CGM.getContext().getSourceManager();
Devang Patelf4c205b2009-02-26 21:10:26 +0000675
676 // Get overall information about the record type for the debug info.
Devang Patelf4c205b2009-02-26 21:10:26 +0000677 llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(Decl->getLocation());
Devang Patel12f0dea2009-04-17 21:35:15 +0000678 PresumedLoc PLoc = SM.getPresumedLoc(Decl->getLocation());
679 unsigned Line = PLoc.isInvalid() ? 0 : PLoc.getLine();
680
Mike Stump11289f42009-09-09 15:08:12 +0000681
Daniel Dunbarc61d0bd2009-05-18 20:51:58 +0000682 unsigned RuntimeLang = DefUnit.getLanguage();
Chris Lattnerc6ad2582009-05-02 01:13:16 +0000683
Devang Patelf4c205b2009-02-26 21:10:26 +0000684 // To handle recursive interface, we
685 // first generate a debug descriptor for the struct as a forward declaration.
686 // Then (if it is a definition) we go through and get debug info for all of
687 // its members. Finally, we create a descriptor for the complete type (which
688 // may refer to the forward decl if the struct is recursive) and replace all
689 // uses of the forward declaration with the final definition.
Devang Patel6a3b3fe2009-07-27 18:42:03 +0000690 llvm::DICompositeType FwdDecl =
Devang Patel58bf6e12009-11-25 17:37:31 +0000691 DebugFactory.CreateCompositeType(Tag, Unit, Decl->getName(),
Devang Patel7bdf0962009-11-12 00:51:46 +0000692 DefUnit, Line, 0, 0, 0, 0,
Chris Lattnerc6ad2582009-05-02 01:13:16 +0000693 llvm::DIType(), llvm::DIArray(),
694 RuntimeLang);
Mike Stump11289f42009-09-09 15:08:12 +0000695
Devang Patelf4c205b2009-02-26 21:10:26 +0000696 // If this is just a forward declaration, return it.
697 if (Decl->isForwardDecl())
698 return FwdDecl;
699
Devang Patel10909d52009-11-16 20:09:38 +0000700 llvm::TrackingVH<llvm::MDNode> FwdDeclNode = FwdDecl.getNode();
Devang Patelf4c205b2009-02-26 21:10:26 +0000701 // Otherwise, insert it into the TypeCache so that recursive uses will find
702 // it.
Daniel Dunbar1cbaae52009-09-19 19:27:24 +0000703 TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl.getNode();
Devang Patelf4c205b2009-02-26 21:10:26 +0000704
705 // Convert all the elements.
706 llvm::SmallVector<llvm::DIDescriptor, 16> EltTys;
707
Devang Patelc0f58ea2009-03-10 21:30:26 +0000708 ObjCInterfaceDecl *SClass = Decl->getSuperClass();
709 if (SClass) {
Mike Stump11289f42009-09-09 15:08:12 +0000710 llvm::DIType SClassTy =
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000711 getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit);
Mike Stump11289f42009-09-09 15:08:12 +0000712 llvm::DIType InhTag =
Devang Patelc0f58ea2009-03-10 21:30:26 +0000713 DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_inheritance,
Chris Lattnerf216fd92009-05-05 05:05:36 +0000714 Unit, "", llvm::DICompileUnit(), 0, 0, 0,
Devang Patelc0f58ea2009-03-10 21:30:26 +0000715 0 /* offset */, 0, SClassTy);
716 EltTys.push_back(InhTag);
717 }
718
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000719 const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(Decl);
Devang Patelf4c205b2009-02-26 21:10:26 +0000720
721 unsigned FieldNo = 0;
722 for (ObjCInterfaceDecl::ivar_iterator I = Decl->ivar_begin(),
723 E = Decl->ivar_end(); I != E; ++I, ++FieldNo) {
724 ObjCIvarDecl *Field = *I;
725 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
726
Devang Patel58bf6e12009-11-25 17:37:31 +0000727 llvm::StringRef FieldName = Field->getName();
Devang Patelf4c205b2009-02-26 21:10:26 +0000728
Devang Pateldf348f12009-04-27 22:40:36 +0000729 // Ignore unnamed fields.
Devang Patel58bf6e12009-11-25 17:37:31 +0000730 if (FieldName.empty())
Devang Pateldf348f12009-04-27 22:40:36 +0000731 continue;
732
Devang Patelf4c205b2009-02-26 21:10:26 +0000733 // Get the location for the field.
734 SourceLocation FieldDefLoc = Field->getLocation();
735 llvm::DICompileUnit FieldDefUnit = getOrCreateCompileUnit(FieldDefLoc);
Devang Patel12f0dea2009-04-17 21:35:15 +0000736 PresumedLoc PLoc = SM.getPresumedLoc(FieldDefLoc);
737 unsigned FieldLine = PLoc.isInvalid() ? 0 : PLoc.getLine();
738
Mike Stump11289f42009-09-09 15:08:12 +0000739
Devang Patel9f804932009-03-20 18:24:39 +0000740 QualType FType = Field->getType();
741 uint64_t FieldSize = 0;
742 unsigned FieldAlign = 0;
Devang Patelec4bad52009-03-19 00:23:53 +0000743
Devang Patel9f804932009-03-20 18:24:39 +0000744 if (!FType->isIncompleteArrayType()) {
Mike Stump11289f42009-09-09 15:08:12 +0000745
Devang Patel9f804932009-03-20 18:24:39 +0000746 // Bit size, align and offset of the type.
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000747 FieldSize = CGM.getContext().getTypeSize(FType);
Devang Patel9f804932009-03-20 18:24:39 +0000748 Expr *BitWidth = Field->getBitWidth();
749 if (BitWidth)
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000750 FieldSize = BitWidth->EvaluateAsInt(CGM.getContext()).getZExtValue();
Eli Friedman1c4a1752009-04-26 19:19:15 +0000751
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000752 FieldAlign = CGM.getContext().getTypeAlign(FType);
Devang Patel9f804932009-03-20 18:24:39 +0000753 }
754
Mike Stump11289f42009-09-09 15:08:12 +0000755 uint64_t FieldOffset = RL.getFieldOffset(FieldNo);
756
Devang Patelec4bad52009-03-19 00:23:53 +0000757 unsigned Flags = 0;
758 if (Field->getAccessControl() == ObjCIvarDecl::Protected)
759 Flags = llvm::DIType::FlagProtected;
760 else if (Field->getAccessControl() == ObjCIvarDecl::Private)
761 Flags = llvm::DIType::FlagPrivate;
Mike Stump11289f42009-09-09 15:08:12 +0000762
Devang Patelf4c205b2009-02-26 21:10:26 +0000763 // Create a DW_TAG_member node to remember the offset of this field in the
764 // struct. FIXME: This is an absolutely insane way to capture this
765 // information. When we gut debug info, this should be fixed.
766 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
767 FieldName, FieldDefUnit,
768 FieldLine, FieldSize, FieldAlign,
Devang Patelec4bad52009-03-19 00:23:53 +0000769 FieldOffset, Flags, FieldTy);
Devang Patelf4c205b2009-02-26 21:10:26 +0000770 EltTys.push_back(FieldTy);
771 }
Mike Stump11289f42009-09-09 15:08:12 +0000772
Devang Patelf4c205b2009-02-26 21:10:26 +0000773 llvm::DIArray Elements =
Jay Foad7d0479f2009-05-21 09:52:38 +0000774 DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
Devang Patelf4c205b2009-02-26 21:10:26 +0000775
776 // Bit size, align and offset of the type.
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000777 uint64_t Size = CGM.getContext().getTypeSize(Ty);
778 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
Mike Stump11289f42009-09-09 15:08:12 +0000779
Devang Patel6a3b3fe2009-07-27 18:42:03 +0000780 llvm::DICompositeType RealDecl =
Devang Patel58bf6e12009-11-25 17:37:31 +0000781 DebugFactory.CreateCompositeType(Tag, Unit, Decl->getName(), DefUnit,
Devang Patel7bdf0962009-11-12 00:51:46 +0000782 Line, Size, Align, 0, 0, llvm::DIType(),
783 Elements, RuntimeLang);
Devang Patelf4c205b2009-02-26 21:10:26 +0000784
785 // Now that we have a real decl for the struct, replace anything using the
786 // old decl with the new one. This will recursively update the debug info.
Devang Patel10909d52009-11-16 20:09:38 +0000787 llvm::DIDerivedType(FwdDeclNode).replaceAllUsesWith(RealDecl);
Devang Patel9c3a0182009-07-13 17:03:14 +0000788
Devang Patelf4c205b2009-02-26 21:10:26 +0000789 return RealDecl;
790}
791
Chris Lattneraffb3732008-11-10 06:08:34 +0000792llvm::DIType CGDebugInfo::CreateType(const EnumType *Ty,
793 llvm::DICompileUnit Unit) {
794 EnumDecl *Decl = Ty->getDecl();
795
796 llvm::SmallVector<llvm::DIDescriptor, 32> Enumerators;
797
798 // Create DIEnumerator elements for each enumerator.
Mike Stump11289f42009-09-09 15:08:12 +0000799 for (EnumDecl::enumerator_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +0000800 Enum = Decl->enumerator_begin(), EnumEnd = Decl->enumerator_end();
Douglas Gregor91f84212008-12-11 16:49:14 +0000801 Enum != EnumEnd; ++Enum) {
Devang Patel58bf6e12009-11-25 17:37:31 +0000802 Enumerators.push_back(DebugFactory.CreateEnumerator(Enum->getName(),
Douglas Gregor91f84212008-12-11 16:49:14 +0000803 Enum->getInitVal().getZExtValue()));
Chris Lattneraffb3732008-11-10 06:08:34 +0000804 }
Mike Stump11289f42009-09-09 15:08:12 +0000805
Chris Lattneraffb3732008-11-10 06:08:34 +0000806 // Return a CompositeType for the enum itself.
807 llvm::DIArray EltArray =
Jay Foad7d0479f2009-05-21 09:52:38 +0000808 DebugFactory.GetOrCreateArray(Enumerators.data(), Enumerators.size());
Chris Lattneraffb3732008-11-10 06:08:34 +0000809
Chris Lattneraffb3732008-11-10 06:08:34 +0000810 SourceLocation DefLoc = Decl->getLocation();
811 llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(DefLoc);
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000812 SourceManager &SM = CGM.getContext().getSourceManager();
Devang Patel12f0dea2009-04-17 21:35:15 +0000813 PresumedLoc PLoc = SM.getPresumedLoc(DefLoc);
814 unsigned Line = PLoc.isInvalid() ? 0 : PLoc.getLine();
815
Mike Stump11289f42009-09-09 15:08:12 +0000816
Chris Lattneraffb3732008-11-10 06:08:34 +0000817 // Size and align of the type.
Eli Friedman2ad7e172009-05-04 04:39:55 +0000818 uint64_t Size = 0;
819 unsigned Align = 0;
820 if (!Ty->isIncompleteType()) {
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000821 Size = CGM.getContext().getTypeSize(Ty);
822 Align = CGM.getContext().getTypeAlign(Ty);
Eli Friedman2ad7e172009-05-04 04:39:55 +0000823 }
Mike Stump11289f42009-09-09 15:08:12 +0000824
Devang Patele21912d2009-10-20 19:55:01 +0000825 llvm::DIType DbgTy =
826 DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_enumeration_type,
Devang Patel58bf6e12009-11-25 17:37:31 +0000827 Unit, Decl->getName(), DefUnit, Line,
Devang Patele21912d2009-10-20 19:55:01 +0000828 Size, Align, 0, 0,
829 llvm::DIType(), EltArray);
Devang Patele21912d2009-10-20 19:55:01 +0000830 return DbgTy;
Chris Lattneraffb3732008-11-10 06:08:34 +0000831}
832
833llvm::DIType CGDebugInfo::CreateType(const TagType *Ty,
834 llvm::DICompileUnit Unit) {
835 if (const RecordType *RT = dyn_cast<RecordType>(Ty))
836 return CreateType(RT, Unit);
837 else if (const EnumType *ET = dyn_cast<EnumType>(Ty))
838 return CreateType(ET, Unit);
Mike Stump11289f42009-09-09 15:08:12 +0000839
Chris Lattneraffb3732008-11-10 06:08:34 +0000840 return llvm::DIType();
841}
842
843llvm::DIType CGDebugInfo::CreateType(const ArrayType *Ty,
844 llvm::DICompileUnit Unit) {
Anders Carlssond8cd7b62009-01-05 01:23:29 +0000845 uint64_t Size;
846 uint64_t Align;
Mike Stump11289f42009-09-09 15:08:12 +0000847
848
Nuno Lopesbb537dc2009-01-28 00:35:17 +0000849 // FIXME: make getTypeAlign() aware of VLAs and incomplete array types
Anders Carlssond8cd7b62009-01-05 01:23:29 +0000850 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(Ty)) {
Anders Carlssond8cd7b62009-01-05 01:23:29 +0000851 Size = 0;
852 Align =
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000853 CGM.getContext().getTypeAlign(CGM.getContext().getBaseElementType(VAT));
Nuno Lopesbb537dc2009-01-28 00:35:17 +0000854 } else if (Ty->isIncompleteArrayType()) {
855 Size = 0;
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000856 Align = CGM.getContext().getTypeAlign(Ty->getElementType());
Anders Carlssond8cd7b62009-01-05 01:23:29 +0000857 } else {
858 // Size and align of the whole array, not the element type.
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000859 Size = CGM.getContext().getTypeSize(Ty);
860 Align = CGM.getContext().getTypeAlign(Ty);
Anders Carlssond8cd7b62009-01-05 01:23:29 +0000861 }
Mike Stump11289f42009-09-09 15:08:12 +0000862
Chris Lattneraffb3732008-11-10 06:08:34 +0000863 // Add the dimensions of the array. FIXME: This loses CV qualifiers from
864 // interior arrays, do we care? Why aren't nested arrays represented the
865 // obvious/recursive way?
866 llvm::SmallVector<llvm::DIDescriptor, 8> Subscripts;
867 QualType EltTy(Ty, 0);
868 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
Sanjiv Gupta224e8ea2008-06-09 10:47:41 +0000869 uint64_t Upper = 0;
Mike Stump11289f42009-09-09 15:08:12 +0000870 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(Ty))
Devang Pateld4bbb082009-08-14 20:57:45 +0000871 if (CAT->getSize().getZExtValue())
Mike Stump11289f42009-09-09 15:08:12 +0000872 Upper = CAT->getSize().getZExtValue() - 1;
Chris Lattneraffb3732008-11-10 06:08:34 +0000873 // FIXME: Verify this is right for VLAs.
874 Subscripts.push_back(DebugFactory.GetOrCreateSubrange(0, Upper));
875 EltTy = Ty->getElementType();
Sanjiv Gupta224e8ea2008-06-09 10:47:41 +0000876 }
Mike Stump11289f42009-09-09 15:08:12 +0000877
Chris Lattneraffb3732008-11-10 06:08:34 +0000878 llvm::DIArray SubscriptArray =
Daniel Dunbarbee70bd2009-05-26 19:40:20 +0000879 DebugFactory.GetOrCreateArray(Subscripts.data(), Subscripts.size());
Chris Lattneraffb3732008-11-10 06:08:34 +0000880
Devang Patele21912d2009-10-20 19:55:01 +0000881 llvm::DIType DbgTy =
882 DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_array_type,
883 Unit, "", llvm::DICompileUnit(),
884 0, Size, Align, 0, 0,
885 getOrCreateType(EltTy, Unit),
886 SubscriptArray);
Devang Patele21912d2009-10-20 19:55:01 +0000887 return DbgTy;
Chris Lattneraffb3732008-11-10 06:08:34 +0000888}
889
Anders Carlsson443f6772009-11-06 19:19:55 +0000890llvm::DIType CGDebugInfo::CreateType(const LValueReferenceType *Ty,
891 llvm::DICompileUnit Unit) {
892 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type,
893 Ty, Ty->getPointeeType(), Unit);
894}
Chris Lattneraffb3732008-11-10 06:08:34 +0000895
Anders Carlsson3efc6e62009-12-06 18:00:51 +0000896llvm::DIType CGDebugInfo::CreateType(const MemberPointerType *Ty,
897 llvm::DICompileUnit U) {
898 QualType PointerDiffTy = CGM.getContext().getPointerDiffType();
899 llvm::DIType PointerDiffDITy = getOrCreateType(PointerDiffTy, U);
900
901 if (!Ty->getPointeeType()->isFunctionType()) {
902 // We have a data member pointer type.
903 return PointerDiffDITy;
904 }
905
906 // We have a member function pointer type. Treat it as a struct with two
907 // ptrdiff_t members.
908 std::pair<uint64_t, unsigned> Info = CGM.getContext().getTypeInfo(Ty);
909
910 uint64_t FieldOffset = 0;
911 llvm::DIDescriptor ElementTypes[2];
912
913 // FIXME: This should probably be a function type instead.
914 ElementTypes[0] =
915 DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, U,
916 "ptr", llvm::DICompileUnit(), 0,
917 Info.first, Info.second, FieldOffset, 0,
918 PointerDiffDITy);
919 FieldOffset += Info.first;
920
921 ElementTypes[1] =
922 DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, U,
923 "ptr", llvm::DICompileUnit(), 0,
924 Info.first, Info.second, FieldOffset, 0,
925 PointerDiffDITy);
926
927 llvm::DIArray Elements =
928 DebugFactory.GetOrCreateArray(&ElementTypes[0],
929 llvm::array_lengthof(ElementTypes));
930
931 return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_structure_type,
932 U, llvm::StringRef("test"),
933 llvm::DICompileUnit(), 0, FieldOffset,
934 0, 0, 0, llvm::DIType(), Elements);
935}
936
Douglas Gregor0f139a12009-12-21 20:18:30 +0000937static QualType UnwrapTypeForDebugInfo(QualType T) {
938 do {
939 QualType LastT = T;
940 switch (T->getTypeClass()) {
941 default:
942 return T;
943 case Type::TemplateSpecialization:
944 T = cast<TemplateSpecializationType>(T)->desugar();
945 break;
946 case Type::TypeOfExpr: {
947 TypeOfExprType *Ty = cast<TypeOfExprType>(T);
948 T = Ty->getUnderlyingExpr()->getType();
949 break;
950 }
951 case Type::TypeOf:
952 T = cast<TypeOfType>(T)->getUnderlyingType();
953 break;
954 case Type::Decltype:
955 T = cast<DecltypeType>(T)->getUnderlyingType();
956 break;
957 case Type::QualifiedName:
958 T = cast<QualifiedNameType>(T)->getNamedType();
959 break;
960 case Type::SubstTemplateTypeParm:
961 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
962 break;
963 case Type::Elaborated:
964 T = cast<ElaboratedType>(T)->getUnderlyingType();
965 break;
966 }
967
968 assert(T != LastT && "Type unwrapping failed to unwrap!");
969 if (T == LastT)
970 return T;
971 } while (true);
972
973 return T;
Anders Carlsson0acee6e2009-11-14 21:08:12 +0000974}
975
Sanjiv Gupta98070572008-05-25 05:15:42 +0000976/// getOrCreateType - Get the type from the cache or create a new
977/// one if necessary.
Chris Lattneraffb3732008-11-10 06:08:34 +0000978llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty,
979 llvm::DICompileUnit Unit) {
980 if (Ty.isNull())
981 return llvm::DIType();
Mike Stump11289f42009-09-09 15:08:12 +0000982
Douglas Gregor0f139a12009-12-21 20:18:30 +0000983 // Unwrap the type as needed for debug information.
984 Ty = UnwrapTypeForDebugInfo(Ty);
Anders Carlsson0acee6e2009-11-14 21:08:12 +0000985
Daniel Dunbar1cbaae52009-09-19 19:27:24 +0000986 // Check for existing entry.
Daniel Dunbar99961382009-09-19 20:17:48 +0000987 std::map<void *, llvm::WeakVH>::iterator it =
Daniel Dunbar1cbaae52009-09-19 19:27:24 +0000988 TypeCache.find(Ty.getAsOpaquePtr());
Daniel Dunbar99961382009-09-19 20:17:48 +0000989 if (it != TypeCache.end()) {
990 // Verify that the debug info still exists.
991 if (&*it->second)
992 return llvm::DIType(cast<llvm::MDNode>(it->second));
993 }
Daniel Dunbarde870bd2009-09-19 19:27:14 +0000994
Daniel Dunbar1cbaae52009-09-19 19:27:24 +0000995 // Otherwise create the type.
996 llvm::DIType Res = CreateTypeNode(Ty, Unit);
Anders Carlsson6037e782009-11-14 20:52:05 +0000997
998 // And update the type cache.
999 TypeCache[Ty.getAsOpaquePtr()] = Res.getNode();
Daniel Dunbar1cbaae52009-09-19 19:27:24 +00001000 return Res;
Daniel Dunbarde870bd2009-09-19 19:27:14 +00001001}
1002
Anders Carlsson6037e782009-11-14 20:52:05 +00001003/// CreateTypeNode - Create a new debug type node.
Daniel Dunbarde870bd2009-09-19 19:27:14 +00001004llvm::DIType CGDebugInfo::CreateTypeNode(QualType Ty,
1005 llvm::DICompileUnit Unit) {
John McCall0cf15512009-09-25 01:40:47 +00001006 // Handle qualifiers, which recursively handles what they refer to.
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00001007 if (Ty.hasLocalQualifiers())
John McCall0cf15512009-09-25 01:40:47 +00001008 return CreateQualifiedType(Ty, Unit);
Sanjiv Gupta98070572008-05-25 05:15:42 +00001009
Douglas Gregor0915b432009-12-21 19:57:21 +00001010 const char *Diag = 0;
1011
Sanjiv Gupta98070572008-05-25 05:15:42 +00001012 // Work out details of type.
Chris Lattneraffb3732008-11-10 06:08:34 +00001013 switch (Ty->getTypeClass()) {
Douglas Gregordeaad8c2009-02-26 23:50:07 +00001014#define TYPE(Class, Base)
1015#define ABSTRACT_TYPE(Class, Base)
1016#define NON_CANONICAL_TYPE(Class, Base)
1017#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1018#include "clang/AST/TypeNodes.def"
1019 assert(false && "Dependent types cannot show up in debug information");
Argyrios Kyrtzidise9189262009-08-19 01:28:17 +00001020
Anders Carlsson25ed5c22009-11-06 18:24:04 +00001021 // FIXME: Handle these.
1022 case Type::ExtVector:
1023 case Type::Vector:
1024 return llvm::DIType();
Douglas Gregor0915b432009-12-21 19:57:21 +00001025
Daniel Dunbarf5c79702009-07-14 01:20:56 +00001026 case Type::ObjCObjectPointer:
Daniel Dunbarde870bd2009-09-19 19:27:14 +00001027 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
Mike Stump11289f42009-09-09 15:08:12 +00001028 case Type::ObjCInterface:
Daniel Dunbarde870bd2009-09-19 19:27:14 +00001029 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
1030 case Type::Builtin: return CreateType(cast<BuiltinType>(Ty), Unit);
1031 case Type::Complex: return CreateType(cast<ComplexType>(Ty), Unit);
1032 case Type::Pointer: return CreateType(cast<PointerType>(Ty), Unit);
Mike Stump31f099c2009-05-14 02:03:51 +00001033 case Type::BlockPointer:
Daniel Dunbarde870bd2009-09-19 19:27:14 +00001034 return CreateType(cast<BlockPointerType>(Ty), Unit);
1035 case Type::Typedef: return CreateType(cast<TypedefType>(Ty), Unit);
Douglas Gregordeaad8c2009-02-26 23:50:07 +00001036 case Type::Record:
Douglas Gregordeaad8c2009-02-26 23:50:07 +00001037 case Type::Enum:
Daniel Dunbarde870bd2009-09-19 19:27:14 +00001038 return CreateType(cast<TagType>(Ty), Unit);
Chris Lattneraffb3732008-11-10 06:08:34 +00001039 case Type::FunctionProto:
1040 case Type::FunctionNoProto:
Daniel Dunbarde870bd2009-09-19 19:27:14 +00001041 return CreateType(cast<FunctionType>(Ty), Unit);
Chris Lattneraffb3732008-11-10 06:08:34 +00001042 case Type::ConstantArray:
1043 case Type::VariableArray:
1044 case Type::IncompleteArray:
Daniel Dunbarde870bd2009-09-19 19:27:14 +00001045 return CreateType(cast<ArrayType>(Ty), Unit);
Anders Carlsson443f6772009-11-06 19:19:55 +00001046
1047 case Type::LValueReference:
1048 return CreateType(cast<LValueReferenceType>(Ty), Unit);
1049
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001050 case Type::MemberPointer:
1051 return CreateType(cast<MemberPointerType>(Ty), Unit);
Douglas Gregor0915b432009-12-21 19:57:21 +00001052
1053 case Type::TemplateSpecialization:
Douglas Gregor0915b432009-12-21 19:57:21 +00001054 case Type::Elaborated:
Douglas Gregor0915b432009-12-21 19:57:21 +00001055 case Type::QualifiedName:
Douglas Gregor0915b432009-12-21 19:57:21 +00001056 case Type::SubstTemplateTypeParm:
Douglas Gregor0915b432009-12-21 19:57:21 +00001057 case Type::TypeOfExpr:
1058 case Type::TypeOf:
Douglas Gregor0f139a12009-12-21 20:18:30 +00001059 case Type::Decltype:
1060 llvm_unreachable("type should have been unwrapped!");
1061 return llvm::DIType();
Douglas Gregor0915b432009-12-21 19:57:21 +00001062
1063 case Type::RValueReference:
1064 // FIXME: Implement!
1065 Diag = "rvalue references";
1066 break;
Sanjiv Gupta98070572008-05-25 05:15:42 +00001067 }
Douglas Gregor0915b432009-12-21 19:57:21 +00001068
1069 assert(Diag && "Fall through without a diagnostic?");
1070 unsigned DiagID = CGM.getDiags().getCustomDiagID(Diagnostic::Error,
1071 "debug information for %0 is not yet supported");
1072 CGM.getDiags().Report(FullSourceLoc(), DiagID)
1073 << Diag;
1074 return llvm::DIType();
Sanjiv Gupta98070572008-05-25 05:15:42 +00001075}
1076
1077/// EmitFunctionStart - Constructs the debug code for entering a function -
1078/// "llvm.dbg.func.start.".
Devang Patel934661e2010-01-14 00:36:21 +00001079void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, QualType FnType,
Sanjiv Gupta98070572008-05-25 05:15:42 +00001080 llvm::Function *Fn,
Chris Lattneraffb3732008-11-10 06:08:34 +00001081 CGBuilderTy &Builder) {
Mike Stump11289f42009-09-09 15:08:12 +00001082
Devang Patel934661e2010-01-14 00:36:21 +00001083 llvm::StringRef Name;
1084 llvm::StringRef LinkageName;
1085
1086 const Decl *D = GD.getDecl();
1087 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Devang Patel7a12ad02010-01-19 01:54:44 +00001088 // If there is a DISubprogram for this function available then use it.
1089 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator
1090 FI = SPCache.find(FD);
1091 if (FI != SPCache.end()) {
1092 llvm::DISubprogram SP(dyn_cast_or_null<llvm::MDNode>(FI->second));
1093 if (!SP.isNull() && SP.isSubprogram() && SP.isDefinition()) {
1094 RegionStack.push_back(SP.getNode());
1095 return;
1096 }
1097 }
Devang Patel934661e2010-01-14 00:36:21 +00001098 Name = getFunctionName(FD);
Eli Friedman8fdc2cb2010-01-16 00:43:13 +00001099 if (!Name.empty() && Name[0] == '\01')
Devang Patel2d630102010-01-14 21:46:57 +00001100 Name = Name.substr(1);
Devang Patel934661e2010-01-14 00:36:21 +00001101 // Use mangled name as linkage name for c/c++ functions.
Devang Patel2d630102010-01-14 21:46:57 +00001102 LinkageName = CGM.getMangledName(GD);
Devang Patel934661e2010-01-14 00:36:21 +00001103 } else {
1104 // Use llvm function name as linkage name.
1105 Name = Fn->getName();
Devang Patel934661e2010-01-14 00:36:21 +00001106 LinkageName = Name;
Devang Patel757daca2010-01-19 00:25:12 +00001107 if (!Name.empty() && Name[0] == '\01')
1108 Name = Name.substr(1);
Devang Patel934661e2010-01-14 00:36:21 +00001109 }
Mike Stump11289f42009-09-09 15:08:12 +00001110
Devang Patelea84f592010-01-14 18:06:13 +00001111 // It is expected that CurLoc is set before using EmitFunctionStart.
1112 // Usually, CurLoc points to the left bracket location of compound
1113 // statement representing function body.
Chris Lattneraffb3732008-11-10 06:08:34 +00001114 llvm::DICompileUnit Unit = getOrCreateCompileUnit(CurLoc);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001115 SourceManager &SM = CGM.getContext().getSourceManager();
Devang Patel2ac33a02009-04-08 19:47:04 +00001116 unsigned LineNo = SM.getPresumedLoc(CurLoc).getLine();
Mike Stump11289f42009-09-09 15:08:12 +00001117
Chris Lattneraffb3732008-11-10 06:08:34 +00001118 llvm::DISubprogram SP =
Devang Patel9be7b202009-07-14 21:31:22 +00001119 DebugFactory.CreateSubprogram(Unit, Name, Name, LinkageName, Unit, LineNo,
Mike Stumpae2559a2009-10-23 01:52:13 +00001120 getOrCreateType(FnType, Unit),
Chris Lattneraffb3732008-11-10 06:08:34 +00001121 Fn->hasInternalLinkage(), true/*definition*/);
Mike Stump11289f42009-09-09 15:08:12 +00001122
Sanjiv Gupta98070572008-05-25 05:15:42 +00001123 // Push function on region stack.
Devang Patelb40f2952009-11-13 19:10:24 +00001124 RegionStack.push_back(SP.getNode());
Sanjiv Gupta98070572008-05-25 05:15:42 +00001125}
1126
1127
Chris Lattneraffb3732008-11-10 06:08:34 +00001128void CGDebugInfo::EmitStopPoint(llvm::Function *Fn, CGBuilderTy &Builder) {
Sanjiv Gupta98070572008-05-25 05:15:42 +00001129 if (CurLoc.isInvalid() || CurLoc.isMacroID()) return;
Mike Stump11289f42009-09-09 15:08:12 +00001130
Sanjiv Gupta15cb6692008-05-08 08:54:20 +00001131 // Don't bother if things are the same as last time.
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001132 SourceManager &SM = CGM.getContext().getSourceManager();
Mike Stump11289f42009-09-09 15:08:12 +00001133 if (CurLoc == PrevLoc
Chris Lattner88ea93e2009-02-04 01:06:56 +00001134 || (SM.getInstantiationLineNumber(CurLoc) ==
1135 SM.getInstantiationLineNumber(PrevLoc)
Sanjiv Gupta15cb6692008-05-08 08:54:20 +00001136 && SM.isFromSameFile(CurLoc, PrevLoc)))
1137 return;
Sanjiv Gupta15cb6692008-05-08 08:54:20 +00001138
1139 // Update last state.
1140 PrevLoc = CurLoc;
1141
1142 // Get the appropriate compile unit.
Chris Lattneraffb3732008-11-10 06:08:34 +00001143 llvm::DICompileUnit Unit = getOrCreateCompileUnit(CurLoc);
Devang Patel2ac33a02009-04-08 19:47:04 +00001144 PresumedLoc PLoc = SM.getPresumedLoc(CurLoc);
Devang Patel5d90d622009-10-06 18:36:08 +00001145
Devang Patelb40f2952009-11-13 19:10:24 +00001146 llvm::DIDescriptor DR(RegionStack.back());
Devang Patel5d90d622009-10-06 18:36:08 +00001147 llvm::DIScope DS = llvm::DIScope(DR.getNode());
1148 llvm::DILocation DO(NULL);
1149 llvm::DILocation DL =
1150 DebugFactory.CreateLocation(PLoc.getLine(), PLoc.getColumn(),
1151 DS, DO);
1152 Builder.SetCurrentDebugLocation(DL.getNode());
Sanjiv Gupta15cb6692008-05-08 08:54:20 +00001153}
1154
1155/// EmitRegionStart- Constructs the debug code for entering a declarative
1156/// region - "llvm.dbg.region.start.".
Chris Lattneraffb3732008-11-10 06:08:34 +00001157void CGDebugInfo::EmitRegionStart(llvm::Function *Fn, CGBuilderTy &Builder) {
Devang Patelb40f2952009-11-13 19:10:24 +00001158 llvm::DIDescriptor D =
1159 DebugFactory.CreateLexicalBlock(RegionStack.empty() ?
1160 llvm::DIDescriptor() :
1161 llvm::DIDescriptor(RegionStack.back()));
1162 RegionStack.push_back(D.getNode());
Sanjiv Gupta15cb6692008-05-08 08:54:20 +00001163}
1164
1165/// EmitRegionEnd - Constructs the debug code for exiting a declarative
1166/// region - "llvm.dbg.region.end."
Chris Lattneraffb3732008-11-10 06:08:34 +00001167void CGDebugInfo::EmitRegionEnd(llvm::Function *Fn, CGBuilderTy &Builder) {
Daniel Dunbar380827c2008-10-17 01:07:56 +00001168 assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
1169
Sanjiv Gupta15cb6692008-05-08 08:54:20 +00001170 // Provide an region stop point.
1171 EmitStopPoint(Fn, Builder);
Mike Stump11289f42009-09-09 15:08:12 +00001172
Sanjiv Gupta98070572008-05-25 05:15:42 +00001173 RegionStack.pop_back();
Sanjiv Gupta15cb6692008-05-08 08:54:20 +00001174}
1175
Sanjiv Gupta18de6242008-05-30 10:30:31 +00001176/// EmitDeclare - Emit local variable declaration debug info.
Chris Lattneraffb3732008-11-10 06:08:34 +00001177void CGDebugInfo::EmitDeclare(const VarDecl *Decl, unsigned Tag,
1178 llvm::Value *Storage, CGBuilderTy &Builder) {
Daniel Dunbar380827c2008-10-17 01:07:56 +00001179 assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
1180
Devang Patelafc1c1d2009-03-27 23:16:32 +00001181 // Do not emit variable debug information while generating optimized code.
1182 // The llvm optimizer and code generator are not yet ready to support
1183 // optimized code debugging.
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001184 const CodeGenOptions &CGO = CGM.getCodeGenOpts();
Chandler Carruthbc55fe22009-11-12 17:24:48 +00001185 if (CGO.OptimizationLevel)
Devang Patelafc1c1d2009-03-27 23:16:32 +00001186 return;
1187
Chris Lattner362d8ae2009-05-05 04:57:08 +00001188 llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation());
Mike Stump2114d7c2009-09-22 02:12:52 +00001189 QualType Type = Decl->getType();
1190 llvm::DIType Ty = getOrCreateType(Type, Unit);
1191 if (Decl->hasAttr<BlocksAttr>()) {
1192 llvm::DICompileUnit DefUnit;
1193 unsigned Tag = llvm::dwarf::DW_TAG_structure_type;
1194
1195 llvm::SmallVector<llvm::DIDescriptor, 5> EltTys;
1196
1197 llvm::DIType FieldTy;
1198
1199 QualType FType;
1200 uint64_t FieldSize, FieldOffset;
1201 unsigned FieldAlign;
1202
1203 llvm::DIArray Elements;
1204 llvm::DIType EltTy;
1205
1206 // Build up structure for the byref. See BuildByRefType.
1207 FieldOffset = 0;
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001208 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Mike Stump2114d7c2009-09-22 02:12:52 +00001209 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001210 FieldSize = CGM.getContext().getTypeSize(FType);
1211 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2114d7c2009-09-22 02:12:52 +00001212 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1213 "__isa", DefUnit,
1214 0, FieldSize, FieldAlign,
1215 FieldOffset, 0, FieldTy);
1216 EltTys.push_back(FieldTy);
1217 FieldOffset += FieldSize;
1218
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001219 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Mike Stump2114d7c2009-09-22 02:12:52 +00001220 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001221 FieldSize = CGM.getContext().getTypeSize(FType);
1222 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2114d7c2009-09-22 02:12:52 +00001223 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1224 "__forwarding", DefUnit,
1225 0, FieldSize, FieldAlign,
1226 FieldOffset, 0, FieldTy);
1227 EltTys.push_back(FieldTy);
1228 FieldOffset += FieldSize;
1229
Anders Carlsson88ea2452009-12-29 07:07:36 +00001230 FType = CGM.getContext().IntTy;
Mike Stump2114d7c2009-09-22 02:12:52 +00001231 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001232 FieldSize = CGM.getContext().getTypeSize(FType);
1233 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2114d7c2009-09-22 02:12:52 +00001234 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1235 "__flags", DefUnit,
1236 0, FieldSize, FieldAlign,
1237 FieldOffset, 0, FieldTy);
1238 EltTys.push_back(FieldTy);
1239 FieldOffset += FieldSize;
1240
Anders Carlsson88ea2452009-12-29 07:07:36 +00001241 FType = CGM.getContext().IntTy;
Mike Stump2114d7c2009-09-22 02:12:52 +00001242 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001243 FieldSize = CGM.getContext().getTypeSize(FType);
1244 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2114d7c2009-09-22 02:12:52 +00001245 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1246 "__size", DefUnit,
1247 0, FieldSize, FieldAlign,
1248 FieldOffset, 0, FieldTy);
1249 EltTys.push_back(FieldTy);
1250 FieldOffset += FieldSize;
1251
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001252 bool HasCopyAndDispose = CGM.BlockRequiresCopying(Type);
Mike Stump2114d7c2009-09-22 02:12:52 +00001253 if (HasCopyAndDispose) {
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001254 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Mike Stump2114d7c2009-09-22 02:12:52 +00001255 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001256 FieldSize = CGM.getContext().getTypeSize(FType);
1257 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2114d7c2009-09-22 02:12:52 +00001258 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1259 "__copy_helper", DefUnit,
1260 0, FieldSize, FieldAlign,
1261 FieldOffset, 0, FieldTy);
1262 EltTys.push_back(FieldTy);
1263 FieldOffset += FieldSize;
1264
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001265 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Mike Stump2114d7c2009-09-22 02:12:52 +00001266 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001267 FieldSize = CGM.getContext().getTypeSize(FType);
1268 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2114d7c2009-09-22 02:12:52 +00001269 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1270 "__destroy_helper", DefUnit,
1271 0, FieldSize, FieldAlign,
1272 FieldOffset, 0, FieldTy);
1273 EltTys.push_back(FieldTy);
1274 FieldOffset += FieldSize;
1275 }
1276
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001277 unsigned Align = CGM.getContext().getDeclAlignInBytes(Decl);
1278 if (Align > CGM.getContext().Target.getPointerAlign(0) / 8) {
Mike Stump2114d7c2009-09-22 02:12:52 +00001279 unsigned AlignedOffsetInBytes
Mike Stump207c680f2009-09-22 02:44:17 +00001280 = llvm::RoundUpToAlignment(FieldOffset/8, Align);
Mike Stump2114d7c2009-09-22 02:12:52 +00001281 unsigned NumPaddingBytes
Mike Stump207c680f2009-09-22 02:44:17 +00001282 = AlignedOffsetInBytes - FieldOffset/8;
Mike Stump2114d7c2009-09-22 02:12:52 +00001283
1284 if (NumPaddingBytes > 0) {
1285 llvm::APInt pad(32, NumPaddingBytes);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001286 FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy,
Mike Stump2114d7c2009-09-22 02:12:52 +00001287 pad, ArrayType::Normal, 0);
1288 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001289 FieldSize = CGM.getContext().getTypeSize(FType);
1290 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2114d7c2009-09-22 02:12:52 +00001291 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member,
1292 Unit, "", DefUnit,
1293 0, FieldSize, FieldAlign,
1294 FieldOffset, 0, FieldTy);
1295 EltTys.push_back(FieldTy);
1296 FieldOffset += FieldSize;
1297 }
1298 }
1299
1300 FType = Type;
1301 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001302 FieldSize = CGM.getContext().getTypeSize(FType);
Mike Stump207c680f2009-09-22 02:44:17 +00001303 FieldAlign = Align*8;
Mike Stump2114d7c2009-09-22 02:12:52 +00001304
1305 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
Devang Patel58bf6e12009-11-25 17:37:31 +00001306 Decl->getName(), DefUnit,
Mike Stump2114d7c2009-09-22 02:12:52 +00001307 0, FieldSize, FieldAlign,
1308 FieldOffset, 0, FieldTy);
1309 EltTys.push_back(FieldTy);
1310 FieldOffset += FieldSize;
1311
1312 Elements = DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
1313
1314 unsigned Flags = llvm::DIType::FlagBlockByrefStruct;
1315
1316 Ty = DebugFactory.CreateCompositeType(Tag, Unit, "",
1317 llvm::DICompileUnit(),
1318 0, FieldOffset, 0, 0, Flags,
1319 llvm::DIType(), Elements);
1320 }
Chris Lattner362d8ae2009-05-05 04:57:08 +00001321
Chris Lattneraffb3732008-11-10 06:08:34 +00001322 // Get location information.
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001323 SourceManager &SM = CGM.getContext().getSourceManager();
Devang Patel12f0dea2009-04-17 21:35:15 +00001324 PresumedLoc PLoc = SM.getPresumedLoc(Decl->getLocation());
Chris Lattner362d8ae2009-05-05 04:57:08 +00001325 unsigned Line = 0;
Eli Friedmanb05d0822009-11-16 20:33:31 +00001326 unsigned Column = 0;
1327 if (!PLoc.isInvalid()) {
Chris Lattner362d8ae2009-05-05 04:57:08 +00001328 Line = PLoc.getLine();
Eli Friedmanb05d0822009-11-16 20:33:31 +00001329 Column = PLoc.getColumn();
1330 } else {
Chris Lattner362d8ae2009-05-05 04:57:08 +00001331 Unit = llvm::DICompileUnit();
Eli Friedmanb05d0822009-11-16 20:33:31 +00001332 }
Mike Stump11289f42009-09-09 15:08:12 +00001333
Chris Lattneraffb3732008-11-10 06:08:34 +00001334 // Create the descriptor for the variable.
Mike Stump11289f42009-09-09 15:08:12 +00001335 llvm::DIVariable D =
Devang Patelb40f2952009-11-13 19:10:24 +00001336 DebugFactory.CreateVariable(Tag, llvm::DIDescriptor(RegionStack.back()),
Devang Patel58bf6e12009-11-25 17:37:31 +00001337 Decl->getName(),
Chris Lattner362d8ae2009-05-05 04:57:08 +00001338 Unit, Line, Ty);
Chris Lattneraffb3732008-11-10 06:08:34 +00001339 // Insert an llvm.dbg.declare into the current block.
Devang Patel53485152009-11-11 19:10:19 +00001340 llvm::Instruction *Call =
Devang Patelaf993bf2009-11-10 23:07:24 +00001341 DebugFactory.InsertDeclare(Storage, D, Builder.GetInsertBlock());
Devang Patel94f798c2009-11-12 18:21:39 +00001342
Devang Patelb40f2952009-11-13 19:10:24 +00001343 llvm::DIScope DS(RegionStack.back());
Devang Patel94f798c2009-11-12 18:21:39 +00001344 llvm::DILocation DO(NULL);
Chris Lattner5e124bf2009-12-28 21:44:41 +00001345 llvm::DILocation DL = DebugFactory.CreateLocation(Line, Column, DS, DO);
1346
Chris Lattner9f021fd2009-12-28 23:41:39 +00001347 Call->setMetadata("dbg", DL.getNode());
Sanjiv Gupta18de6242008-05-30 10:30:31 +00001348}
1349
Mike Stump2e722b92009-09-30 02:43:10 +00001350/// EmitDeclare - Emit local variable declaration debug info.
1351void CGDebugInfo::EmitDeclare(const BlockDeclRefExpr *BDRE, unsigned Tag,
1352 llvm::Value *Storage, CGBuilderTy &Builder,
1353 CodeGenFunction *CGF) {
1354 const ValueDecl *Decl = BDRE->getDecl();
1355 assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
1356
1357 // Do not emit variable debug information while generating optimized code.
1358 // The llvm optimizer and code generator are not yet ready to support
1359 // optimized code debugging.
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001360 const CodeGenOptions &CGO = CGM.getCodeGenOpts();
Chandler Carruthbc55fe22009-11-12 17:24:48 +00001361 if (CGO.OptimizationLevel || Builder.GetInsertBlock() == 0)
Mike Stump2e722b92009-09-30 02:43:10 +00001362 return;
1363
1364 uint64_t XOffset = 0;
1365 llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation());
1366 QualType Type = Decl->getType();
1367 llvm::DIType Ty = getOrCreateType(Type, Unit);
1368 if (Decl->hasAttr<BlocksAttr>()) {
1369 llvm::DICompileUnit DefUnit;
1370 unsigned Tag = llvm::dwarf::DW_TAG_structure_type;
1371
1372 llvm::SmallVector<llvm::DIDescriptor, 5> EltTys;
1373
1374 llvm::DIType FieldTy;
1375
1376 QualType FType;
1377 uint64_t FieldSize, FieldOffset;
1378 unsigned FieldAlign;
1379
1380 llvm::DIArray Elements;
1381 llvm::DIType EltTy;
1382
1383 // Build up structure for the byref. See BuildByRefType.
1384 FieldOffset = 0;
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001385 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Mike Stump2e722b92009-09-30 02:43:10 +00001386 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001387 FieldSize = CGM.getContext().getTypeSize(FType);
1388 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2e722b92009-09-30 02:43:10 +00001389 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1390 "__isa", DefUnit,
1391 0, FieldSize, FieldAlign,
1392 FieldOffset, 0, FieldTy);
1393 EltTys.push_back(FieldTy);
1394 FieldOffset += FieldSize;
1395
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001396 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Mike Stump2e722b92009-09-30 02:43:10 +00001397 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001398 FieldSize = CGM.getContext().getTypeSize(FType);
1399 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2e722b92009-09-30 02:43:10 +00001400 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1401 "__forwarding", DefUnit,
1402 0, FieldSize, FieldAlign,
1403 FieldOffset, 0, FieldTy);
1404 EltTys.push_back(FieldTy);
1405 FieldOffset += FieldSize;
1406
Anders Carlsson88ea2452009-12-29 07:07:36 +00001407 FType = CGM.getContext().IntTy;
Mike Stump2e722b92009-09-30 02:43:10 +00001408 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001409 FieldSize = CGM.getContext().getTypeSize(FType);
1410 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2e722b92009-09-30 02:43:10 +00001411 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1412 "__flags", DefUnit,
1413 0, FieldSize, FieldAlign,
1414 FieldOffset, 0, FieldTy);
1415 EltTys.push_back(FieldTy);
1416 FieldOffset += FieldSize;
1417
Anders Carlsson88ea2452009-12-29 07:07:36 +00001418 FType = CGM.getContext().IntTy;
Mike Stump2e722b92009-09-30 02:43:10 +00001419 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001420 FieldSize = CGM.getContext().getTypeSize(FType);
1421 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2e722b92009-09-30 02:43:10 +00001422 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1423 "__size", DefUnit,
1424 0, FieldSize, FieldAlign,
1425 FieldOffset, 0, FieldTy);
1426 EltTys.push_back(FieldTy);
1427 FieldOffset += FieldSize;
1428
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001429 bool HasCopyAndDispose = CGM.BlockRequiresCopying(Type);
Mike Stump2e722b92009-09-30 02:43:10 +00001430 if (HasCopyAndDispose) {
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001431 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Mike Stump2e722b92009-09-30 02:43:10 +00001432 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001433 FieldSize = CGM.getContext().getTypeSize(FType);
1434 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2e722b92009-09-30 02:43:10 +00001435 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1436 "__copy_helper", DefUnit,
1437 0, FieldSize, FieldAlign,
1438 FieldOffset, 0, FieldTy);
1439 EltTys.push_back(FieldTy);
1440 FieldOffset += FieldSize;
1441
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001442 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Mike Stump2e722b92009-09-30 02:43:10 +00001443 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001444 FieldSize = CGM.getContext().getTypeSize(FType);
1445 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2e722b92009-09-30 02:43:10 +00001446 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1447 "__destroy_helper", DefUnit,
1448 0, FieldSize, FieldAlign,
1449 FieldOffset, 0, FieldTy);
1450 EltTys.push_back(FieldTy);
1451 FieldOffset += FieldSize;
1452 }
1453
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001454 unsigned Align = CGM.getContext().getDeclAlignInBytes(Decl);
1455 if (Align > CGM.getContext().Target.getPointerAlign(0) / 8) {
Mike Stump2e722b92009-09-30 02:43:10 +00001456 unsigned AlignedOffsetInBytes
1457 = llvm::RoundUpToAlignment(FieldOffset/8, Align);
1458 unsigned NumPaddingBytes
1459 = AlignedOffsetInBytes - FieldOffset/8;
1460
1461 if (NumPaddingBytes > 0) {
1462 llvm::APInt pad(32, NumPaddingBytes);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001463 FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy,
Mike Stump2e722b92009-09-30 02:43:10 +00001464 pad, ArrayType::Normal, 0);
1465 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001466 FieldSize = CGM.getContext().getTypeSize(FType);
1467 FieldAlign = CGM.getContext().getTypeAlign(FType);
Mike Stump2e722b92009-09-30 02:43:10 +00001468 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member,
1469 Unit, "", DefUnit,
1470 0, FieldSize, FieldAlign,
1471 FieldOffset, 0, FieldTy);
1472 EltTys.push_back(FieldTy);
1473 FieldOffset += FieldSize;
1474 }
1475 }
1476
1477 FType = Type;
1478 FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001479 FieldSize = CGM.getContext().getTypeSize(FType);
Mike Stump2e722b92009-09-30 02:43:10 +00001480 FieldAlign = Align*8;
Mike Stump2e722b92009-09-30 02:43:10 +00001481
1482 XOffset = FieldOffset;
1483 FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
Devang Patel58bf6e12009-11-25 17:37:31 +00001484 Decl->getName(), DefUnit,
Mike Stump2e722b92009-09-30 02:43:10 +00001485 0, FieldSize, FieldAlign,
1486 FieldOffset, 0, FieldTy);
1487 EltTys.push_back(FieldTy);
1488 FieldOffset += FieldSize;
1489
1490 Elements = DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
1491
1492 unsigned Flags = llvm::DIType::FlagBlockByrefStruct;
1493
1494 Ty = DebugFactory.CreateCompositeType(Tag, Unit, "",
1495 llvm::DICompileUnit(),
1496 0, FieldOffset, 0, 0, Flags,
1497 llvm::DIType(), Elements);
1498 }
1499
1500 // Get location information.
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001501 SourceManager &SM = CGM.getContext().getSourceManager();
Mike Stump2e722b92009-09-30 02:43:10 +00001502 PresumedLoc PLoc = SM.getPresumedLoc(Decl->getLocation());
1503 unsigned Line = 0;
1504 if (!PLoc.isInvalid())
1505 Line = PLoc.getLine();
1506 else
1507 Unit = llvm::DICompileUnit();
1508
Ken Dyck40775002010-01-11 17:06:35 +00001509 CharUnits offset = CGF->BlockDecls[Decl];
Mike Stump2e722b92009-09-30 02:43:10 +00001510 llvm::SmallVector<llvm::Value *, 9> addr;
Chris Lattnerbf784782010-01-25 03:29:35 +00001511 const llvm::Type *Int64Ty = llvm::Type::getInt64Ty(CGM.getLLVMContext());
1512 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIFactory::OpDeref));
1513 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIFactory::OpPlus));
1514 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
Mike Stump2e722b92009-09-30 02:43:10 +00001515 if (BDRE->isByRef()) {
Chris Lattnerbf784782010-01-25 03:29:35 +00001516 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIFactory::OpDeref));
1517 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIFactory::OpPlus));
Ken Dyck40775002010-01-11 17:06:35 +00001518 // offset of __forwarding field
1519 offset = CharUnits::fromQuantity(CGF->LLVMPointerWidth/8);
Chris Lattnerbf784782010-01-25 03:29:35 +00001520 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
1521 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIFactory::OpDeref));
1522 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIFactory::OpPlus));
Ken Dyck40775002010-01-11 17:06:35 +00001523 // offset of x field
1524 offset = CharUnits::fromQuantity(XOffset/8);
Chris Lattnerbf784782010-01-25 03:29:35 +00001525 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
Mike Stump2e722b92009-09-30 02:43:10 +00001526 }
1527
1528 // Create the descriptor for the variable.
1529 llvm::DIVariable D =
Chris Lattner83b0dd12010-01-25 03:34:56 +00001530 DebugFactory.CreateComplexVariable(Tag,
1531 llvm::DIDescriptor(RegionStack.back()),
Devang Patel58bf6e12009-11-25 17:37:31 +00001532 Decl->getName(), Unit, Line, Ty,
Mike Stump2e722b92009-09-30 02:43:10 +00001533 addr);
1534 // Insert an llvm.dbg.declare into the current block.
Devang Patel53485152009-11-11 19:10:19 +00001535 llvm::Instruction *Call =
Chris Lattner83b0dd12010-01-25 03:34:56 +00001536 DebugFactory.InsertDeclare(Storage, D, Builder.GetInsertBlock());
Devang Patel94f798c2009-11-12 18:21:39 +00001537
Devang Patelb40f2952009-11-13 19:10:24 +00001538 llvm::DIScope DS(RegionStack.back());
Devang Patel94f798c2009-11-12 18:21:39 +00001539 llvm::DILocation DO(NULL);
1540 llvm::DILocation DL =
1541 DebugFactory.CreateLocation(Line, PLoc.getColumn(), DS, DO);
Chris Lattner5e124bf2009-12-28 21:44:41 +00001542
Chris Lattner9f021fd2009-12-28 23:41:39 +00001543 Call->setMetadata("dbg", DL.getNode());
Mike Stump2e722b92009-09-30 02:43:10 +00001544}
1545
Chris Lattneraffb3732008-11-10 06:08:34 +00001546void CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *Decl,
1547 llvm::Value *Storage,
1548 CGBuilderTy &Builder) {
1549 EmitDeclare(Decl, llvm::dwarf::DW_TAG_auto_variable, Storage, Builder);
1550}
1551
Mike Stump2e722b92009-09-30 02:43:10 +00001552void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
1553 const BlockDeclRefExpr *BDRE, llvm::Value *Storage, CGBuilderTy &Builder,
1554 CodeGenFunction *CGF) {
1555 EmitDeclare(BDRE, llvm::dwarf::DW_TAG_auto_variable, Storage, Builder, CGF);
1556}
1557
Chris Lattneraffb3732008-11-10 06:08:34 +00001558/// EmitDeclareOfArgVariable - Emit call to llvm.dbg.declare for an argument
1559/// variable declaration.
1560void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *Decl, llvm::Value *AI,
1561 CGBuilderTy &Builder) {
1562 EmitDeclare(Decl, llvm::dwarf::DW_TAG_arg_variable, AI, Builder);
1563}
1564
1565
1566
Sanjiv Gupta158143a2008-06-05 08:59:10 +00001567/// EmitGlobalVariable - Emit information about a global variable.
Mike Stump11289f42009-09-09 15:08:12 +00001568void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
Chris Lattneraffb3732008-11-10 06:08:34 +00001569 const VarDecl *Decl) {
Devang Patelafc1c1d2009-03-27 23:16:32 +00001570
Sanjiv Gupta158143a2008-06-05 08:59:10 +00001571 // Create global variable debug descriptor.
Chris Lattneraffb3732008-11-10 06:08:34 +00001572 llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation());
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001573 SourceManager &SM = CGM.getContext().getSourceManager();
Devang Patel12f0dea2009-04-17 21:35:15 +00001574 PresumedLoc PLoc = SM.getPresumedLoc(Decl->getLocation());
1575 unsigned LineNo = PLoc.isInvalid() ? 0 : PLoc.getLine();
Chris Lattner86d7d912008-11-24 03:54:41 +00001576
Anders Carlssonf7a9a922008-11-26 17:40:42 +00001577 QualType T = Decl->getType();
1578 if (T->isIncompleteArrayType()) {
Mike Stump11289f42009-09-09 15:08:12 +00001579
Anders Carlssonf7a9a922008-11-26 17:40:42 +00001580 // CodeGen turns int[] into int[1] so we'll do the same here.
1581 llvm::APSInt ConstVal(32);
Mike Stump11289f42009-09-09 15:08:12 +00001582
Anders Carlssonf7a9a922008-11-26 17:40:42 +00001583 ConstVal = 1;
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001584 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
Mike Stump11289f42009-09-09 15:08:12 +00001585
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001586 T = CGM.getContext().getConstantArrayType(ET, ConstVal,
Anders Carlssonf7a9a922008-11-26 17:40:42 +00001587 ArrayType::Normal, 0);
1588 }
Devang Patel58bf6e12009-11-25 17:37:31 +00001589 llvm::StringRef DeclName = Decl->getName();
Devang Patel7bdf0962009-11-12 00:51:46 +00001590 DebugFactory.CreateGlobalVariable(getContext(Decl, Unit), DeclName, DeclName,
Devang Patel58bf6e12009-11-25 17:37:31 +00001591 llvm::StringRef(), Unit, LineNo,
Anders Carlssonf7a9a922008-11-26 17:40:42 +00001592 getOrCreateType(T, Unit),
Chris Lattneraffb3732008-11-10 06:08:34 +00001593 Var->hasInternalLinkage(),
1594 true/*definition*/, Var);
Sanjiv Gupta158143a2008-06-05 08:59:10 +00001595}
1596
Devang Patelf4c205b2009-02-26 21:10:26 +00001597/// EmitGlobalVariable - Emit information about an objective-c interface.
Mike Stump11289f42009-09-09 15:08:12 +00001598void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
Devang Patelf4c205b2009-02-26 21:10:26 +00001599 ObjCInterfaceDecl *Decl) {
1600 // Create global variable debug descriptor.
1601 llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation());
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001602 SourceManager &SM = CGM.getContext().getSourceManager();
Devang Patel12f0dea2009-04-17 21:35:15 +00001603 PresumedLoc PLoc = SM.getPresumedLoc(Decl->getLocation());
1604 unsigned LineNo = PLoc.isInvalid() ? 0 : PLoc.getLine();
Devang Patelf4c205b2009-02-26 21:10:26 +00001605
Devang Patel58bf6e12009-11-25 17:37:31 +00001606 llvm::StringRef Name = Decl->getName();
Devang Patelf4c205b2009-02-26 21:10:26 +00001607
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001608 QualType T = CGM.getContext().getObjCInterfaceType(Decl);
Devang Patelf4c205b2009-02-26 21:10:26 +00001609 if (T->isIncompleteArrayType()) {
Mike Stump11289f42009-09-09 15:08:12 +00001610
Devang Patelf4c205b2009-02-26 21:10:26 +00001611 // CodeGen turns int[] into int[1] so we'll do the same here.
1612 llvm::APSInt ConstVal(32);
Mike Stump11289f42009-09-09 15:08:12 +00001613
Devang Patelf4c205b2009-02-26 21:10:26 +00001614 ConstVal = 1;
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001615 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
Mike Stump11289f42009-09-09 15:08:12 +00001616
Anders Carlsson3efc6e62009-12-06 18:00:51 +00001617 T = CGM.getContext().getConstantArrayType(ET, ConstVal,
Devang Patelf4c205b2009-02-26 21:10:26 +00001618 ArrayType::Normal, 0);
1619 }
1620
Devang Patele4f2b2a2009-10-20 18:26:30 +00001621 DebugFactory.CreateGlobalVariable(Unit, Name, Name, Name, Unit, LineNo,
Devang Patelf4c205b2009-02-26 21:10:26 +00001622 getOrCreateType(T, Unit),
1623 Var->hasInternalLinkage(),
1624 true/*definition*/, Var);
1625}