blob: 1e0eeb2122e66747ed4d1bce7c143a3782b3a0f4 [file] [log] [blame]
Sanjiv Guptae8b9f5b2008-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 Stumpb1a6e682009-09-30 02:43:10 +000015#include "CodeGenFunction.h"
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +000016#include "CodeGenModule.h"
John McCalld16c2cf2011-02-08 08:22:06 +000017#include "CGBlocks.h"
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +000018#include "clang/AST/ASTContext.h"
Devang Patel2ed8f002010-08-27 17:47:47 +000019#include "clang/AST/DeclFriend.h"
Devang Patel9ca36b62009-02-26 21:10:26 +000020#include "clang/AST/DeclObjC.h"
Devang Patel700a1cb2010-07-20 20:24:18 +000021#include "clang/AST/DeclTemplate.h"
Chris Lattner3cc5c402008-11-11 07:01:36 +000022#include "clang/AST/Expr.h"
Anders Carlsson19cc4ab2009-07-18 19:43:29 +000023#include "clang/AST/RecordLayout.h"
Benjamin Kramer00bd44d2012-02-04 12:31:12 +000024#include "clang/Basic/SourceManager.h"
Benjamin Kramerd7a3e2c2012-02-07 22:29:24 +000025#include "clang/Basic/FileManager.h"
Mike Stump5a862172009-09-15 21:48:34 +000026#include "clang/Basic/Version.h"
Chandler Carruth06057ce2010-06-15 23:19:56 +000027#include "clang/Frontend/CodeGenOptions.h"
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +000028#include "llvm/Constants.h"
29#include "llvm/DerivedTypes.h"
30#include "llvm/Instructions.h"
31#include "llvm/Intrinsics.h"
32#include "llvm/Module.h"
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +000033#include "llvm/ADT/StringExtras.h"
34#include "llvm/ADT/SmallVector.h"
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +000035#include "llvm/Support/Dwarf.h"
Benjamin Kramerbcbca752011-10-14 18:45:11 +000036#include "llvm/Support/FileSystem.h"
John McCall6b5a61b2011-02-07 10:33:21 +000037#include "llvm/Target/TargetData.h"
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +000038using namespace clang;
39using namespace clang::CodeGen;
40
Anders Carlsson20f12a22009-12-06 18:00:51 +000041CGDebugInfo::CGDebugInfo(CodeGenModule &CGM)
Devang Patel823d8e92010-12-08 22:42:58 +000042 : CGM(CGM), DBuilder(CGM.getModule()),
Dan Gohman4cac5b42010-08-20 22:02:57 +000043 BlockLiteralGenericSet(false) {
Devang Patel17800552010-03-09 00:44:50 +000044 CreateCompileUnit();
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +000045}
46
Chris Lattner9c85ba32008-11-10 06:08:34 +000047CGDebugInfo::~CGDebugInfo() {
Eric Christopherab5278e2011-10-11 23:00:51 +000048 assert(LexicalBlockStack.empty() &&
49 "Region stack mismatch, stack not empty!");
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +000050}
51
Chris Lattner9c85ba32008-11-10 06:08:34 +000052void CGDebugInfo::setLocation(SourceLocation Loc) {
Eric Christopher944542e2011-10-11 23:00:45 +000053 // If the new location isn't valid return.
54 if (!Loc.isValid()) return;
55
56 CurLoc = CGM.getContext().getSourceManager().getExpansionLoc(Loc);
Eric Christopher73fb3502011-10-13 21:45:18 +000057
58 // If we've changed files in the middle of a lexical scope go ahead
59 // and create a new lexical scope with file node if it's different
60 // from the one in the scope.
61 if (LexicalBlockStack.empty()) return;
62
63 SourceManager &SM = CGM.getContext().getSourceManager();
64 PresumedLoc PCLoc = SM.getPresumedLoc(CurLoc);
65 PresumedLoc PPLoc = SM.getPresumedLoc(PrevLoc);
66
67 if (PCLoc.isInvalid() || PPLoc.isInvalid() ||
68 !strcmp(PPLoc.getFilename(), PCLoc.getFilename()))
69 return;
70
71 llvm::MDNode *LB = LexicalBlockStack.back();
72 llvm::DIScope Scope = llvm::DIScope(LB);
73 if (Scope.isLexicalBlockFile()) {
74 llvm::DILexicalBlockFile LBF = llvm::DILexicalBlockFile(LB);
75 llvm::DIDescriptor D
76 = DBuilder.createLexicalBlockFile(LBF.getScope(),
Devang Patel53bc5182012-02-08 00:10:20 +000077 getOrCreateFile(CurLoc));
Eric Christopher73fb3502011-10-13 21:45:18 +000078 llvm::MDNode *N = D;
79 LexicalBlockStack.pop_back();
80 LexicalBlockStack.push_back(N);
81 } else if (Scope.isLexicalBlock()) {
82 llvm::DIDescriptor D
83 = DBuilder.createLexicalBlockFile(Scope, getOrCreateFile(CurLoc));
84 llvm::MDNode *N = D;
85 LexicalBlockStack.pop_back();
86 LexicalBlockStack.push_back(N);
87 }
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +000088}
89
Devang Patel33583052010-01-28 23:15:27 +000090/// getContextDescriptor - Get context info for the decl.
Devang Patel170cef32010-12-09 00:33:05 +000091llvm::DIDescriptor CGDebugInfo::getContextDescriptor(const Decl *Context) {
Devang Pateleb6d79b2010-02-01 21:34:11 +000092 if (!Context)
Devang Patel170cef32010-12-09 00:33:05 +000093 return TheCU;
Devang Pateleb6d79b2010-02-01 21:34:11 +000094
95 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator
96 I = RegionMap.find(Context);
97 if (I != RegionMap.end())
Gabor Greif38c9b172010-09-18 13:00:17 +000098 return llvm::DIDescriptor(dyn_cast_or_null<llvm::MDNode>(&*I->second));
Devang Patel411894b2010-02-01 22:40:08 +000099
Devang Pateleb6d79b2010-02-01 21:34:11 +0000100 // Check namespace.
101 if (const NamespaceDecl *NSDecl = dyn_cast<NamespaceDecl>(Context))
Devang Patel170cef32010-12-09 00:33:05 +0000102 return llvm::DIDescriptor(getOrCreateNameSpace(NSDecl));
Devang Patel8b90a782010-05-13 23:52:37 +0000103
104 if (const RecordDecl *RDecl = dyn_cast<RecordDecl>(Context)) {
105 if (!RDecl->isDependentType()) {
Devang Patela2e57692010-10-28 17:27:32 +0000106 llvm::DIType Ty = getOrCreateType(CGM.getContext().getTypeDeclType(RDecl),
Devang Patel170cef32010-12-09 00:33:05 +0000107 getOrCreateMainFile());
Devang Patel8b90a782010-05-13 23:52:37 +0000108 return llvm::DIDescriptor(Ty);
109 }
110 }
Devang Patel170cef32010-12-09 00:33:05 +0000111 return TheCU;
Devang Patel979ec2e2009-10-06 00:35:31 +0000112}
113
Devang Patel9c6c3a02010-01-14 00:36:21 +0000114/// getFunctionName - Get function name for the given FunctionDecl. If the
115/// name is constructred on demand (e.g. C++ destructor) then the name
116/// is stored on the side.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000117StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) {
Devang Patel9c6c3a02010-01-14 00:36:21 +0000118 assert (FD && "Invalid FunctionDecl!");
119 IdentifierInfo *FII = FD->getIdentifier();
Eric Christopher16717452012-03-14 00:25:46 +0000120 FunctionTemplateSpecializationInfo *Info
121 = FD->getTemplateSpecializationInfo();
122 if (!Info && FII)
Devang Patel9c6c3a02010-01-14 00:36:21 +0000123 return FII->getName();
124
125 // Otherwise construct human readable name for debug info.
126 std::string NS = FD->getNameAsString();
127
Eric Christopher16717452012-03-14 00:25:46 +0000128 // Add any template specialization args.
129 if (Info) {
130 const TemplateArgumentList *TArgs = Info->TemplateArguments;
131 const TemplateArgument *Args = TArgs->data();
132 unsigned NumArgs = TArgs->size();
133 PrintingPolicy Policy(CGM.getLangOpts());
134 NS += TemplateSpecializationType::PrintTemplateArgumentList(Args,
135 NumArgs,
136 Policy);
137 }
138
Devang Patel9c6c3a02010-01-14 00:36:21 +0000139 // Copy this name on the side and use its reference.
Devang Patel89f05f82010-01-28 18:21:00 +0000140 char *StrPtr = DebugInfoNames.Allocate<char>(NS.length());
Benjamin Kramer1b627dc2010-01-23 18:16:07 +0000141 memcpy(StrPtr, NS.data(), NS.length());
Chris Lattner5f9e2722011-07-23 10:55:15 +0000142 return StringRef(StrPtr, NS.length());
Devang Patel9c6c3a02010-01-14 00:36:21 +0000143}
144
Chris Lattner5f9e2722011-07-23 10:55:15 +0000145StringRef CGDebugInfo::getObjCMethodName(const ObjCMethodDecl *OMD) {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000146 SmallString<256> MethodName;
David Chisnall52044a22010-09-02 18:01:51 +0000147 llvm::raw_svector_ostream OS(MethodName);
148 OS << (OMD->isInstanceMethod() ? '-' : '+') << '[';
149 const DeclContext *DC = OMD->getDeclContext();
Devang Patela2e57692010-10-28 17:27:32 +0000150 if (const ObjCImplementationDecl *OID =
151 dyn_cast<const ObjCImplementationDecl>(DC)) {
David Chisnall52044a22010-09-02 18:01:51 +0000152 OS << OID->getName();
Devang Patela2e57692010-10-28 17:27:32 +0000153 } else if (const ObjCInterfaceDecl *OID =
154 dyn_cast<const ObjCInterfaceDecl>(DC)) {
Fariborz Jahanian1a4c9372010-10-18 17:51:06 +0000155 OS << OID->getName();
Devang Patela2e57692010-10-28 17:27:32 +0000156 } else if (const ObjCCategoryImplDecl *OCD =
157 dyn_cast<const ObjCCategoryImplDecl>(DC)){
David Chisnall52044a22010-09-02 18:01:51 +0000158 OS << ((NamedDecl *)OCD)->getIdentifier()->getNameStart() << '(' <<
159 OCD->getIdentifier()->getNameStart() << ')';
160 }
161 OS << ' ' << OMD->getSelector().getAsString() << ']';
162
163 char *StrPtr = DebugInfoNames.Allocate<char>(OS.tell());
164 memcpy(StrPtr, MethodName.begin(), OS.tell());
Chris Lattner5f9e2722011-07-23 10:55:15 +0000165 return StringRef(StrPtr, OS.tell());
David Chisnall52044a22010-09-02 18:01:51 +0000166}
167
Devang Patel1f15c192011-04-18 17:30:25 +0000168/// getSelectorName - Return selector name. This is used for debugging
Devang Patel90c1eed2011-04-16 00:37:51 +0000169/// info.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000170StringRef CGDebugInfo::getSelectorName(Selector S) {
Benjamin Kramer2b5cfbc2011-10-14 18:45:16 +0000171 const std::string &SName = S.getAsString();
172 char *StrPtr = DebugInfoNames.Allocate<char>(SName.size());
173 memcpy(StrPtr, SName.data(), SName.size());
174 return StringRef(StrPtr, SName.size());
Devang Patel90c1eed2011-04-16 00:37:51 +0000175}
176
Devang Patel700a1cb2010-07-20 20:24:18 +0000177/// getClassName - Get class name including template argument list.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000178StringRef
Eric Christopher9caf4402012-02-08 01:53:14 +0000179CGDebugInfo::getClassName(const RecordDecl *RD) {
180 const ClassTemplateSpecializationDecl *Spec
Devang Patel700a1cb2010-07-20 20:24:18 +0000181 = dyn_cast<ClassTemplateSpecializationDecl>(RD);
182 if (!Spec)
183 return RD->getName();
184
185 const TemplateArgument *Args;
186 unsigned NumArgs;
187 std::string Buffer;
188 if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) {
189 const TemplateSpecializationType *TST =
190 cast<TemplateSpecializationType>(TAW->getType());
191 Args = TST->getArgs();
192 NumArgs = TST->getNumArgs();
193 } else {
194 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
Douglas Gregor910f8002010-11-07 23:05:16 +0000195 Args = TemplateArgs.data();
196 NumArgs = TemplateArgs.size();
Devang Patel700a1cb2010-07-20 20:24:18 +0000197 }
198 Buffer = RD->getIdentifier()->getNameStart();
David Blaikie4e4d0842012-03-11 07:00:24 +0000199 PrintingPolicy Policy(CGM.getLangOpts());
Devang Patel700a1cb2010-07-20 20:24:18 +0000200 Buffer += TemplateSpecializationType::PrintTemplateArgumentList(Args,
201 NumArgs,
202 Policy);
203
204 // Copy this name on the side and use its reference.
205 char *StrPtr = DebugInfoNames.Allocate<char>(Buffer.length());
206 memcpy(StrPtr, Buffer.data(), Buffer.length());
Chris Lattner5f9e2722011-07-23 10:55:15 +0000207 return StringRef(StrPtr, Buffer.length());
Devang Patel700a1cb2010-07-20 20:24:18 +0000208}
209
Devang Patel17800552010-03-09 00:44:50 +0000210/// getOrCreateFile - Get the file debug info descriptor for the input location.
211llvm::DIFile CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
Devang Patel823d8e92010-12-08 22:42:58 +0000212 if (!Loc.isValid())
213 // If Location is not valid then use main input file.
Devang Patel16674e82011-02-22 18:56:36 +0000214 return DBuilder.createFile(TheCU.getFilename(), TheCU.getDirectory());
Devang Patel823d8e92010-12-08 22:42:58 +0000215
Anders Carlsson20f12a22009-12-06 18:00:51 +0000216 SourceManager &SM = CGM.getContext().getSourceManager();
Devang Patel17800552010-03-09 00:44:50 +0000217 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
Ted Kremenek9c250392010-03-30 00:27:51 +0000218
Chris Lattner5f9e2722011-07-23 10:55:15 +0000219 if (PLoc.isInvalid() || StringRef(PLoc.getFilename()).empty())
Douglas Gregor8c457a82010-11-11 20:45:16 +0000220 // If the location is not valid then use main input file.
Devang Patel16674e82011-02-22 18:56:36 +0000221 return DBuilder.createFile(TheCU.getFilename(), TheCU.getDirectory());
Douglas Gregor8c457a82010-11-11 20:45:16 +0000222
Ted Kremenek9c250392010-03-30 00:27:51 +0000223 // Cache the results.
224 const char *fname = PLoc.getFilename();
225 llvm::DenseMap<const char *, llvm::WeakVH>::iterator it =
226 DIFileCache.find(fname);
227
228 if (it != DIFileCache.end()) {
229 // Verify that the information still exists.
230 if (&*it->second)
231 return llvm::DIFile(cast<llvm::MDNode>(it->second));
232 }
233
Devang Patel16674e82011-02-22 18:56:36 +0000234 llvm::DIFile F = DBuilder.createFile(PLoc.getFilename(), getCurrentDirname());
Ted Kremenek9c250392010-03-30 00:27:51 +0000235
Devang Patelab699792010-05-07 18:12:35 +0000236 DIFileCache[fname] = F;
Ted Kremenek9c250392010-03-30 00:27:51 +0000237 return F;
Devang Patel17800552010-03-09 00:44:50 +0000238}
Devang Patel8ab870d2010-05-12 23:46:38 +0000239
Devang Patel532105f2010-10-28 22:03:20 +0000240/// getOrCreateMainFile - Get the file info for main compile unit.
241llvm::DIFile CGDebugInfo::getOrCreateMainFile() {
Devang Patel16674e82011-02-22 18:56:36 +0000242 return DBuilder.createFile(TheCU.getFilename(), TheCU.getDirectory());
Devang Patel532105f2010-10-28 22:03:20 +0000243}
244
Devang Patel8ab870d2010-05-12 23:46:38 +0000245/// getLineNumber - Get line number for the location. If location is invalid
246/// then use current location.
247unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) {
Devang Patel362ed2a2012-02-06 23:24:13 +0000248 if (Loc.isInvalid() && CurLoc.isInvalid())
249 return 0;
Devang Patel8ab870d2010-05-12 23:46:38 +0000250 SourceManager &SM = CGM.getContext().getSourceManager();
251 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
Douglas Gregor8c457a82010-11-11 20:45:16 +0000252 return PLoc.isValid()? PLoc.getLine() : 0;
Devang Patel8ab870d2010-05-12 23:46:38 +0000253}
254
255/// getColumnNumber - Get column number for the location. If location is
256/// invalid then use current location.
257unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc) {
Devang Patel362ed2a2012-02-06 23:24:13 +0000258 if (Loc.isInvalid() && CurLoc.isInvalid())
259 return 0;
Devang Patel8ab870d2010-05-12 23:46:38 +0000260 SourceManager &SM = CGM.getContext().getSourceManager();
261 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
Douglas Gregor8c457a82010-11-11 20:45:16 +0000262 return PLoc.isValid()? PLoc.getColumn() : 0;
Devang Patel8ab870d2010-05-12 23:46:38 +0000263}
264
Chris Lattner5f9e2722011-07-23 10:55:15 +0000265StringRef CGDebugInfo::getCurrentDirname() {
Nick Lewycky7c4fd912011-10-21 02:32:14 +0000266 if (!CGM.getCodeGenOpts().DebugCompilationDir.empty())
267 return CGM.getCodeGenOpts().DebugCompilationDir;
268
Devang Patelac4d13c2010-07-27 15:17:16 +0000269 if (!CWDName.empty())
270 return CWDName;
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000271 SmallString<256> CWD;
Benjamin Kramerbcbca752011-10-14 18:45:11 +0000272 llvm::sys::fs::current_path(CWD);
273 char *CompDirnamePtr = DebugInfoNames.Allocate<char>(CWD.size());
274 memcpy(CompDirnamePtr, CWD.data(), CWD.size());
Chris Lattner5f9e2722011-07-23 10:55:15 +0000275 return CWDName = StringRef(CompDirnamePtr, CWD.size());
Devang Patelac4d13c2010-07-27 15:17:16 +0000276}
277
Devang Patel17800552010-03-09 00:44:50 +0000278/// CreateCompileUnit - Create new compile unit.
279void CGDebugInfo::CreateCompileUnit() {
280
281 // Get absolute path name.
Douglas Gregorac91b4c2010-03-18 23:46:43 +0000282 SourceManager &SM = CGM.getContext().getSourceManager();
Douglas Gregorf7ad5002010-03-19 14:49:09 +0000283 std::string MainFileName = CGM.getCodeGenOpts().MainFileName;
284 if (MainFileName.empty())
Devang Patel22fe5852010-03-12 21:04:27 +0000285 MainFileName = "<unknown>";
Douglas Gregorf7ad5002010-03-19 14:49:09 +0000286
Douglas Gregorf6728fc2010-03-22 21:28:29 +0000287 // The main file name provided via the "-main-file-name" option contains just
288 // the file name itself with no path information. This file name may have had
289 // a relative path, so we look into the actual file entry for the main
290 // file to determine the real absolute path for the file.
Devang Patel6e6bc392010-07-23 23:04:28 +0000291 std::string MainFileDir;
Devang Patelac4d13c2010-07-27 15:17:16 +0000292 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
Douglas Gregorf7ad5002010-03-19 14:49:09 +0000293 MainFileDir = MainFile->getDir()->getName();
Devang Patelac4d13c2010-07-27 15:17:16 +0000294 if (MainFileDir != ".")
295 MainFileName = MainFileDir + "/" + MainFileName;
296 }
Douglas Gregorf7ad5002010-03-19 14:49:09 +0000297
Devang Patelac4d13c2010-07-27 15:17:16 +0000298 // Save filename string.
299 char *FilenamePtr = DebugInfoNames.Allocate<char>(MainFileName.length());
300 memcpy(FilenamePtr, MainFileName.c_str(), MainFileName.length());
Chris Lattner5f9e2722011-07-23 10:55:15 +0000301 StringRef Filename(FilenamePtr, MainFileName.length());
Devang Patelac4d13c2010-07-27 15:17:16 +0000302
Chris Lattner515455a2009-03-25 03:28:08 +0000303 unsigned LangTag;
David Blaikie4e4d0842012-03-11 07:00:24 +0000304 const LangOptions &LO = CGM.getLangOpts();
Chris Lattner515455a2009-03-25 03:28:08 +0000305 if (LO.CPlusPlus) {
306 if (LO.ObjC1)
307 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
308 else
309 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
310 } else if (LO.ObjC1) {
Devang Patel8d9aefc2009-03-24 20:35:51 +0000311 LangTag = llvm::dwarf::DW_LANG_ObjC;
Chris Lattner515455a2009-03-25 03:28:08 +0000312 } else if (LO.C99) {
Devang Patel8d9aefc2009-03-24 20:35:51 +0000313 LangTag = llvm::dwarf::DW_LANG_C99;
Chris Lattner515455a2009-03-25 03:28:08 +0000314 } else {
315 LangTag = llvm::dwarf::DW_LANG_C89;
316 }
Devang Patel446c6192009-04-17 21:06:59 +0000317
Daniel Dunbar19f19832010-08-24 17:41:09 +0000318 std::string Producer = getClangFullVersion();
Chris Lattner4c2577a2009-05-02 01:00:04 +0000319
320 // Figure out which version of the ObjC runtime we have.
321 unsigned RuntimeVers = 0;
322 if (LO.ObjC1)
323 RuntimeVers = LO.ObjCNonFragileABI ? 2 : 1;
Mike Stump1eb44332009-09-09 15:08:12 +0000324
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +0000325 // Create new compile unit.
Devang Patel16674e82011-02-22 18:56:36 +0000326 DBuilder.createCompileUnit(
Devang Patel58115002010-07-27 20:49:59 +0000327 LangTag, Filename, getCurrentDirname(),
Devang Patel823d8e92010-12-08 22:42:58 +0000328 Producer,
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +0000329 LO.Optimize, CGM.getCodeGenOpts().DwarfDebugFlags, RuntimeVers);
Devang Patel823d8e92010-12-08 22:42:58 +0000330 // FIXME - Eliminate TheCU.
331 TheCU = llvm::DICompileUnit(DBuilder.getCU());
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +0000332}
333
Devang Patel65e99f22009-02-25 01:36:11 +0000334/// CreateType - Get the Basic type from the cache or create a new
Chris Lattner9c85ba32008-11-10 06:08:34 +0000335/// one if necessary.
Devang Patelf1d1d9a2010-11-01 16:52:40 +0000336llvm::DIType CGDebugInfo::CreateType(const BuiltinType *BT) {
Chris Lattner9c85ba32008-11-10 06:08:34 +0000337 unsigned Encoding = 0;
Devang Patel05127ca2010-07-28 23:23:29 +0000338 const char *BTName = NULL;
Chris Lattner9c85ba32008-11-10 06:08:34 +0000339 switch (BT->getKind()) {
John McCalle0a22d02011-10-18 21:02:43 +0000340#define BUILTIN_TYPE(Id, SingletonId)
341#define PLACEHOLDER_TYPE(Id, SingletonId) \
342 case BuiltinType::Id:
343#include "clang/AST/BuiltinTypes.def"
Devang Patele7566cf2011-09-12 18:50:21 +0000344 case BuiltinType::Dependent:
John McCalle0a22d02011-10-18 21:02:43 +0000345 llvm_unreachable("Unexpected builtin type");
Devang Patele7566cf2011-09-12 18:50:21 +0000346 case BuiltinType::NullPtr:
Devang Patelf60dca32011-09-14 23:14:14 +0000347 return DBuilder.
David Blaikie4e4d0842012-03-11 07:00:24 +0000348 createNullPtrType(BT->getName(CGM.getContext().getLangOpts()));
Chris Lattner9c85ba32008-11-10 06:08:34 +0000349 case BuiltinType::Void:
350 return llvm::DIType();
Devang Patelc8972c62010-07-28 01:33:15 +0000351 case BuiltinType::ObjCClass:
Eric Christopher917bc8d2012-02-20 18:05:04 +0000352 return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
Eric Christophere86b9ea2012-02-20 23:02:36 +0000353 "objc_class", getOrCreateMainFile(),
354 0);
Devang Patelc8972c62010-07-28 01:33:15 +0000355 case BuiltinType::ObjCId: {
356 // typedef struct objc_class *Class;
357 // typedef struct objc_object {
358 // Class isa;
359 // } *id;
360
Eric Christopherb45cfea2012-02-23 00:43:12 +0000361 // TODO: Cache these two types to avoid duplicates.
Eric Christopher917bc8d2012-02-20 18:05:04 +0000362 llvm::DIType OCTy =
363 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
Eric Christophere86b9ea2012-02-20 23:02:36 +0000364 "objc_class", getOrCreateMainFile(),
365 0);
Devang Patelc8972c62010-07-28 01:33:15 +0000366 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
367
Devang Patel16674e82011-02-22 18:56:36 +0000368 llvm::DIType ISATy = DBuilder.createPointerType(OCTy, Size);
Devang Patelc8972c62010-07-28 01:33:15 +0000369
Chris Lattner5f9e2722011-07-23 10:55:15 +0000370 SmallVector<llvm::Value *, 16> EltTys;
Devang Patelc8972c62010-07-28 01:33:15 +0000371 llvm::DIType FieldTy =
Devang Patel1d323e02011-06-24 22:00:59 +0000372 DBuilder.createMemberType(getOrCreateMainFile(), "isa",
373 getOrCreateMainFile(), 0, Size,
374 0, 0, 0, ISATy);
Devang Patelc8972c62010-07-28 01:33:15 +0000375 EltTys.push_back(FieldTy);
Jay Foadc556ef22011-04-24 10:11:03 +0000376 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys);
Devang Patelc8972c62010-07-28 01:33:15 +0000377
Devang Patel16674e82011-02-22 18:56:36 +0000378 return DBuilder.createStructType(TheCU, "objc_object",
Devang Patel823d8e92010-12-08 22:42:58 +0000379 getOrCreateMainFile(),
380 0, 0, 0, 0, Elements);
Devang Patelc8972c62010-07-28 01:33:15 +0000381 }
Devang Patel6e108ce2011-02-09 03:15:05 +0000382 case BuiltinType::ObjCSel: {
Eric Christopher917bc8d2012-02-20 18:05:04 +0000383 return
384 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
Eric Christophere86b9ea2012-02-20 23:02:36 +0000385 "objc_selector", getOrCreateMainFile(),
386 0);
Devang Patel6e108ce2011-02-09 03:15:05 +0000387 }
Chris Lattner9c85ba32008-11-10 06:08:34 +0000388 case BuiltinType::UChar:
389 case BuiltinType::Char_U: Encoding = llvm::dwarf::DW_ATE_unsigned_char; break;
390 case BuiltinType::Char_S:
391 case BuiltinType::SChar: Encoding = llvm::dwarf::DW_ATE_signed_char; break;
Devang Patele8ee3f22011-09-12 17:11:58 +0000392 case BuiltinType::Char16:
393 case BuiltinType::Char32: Encoding = llvm::dwarf::DW_ATE_UTF; break;
Chris Lattner9c85ba32008-11-10 06:08:34 +0000394 case BuiltinType::UShort:
395 case BuiltinType::UInt:
Devang Patel31c79b42011-05-05 17:06:30 +0000396 case BuiltinType::UInt128:
Chris Lattner9c85ba32008-11-10 06:08:34 +0000397 case BuiltinType::ULong:
Devang Patel68f76b12011-09-10 00:44:49 +0000398 case BuiltinType::WChar_U:
Chris Lattner9c85ba32008-11-10 06:08:34 +0000399 case BuiltinType::ULongLong: Encoding = llvm::dwarf::DW_ATE_unsigned; break;
400 case BuiltinType::Short:
401 case BuiltinType::Int:
Devang Patel31c79b42011-05-05 17:06:30 +0000402 case BuiltinType::Int128:
Chris Lattner9c85ba32008-11-10 06:08:34 +0000403 case BuiltinType::Long:
Devang Patel68f76b12011-09-10 00:44:49 +0000404 case BuiltinType::WChar_S:
Chris Lattner9c85ba32008-11-10 06:08:34 +0000405 case BuiltinType::LongLong: Encoding = llvm::dwarf::DW_ATE_signed; break;
406 case BuiltinType::Bool: Encoding = llvm::dwarf::DW_ATE_boolean; break;
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +0000407 case BuiltinType::Half:
Chris Lattner9c85ba32008-11-10 06:08:34 +0000408 case BuiltinType::Float:
Devang Patel7c173cb2009-10-12 22:28:31 +0000409 case BuiltinType::LongDouble:
Chris Lattner9c85ba32008-11-10 06:08:34 +0000410 case BuiltinType::Double: Encoding = llvm::dwarf::DW_ATE_float; break;
Mike Stump1eb44332009-09-09 15:08:12 +0000411 }
Devang Patel05127ca2010-07-28 23:23:29 +0000412
413 switch (BT->getKind()) {
414 case BuiltinType::Long: BTName = "long int"; break;
415 case BuiltinType::LongLong: BTName = "long long int"; break;
416 case BuiltinType::ULong: BTName = "long unsigned int"; break;
417 case BuiltinType::ULongLong: BTName = "long long unsigned int"; break;
418 default:
David Blaikie4e4d0842012-03-11 07:00:24 +0000419 BTName = BT->getName(CGM.getContext().getLangOpts());
Devang Patel05127ca2010-07-28 23:23:29 +0000420 break;
421 }
Chris Lattner9c85ba32008-11-10 06:08:34 +0000422 // Bit size, align and offset of the type.
Anders Carlsson20f12a22009-12-06 18:00:51 +0000423 uint64_t Size = CGM.getContext().getTypeSize(BT);
424 uint64_t Align = CGM.getContext().getTypeAlign(BT);
Devang Patelca80a5f2009-10-20 19:55:01 +0000425 llvm::DIType DbgTy =
Devang Patel16674e82011-02-22 18:56:36 +0000426 DBuilder.createBasicType(BTName, Size, Align, Encoding);
Devang Patelca80a5f2009-10-20 19:55:01 +0000427 return DbgTy;
Chris Lattner9c85ba32008-11-10 06:08:34 +0000428}
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +0000429
Devang Patel344ff5d2010-12-09 00:25:29 +0000430llvm::DIType CGDebugInfo::CreateType(const ComplexType *Ty) {
Chris Lattnerb7003772009-04-23 06:13:01 +0000431 // Bit size, align and offset of the type.
432 unsigned Encoding = llvm::dwarf::DW_ATE_complex_float;
433 if (Ty->isComplexIntegerType())
434 Encoding = llvm::dwarf::DW_ATE_lo_user;
Mike Stump1eb44332009-09-09 15:08:12 +0000435
Anders Carlsson20f12a22009-12-06 18:00:51 +0000436 uint64_t Size = CGM.getContext().getTypeSize(Ty);
437 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
Devang Patelca80a5f2009-10-20 19:55:01 +0000438 llvm::DIType DbgTy =
Devang Patel16674e82011-02-22 18:56:36 +0000439 DBuilder.createBasicType("complex", Size, Align, Encoding);
Devang Patel823d8e92010-12-08 22:42:58 +0000440
Devang Patelca80a5f2009-10-20 19:55:01 +0000441 return DbgTy;
Chris Lattnerb7003772009-04-23 06:13:01 +0000442}
443
John McCalla1805292009-09-25 01:40:47 +0000444/// CreateCVRType - Get the qualified type from the cache or create
Sanjiv Guptaf58c27a2008-06-07 04:46:53 +0000445/// a new one if necessary.
Devang Patel17800552010-03-09 00:44:50 +0000446llvm::DIType CGDebugInfo::CreateQualifiedType(QualType Ty, llvm::DIFile Unit) {
John McCalla1805292009-09-25 01:40:47 +0000447 QualifierCollector Qc;
448 const Type *T = Qc.strip(Ty);
449
450 // Ignore these qualifiers for now.
451 Qc.removeObjCGCAttr();
452 Qc.removeAddressSpace();
John McCallf85e1932011-06-15 23:02:42 +0000453 Qc.removeObjCLifetime();
John McCalla1805292009-09-25 01:40:47 +0000454
Chris Lattner9c85ba32008-11-10 06:08:34 +0000455 // We will create one Derived type for one qualifier and recurse to handle any
456 // additional ones.
Chris Lattner9c85ba32008-11-10 06:08:34 +0000457 unsigned Tag;
John McCalla1805292009-09-25 01:40:47 +0000458 if (Qc.hasConst()) {
Chris Lattner9c85ba32008-11-10 06:08:34 +0000459 Tag = llvm::dwarf::DW_TAG_const_type;
John McCalla1805292009-09-25 01:40:47 +0000460 Qc.removeConst();
461 } else if (Qc.hasVolatile()) {
Chris Lattner9c85ba32008-11-10 06:08:34 +0000462 Tag = llvm::dwarf::DW_TAG_volatile_type;
John McCalla1805292009-09-25 01:40:47 +0000463 Qc.removeVolatile();
464 } else if (Qc.hasRestrict()) {
Chris Lattner9c85ba32008-11-10 06:08:34 +0000465 Tag = llvm::dwarf::DW_TAG_restrict_type;
John McCalla1805292009-09-25 01:40:47 +0000466 Qc.removeRestrict();
467 } else {
468 assert(Qc.empty() && "Unknown type qualifier for debug info");
469 return getOrCreateType(QualType(T, 0), Unit);
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +0000470 }
Mike Stump1eb44332009-09-09 15:08:12 +0000471
John McCall49f4e1c2010-12-10 11:01:00 +0000472 llvm::DIType FromTy = getOrCreateType(Qc.apply(CGM.getContext(), T), Unit);
John McCalla1805292009-09-25 01:40:47 +0000473
Daniel Dunbar3845f862008-10-31 03:54:29 +0000474 // No need to fill in the Name, Line, Size, Alignment, Offset in case of
475 // CVR derived types.
Devang Patel16674e82011-02-22 18:56:36 +0000476 llvm::DIType DbgTy = DBuilder.createQualifiedType(Tag, FromTy);
Devang Patel823d8e92010-12-08 22:42:58 +0000477
Devang Patelca80a5f2009-10-20 19:55:01 +0000478 return DbgTy;
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +0000479}
480
Daniel Dunbar9df4bb32009-07-14 01:20:56 +0000481llvm::DIType CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty,
Devang Patel17800552010-03-09 00:44:50 +0000482 llvm::DIFile Unit) {
Devang Patelca80a5f2009-10-20 19:55:01 +0000483 llvm::DIType DbgTy =
Anders Carlssona031b352009-11-06 19:19:55 +0000484 CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
485 Ty->getPointeeType(), Unit);
Devang Patelca80a5f2009-10-20 19:55:01 +0000486 return DbgTy;
Daniel Dunbar9df4bb32009-07-14 01:20:56 +0000487}
488
Chris Lattner9c85ba32008-11-10 06:08:34 +0000489llvm::DIType CGDebugInfo::CreateType(const PointerType *Ty,
Devang Patel17800552010-03-09 00:44:50 +0000490 llvm::DIFile Unit) {
Anders Carlssona031b352009-11-06 19:19:55 +0000491 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
492 Ty->getPointeeType(), Unit);
493}
494
Eric Christopher5d613b52012-01-25 02:06:59 +0000495// Creates a forward declaration for a RecordDecl in the given context.
496llvm::DIType CGDebugInfo::createRecordFwdDecl(const RecordDecl *RD,
Devang Patel53bc5182012-02-08 00:10:20 +0000497 llvm::DIDescriptor Ctx) {
Eric Christopher5d613b52012-01-25 02:06:59 +0000498 llvm::DIFile DefUnit = getOrCreateFile(RD->getLocation());
499 unsigned Line = getLineNumber(RD->getLocation());
Eric Christophere88a71f2012-02-13 15:08:45 +0000500 StringRef RDName = RD->getName();
501
502 // Get the tag.
Eric Christopher5d613b52012-01-25 02:06:59 +0000503 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
Eric Christophere88a71f2012-02-13 15:08:45 +0000504 unsigned Tag = 0;
505 if (CXXDecl) {
506 RDName = getClassName(RD);
507 Tag = llvm::dwarf::DW_TAG_class_type;
508 }
Eric Christopher5d613b52012-01-25 02:06:59 +0000509 else if (RD->isStruct())
Eric Christophere88a71f2012-02-13 15:08:45 +0000510 Tag = llvm::dwarf::DW_TAG_structure_type;
Eric Christopher5d613b52012-01-25 02:06:59 +0000511 else if (RD->isUnion())
Eric Christophere88a71f2012-02-13 15:08:45 +0000512 Tag = llvm::dwarf::DW_TAG_union_type;
Eric Christopher5d613b52012-01-25 02:06:59 +0000513 else
514 llvm_unreachable("Unknown RecordDecl type!");
Eric Christophere88a71f2012-02-13 15:08:45 +0000515
516 // Create the type.
Eric Christopher1486d2c2012-02-18 00:50:14 +0000517 return DBuilder.createForwardDecl(Tag, RDName, DefUnit, Line);
Eric Christopher5d613b52012-01-25 02:06:59 +0000518}
519
Eric Christopher4ddca8a2012-01-20 22:10:15 +0000520// Walk up the context chain and create forward decls for record decls,
521// and normal descriptors for namespaces.
522llvm::DIDescriptor CGDebugInfo::createContextChain(const Decl *Context) {
523 if (!Context)
524 return TheCU;
525
526 // See if we already have the parent.
527 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator
528 I = RegionMap.find(Context);
529 if (I != RegionMap.end())
530 return llvm::DIDescriptor(dyn_cast_or_null<llvm::MDNode>(&*I->second));
531
532 // Check namespace.
533 if (const NamespaceDecl *NSDecl = dyn_cast<NamespaceDecl>(Context))
534 return llvm::DIDescriptor(getOrCreateNameSpace(NSDecl));
535
536 if (const RecordDecl *RD = dyn_cast<RecordDecl>(Context)) {
537 if (!RD->isDependentType()) {
Eric Christopher9965dea2012-02-16 22:54:45 +0000538 llvm::DIType Ty = getOrCreateLimitedType(CGM.getContext().getTypeDeclType(RD),
539 getOrCreateMainFile());
Eric Christopher4ddca8a2012-01-20 22:10:15 +0000540 return llvm::DIDescriptor(Ty);
541 }
542 }
543 return TheCU;
544}
545
Eric Christopheredc95922011-09-13 23:45:09 +0000546/// CreatePointeeType - Create Pointee type. If Pointee is a record
Devang Patelc69e1cf2010-09-30 19:05:55 +0000547/// then emit record's fwd if debug info size reduction is enabled.
548llvm::DIType CGDebugInfo::CreatePointeeType(QualType PointeeTy,
549 llvm::DIFile Unit) {
550 if (!CGM.getCodeGenOpts().LimitDebugInfo)
551 return getOrCreateType(PointeeTy, Unit);
Devang Patel41422512011-10-24 23:15:17 +0000552
553 // Limit debug info for the pointee type.
554
Eric Christopher973bbb62011-12-16 23:40:18 +0000555 // If we have an existing type, use that, it's still smaller than creating
556 // a new type.
557 llvm::DIType Ty = getTypeOrNull(PointeeTy);
558 if (Ty.Verify()) return Ty;
559
Devang Patel41422512011-10-24 23:15:17 +0000560 // Handle qualifiers.
561 if (PointeeTy.hasLocalQualifiers())
562 return CreateQualifiedType(PointeeTy, Unit);
563
Devang Patelc69e1cf2010-09-30 19:05:55 +0000564 if (const RecordType *RTy = dyn_cast<RecordType>(PointeeTy)) {
565 RecordDecl *RD = RTy->getDecl();
Devang Patelc69e1cf2010-09-30 19:05:55 +0000566 llvm::DIDescriptor FDContext =
John McCall8178df32011-02-22 22:38:33 +0000567 getContextDescriptor(cast<Decl>(RD->getDeclContext()));
Eric Christopher86211df2012-02-20 18:05:24 +0000568 llvm::DIType RetTy = createRecordFwdDecl(RD, FDContext);
569 TypeCache[QualType(RTy, 0).getAsOpaquePtr()] = RetTy;
570 return RetTy;
Devang Patelc69e1cf2010-09-30 19:05:55 +0000571 }
572 return getOrCreateType(PointeeTy, Unit);
Eric Christopher42e75da2012-02-13 14:56:11 +0000573
Devang Patelc69e1cf2010-09-30 19:05:55 +0000574}
575
Anders Carlssona031b352009-11-06 19:19:55 +0000576llvm::DIType CGDebugInfo::CreatePointerLikeType(unsigned Tag,
577 const Type *Ty,
578 QualType PointeeTy,
Devang Patel17800552010-03-09 00:44:50 +0000579 llvm::DIFile Unit) {
Devang Patel823d8e92010-12-08 22:42:58 +0000580 if (Tag == llvm::dwarf::DW_TAG_reference_type)
Devang Patel16674e82011-02-22 18:56:36 +0000581 return DBuilder.createReferenceType(CreatePointeeType(PointeeTy, Unit));
Devang Patel823d8e92010-12-08 22:42:58 +0000582
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +0000583 // Bit size, align and offset of the type.
Anders Carlssona031b352009-11-06 19:19:55 +0000584 // Size is always the size of a pointer. We can't use getTypeSize here
585 // because that does not return the correct value for references.
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000586 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000587 uint64_t Size = CGM.getContext().getTargetInfo().getPointerWidth(AS);
Anders Carlsson20f12a22009-12-06 18:00:51 +0000588 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +0000589
Nick Lewycky7480d962011-11-10 00:34:02 +0000590 return DBuilder.createPointerType(CreatePointeeType(PointeeTy, Unit),
591 Size, Align);
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +0000592}
593
Mike Stump9bc093c2009-05-14 02:03:51 +0000594llvm::DIType CGDebugInfo::CreateType(const BlockPointerType *Ty,
Devang Patel17800552010-03-09 00:44:50 +0000595 llvm::DIFile Unit) {
Mike Stump9bc093c2009-05-14 02:03:51 +0000596 if (BlockLiteralGenericSet)
597 return BlockLiteralGeneric;
598
Chris Lattner5f9e2722011-07-23 10:55:15 +0000599 SmallVector<llvm::Value *, 8> EltTys;
Mike Stump9bc093c2009-05-14 02:03:51 +0000600 llvm::DIType FieldTy;
Mike Stump9bc093c2009-05-14 02:03:51 +0000601 QualType FType;
602 uint64_t FieldSize, FieldOffset;
603 unsigned FieldAlign;
Mike Stump9bc093c2009-05-14 02:03:51 +0000604 llvm::DIArray Elements;
605 llvm::DIType EltTy, DescTy;
606
607 FieldOffset = 0;
Anders Carlsson20f12a22009-12-06 18:00:51 +0000608 FType = CGM.getContext().UnsignedLongTy;
Benjamin Kramer48c70f62010-04-24 20:19:58 +0000609 EltTys.push_back(CreateMemberType(Unit, FType, "reserved", &FieldOffset));
610 EltTys.push_back(CreateMemberType(Unit, FType, "Size", &FieldOffset));
Mike Stump9bc093c2009-05-14 02:03:51 +0000611
Jay Foadc556ef22011-04-24 10:11:03 +0000612 Elements = DBuilder.getOrCreateArray(EltTys);
Mike Stump9bc093c2009-05-14 02:03:51 +0000613 EltTys.clear();
614
Devang Patele2472482010-09-29 21:05:52 +0000615 unsigned Flags = llvm::DIDescriptor::FlagAppleBlock;
Devang Patel8ab870d2010-05-12 23:46:38 +0000616 unsigned LineNo = getLineNumber(CurLoc);
Mike Stump3d363c52009-10-02 02:30:50 +0000617
Devang Patel16674e82011-02-22 18:56:36 +0000618 EltTy = DBuilder.createStructType(Unit, "__block_descriptor",
Devang Patel823d8e92010-12-08 22:42:58 +0000619 Unit, LineNo, FieldOffset, 0,
620 Flags, Elements);
Mike Stump1eb44332009-09-09 15:08:12 +0000621
Mike Stump9bc093c2009-05-14 02:03:51 +0000622 // Bit size, align and offset of the type.
Anders Carlsson20f12a22009-12-06 18:00:51 +0000623 uint64_t Size = CGM.getContext().getTypeSize(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +0000624
Devang Patel16674e82011-02-22 18:56:36 +0000625 DescTy = DBuilder.createPointerType(EltTy, Size);
Mike Stump9bc093c2009-05-14 02:03:51 +0000626
627 FieldOffset = 0;
Anders Carlsson20f12a22009-12-06 18:00:51 +0000628 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Benjamin Kramer48c70f62010-04-24 20:19:58 +0000629 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
Anders Carlsson20f12a22009-12-06 18:00:51 +0000630 FType = CGM.getContext().IntTy;
Benjamin Kramer48c70f62010-04-24 20:19:58 +0000631 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
632 EltTys.push_back(CreateMemberType(Unit, FType, "__reserved", &FieldOffset));
Benjamin Kramerd3651cc2010-04-24 20:26:20 +0000633 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Benjamin Kramer48c70f62010-04-24 20:19:58 +0000634 EltTys.push_back(CreateMemberType(Unit, FType, "__FuncPtr", &FieldOffset));
Mike Stump9bc093c2009-05-14 02:03:51 +0000635
Anders Carlsson20f12a22009-12-06 18:00:51 +0000636 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Mike Stump9bc093c2009-05-14 02:03:51 +0000637 FieldTy = DescTy;
Anders Carlsson20f12a22009-12-06 18:00:51 +0000638 FieldSize = CGM.getContext().getTypeSize(Ty);
639 FieldAlign = CGM.getContext().getTypeAlign(Ty);
Devang Patel1d323e02011-06-24 22:00:59 +0000640 FieldTy = DBuilder.createMemberType(Unit, "__descriptor", Unit,
Devang Patel823d8e92010-12-08 22:42:58 +0000641 LineNo, FieldSize, FieldAlign,
642 FieldOffset, 0, FieldTy);
Mike Stump9bc093c2009-05-14 02:03:51 +0000643 EltTys.push_back(FieldTy);
644
645 FieldOffset += FieldSize;
Jay Foadc556ef22011-04-24 10:11:03 +0000646 Elements = DBuilder.getOrCreateArray(EltTys);
Mike Stump9bc093c2009-05-14 02:03:51 +0000647
Devang Patel16674e82011-02-22 18:56:36 +0000648 EltTy = DBuilder.createStructType(Unit, "__block_literal_generic",
Devang Patel823d8e92010-12-08 22:42:58 +0000649 Unit, LineNo, FieldOffset, 0,
650 Flags, Elements);
Mike Stump1eb44332009-09-09 15:08:12 +0000651
Mike Stump9bc093c2009-05-14 02:03:51 +0000652 BlockLiteralGenericSet = true;
Devang Patel16674e82011-02-22 18:56:36 +0000653 BlockLiteralGeneric = DBuilder.createPointerType(EltTy, Size);
Mike Stump9bc093c2009-05-14 02:03:51 +0000654 return BlockLiteralGeneric;
655}
656
Nick Lewycky7480d962011-11-10 00:34:02 +0000657llvm::DIType CGDebugInfo::CreateType(const TypedefType *Ty, llvm::DIFile Unit) {
Chris Lattner9c85ba32008-11-10 06:08:34 +0000658 // Typedefs are derived from some other type. If we have a typedef of a
659 // typedef, make sure to emit the whole chain.
660 llvm::DIType Src = getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit);
Devang Patel823d8e92010-12-08 22:42:58 +0000661 if (!Src.Verify())
662 return llvm::DIType();
Chris Lattner9c85ba32008-11-10 06:08:34 +0000663 // We don't set size information, but do specify where the typedef was
664 // declared.
Devang Patel8ab870d2010-05-12 23:46:38 +0000665 unsigned Line = getLineNumber(Ty->getDecl()->getLocation());
Devang Patelc4903122011-06-03 17:23:47 +0000666 const TypedefNameDecl *TyDecl = Ty->getDecl();
Eric Christopher9965dea2012-02-16 22:54:45 +0000667
Nick Lewycky7480d962011-11-10 00:34:02 +0000668 llvm::DIDescriptor TypedefContext =
Devang Patelc4903122011-06-03 17:23:47 +0000669 getContextDescriptor(cast<Decl>(Ty->getDecl()->getDeclContext()));
Eric Christopher9965dea2012-02-16 22:54:45 +0000670
671 return
Nick Lewycky7480d962011-11-10 00:34:02 +0000672 DBuilder.createTypedef(Src, TyDecl->getName(), Unit, Line, TypedefContext);
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +0000673}
674
Chris Lattner9c85ba32008-11-10 06:08:34 +0000675llvm::DIType CGDebugInfo::CreateType(const FunctionType *Ty,
Devang Patel17800552010-03-09 00:44:50 +0000676 llvm::DIFile Unit) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000677 SmallVector<llvm::Value *, 16> EltTys;
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +0000678
Chris Lattner9c85ba32008-11-10 06:08:34 +0000679 // Add the result type at least.
680 EltTys.push_back(getOrCreateType(Ty->getResultType(), Unit));
Mike Stump1eb44332009-09-09 15:08:12 +0000681
Chris Lattner9c85ba32008-11-10 06:08:34 +0000682 // Set up remainder of arguments if there is a prototype.
683 // FIXME: IF NOT, HOW IS THIS REPRESENTED? llvm-gcc doesn't represent '...'!
Devang Patelaf164bb2010-10-06 20:51:45 +0000684 if (isa<FunctionNoProtoType>(Ty))
Devang Patel16674e82011-02-22 18:56:36 +0000685 EltTys.push_back(DBuilder.createUnspecifiedParameter());
Devang Patelaf164bb2010-10-06 20:51:45 +0000686 else if (const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(Ty)) {
Eric Christopher42e75da2012-02-13 14:56:11 +0000687 for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
688 EltTys.push_back(getOrCreateType(FTP->getArgType(i), Unit));
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +0000689 }
690
Jay Foadc556ef22011-04-24 10:11:03 +0000691 llvm::DIArray EltTypeArray = DBuilder.getOrCreateArray(EltTys);
Mike Stump1eb44332009-09-09 15:08:12 +0000692
Devang Patel16674e82011-02-22 18:56:36 +0000693 llvm::DIType DbgTy = DBuilder.createSubroutineType(Unit, EltTypeArray);
Devang Patelca80a5f2009-10-20 19:55:01 +0000694 return DbgTy;
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +0000695}
696
Eric Christopher42e75da2012-02-13 14:56:11 +0000697
Eric Christopher6faa5542012-01-26 01:57:13 +0000698void CGDebugInfo::
699CollectRecordStaticVars(const RecordDecl *RD, llvm::DIType FwdDecl) {
700
701 for (RecordDecl::decl_iterator I = RD->decls_begin(), E = RD->decls_end();
702 I != E; ++I)
703 if (const VarDecl *V = dyn_cast<VarDecl>(*I)) {
704 if (V->getInit()) {
705 const APValue *Value = V->evaluateValue();
706 if (Value && Value->isInt()) {
707 llvm::ConstantInt *CI
708 = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->getInt());
709
710 // Create the descriptor for static variable.
711 llvm::DIFile VUnit = getOrCreateFile(V->getLocation());
712 StringRef VName = V->getName();
713 llvm::DIType VTy = getOrCreateType(V->getType(), VUnit);
714 // Do not use DIGlobalVariable for enums.
715 if (VTy.getTag() != llvm::dwarf::DW_TAG_enumeration_type) {
716 DBuilder.createStaticVariable(FwdDecl, VName, VName, VUnit,
717 getLineNumber(V->getLocation()),
718 VTy, true, CI);
719 }
720 }
721 }
722 }
723}
724
Chris Lattner5f9e2722011-07-23 10:55:15 +0000725llvm::DIType CGDebugInfo::createFieldType(StringRef name,
John McCall8178df32011-02-22 22:38:33 +0000726 QualType type,
Richard Smitha6b8b2c2011-10-10 18:28:20 +0000727 uint64_t sizeInBitsOverride,
John McCall8178df32011-02-22 22:38:33 +0000728 SourceLocation loc,
729 AccessSpecifier AS,
730 uint64_t offsetInBits,
Devang Patel1d323e02011-06-24 22:00:59 +0000731 llvm::DIFile tunit,
732 llvm::DIDescriptor scope) {
John McCall8178df32011-02-22 22:38:33 +0000733 llvm::DIType debugType = getOrCreateType(type, tunit);
734
735 // Get the location for the field.
736 llvm::DIFile file = getOrCreateFile(loc);
737 unsigned line = getLineNumber(loc);
738
739 uint64_t sizeInBits = 0;
740 unsigned alignInBits = 0;
741 if (!type->isIncompleteArrayType()) {
742 llvm::tie(sizeInBits, alignInBits) = CGM.getContext().getTypeInfo(type);
743
Richard Smitha6b8b2c2011-10-10 18:28:20 +0000744 if (sizeInBitsOverride)
745 sizeInBits = sizeInBitsOverride;
John McCall8178df32011-02-22 22:38:33 +0000746 }
747
748 unsigned flags = 0;
749 if (AS == clang::AS_private)
750 flags |= llvm::DIDescriptor::FlagPrivate;
751 else if (AS == clang::AS_protected)
752 flags |= llvm::DIDescriptor::FlagProtected;
753
Devang Patel1d323e02011-06-24 22:00:59 +0000754 return DBuilder.createMemberType(scope, name, file, line, sizeInBits,
755 alignInBits, offsetInBits, flags, debugType);
John McCall8178df32011-02-22 22:38:33 +0000756}
757
Devang Patel428deb52010-01-19 00:00:59 +0000758/// CollectRecordFields - A helper function to collect debug info for
759/// record fields. This is used while creating debug info entry for a Record.
760void CGDebugInfo::
John McCall8178df32011-02-22 22:38:33 +0000761CollectRecordFields(const RecordDecl *record, llvm::DIFile tunit,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000762 SmallVectorImpl<llvm::Value *> &elements,
Devang Patel1d323e02011-06-24 22:00:59 +0000763 llvm::DIType RecordTy) {
John McCall8178df32011-02-22 22:38:33 +0000764 unsigned fieldNo = 0;
765 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(record);
Eric Christopherad8de512012-03-01 21:36:52 +0000766 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(record);
767
768 // For C++11 Lambdas a Fields will be the same as a Capture, but the Capture
769 // has the name and the location of the variable so we should iterate over
770 // both concurrently.
771 if (CXXDecl && CXXDecl->isLambda()) {
772 RecordDecl::field_iterator Field = CXXDecl->field_begin();
773 unsigned fieldno = 0;
774 for (CXXRecordDecl::capture_const_iterator I = CXXDecl->captures_begin(),
775 E = CXXDecl->captures_end(); I != E; ++I, ++Field, ++fieldno) {
776 const LambdaExpr::Capture C = *I;
777 // TODO: Need to handle 'this' in some way by probably renaming the
778 // this of the lambda class and having a field member of 'this'.
779 if (C.capturesVariable()) {
780 VarDecl *V = C.getCapturedVar();
781 llvm::DIFile VUnit = getOrCreateFile(C.getLocation());
782 StringRef VName = V->getName();
783 uint64_t SizeInBitsOverride = 0;
784 if (Field->isBitField()) {
785 SizeInBitsOverride = Field->getBitWidthValue(CGM.getContext());
786 assert(SizeInBitsOverride && "found named 0-width bitfield");
787 }
788 llvm::DIType fieldType
789 = createFieldType(VName, Field->getType(), SizeInBitsOverride, C.getLocation(),
790 Field->getAccess(), layout.getFieldOffset(fieldno),
791 VUnit, RecordTy);
792 elements.push_back(fieldType);
793 }
794 }
795 } else {
796 bool IsMsStruct = record->hasAttr<MsStructAttr>();
797 const FieldDecl *LastFD = 0;
798 for (RecordDecl::field_iterator I = record->field_begin(),
799 E = record->field_end();
800 I != E; ++I, ++fieldNo) {
801 FieldDecl *field = *I;
802
803 if (IsMsStruct) {
804 // Zero-length bitfields following non-bitfield members are ignored
805 if (CGM.getContext().ZeroBitfieldFollowsNonBitfield((field), LastFD)) {
806 --fieldNo;
807 continue;
808 }
809 LastFD = field;
810 }
811
812 StringRef name = field->getName();
813 QualType type = field->getType();
814
815 // Ignore unnamed fields unless they're anonymous structs/unions.
816 if (name.empty() && !type->isRecordType()) {
817 LastFD = field;
Fariborz Jahanianfbc3cc62011-04-28 23:43:23 +0000818 continue;
819 }
Eric Christopherad8de512012-03-01 21:36:52 +0000820
821 uint64_t SizeInBitsOverride = 0;
822 if (field->isBitField()) {
823 SizeInBitsOverride = field->getBitWidthValue(CGM.getContext());
824 assert(SizeInBitsOverride && "found named 0-width bitfield");
825 }
826
827 llvm::DIType fieldType
828 = createFieldType(name, type, SizeInBitsOverride,
829 field->getLocation(), field->getAccess(),
830 layout.getFieldOffset(fieldNo), tunit, RecordTy);
831
832 elements.push_back(fieldType);
Fariborz Jahanianfbc3cc62011-04-28 23:43:23 +0000833 }
Devang Patel428deb52010-01-19 00:00:59 +0000834 }
835}
836
Devang Patela6da1922010-01-28 00:28:01 +0000837/// getOrCreateMethodType - CXXMethodDecl's type is a FunctionType. This
838/// function type is not updated to include implicit "this" pointer. Use this
839/// routine to get a method type which includes "this" pointer.
840llvm::DIType
841CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method,
Devang Patel17800552010-03-09 00:44:50 +0000842 llvm::DIFile Unit) {
Douglas Gregor5f970ee2010-05-04 18:18:31 +0000843 llvm::DIType FnTy
844 = getOrCreateType(QualType(Method->getType()->getAs<FunctionProtoType>(),
845 0),
846 Unit);
Eric Christopher3b10cfe2012-03-13 23:40:48 +0000847
Devang Patela6da1922010-01-28 00:28:01 +0000848 // Add "this" pointer.
Devang Patelab699792010-05-07 18:12:35 +0000849 llvm::DIArray Args = llvm::DICompositeType(FnTy).getTypeArray();
Devang Patela6da1922010-01-28 00:28:01 +0000850 assert (Args.getNumElements() && "Invalid number of arguments!");
851
Chris Lattner5f9e2722011-07-23 10:55:15 +0000852 SmallVector<llvm::Value *, 16> Elts;
Devang Patela6da1922010-01-28 00:28:01 +0000853
854 // First element is always return type. For 'void' functions it is NULL.
855 Elts.push_back(Args.getElement(0));
856
Eric Christopher2121cda2011-09-14 01:10:50 +0000857 if (!Method->isStatic()) {
858 // "this" pointer is always first argument.
859 QualType ThisPtr = Method->getThisType(CGM.getContext());
Devang Patelef8857d2011-10-28 21:12:13 +0000860
861 const CXXRecordDecl *RD = Method->getParent();
862 if (isa<ClassTemplateSpecializationDecl>(RD)) {
863 // Create pointer type directly in this case.
864 const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr);
865 QualType PointeeTy = ThisPtrTy->getPointeeType();
866 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
867 uint64_t Size = CGM.getContext().getTargetInfo().getPointerWidth(AS);
868 uint64_t Align = CGM.getContext().getTypeAlign(ThisPtrTy);
Nick Lewyckyd4c100e2011-11-09 04:25:21 +0000869 llvm::DIType PointeeType = getOrCreateType(PointeeTy, Unit);
Eric Christopher3b8e1972012-02-09 07:26:21 +0000870 llvm::DIType ThisPtrType = DBuilder.createPointerType(PointeeType, Size, Align);
Devang Patelef8857d2011-10-28 21:12:13 +0000871 TypeCache[ThisPtr.getAsOpaquePtr()] = ThisPtrType;
Eric Christopher3b8e1972012-02-09 07:26:21 +0000872 // TODO: This and the artificial type below are misleading, the
873 // types aren't artificial the argument is, but the current
874 // metadata doesn't represent that.
875 ThisPtrType = DBuilder.createArtificialType(ThisPtrType);
Devang Patelef8857d2011-10-28 21:12:13 +0000876 Elts.push_back(ThisPtrType);
877 } else {
Eric Christopher3b8e1972012-02-09 07:26:21 +0000878 llvm::DIType ThisPtrType = getOrCreateType(ThisPtr, Unit);
Devang Patelef8857d2011-10-28 21:12:13 +0000879 TypeCache[ThisPtr.getAsOpaquePtr()] = ThisPtrType;
Eric Christopher3b8e1972012-02-09 07:26:21 +0000880 ThisPtrType = DBuilder.createArtificialType(ThisPtrType);
Devang Patelef8857d2011-10-28 21:12:13 +0000881 Elts.push_back(ThisPtrType);
882 }
Eric Christopher2121cda2011-09-14 01:10:50 +0000883 }
Devang Patela6da1922010-01-28 00:28:01 +0000884
885 // Copy rest of the arguments.
886 for (unsigned i = 1, e = Args.getNumElements(); i != e; ++i)
887 Elts.push_back(Args.getElement(i));
888
Jay Foadc556ef22011-04-24 10:11:03 +0000889 llvm::DIArray EltTypeArray = DBuilder.getOrCreateArray(Elts);
Devang Patela6da1922010-01-28 00:28:01 +0000890
Devang Patel16674e82011-02-22 18:56:36 +0000891 return DBuilder.createSubroutineType(Unit, EltTypeArray);
Devang Patela6da1922010-01-28 00:28:01 +0000892}
893
Devang Patel58faf202010-10-22 17:11:50 +0000894/// isFunctionLocalClass - Return true if CXXRecordDecl is defined
895/// inside a function.
896static bool isFunctionLocalClass(const CXXRecordDecl *RD) {
Nick Lewycky7480d962011-11-10 00:34:02 +0000897 if (const CXXRecordDecl *NRD = dyn_cast<CXXRecordDecl>(RD->getDeclContext()))
Devang Patel58faf202010-10-22 17:11:50 +0000898 return isFunctionLocalClass(NRD);
Nick Lewycky7480d962011-11-10 00:34:02 +0000899 if (isa<FunctionDecl>(RD->getDeclContext()))
Devang Patel58faf202010-10-22 17:11:50 +0000900 return true;
901 return false;
Devang Patel58faf202010-10-22 17:11:50 +0000902}
Nick Lewyckyd4c100e2011-11-09 04:25:21 +0000903
Anders Carlssond6f9a0d2010-01-26 04:49:33 +0000904/// CreateCXXMemberFunction - A helper function to create a DISubprogram for
905/// a single member function GlobalDecl.
906llvm::DISubprogram
Anders Carlsson4433f1c2010-01-26 05:19:50 +0000907CGDebugInfo::CreateCXXMemberFunction(const CXXMethodDecl *Method,
Devang Patel17800552010-03-09 00:44:50 +0000908 llvm::DIFile Unit,
Dan Gohman4cac5b42010-08-20 22:02:57 +0000909 llvm::DIType RecordTy) {
Anders Carlsson4433f1c2010-01-26 05:19:50 +0000910 bool IsCtorOrDtor =
911 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
912
Chris Lattner5f9e2722011-07-23 10:55:15 +0000913 StringRef MethodName = getFunctionName(Method);
Devang Patela6da1922010-01-28 00:28:01 +0000914 llvm::DIType MethodTy = getOrCreateMethodType(Method, Unit);
Anders Carlsson4433f1c2010-01-26 05:19:50 +0000915
916 // Since a single ctor/dtor corresponds to multiple functions, it doesn't
917 // make sense to give a single ctor/dtor a linkage name.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000918 StringRef MethodLinkageName;
Devang Patel58faf202010-10-22 17:11:50 +0000919 if (!IsCtorOrDtor && !isFunctionLocalClass(Method->getParent()))
Anders Carlsson9a20d552010-06-22 16:16:50 +0000920 MethodLinkageName = CGM.getMangledName(Method);
Anders Carlsson4433f1c2010-01-26 05:19:50 +0000921
Anders Carlssond6f9a0d2010-01-26 04:49:33 +0000922 // Get the location for the method.
Devang Patel8ab870d2010-05-12 23:46:38 +0000923 llvm::DIFile MethodDefUnit = getOrCreateFile(Method->getLocation());
924 unsigned MethodLine = getLineNumber(Method->getLocation());
Anders Carlssond6f9a0d2010-01-26 04:49:33 +0000925
926 // Collect virtual method info.
927 llvm::DIType ContainingType;
928 unsigned Virtuality = 0;
929 unsigned VIndex = 0;
Anders Carlsson4433f1c2010-01-26 05:19:50 +0000930
Anders Carlssond6f9a0d2010-01-26 04:49:33 +0000931 if (Method->isVirtual()) {
Anders Carlsson4433f1c2010-01-26 05:19:50 +0000932 if (Method->isPure())
933 Virtuality = llvm::dwarf::DW_VIRTUALITY_pure_virtual;
934 else
935 Virtuality = llvm::dwarf::DW_VIRTUALITY_virtual;
936
937 // It doesn't make sense to give a virtual destructor a vtable index,
938 // since a single destructor has two entries in the vtable.
939 if (!isa<CXXDestructorDecl>(Method))
Peter Collingbourne1d2b3172011-09-26 01:56:30 +0000940 VIndex = CGM.getVTableContext().getMethodVTableIndex(Method);
Anders Carlssond6f9a0d2010-01-26 04:49:33 +0000941 ContainingType = RecordTy;
942 }
943
Devang Patele2472482010-09-29 21:05:52 +0000944 unsigned Flags = 0;
945 if (Method->isImplicit())
946 Flags |= llvm::DIDescriptor::FlagArtificial;
Devang Patel10a7a6a2010-09-29 21:46:16 +0000947 AccessSpecifier Access = Method->getAccess();
948 if (Access == clang::AS_private)
949 Flags |= llvm::DIDescriptor::FlagPrivate;
950 else if (Access == clang::AS_protected)
951 Flags |= llvm::DIDescriptor::FlagProtected;
Devang Pateld78a0192010-10-01 23:32:17 +0000952 if (const CXXConstructorDecl *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
953 if (CXXC->isExplicit())
954 Flags |= llvm::DIDescriptor::FlagExplicit;
955 } else if (const CXXConversionDecl *CXXC =
956 dyn_cast<CXXConversionDecl>(Method)) {
957 if (CXXC->isExplicit())
958 Flags |= llvm::DIDescriptor::FlagExplicit;
959 }
Devang Patel3951e712010-10-07 22:03:49 +0000960 if (Method->hasPrototype())
961 Flags |= llvm::DIDescriptor::FlagPrototyped;
Eric Christopher3b10cfe2012-03-13 23:40:48 +0000962
963 llvm::DIArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
Anders Carlssond6f9a0d2010-01-26 04:49:33 +0000964 llvm::DISubprogram SP =
Nick Lewycky7803ec82011-09-01 21:49:51 +0000965 DBuilder.createMethod(RecordTy, MethodName, MethodLinkageName,
Devang Patel823d8e92010-12-08 22:42:58 +0000966 MethodDefUnit, MethodLine,
967 MethodTy, /*isLocalToUnit=*/false,
968 /* isDefinition=*/ false,
969 Virtuality, VIndex, ContainingType,
Eric Christopher3b10cfe2012-03-13 23:40:48 +0000970 Flags, CGM.getLangOpts().Optimize, NULL,
971 TParamsArray);
Anders Carlsson4433f1c2010-01-26 05:19:50 +0000972
Eric Christopherdeae6a82011-11-17 23:45:00 +0000973 SPCache[Method->getCanonicalDecl()] = llvm::WeakVH(SP);
Anders Carlssond6f9a0d2010-01-26 04:49:33 +0000974
975 return SP;
976}
977
Devang Patel4125fd22010-01-19 01:54:44 +0000978/// CollectCXXMemberFunctions - A helper function to collect debug info for
Eric Christopher7c9b2fd2012-01-12 01:26:51 +0000979/// C++ member functions. This is used while creating debug info entry for
Devang Patel4125fd22010-01-19 01:54:44 +0000980/// a Record.
981void CGDebugInfo::
Devang Patel17800552010-03-09 00:44:50 +0000982CollectCXXMemberFunctions(const CXXRecordDecl *RD, llvm::DIFile Unit,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000983 SmallVectorImpl<llvm::Value *> &EltTys,
Dan Gohman4cac5b42010-08-20 22:02:57 +0000984 llvm::DIType RecordTy) {
Eric Christopher3b10cfe2012-03-13 23:40:48 +0000985
986 // Since we want more than just the individual member decls if we
987 // have templated functions iterate over every declaration to gather
988 // the functions.
989 for(DeclContext::decl_iterator I = RD->decls_begin(),
990 E = RD->decls_end(); I != E; ++I) {
991 Decl *D = *I;
992 if (D->isImplicit() && !D->isUsed())
Anders Carlssonbea9b232010-01-26 04:40:11 +0000993 continue;
Devang Patel4125fd22010-01-19 01:54:44 +0000994
Eric Christopher3b10cfe2012-03-13 23:40:48 +0000995 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
996 EltTys.push_back(CreateCXXMemberFunction(Method, Unit, RecordTy));
997 else if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D))
998 for (FunctionTemplateDecl::spec_iterator SI = FTD->spec_begin(),
999 SE = FTD->spec_end(); SI != SE; ++SI) {
1000 FunctionDecl *FD = *SI;
1001 if (CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(FD))
1002 EltTys.push_back(CreateCXXMemberFunction(M, Unit, RecordTy));
1003 }
Devang Patel4125fd22010-01-19 01:54:44 +00001004 }
1005}
1006
Devang Patel2ed8f002010-08-27 17:47:47 +00001007/// CollectCXXFriends - A helper function to collect debug info for
1008/// C++ base classes. This is used while creating debug info entry for
1009/// a Record.
1010void CGDebugInfo::
1011CollectCXXFriends(const CXXRecordDecl *RD, llvm::DIFile Unit,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001012 SmallVectorImpl<llvm::Value *> &EltTys,
Devang Patel2ed8f002010-08-27 17:47:47 +00001013 llvm::DIType RecordTy) {
Eric Christopher121c67d2012-01-12 01:26:58 +00001014 for (CXXRecordDecl::friend_iterator BI = RD->friend_begin(),
Devang Patel2ed8f002010-08-27 17:47:47 +00001015 BE = RD->friend_end(); BI != BE; ++BI) {
Nick Lewycky7803ec82011-09-01 21:49:51 +00001016 if ((*BI)->isUnsupportedFriend())
1017 continue;
Devang Patel823d8e92010-12-08 22:42:58 +00001018 if (TypeSourceInfo *TInfo = (*BI)->getFriendType())
Devang Patel16674e82011-02-22 18:56:36 +00001019 EltTys.push_back(DBuilder.createFriend(RecordTy,
Devang Patel823d8e92010-12-08 22:42:58 +00001020 getOrCreateType(TInfo->getType(),
1021 Unit)));
Devang Patel2ed8f002010-08-27 17:47:47 +00001022 }
1023}
1024
Devang Patela245c5b2010-01-25 23:32:18 +00001025/// CollectCXXBases - A helper function to collect debug info for
1026/// C++ base classes. This is used while creating debug info entry for
1027/// a Record.
1028void CGDebugInfo::
Devang Patel17800552010-03-09 00:44:50 +00001029CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile Unit,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001030 SmallVectorImpl<llvm::Value *> &EltTys,
Dan Gohman4cac5b42010-08-20 22:02:57 +00001031 llvm::DIType RecordTy) {
Devang Patela245c5b2010-01-25 23:32:18 +00001032
Devang Patel239cec62010-02-01 21:39:52 +00001033 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1034 for (CXXRecordDecl::base_class_const_iterator BI = RD->bases_begin(),
1035 BE = RD->bases_end(); BI != BE; ++BI) {
Devang Patelca7daed2010-01-28 21:54:15 +00001036 unsigned BFlags = 0;
Devang Patel62c117d2011-04-04 20:36:06 +00001037 uint64_t BaseOffset;
Devang Patelca7daed2010-01-28 21:54:15 +00001038
1039 const CXXRecordDecl *Base =
1040 cast<CXXRecordDecl>(BI->getType()->getAs<RecordType>()->getDecl());
1041
1042 if (BI->isVirtual()) {
Anders Carlssonbba16072010-03-11 07:15:17 +00001043 // virtual base offset offset is -ve. The code generator emits dwarf
Devang Pateld5322da2010-02-09 19:09:28 +00001044 // expression where it expects +ve number.
Ken Dyck14c65ca2011-04-07 12:37:09 +00001045 BaseOffset =
Peter Collingbourne1d2b3172011-09-26 01:56:30 +00001046 0 - CGM.getVTableContext()
1047 .getVirtualBaseOffsetOffset(RD, Base).getQuantity();
Devang Patele2472482010-09-29 21:05:52 +00001048 BFlags = llvm::DIDescriptor::FlagVirtual;
Devang Patelca7daed2010-01-28 21:54:15 +00001049 } else
Devang Patel62c117d2011-04-04 20:36:06 +00001050 BaseOffset = RL.getBaseClassOffsetInBits(Base);
Ken Dyck14c65ca2011-04-07 12:37:09 +00001051 // FIXME: Inconsistent units for BaseOffset. It is in bytes when
1052 // BI->isVirtual() and bits when not.
Devang Patelca7daed2010-01-28 21:54:15 +00001053
1054 AccessSpecifier Access = BI->getAccessSpecifier();
1055 if (Access == clang::AS_private)
Devang Patele2472482010-09-29 21:05:52 +00001056 BFlags |= llvm::DIDescriptor::FlagPrivate;
Devang Patelca7daed2010-01-28 21:54:15 +00001057 else if (Access == clang::AS_protected)
Devang Patele2472482010-09-29 21:05:52 +00001058 BFlags |= llvm::DIDescriptor::FlagProtected;
Devang Patelca7daed2010-01-28 21:54:15 +00001059
Devang Patel823d8e92010-12-08 22:42:58 +00001060 llvm::DIType DTy =
Devang Patel16674e82011-02-22 18:56:36 +00001061 DBuilder.createInheritance(RecordTy,
Devang Patel823d8e92010-12-08 22:42:58 +00001062 getOrCreateType(BI->getType(), Unit),
Devang Patel62c117d2011-04-04 20:36:06 +00001063 BaseOffset, BFlags);
Devang Patelca7daed2010-01-28 21:54:15 +00001064 EltTys.push_back(DTy);
1065 }
Devang Patela245c5b2010-01-25 23:32:18 +00001066}
1067
Devang Patel5ecb1df2011-04-05 22:54:11 +00001068/// CollectTemplateParams - A helper function to collect template parameters.
Devang Patel9c1714b2011-04-05 17:30:54 +00001069llvm::DIArray CGDebugInfo::
Devang Patel5ecb1df2011-04-05 22:54:11 +00001070CollectTemplateParams(const TemplateParameterList *TPList,
1071 const TemplateArgumentList &TAList,
1072 llvm::DIFile Unit) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001073 SmallVector<llvm::Value *, 16> TemplateParams;
Devang Patelc5ce2972011-04-05 20:15:06 +00001074 for (unsigned i = 0, e = TAList.size(); i != e; ++i) {
1075 const TemplateArgument &TA = TAList[i];
Devang Patel5ecb1df2011-04-05 22:54:11 +00001076 const NamedDecl *ND = TPList->getParam(i);
Devang Patel9c1714b2011-04-05 17:30:54 +00001077 if (TA.getKind() == TemplateArgument::Type) {
1078 llvm::DIType TTy = getOrCreateType(TA.getAsType(), Unit);
1079 llvm::DITemplateTypeParameter TTP =
Devang Patelc5ce2972011-04-05 20:15:06 +00001080 DBuilder.createTemplateTypeParameter(TheCU, ND->getName(), TTy);
Devang Patel9c1714b2011-04-05 17:30:54 +00001081 TemplateParams.push_back(TTP);
1082 } else if (TA.getKind() == TemplateArgument::Integral) {
1083 llvm::DIType TTy = getOrCreateType(TA.getIntegralType(), Unit);
Devang Patel9c1714b2011-04-05 17:30:54 +00001084 llvm::DITemplateValueParameter TVP =
Devang Patelc5ce2972011-04-05 20:15:06 +00001085 DBuilder.createTemplateValueParameter(TheCU, ND->getName(), TTy,
1086 TA.getAsIntegral()->getZExtValue());
Devang Patel9c1714b2011-04-05 17:30:54 +00001087 TemplateParams.push_back(TVP);
1088 }
1089 }
Jay Foadc556ef22011-04-24 10:11:03 +00001090 return DBuilder.getOrCreateArray(TemplateParams);
Devang Patel9c1714b2011-04-05 17:30:54 +00001091}
1092
Devang Patel5ecb1df2011-04-05 22:54:11 +00001093/// CollectFunctionTemplateParams - A helper function to collect debug
1094/// info for function template parameters.
1095llvm::DIArray CGDebugInfo::
1096CollectFunctionTemplateParams(const FunctionDecl *FD, llvm::DIFile Unit) {
Eric Christopherab5278e2011-10-11 23:00:51 +00001097 if (FD->getTemplatedKind() ==
1098 FunctionDecl::TK_FunctionTemplateSpecialization) {
Devang Patel5ecb1df2011-04-05 22:54:11 +00001099 const TemplateParameterList *TList =
Eric Christopherab5278e2011-10-11 23:00:51 +00001100 FD->getTemplateSpecializationInfo()->getTemplate()
1101 ->getTemplateParameters();
Devang Patel5ecb1df2011-04-05 22:54:11 +00001102 return
1103 CollectTemplateParams(TList, *FD->getTemplateSpecializationArgs(), Unit);
1104 }
1105 return llvm::DIArray();
1106}
1107
1108/// CollectCXXTemplateParams - A helper function to collect debug info for
1109/// template parameters.
1110llvm::DIArray CGDebugInfo::
1111CollectCXXTemplateParams(const ClassTemplateSpecializationDecl *TSpecial,
1112 llvm::DIFile Unit) {
1113 llvm::PointerUnion<ClassTemplateDecl *,
1114 ClassTemplatePartialSpecializationDecl *>
1115 PU = TSpecial->getSpecializedTemplateOrPartial();
1116
1117 TemplateParameterList *TPList = PU.is<ClassTemplateDecl *>() ?
1118 PU.get<ClassTemplateDecl *>()->getTemplateParameters() :
1119 PU.get<ClassTemplatePartialSpecializationDecl *>()->getTemplateParameters();
1120 const TemplateArgumentList &TAList = TSpecial->getTemplateInstantiationArgs();
1121 return CollectTemplateParams(TPList, TAList, Unit);
1122}
1123
Devang Patel4ce3f202010-01-28 18:11:52 +00001124/// getOrCreateVTablePtrType - Return debug info descriptor for vtable.
Devang Patel17800552010-03-09 00:44:50 +00001125llvm::DIType CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile Unit) {
Devang Patel0804e6e2010-03-08 20:53:17 +00001126 if (VTablePtrType.isValid())
Devang Patel4ce3f202010-01-28 18:11:52 +00001127 return VTablePtrType;
1128
1129 ASTContext &Context = CGM.getContext();
1130
1131 /* Function type */
Devang Patel823d8e92010-12-08 22:42:58 +00001132 llvm::Value *STy = getOrCreateType(Context.IntTy, Unit);
Jay Foadc556ef22011-04-24 10:11:03 +00001133 llvm::DIArray SElements = DBuilder.getOrCreateArray(STy);
Devang Patel16674e82011-02-22 18:56:36 +00001134 llvm::DIType SubTy = DBuilder.createSubroutineType(Unit, SElements);
Devang Patel4ce3f202010-01-28 18:11:52 +00001135 unsigned Size = Context.getTypeSize(Context.VoidPtrTy);
Devang Patel16674e82011-02-22 18:56:36 +00001136 llvm::DIType vtbl_ptr_type = DBuilder.createPointerType(SubTy, Size, 0,
Devang Patel823d8e92010-12-08 22:42:58 +00001137 "__vtbl_ptr_type");
Devang Patel16674e82011-02-22 18:56:36 +00001138 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
Devang Patel4ce3f202010-01-28 18:11:52 +00001139 return VTablePtrType;
1140}
1141
Anders Carlsson046c2942010-04-17 20:15:18 +00001142/// getVTableName - Get vtable name for the given Class.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001143StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) {
Eric Christopher51cb75a2012-01-25 21:47:09 +00001144 // Construct gdb compatible name name.
Devang Patel239cec62010-02-01 21:39:52 +00001145 std::string Name = "_vptr$" + RD->getNameAsString();
Devang Patel4ce3f202010-01-28 18:11:52 +00001146
1147 // Copy this name on the side and use its reference.
Devang Patel89f05f82010-01-28 18:21:00 +00001148 char *StrPtr = DebugInfoNames.Allocate<char>(Name.length());
Devang Patel4ce3f202010-01-28 18:11:52 +00001149 memcpy(StrPtr, Name.data(), Name.length());
Chris Lattner5f9e2722011-07-23 10:55:15 +00001150 return StringRef(StrPtr, Name.length());
Devang Patel4ce3f202010-01-28 18:11:52 +00001151}
1152
1153
Anders Carlsson046c2942010-04-17 20:15:18 +00001154/// CollectVTableInfo - If the C++ class has vtable info then insert appropriate
Devang Patel4ce3f202010-01-28 18:11:52 +00001155/// debug info entry in EltTys vector.
1156void CGDebugInfo::
Anders Carlsson046c2942010-04-17 20:15:18 +00001157CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile Unit,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001158 SmallVectorImpl<llvm::Value *> &EltTys) {
Devang Patel239cec62010-02-01 21:39:52 +00001159 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
Devang Patel4ce3f202010-01-28 18:11:52 +00001160
1161 // If there is a primary base then it will hold vtable info.
1162 if (RL.getPrimaryBase())
1163 return;
1164
1165 // If this class is not dynamic then there is not any vtable info to collect.
Devang Patel239cec62010-02-01 21:39:52 +00001166 if (!RD->isDynamicClass())
Devang Patel4ce3f202010-01-28 18:11:52 +00001167 return;
1168
1169 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
1170 llvm::DIType VPTR
Devang Patel1d323e02011-06-24 22:00:59 +00001171 = DBuilder.createMemberType(Unit, getVTableName(RD), Unit,
Devang Patel823d8e92010-12-08 22:42:58 +00001172 0, Size, 0, 0, 0,
1173 getOrCreateVTablePtrType(Unit));
Devang Patel4ce3f202010-01-28 18:11:52 +00001174 EltTys.push_back(VPTR);
1175}
1176
Devang Patelc69e1cf2010-09-30 19:05:55 +00001177/// getOrCreateRecordType - Emit record type's standalone debug info.
1178llvm::DIType CGDebugInfo::getOrCreateRecordType(QualType RTy,
1179 SourceLocation Loc) {
Nick Lewyckyd4c100e2011-11-09 04:25:21 +00001180 llvm::DIType T = getOrCreateType(RTy, getOrCreateFile(Loc));
Devang Patelc69e1cf2010-09-30 19:05:55 +00001181 return T;
1182}
1183
Devang Patel65e99f22009-02-25 01:36:11 +00001184/// CreateType - get structure or union type.
Devang Patel31f7d022011-01-17 22:23:07 +00001185llvm::DIType CGDebugInfo::CreateType(const RecordType *Ty) {
Devang Pateld6c5a262010-02-01 21:52:22 +00001186 RecordDecl *RD = Ty->getDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00001187
Chris Lattner9c85ba32008-11-10 06:08:34 +00001188 // Get overall information about the record type for the debug info.
Devang Patel8ab870d2010-05-12 23:46:38 +00001189 llvm::DIFile DefUnit = getOrCreateFile(RD->getLocation());
Mike Stump1eb44332009-09-09 15:08:12 +00001190
Chris Lattner9c85ba32008-11-10 06:08:34 +00001191 // Records and classes and unions can all be recursive. To handle them, we
1192 // first generate a debug descriptor for the struct as a forward declaration.
1193 // Then (if it is a definition) we go through and get debug info for all of
1194 // its members. Finally, we create a descriptor for the complete type (which
1195 // may refer to the forward decl if the struct is recursive) and replace all
1196 // uses of the forward declaration with the final definition.
Eric Christopher4ddca8a2012-01-20 22:10:15 +00001197
Eric Christopher9965dea2012-02-16 22:54:45 +00001198 llvm::DIType FwdDecl = getOrCreateLimitedType(QualType(Ty, 0), DefUnit);
Devang Patel0b897992010-07-08 19:56:29 +00001199
Eric Christopher9965dea2012-02-16 22:54:45 +00001200 if (FwdDecl.isForwardDecl())
1201 return FwdDecl;
Benjamin Kramer6181e562012-03-20 19:49:14 +00001202
1203 llvm::TrackingVH<llvm::MDNode> FwdDeclNode(FwdDecl);
1204
Devang Patele4c1ea02010-03-11 20:01:48 +00001205 // Push the struct on region stack.
Eric Christopheraa2164c2011-09-29 00:00:45 +00001206 LexicalBlockStack.push_back(FwdDeclNode);
Devang Patelab699792010-05-07 18:12:35 +00001207 RegionMap[Ty->getDecl()] = llvm::WeakVH(FwdDecl);
Chris Lattner9c85ba32008-11-10 06:08:34 +00001208
Eric Christopher9965dea2012-02-16 22:54:45 +00001209 // Add this to the completed types cache since we're completing it.
1210 CompletedTypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl;
1211
Chris Lattner9c85ba32008-11-10 06:08:34 +00001212 // Convert all the elements.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001213 SmallVector<llvm::Value *, 16> EltTys;
Chris Lattner9c85ba32008-11-10 06:08:34 +00001214
Eric Christopher1c081d92012-01-26 07:01:04 +00001215 // Note: The split of CXXDecl information here is intentional, the
1216 // gdb tests will depend on a certain ordering at printout. The debug
1217 // information offsets are still correct if we merge them all together
1218 // though.
Devang Pateld6c5a262010-02-01 21:52:22 +00001219 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
Devang Patel3064afe2010-01-28 21:41:35 +00001220 if (CXXDecl) {
Eric Christopher3ee8c912012-01-26 06:20:57 +00001221 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
1222 CollectVTableInfo(CXXDecl, DefUnit, EltTys);
Eric Christopher1c081d92012-01-26 07:01:04 +00001223 }
1224
1225 // Collect static variables with initializers and other fields.
1226 CollectRecordStaticVars(RD, FwdDecl);
1227 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
1228 llvm::DIArray TParamsArray;
1229 if (CXXDecl) {
Eric Christopher3ee8c912012-01-26 06:20:57 +00001230 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
1231 CollectCXXFriends(CXXDecl, DefUnit, EltTys, FwdDecl);
Devang Patel9c1714b2011-04-05 17:30:54 +00001232 if (const ClassTemplateSpecializationDecl *TSpecial
1233 = dyn_cast<ClassTemplateSpecializationDecl>(RD))
Eric Christopher3ee8c912012-01-26 06:20:57 +00001234 TParamsArray = CollectCXXTemplateParams(TSpecial, DefUnit);
Devang Patel823d8e92010-12-08 22:42:58 +00001235 }
Devang Patel0ac8f312010-01-28 00:54:21 +00001236
Eric Christopheraa2164c2011-09-29 00:00:45 +00001237 LexicalBlockStack.pop_back();
Devang Patel823d8e92010-12-08 22:42:58 +00001238 llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator RI =
1239 RegionMap.find(Ty->getDecl());
1240 if (RI != RegionMap.end())
1241 RegionMap.erase(RI);
1242
Jay Foadc556ef22011-04-24 10:11:03 +00001243 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys);
Eric Christopher9965dea2012-02-16 22:54:45 +00001244 // FIXME: Magic numbers ahoy! These should be changed when we
1245 // get some enums in llvm/Analysis/DebugInfo.h to refer to
1246 // them.
Eric Christopher64a04302012-02-15 23:51:20 +00001247 if (RD->isUnion())
Benjamin Kramer6181e562012-03-20 19:49:14 +00001248 FwdDeclNode->replaceOperandWith(10, Elements);
Eric Christopher64a04302012-02-15 23:51:20 +00001249 else if (CXXDecl) {
Benjamin Kramer6181e562012-03-20 19:49:14 +00001250 FwdDeclNode->replaceOperandWith(10, Elements);
1251 FwdDeclNode->replaceOperandWith(13, TParamsArray);
Eric Christopher64a04302012-02-15 23:51:20 +00001252 } else
Benjamin Kramer6181e562012-03-20 19:49:14 +00001253 FwdDeclNode->replaceOperandWith(10, Elements);
Eric Christopher64a04302012-02-15 23:51:20 +00001254
Benjamin Kramer6181e562012-03-20 19:49:14 +00001255 RegionMap[Ty->getDecl()] = llvm::WeakVH(FwdDeclNode);
1256 return llvm::DIType(FwdDeclNode);
Chris Lattner9c85ba32008-11-10 06:08:34 +00001257}
1258
John McCallc12c5bb2010-05-15 11:32:37 +00001259/// CreateType - get objective-c object type.
1260llvm::DIType CGDebugInfo::CreateType(const ObjCObjectType *Ty,
1261 llvm::DIFile Unit) {
1262 // Ignore protocols.
1263 return getOrCreateType(Ty->getBaseType(), Unit);
1264}
1265
Devang Patel9ca36b62009-02-26 21:10:26 +00001266/// CreateType - get objective-c interface type.
1267llvm::DIType CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
Devang Patel17800552010-03-09 00:44:50 +00001268 llvm::DIFile Unit) {
Devang Pateld6c5a262010-02-01 21:52:22 +00001269 ObjCInterfaceDecl *ID = Ty->getDecl();
Douglas Gregora6a28972010-11-30 06:38:09 +00001270 if (!ID)
1271 return llvm::DIType();
Devang Patel9ca36b62009-02-26 21:10:26 +00001272
1273 // Get overall information about the record type for the debug info.
Devang Patel17800552010-03-09 00:44:50 +00001274 llvm::DIFile DefUnit = getOrCreateFile(ID->getLocation());
Devang Patel8ab870d2010-05-12 23:46:38 +00001275 unsigned Line = getLineNumber(ID->getLocation());
Devang Patel17800552010-03-09 00:44:50 +00001276 unsigned RuntimeLang = TheCU.getLanguage();
Chris Lattnerac7c8142009-05-02 01:13:16 +00001277
Eric Christopherd1ab1a22011-10-06 00:31:18 +00001278 // If this is just a forward declaration return a special forward-declaration
1279 // debug type since we won't be able to lay out the entire type.
Douglas Gregor7c1f1f12011-12-15 23:32:29 +00001280 ObjCInterfaceDecl *Def = ID->getDefinition();
1281 if (!Def) {
Devang Patel823d8e92010-12-08 22:42:58 +00001282 llvm::DIType FwdDecl =
Eric Christopher917bc8d2012-02-20 18:05:04 +00001283 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
1284 ID->getName(), DefUnit, Line,
1285 RuntimeLang);
Dan Gohman45f7c782010-08-23 21:15:56 +00001286 return FwdDecl;
1287 }
Douglas Gregor7c1f1f12011-12-15 23:32:29 +00001288 ID = Def;
Dan Gohman45f7c782010-08-23 21:15:56 +00001289
Eric Christopher9965dea2012-02-16 22:54:45 +00001290 // Bit size, align and offset of the type.
1291 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1292 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +00001293
Eric Christopher9965dea2012-02-16 22:54:45 +00001294 unsigned Flags = 0;
1295 if (ID->getImplementation())
1296 Flags |= llvm::DIDescriptor::FlagObjcClassComplete;
1297
1298 llvm::DIType RealDecl =
1299 DBuilder.createStructType(Unit, ID->getName(), DefUnit,
1300 Line, Size, Align, Flags,
1301 llvm::DIArray(), RuntimeLang);
1302
Eric Christopheraf3db7d2012-02-27 08:23:23 +00001303 // Otherwise, insert it into the CompletedTypeCache so that recursive uses
1304 // will find it and we're emitting the complete type.
1305 CompletedTypeCache[QualType(Ty, 0).getAsOpaquePtr()] = RealDecl;
Devang Patele4c1ea02010-03-11 20:01:48 +00001306 // Push the struct on region stack.
Benjamin Kramer6181e562012-03-20 19:49:14 +00001307 llvm::TrackingVH<llvm::MDNode> FwdDeclNode(RealDecl);
Eric Christopher9965dea2012-02-16 22:54:45 +00001308
Eric Christopheraa2164c2011-09-29 00:00:45 +00001309 LexicalBlockStack.push_back(FwdDeclNode);
Eric Christopher9965dea2012-02-16 22:54:45 +00001310 RegionMap[Ty->getDecl()] = llvm::WeakVH(RealDecl);
Devang Patel9ca36b62009-02-26 21:10:26 +00001311
1312 // Convert all the elements.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001313 SmallVector<llvm::Value *, 16> EltTys;
Devang Patel9ca36b62009-02-26 21:10:26 +00001314
Devang Pateld6c5a262010-02-01 21:52:22 +00001315 ObjCInterfaceDecl *SClass = ID->getSuperClass();
Devang Patelfbe899f2009-03-10 21:30:26 +00001316 if (SClass) {
Mike Stump1eb44332009-09-09 15:08:12 +00001317 llvm::DIType SClassTy =
Anders Carlsson20f12a22009-12-06 18:00:51 +00001318 getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit);
Douglas Gregora6a28972010-11-30 06:38:09 +00001319 if (!SClassTy.isValid())
1320 return llvm::DIType();
1321
Mike Stump1eb44332009-09-09 15:08:12 +00001322 llvm::DIType InhTag =
Eric Christopher9965dea2012-02-16 22:54:45 +00001323 DBuilder.createInheritance(RealDecl, SClassTy, 0, 0);
Devang Patelfbe899f2009-03-10 21:30:26 +00001324 EltTys.push_back(InhTag);
1325 }
1326
Devang Patel693fcaa2012-02-07 18:40:30 +00001327 for (ObjCContainerDecl::prop_iterator I = ID->prop_begin(),
1328 E = ID->prop_end(); I != E; ++I) {
1329 const ObjCPropertyDecl *PD = *I;
1330 llvm::MDNode *PropertyNode =
1331 DBuilder.createObjCProperty(PD->getName(),
Devang Patel7fb86302012-02-07 18:55:08 +00001332 getSelectorName(PD->getGetterName()),
1333 getSelectorName(PD->getSetterName()),
1334 PD->getPropertyAttributes());
Devang Patel693fcaa2012-02-07 18:40:30 +00001335 EltTys.push_back(PropertyNode);
1336 }
1337
Devang Pateld6c5a262010-02-01 21:52:22 +00001338 const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(ID);
Devang Patel9ca36b62009-02-26 21:10:26 +00001339 unsigned FieldNo = 0;
Fariborz Jahanian97477392010-10-01 00:01:53 +00001340 for (ObjCIvarDecl *Field = ID->all_declared_ivar_begin(); Field;
Fariborz Jahanianfe8fdba2010-10-11 23:55:47 +00001341 Field = Field->getNextIvar(), ++FieldNo) {
Devang Patel9ca36b62009-02-26 21:10:26 +00001342 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
Douglas Gregora6a28972010-11-30 06:38:09 +00001343 if (!FieldTy.isValid())
1344 return llvm::DIType();
1345
Chris Lattner5f9e2722011-07-23 10:55:15 +00001346 StringRef FieldName = Field->getName();
Devang Patel9ca36b62009-02-26 21:10:26 +00001347
Devang Patelde135022009-04-27 22:40:36 +00001348 // Ignore unnamed fields.
Devang Patel73621622009-11-25 17:37:31 +00001349 if (FieldName.empty())
Devang Patelde135022009-04-27 22:40:36 +00001350 continue;
1351
Devang Patel9ca36b62009-02-26 21:10:26 +00001352 // Get the location for the field.
Devang Patel8ab870d2010-05-12 23:46:38 +00001353 llvm::DIFile FieldDefUnit = getOrCreateFile(Field->getLocation());
1354 unsigned FieldLine = getLineNumber(Field->getLocation());
Devang Patel99c20eb2009-03-20 18:24:39 +00001355 QualType FType = Field->getType();
1356 uint64_t FieldSize = 0;
1357 unsigned FieldAlign = 0;
Devang Patelc20482b2009-03-19 00:23:53 +00001358
Devang Patel99c20eb2009-03-20 18:24:39 +00001359 if (!FType->isIncompleteArrayType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001360
Devang Patel99c20eb2009-03-20 18:24:39 +00001361 // Bit size, align and offset of the type.
Richard Smitha6b8b2c2011-10-10 18:28:20 +00001362 FieldSize = Field->isBitField()
1363 ? Field->getBitWidthValue(CGM.getContext())
1364 : CGM.getContext().getTypeSize(FType);
1365 FieldAlign = CGM.getContext().getTypeAlign(FType);
Devang Patel99c20eb2009-03-20 18:24:39 +00001366 }
1367
Eric Christopherd1ab1a22011-10-06 00:31:18 +00001368 // We can't know the offset of our ivar in the structure if we're using
1369 // the non-fragile abi and the debugger should ignore the value anyways.
1370 // Call it the FieldNo+1 due to how debuggers use the information,
1371 // e.g. negating the value when it needs a lookup in the dynamic table.
David Blaikie4e4d0842012-03-11 07:00:24 +00001372 uint64_t FieldOffset = CGM.getLangOpts().ObjCNonFragileABI ? FieldNo+1
Eric Christopherd1ab1a22011-10-06 00:31:18 +00001373 : RL.getFieldOffset(FieldNo);
Mike Stump1eb44332009-09-09 15:08:12 +00001374
Devang Patelc20482b2009-03-19 00:23:53 +00001375 unsigned Flags = 0;
1376 if (Field->getAccessControl() == ObjCIvarDecl::Protected)
Devang Patele2472482010-09-29 21:05:52 +00001377 Flags = llvm::DIDescriptor::FlagProtected;
Devang Patelc20482b2009-03-19 00:23:53 +00001378 else if (Field->getAccessControl() == ObjCIvarDecl::Private)
Devang Patele2472482010-09-29 21:05:52 +00001379 Flags = llvm::DIDescriptor::FlagPrivate;
Mike Stump1eb44332009-09-09 15:08:12 +00001380
Devang Patel693a70d2012-02-04 01:15:04 +00001381 llvm::MDNode *PropertyNode = NULL;
Devang Patel693fcaa2012-02-07 18:40:30 +00001382 if (ObjCImplementationDecl *ImpD = ID->getImplementation()) {
Devang Patel8c6f9c42011-09-19 18:54:16 +00001383 if (ObjCPropertyImplDecl *PImpD =
Devang Patel693fcaa2012-02-07 18:40:30 +00001384 ImpD->FindPropertyImplIvarDecl(Field->getIdentifier())) {
1385 if (ObjCPropertyDecl *PD = PImpD->getPropertyDecl()) {
Devang Patel7fb86302012-02-07 18:55:08 +00001386 PropertyNode =
1387 DBuilder.createObjCProperty(PD->getName(),
Devang Patel693fcaa2012-02-07 18:40:30 +00001388 getSelectorName(PD->getGetterName()),
1389 getSelectorName(PD->getSetterName()),
1390 PD->getPropertyAttributes());
Devang Patel53bc5182012-02-08 00:10:20 +00001391 }
Devang Patel693fcaa2012-02-07 18:40:30 +00001392 }
Devang Patel693a70d2012-02-04 01:15:04 +00001393 }
Devang Patelfa936d82011-04-16 00:12:55 +00001394 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit,
1395 FieldLine, FieldSize, FieldAlign,
1396 FieldOffset, Flags, FieldTy,
Devang Patel5f3c7fa2012-02-06 18:20:02 +00001397 PropertyNode);
Devang Patel9ca36b62009-02-26 21:10:26 +00001398 EltTys.push_back(FieldTy);
1399 }
Mike Stump1eb44332009-09-09 15:08:12 +00001400
Jay Foadc556ef22011-04-24 10:11:03 +00001401 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys);
Benjamin Kramer6181e562012-03-20 19:49:14 +00001402 FwdDeclNode->replaceOperandWith(10, Elements);
Eric Christopher9965dea2012-02-16 22:54:45 +00001403
Eric Christopheraa2164c2011-09-29 00:00:45 +00001404 LexicalBlockStack.pop_back();
Benjamin Kramer6181e562012-03-20 19:49:14 +00001405 return llvm::DIType(FwdDeclNode);
Devang Patel9ca36b62009-02-26 21:10:26 +00001406}
1407
Nick Lewyckyd4c100e2011-11-09 04:25:21 +00001408llvm::DIType CGDebugInfo::CreateType(const VectorType *Ty, llvm::DIFile Unit) {
Devang Patel70c23cd2010-02-23 22:59:39 +00001409 llvm::DIType ElementTy = getOrCreateType(Ty->getElementType(), Unit);
Devang Patel6cf37dd2011-04-08 21:56:52 +00001410 int64_t NumElems = Ty->getNumElements();
1411 int64_t LowerBound = 0;
1412 if (NumElems == 0)
1413 // If number of elements are not known then this is an unbounded array.
1414 // Use Low = 1, Hi = 0 to express such arrays.
1415 LowerBound = 1;
1416 else
Devang Patel70c23cd2010-02-23 22:59:39 +00001417 --NumElems;
Devang Patel70c23cd2010-02-23 22:59:39 +00001418
Devang Patel6cf37dd2011-04-08 21:56:52 +00001419 llvm::Value *Subscript = DBuilder.getOrCreateSubrange(LowerBound, NumElems);
Jay Foadc556ef22011-04-24 10:11:03 +00001420 llvm::DIArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
Devang Patel70c23cd2010-02-23 22:59:39 +00001421
1422 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1423 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1424
1425 return
Devang Patel16674e82011-02-22 18:56:36 +00001426 DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
Devang Patel70c23cd2010-02-23 22:59:39 +00001427}
1428
Chris Lattner9c85ba32008-11-10 06:08:34 +00001429llvm::DIType CGDebugInfo::CreateType(const ArrayType *Ty,
Devang Patel17800552010-03-09 00:44:50 +00001430 llvm::DIFile Unit) {
Anders Carlsson835c9092009-01-05 01:23:29 +00001431 uint64_t Size;
1432 uint64_t Align;
Mike Stump1eb44332009-09-09 15:08:12 +00001433
1434
Nuno Lopes010d5142009-01-28 00:35:17 +00001435 // FIXME: make getTypeAlign() aware of VLAs and incomplete array types
Anders Carlsson835c9092009-01-05 01:23:29 +00001436 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(Ty)) {
Anders Carlsson835c9092009-01-05 01:23:29 +00001437 Size = 0;
1438 Align =
Anders Carlsson20f12a22009-12-06 18:00:51 +00001439 CGM.getContext().getTypeAlign(CGM.getContext().getBaseElementType(VAT));
Nuno Lopes010d5142009-01-28 00:35:17 +00001440 } else if (Ty->isIncompleteArrayType()) {
1441 Size = 0;
Anders Carlsson20f12a22009-12-06 18:00:51 +00001442 Align = CGM.getContext().getTypeAlign(Ty->getElementType());
Devang Patelba690a42011-04-04 23:18:38 +00001443 } else if (Ty->isDependentSizedArrayType() || Ty->isIncompleteType()) {
Devang Patelae503df2011-04-01 19:02:33 +00001444 Size = 0;
1445 Align = 0;
Anders Carlsson835c9092009-01-05 01:23:29 +00001446 } else {
1447 // Size and align of the whole array, not the element type.
Anders Carlsson20f12a22009-12-06 18:00:51 +00001448 Size = CGM.getContext().getTypeSize(Ty);
1449 Align = CGM.getContext().getTypeAlign(Ty);
Anders Carlsson835c9092009-01-05 01:23:29 +00001450 }
Mike Stump1eb44332009-09-09 15:08:12 +00001451
Chris Lattner9c85ba32008-11-10 06:08:34 +00001452 // Add the dimensions of the array. FIXME: This loses CV qualifiers from
1453 // interior arrays, do we care? Why aren't nested arrays represented the
1454 // obvious/recursive way?
Chris Lattner5f9e2722011-07-23 10:55:15 +00001455 SmallVector<llvm::Value *, 8> Subscripts;
Chris Lattner9c85ba32008-11-10 06:08:34 +00001456 QualType EltTy(Ty, 0);
Devang Patelcdf523c2010-10-06 18:30:00 +00001457 if (Ty->isIncompleteArrayType())
Chris Lattner9c85ba32008-11-10 06:08:34 +00001458 EltTy = Ty->getElementType();
Devang Patelcdf523c2010-10-06 18:30:00 +00001459 else {
1460 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
Devang Patel6cf37dd2011-04-08 21:56:52 +00001461 int64_t UpperBound = 0;
1462 int64_t LowerBound = 0;
Nick Lewycky3894c072011-04-09 00:25:15 +00001463 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(Ty)) {
Devang Patelcdf523c2010-10-06 18:30:00 +00001464 if (CAT->getSize().getZExtValue())
Devang Patel6cf37dd2011-04-08 21:56:52 +00001465 UpperBound = CAT->getSize().getZExtValue() - 1;
Nick Lewycky3894c072011-04-09 00:25:15 +00001466 } else
Devang Patel6cf37dd2011-04-08 21:56:52 +00001467 // This is an unbounded array. Use Low = 1, Hi = 0 to express such
1468 // arrays.
1469 LowerBound = 1;
1470
Devang Patelcdf523c2010-10-06 18:30:00 +00001471 // FIXME: Verify this is right for VLAs.
Eric Christopherab5278e2011-10-11 23:00:51 +00001472 Subscripts.push_back(DBuilder.getOrCreateSubrange(LowerBound,
1473 UpperBound));
Devang Patelcdf523c2010-10-06 18:30:00 +00001474 EltTy = Ty->getElementType();
1475 }
Sanjiv Gupta507de852008-06-09 10:47:41 +00001476 }
Mike Stump1eb44332009-09-09 15:08:12 +00001477
Jay Foadc556ef22011-04-24 10:11:03 +00001478 llvm::DIArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
Chris Lattner9c85ba32008-11-10 06:08:34 +00001479
Devang Patelca80a5f2009-10-20 19:55:01 +00001480 llvm::DIType DbgTy =
Devang Patel16674e82011-02-22 18:56:36 +00001481 DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
Devang Patel823d8e92010-12-08 22:42:58 +00001482 SubscriptArray);
Devang Patelca80a5f2009-10-20 19:55:01 +00001483 return DbgTy;
Chris Lattner9c85ba32008-11-10 06:08:34 +00001484}
1485
Anders Carlssona031b352009-11-06 19:19:55 +00001486llvm::DIType CGDebugInfo::CreateType(const LValueReferenceType *Ty,
Devang Patel17800552010-03-09 00:44:50 +00001487 llvm::DIFile Unit) {
Anders Carlssona031b352009-11-06 19:19:55 +00001488 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type,
1489 Ty, Ty->getPointeeType(), Unit);
1490}
Chris Lattner9c85ba32008-11-10 06:08:34 +00001491
Douglas Gregor36b8ee62011-01-22 01:58:15 +00001492llvm::DIType CGDebugInfo::CreateType(const RValueReferenceType *Ty,
1493 llvm::DIFile Unit) {
1494 return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type,
1495 Ty, Ty->getPointeeType(), Unit);
1496}
1497
Anders Carlsson20f12a22009-12-06 18:00:51 +00001498llvm::DIType CGDebugInfo::CreateType(const MemberPointerType *Ty,
Devang Patel17800552010-03-09 00:44:50 +00001499 llvm::DIFile U) {
Anders Carlsson20f12a22009-12-06 18:00:51 +00001500 QualType PointerDiffTy = CGM.getContext().getPointerDiffType();
1501 llvm::DIType PointerDiffDITy = getOrCreateType(PointerDiffTy, U);
1502
1503 if (!Ty->getPointeeType()->isFunctionType()) {
1504 // We have a data member pointer type.
1505 return PointerDiffDITy;
1506 }
1507
1508 // We have a member function pointer type. Treat it as a struct with two
1509 // ptrdiff_t members.
1510 std::pair<uint64_t, unsigned> Info = CGM.getContext().getTypeInfo(Ty);
1511
1512 uint64_t FieldOffset = 0;
Devang Patel823d8e92010-12-08 22:42:58 +00001513 llvm::Value *ElementTypes[2];
Anders Carlsson20f12a22009-12-06 18:00:51 +00001514
1515 // FIXME: This should probably be a function type instead.
1516 ElementTypes[0] =
Devang Patel1d323e02011-06-24 22:00:59 +00001517 DBuilder.createMemberType(U, "ptr", U, 0,
Devang Patel823d8e92010-12-08 22:42:58 +00001518 Info.first, Info.second, FieldOffset, 0,
1519 PointerDiffDITy);
Anders Carlsson20f12a22009-12-06 18:00:51 +00001520 FieldOffset += Info.first;
1521
1522 ElementTypes[1] =
Devang Patel1d323e02011-06-24 22:00:59 +00001523 DBuilder.createMemberType(U, "ptr", U, 0,
Devang Patel823d8e92010-12-08 22:42:58 +00001524 Info.first, Info.second, FieldOffset, 0,
1525 PointerDiffDITy);
Anders Carlsson20f12a22009-12-06 18:00:51 +00001526
Jay Foadc556ef22011-04-24 10:11:03 +00001527 llvm::DIArray Elements = DBuilder.getOrCreateArray(ElementTypes);
Anders Carlsson20f12a22009-12-06 18:00:51 +00001528
Chris Lattner5f9e2722011-07-23 10:55:15 +00001529 return DBuilder.createStructType(U, StringRef("test"),
Devang Patel823d8e92010-12-08 22:42:58 +00001530 U, 0, FieldOffset,
1531 0, 0, Elements);
Anders Carlsson20f12a22009-12-06 18:00:51 +00001532}
1533
Eli Friedmanb001de72011-10-06 23:00:33 +00001534llvm::DIType CGDebugInfo::CreateType(const AtomicType *Ty,
1535 llvm::DIFile U) {
1536 // Ignore the atomic wrapping
1537 // FIXME: What is the correct representation?
1538 return getOrCreateType(Ty->getValueType(), U);
1539}
1540
Devang Patel6237cea2010-08-23 22:07:25 +00001541/// CreateEnumType - get enumeration type.
Devang Patel31f7d022011-01-17 22:23:07 +00001542llvm::DIType CGDebugInfo::CreateEnumType(const EnumDecl *ED) {
1543 llvm::DIFile Unit = getOrCreateFile(ED->getLocation());
Chris Lattner5f9e2722011-07-23 10:55:15 +00001544 SmallVector<llvm::Value *, 16> Enumerators;
Devang Patel6237cea2010-08-23 22:07:25 +00001545
1546 // Create DIEnumerator elements for each enumerator.
1547 for (EnumDecl::enumerator_iterator
1548 Enum = ED->enumerator_begin(), EnumEnd = ED->enumerator_end();
1549 Enum != EnumEnd; ++Enum) {
Devang Patel823d8e92010-12-08 22:42:58 +00001550 Enumerators.push_back(
Devang Patel16674e82011-02-22 18:56:36 +00001551 DBuilder.createEnumerator(Enum->getName(),
Devang Patel823d8e92010-12-08 22:42:58 +00001552 Enum->getInitVal().getZExtValue()));
Devang Patel6237cea2010-08-23 22:07:25 +00001553 }
1554
1555 // Return a CompositeType for the enum itself.
Jay Foadc556ef22011-04-24 10:11:03 +00001556 llvm::DIArray EltArray = DBuilder.getOrCreateArray(Enumerators);
Devang Patel6237cea2010-08-23 22:07:25 +00001557
1558 llvm::DIFile DefUnit = getOrCreateFile(ED->getLocation());
1559 unsigned Line = getLineNumber(ED->getLocation());
1560 uint64_t Size = 0;
Devang Patelffc52e72010-08-24 18:14:06 +00001561 uint64_t Align = 0;
1562 if (!ED->getTypeForDecl()->isIncompleteType()) {
1563 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
1564 Align = CGM.getContext().getTypeAlign(ED->getTypeForDecl());
1565 }
Devang Patel4bc48872010-10-27 23:23:58 +00001566 llvm::DIDescriptor EnumContext =
John McCall8178df32011-02-22 22:38:33 +00001567 getContextDescriptor(cast<Decl>(ED->getDeclContext()));
Devang Patel6237cea2010-08-23 22:07:25 +00001568 llvm::DIType DbgTy =
Devang Patel16674e82011-02-22 18:56:36 +00001569 DBuilder.createEnumerationType(EnumContext, ED->getName(), DefUnit, Line,
Devang Patel823d8e92010-12-08 22:42:58 +00001570 Size, Align, EltArray);
Devang Patel6237cea2010-08-23 22:07:25 +00001571 return DbgTy;
1572}
1573
Douglas Gregor840943d2009-12-21 20:18:30 +00001574static QualType UnwrapTypeForDebugInfo(QualType T) {
1575 do {
1576 QualType LastT = T;
1577 switch (T->getTypeClass()) {
1578 default:
1579 return T;
1580 case Type::TemplateSpecialization:
1581 T = cast<TemplateSpecializationType>(T)->desugar();
1582 break;
John McCallf4c73712011-01-19 06:33:43 +00001583 case Type::TypeOfExpr:
1584 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
Douglas Gregor840943d2009-12-21 20:18:30 +00001585 break;
Douglas Gregor840943d2009-12-21 20:18:30 +00001586 case Type::TypeOf:
1587 T = cast<TypeOfType>(T)->getUnderlyingType();
1588 break;
1589 case Type::Decltype:
1590 T = cast<DecltypeType>(T)->getUnderlyingType();
1591 break;
Sean Huntca63c202011-05-24 22:41:36 +00001592 case Type::UnaryTransform:
1593 T = cast<UnaryTransformType>(T)->getUnderlyingType();
1594 break;
John McCall9d156a72011-01-06 01:58:22 +00001595 case Type::Attributed:
1596 T = cast<AttributedType>(T)->getEquivalentType();
John McCall14aa2172011-03-04 04:00:19 +00001597 break;
Abramo Bagnara465d41b2010-05-11 21:36:43 +00001598 case Type::Elaborated:
1599 T = cast<ElaboratedType>(T)->getNamedType();
Douglas Gregor840943d2009-12-21 20:18:30 +00001600 break;
Abramo Bagnara075f8f12010-12-10 16:29:40 +00001601 case Type::Paren:
1602 T = cast<ParenType>(T)->getInnerType();
1603 break;
Douglas Gregor840943d2009-12-21 20:18:30 +00001604 case Type::SubstTemplateTypeParm:
1605 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
1606 break;
Anders Carlssonebc32792011-03-06 16:43:04 +00001607 case Type::Auto:
1608 T = cast<AutoType>(T)->getDeducedType();
1609 break;
Douglas Gregor840943d2009-12-21 20:18:30 +00001610 }
1611
1612 assert(T != LastT && "Type unwrapping failed to unwrap!");
1613 if (T == LastT)
1614 return T;
1615 } while (true);
Anders Carlsson5b6117a2009-11-14 21:08:12 +00001616}
1617
Eric Christopher973bbb62011-12-16 23:40:18 +00001618/// getType - Get the type from the cache or return null type if it doesn't exist.
1619llvm::DIType CGDebugInfo::getTypeOrNull(QualType Ty) {
Mike Stump1eb44332009-09-09 15:08:12 +00001620
Douglas Gregor840943d2009-12-21 20:18:30 +00001621 // Unwrap the type as needed for debug information.
1622 Ty = UnwrapTypeForDebugInfo(Ty);
Eric Christopher42e75da2012-02-13 14:56:11 +00001623
Daniel Dunbar23e81ba2009-09-19 19:27:24 +00001624 // Check for existing entry.
Ted Kremenek590838b2010-03-29 18:29:57 +00001625 llvm::DenseMap<void *, llvm::WeakVH>::iterator it =
Daniel Dunbar23e81ba2009-09-19 19:27:24 +00001626 TypeCache.find(Ty.getAsOpaquePtr());
Daniel Dunbar65f13c32009-09-19 20:17:48 +00001627 if (it != TypeCache.end()) {
1628 // Verify that the debug info still exists.
1629 if (&*it->second)
1630 return llvm::DIType(cast<llvm::MDNode>(it->second));
1631 }
Daniel Dunbar03faac32009-09-19 19:27:14 +00001632
Eric Christopher973bbb62011-12-16 23:40:18 +00001633 return llvm::DIType();
1634}
1635
Eric Christopher9965dea2012-02-16 22:54:45 +00001636/// getCompletedTypeOrNull - Get the type from the cache or return null if it
1637/// doesn't exist.
1638llvm::DIType CGDebugInfo::getCompletedTypeOrNull(QualType Ty) {
1639
1640 // Unwrap the type as needed for debug information.
1641 Ty = UnwrapTypeForDebugInfo(Ty);
1642
1643 // Check for existing entry.
1644 llvm::DenseMap<void *, llvm::WeakVH>::iterator it =
1645 CompletedTypeCache.find(Ty.getAsOpaquePtr());
1646 if (it != CompletedTypeCache.end()) {
1647 // Verify that the debug info still exists.
1648 if (&*it->second)
1649 return llvm::DIType(cast<llvm::MDNode>(it->second));
1650 }
1651
1652 return llvm::DIType();
1653}
1654
1655
Eric Christopher973bbb62011-12-16 23:40:18 +00001656/// getOrCreateType - Get the type from the cache or create a new
1657/// one if necessary.
1658llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile Unit) {
1659 if (Ty.isNull())
1660 return llvm::DIType();
1661
1662 // Unwrap the type as needed for debug information.
1663 Ty = UnwrapTypeForDebugInfo(Ty);
Eric Christopher42e75da2012-02-13 14:56:11 +00001664
Eric Christopher9965dea2012-02-16 22:54:45 +00001665 llvm::DIType T = getCompletedTypeOrNull(Ty);
1666
Eric Christopher42e75da2012-02-13 14:56:11 +00001667 if (T.Verify()) return T;
Eric Christopher973bbb62011-12-16 23:40:18 +00001668
Daniel Dunbar23e81ba2009-09-19 19:27:24 +00001669 // Otherwise create the type.
1670 llvm::DIType Res = CreateTypeNode(Ty, Unit);
Eric Christopher7ff0c5d2012-02-18 00:50:17 +00001671
1672 llvm::DIType TC = getTypeOrNull(Ty);
1673 if (TC.Verify() && TC.isForwardDecl())
1674 ReplaceMap.push_back(std::make_pair(Ty.getAsOpaquePtr(), TC));
Eric Christopher9965dea2012-02-16 22:54:45 +00001675
Anders Carlsson0dd57c62009-11-14 20:52:05 +00001676 // And update the type cache.
Eric Christopher9965dea2012-02-16 22:54:45 +00001677 TypeCache[Ty.getAsOpaquePtr()] = Res;
1678
1679 if (!Res.isForwardDecl())
1680 CompletedTypeCache[Ty.getAsOpaquePtr()] = Res;
Daniel Dunbar23e81ba2009-09-19 19:27:24 +00001681 return Res;
Daniel Dunbar03faac32009-09-19 19:27:14 +00001682}
1683
Anders Carlsson0dd57c62009-11-14 20:52:05 +00001684/// CreateTypeNode - Create a new debug type node.
Nick Lewycky7b3819d2011-11-09 04:27:23 +00001685llvm::DIType CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile Unit) {
John McCalla1805292009-09-25 01:40:47 +00001686 // Handle qualifiers, which recursively handles what they refer to.
Douglas Gregora4923eb2009-11-16 21:35:15 +00001687 if (Ty.hasLocalQualifiers())
John McCalla1805292009-09-25 01:40:47 +00001688 return CreateQualifiedType(Ty, Unit);
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +00001689
Douglas Gregor2101a822009-12-21 19:57:21 +00001690 const char *Diag = 0;
1691
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +00001692 // Work out details of type.
Chris Lattner9c85ba32008-11-10 06:08:34 +00001693 switch (Ty->getTypeClass()) {
Douglas Gregor72564e72009-02-26 23:50:07 +00001694#define TYPE(Class, Base)
1695#define ABSTRACT_TYPE(Class, Base)
1696#define NON_CANONICAL_TYPE(Class, Base)
1697#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1698#include "clang/AST/TypeNodes.def"
David Blaikieb219cfc2011-09-23 05:06:16 +00001699 llvm_unreachable("Dependent types cannot show up in debug information");
Argyrios Kyrtzidis1bb8a452009-08-19 01:28:17 +00001700
Anders Carlssonbfe69952009-11-06 18:24:04 +00001701 case Type::ExtVector:
Devang Patel70c23cd2010-02-23 22:59:39 +00001702 case Type::Vector:
1703 return CreateType(cast<VectorType>(Ty), Unit);
Daniel Dunbar9df4bb32009-07-14 01:20:56 +00001704 case Type::ObjCObjectPointer:
Daniel Dunbar03faac32009-09-19 19:27:14 +00001705 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
John McCallc12c5bb2010-05-15 11:32:37 +00001706 case Type::ObjCObject:
1707 return CreateType(cast<ObjCObjectType>(Ty), Unit);
Mike Stump1eb44332009-09-09 15:08:12 +00001708 case Type::ObjCInterface:
Daniel Dunbar03faac32009-09-19 19:27:14 +00001709 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
Nick Lewyckyd4c100e2011-11-09 04:25:21 +00001710 case Type::Builtin:
1711 return CreateType(cast<BuiltinType>(Ty));
1712 case Type::Complex:
1713 return CreateType(cast<ComplexType>(Ty));
1714 case Type::Pointer:
1715 return CreateType(cast<PointerType>(Ty), Unit);
Mike Stump9bc093c2009-05-14 02:03:51 +00001716 case Type::BlockPointer:
Daniel Dunbar03faac32009-09-19 19:27:14 +00001717 return CreateType(cast<BlockPointerType>(Ty), Unit);
Nick Lewyckyd4c100e2011-11-09 04:25:21 +00001718 case Type::Typedef:
1719 return CreateType(cast<TypedefType>(Ty), Unit);
Douglas Gregor72564e72009-02-26 23:50:07 +00001720 case Type::Record:
Nick Lewyckyd4c100e2011-11-09 04:25:21 +00001721 return CreateType(cast<RecordType>(Ty));
Douglas Gregor72564e72009-02-26 23:50:07 +00001722 case Type::Enum:
Nick Lewyckyd4c100e2011-11-09 04:25:21 +00001723 return CreateEnumType(cast<EnumType>(Ty)->getDecl());
Chris Lattner9c85ba32008-11-10 06:08:34 +00001724 case Type::FunctionProto:
1725 case Type::FunctionNoProto:
Daniel Dunbar03faac32009-09-19 19:27:14 +00001726 return CreateType(cast<FunctionType>(Ty), Unit);
Chris Lattner9c85ba32008-11-10 06:08:34 +00001727 case Type::ConstantArray:
1728 case Type::VariableArray:
1729 case Type::IncompleteArray:
Daniel Dunbar03faac32009-09-19 19:27:14 +00001730 return CreateType(cast<ArrayType>(Ty), Unit);
Anders Carlssona031b352009-11-06 19:19:55 +00001731
1732 case Type::LValueReference:
1733 return CreateType(cast<LValueReferenceType>(Ty), Unit);
Douglas Gregor36b8ee62011-01-22 01:58:15 +00001734 case Type::RValueReference:
1735 return CreateType(cast<RValueReferenceType>(Ty), Unit);
Anders Carlssona031b352009-11-06 19:19:55 +00001736
Anders Carlsson20f12a22009-12-06 18:00:51 +00001737 case Type::MemberPointer:
1738 return CreateType(cast<MemberPointerType>(Ty), Unit);
Douglas Gregor2101a822009-12-21 19:57:21 +00001739
Eli Friedmanb001de72011-10-06 23:00:33 +00001740 case Type::Atomic:
1741 return CreateType(cast<AtomicType>(Ty), Unit);
1742
John McCall9d156a72011-01-06 01:58:22 +00001743 case Type::Attributed:
Douglas Gregor2101a822009-12-21 19:57:21 +00001744 case Type::TemplateSpecialization:
Douglas Gregor2101a822009-12-21 19:57:21 +00001745 case Type::Elaborated:
Abramo Bagnara075f8f12010-12-10 16:29:40 +00001746 case Type::Paren:
Douglas Gregor2101a822009-12-21 19:57:21 +00001747 case Type::SubstTemplateTypeParm:
Douglas Gregor2101a822009-12-21 19:57:21 +00001748 case Type::TypeOfExpr:
1749 case Type::TypeOf:
Douglas Gregor840943d2009-12-21 20:18:30 +00001750 case Type::Decltype:
Sean Huntca63c202011-05-24 22:41:36 +00001751 case Type::UnaryTransform:
Richard Smith34b41d92011-02-20 03:19:35 +00001752 case Type::Auto:
Douglas Gregor840943d2009-12-21 20:18:30 +00001753 llvm_unreachable("type should have been unwrapped!");
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +00001754 }
Douglas Gregor2101a822009-12-21 19:57:21 +00001755
1756 assert(Diag && "Fall through without a diagnostic?");
David Blaikied6471f72011-09-25 23:23:43 +00001757 unsigned DiagID = CGM.getDiags().getCustomDiagID(DiagnosticsEngine::Error,
Douglas Gregor2101a822009-12-21 19:57:21 +00001758 "debug information for %0 is not yet supported");
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +00001759 CGM.getDiags().Report(DiagID)
Douglas Gregor2101a822009-12-21 19:57:21 +00001760 << Diag;
1761 return llvm::DIType();
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +00001762}
1763
Eric Christopher9965dea2012-02-16 22:54:45 +00001764/// getOrCreateLimitedType - Get the type from the cache or create a new
1765/// limited type if necessary.
1766llvm::DIType CGDebugInfo::getOrCreateLimitedType(QualType Ty,
1767 llvm::DIFile Unit) {
1768 if (Ty.isNull())
1769 return llvm::DIType();
1770
1771 // Unwrap the type as needed for debug information.
1772 Ty = UnwrapTypeForDebugInfo(Ty);
1773
1774 llvm::DIType T = getTypeOrNull(Ty);
1775
1776 // We may have cached a forward decl when we could have created
1777 // a non-forward decl. Go ahead and create a non-forward decl
1778 // now.
1779 if (T.Verify() && !T.isForwardDecl()) return T;
1780
1781 // Otherwise create the type.
1782 llvm::DIType Res = CreateLimitedTypeNode(Ty, Unit);
1783
Eric Christopher7ff0c5d2012-02-18 00:50:17 +00001784 if (T.Verify() && T.isForwardDecl())
1785 ReplaceMap.push_back(std::make_pair(Ty.getAsOpaquePtr(), T));
1786
Eric Christopher9965dea2012-02-16 22:54:45 +00001787 // And update the type cache.
1788 TypeCache[Ty.getAsOpaquePtr()] = Res;
1789 return Res;
1790}
1791
1792// TODO: Currently used for context chains when limiting debug info.
1793llvm::DIType CGDebugInfo::CreateLimitedType(const RecordType *Ty) {
1794 RecordDecl *RD = Ty->getDecl();
1795
1796 // Get overall information about the record type for the debug info.
1797 llvm::DIFile DefUnit = getOrCreateFile(RD->getLocation());
1798 unsigned Line = getLineNumber(RD->getLocation());
1799 StringRef RDName = RD->getName();
1800
1801 llvm::DIDescriptor RDContext;
1802 if (CGM.getCodeGenOpts().LimitDebugInfo)
1803 RDContext = createContextChain(cast<Decl>(RD->getDeclContext()));
1804 else
1805 RDContext = getContextDescriptor(cast<Decl>(RD->getDeclContext()));
1806
1807 // If this is just a forward declaration, construct an appropriately
1808 // marked node and just return it.
Eric Christopher7ff0c5d2012-02-18 00:50:17 +00001809 if (!RD->getDefinition())
1810 return createRecordFwdDecl(RD, RDContext);
Eric Christopher9965dea2012-02-16 22:54:45 +00001811
1812 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1813 uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1814 const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
Benjamin Kramer6181e562012-03-20 19:49:14 +00001815 llvm::TrackingVH<llvm::MDNode> RealDecl;
Eric Christopher9965dea2012-02-16 22:54:45 +00001816
1817 if (RD->isUnion())
1818 RealDecl = DBuilder.createUnionType(RDContext, RDName, DefUnit, Line,
1819 Size, Align, 0, llvm::DIArray());
1820 else if (CXXDecl) {
1821 RDName = getClassName(RD);
1822
1823 // FIXME: This could be a struct type giving a default visibility different
1824 // than C++ class type, but needs llvm metadata changes first.
1825 RealDecl = DBuilder.createClassType(RDContext, RDName, DefUnit, Line,
1826 Size, Align, 0, 0, llvm::DIType(),
Eric Christopher86211df2012-02-20 18:05:24 +00001827 llvm::DIArray(), llvm::DIType(),
Eric Christopher9965dea2012-02-16 22:54:45 +00001828 llvm::DIArray());
1829 } else
1830 RealDecl = DBuilder.createStructType(RDContext, RDName, DefUnit, Line,
1831 Size, Align, 0, llvm::DIArray());
1832
1833 RegionMap[Ty->getDecl()] = llvm::WeakVH(RealDecl);
1834 TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = llvm::DIType(RealDecl);
1835
1836 if (CXXDecl) {
1837 // A class's primary base or the class itself contains the vtable.
1838 llvm::MDNode *ContainingType = NULL;
1839 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1840 if (const CXXRecordDecl *PBase = RL.getPrimaryBase()) {
1841 // Seek non virtual primary base root.
1842 while (1) {
1843 const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase);
1844 const CXXRecordDecl *PBT = BRL.getPrimaryBase();
1845 if (PBT && !BRL.isPrimaryBaseVirtual())
1846 PBase = PBT;
1847 else
1848 break;
1849 }
1850 ContainingType =
1851 getOrCreateType(QualType(PBase->getTypeForDecl(), 0), DefUnit);
1852 }
1853 else if (CXXDecl->isDynamicClass())
1854 ContainingType = RealDecl;
1855
Eric Christopher1e009d52012-02-17 07:09:48 +00001856 RealDecl->replaceOperandWith(12, ContainingType);
Eric Christopher9965dea2012-02-16 22:54:45 +00001857 }
1858 return llvm::DIType(RealDecl);
1859}
1860
1861/// CreateLimitedTypeNode - Create a new debug type node, but only forward
1862/// declare composite types that haven't been processed yet.
1863llvm::DIType CGDebugInfo::CreateLimitedTypeNode(QualType Ty,llvm::DIFile Unit) {
1864
1865 // Work out details of type.
1866 switch (Ty->getTypeClass()) {
1867#define TYPE(Class, Base)
1868#define ABSTRACT_TYPE(Class, Base)
1869#define NON_CANONICAL_TYPE(Class, Base)
1870#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1871 #include "clang/AST/TypeNodes.def"
1872 llvm_unreachable("Dependent types cannot show up in debug information");
1873
1874 case Type::Record:
1875 return CreateLimitedType(cast<RecordType>(Ty));
1876 default:
1877 return CreateTypeNode(Ty, Unit);
1878 }
1879}
1880
Benjamin Kramer48c70f62010-04-24 20:19:58 +00001881/// CreateMemberType - Create new member and increase Offset by FType's size.
1882llvm::DIType CGDebugInfo::CreateMemberType(llvm::DIFile Unit, QualType FType,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001883 StringRef Name,
Benjamin Kramer48c70f62010-04-24 20:19:58 +00001884 uint64_t *Offset) {
1885 llvm::DIType FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
1886 uint64_t FieldSize = CGM.getContext().getTypeSize(FType);
1887 unsigned FieldAlign = CGM.getContext().getTypeAlign(FType);
Devang Patel1d323e02011-06-24 22:00:59 +00001888 llvm::DIType Ty = DBuilder.createMemberType(Unit, Name, Unit, 0,
Devang Patel823d8e92010-12-08 22:42:58 +00001889 FieldSize, FieldAlign,
1890 *Offset, 0, FieldTy);
Benjamin Kramer48c70f62010-04-24 20:19:58 +00001891 *Offset += FieldSize;
1892 return Ty;
1893}
1894
Devang Patel120bf322011-04-23 00:08:01 +00001895/// getFunctionDeclaration - Return debug info descriptor to describe method
1896/// declaration for the given method definition.
1897llvm::DISubprogram CGDebugInfo::getFunctionDeclaration(const Decl *D) {
1898 const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
1899 if (!FD) return llvm::DISubprogram();
1900
1901 // Setup context.
1902 getContextDescriptor(cast<Decl>(D->getDeclContext()));
1903
Devang Patel22a5cdf2011-04-29 23:42:32 +00001904 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator
Eric Christopherdeae6a82011-11-17 23:45:00 +00001905 MI = SPCache.find(FD->getCanonicalDecl());
Devang Patel22a5cdf2011-04-29 23:42:32 +00001906 if (MI != SPCache.end()) {
1907 llvm::DISubprogram SP(dyn_cast_or_null<llvm::MDNode>(&*MI->second));
1908 if (SP.isSubprogram() && !llvm::DISubprogram(SP).isDefinition())
1909 return SP;
1910 }
1911
Devang Patel120bf322011-04-23 00:08:01 +00001912 for (FunctionDecl::redecl_iterator I = FD->redecls_begin(),
1913 E = FD->redecls_end(); I != E; ++I) {
1914 const FunctionDecl *NextFD = *I;
1915 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator
Eric Christopherdeae6a82011-11-17 23:45:00 +00001916 MI = SPCache.find(NextFD->getCanonicalDecl());
Devang Patel120bf322011-04-23 00:08:01 +00001917 if (MI != SPCache.end()) {
1918 llvm::DISubprogram SP(dyn_cast_or_null<llvm::MDNode>(&*MI->second));
1919 if (SP.isSubprogram() && !llvm::DISubprogram(SP).isDefinition())
1920 return SP;
1921 }
1922 }
1923 return llvm::DISubprogram();
1924}
1925
Devang Patel1c296522011-05-31 20:46:46 +00001926// getOrCreateFunctionType - Construct DIType. If it is a c++ method, include
1927// implicit parameter "this".
Eric Christopherab5278e2011-10-11 23:00:51 +00001928llvm::DIType CGDebugInfo::getOrCreateFunctionType(const Decl * D,
1929 QualType FnType,
Devang Patel1c296522011-05-31 20:46:46 +00001930 llvm::DIFile F) {
1931 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
1932 return getOrCreateMethodType(Method, F);
Nick Lewycky7480d962011-11-10 00:34:02 +00001933 if (const ObjCMethodDecl *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
Devang Patelc478f212011-05-31 21:18:50 +00001934 // Add "self" and "_cmd"
Chris Lattner5f9e2722011-07-23 10:55:15 +00001935 SmallVector<llvm::Value *, 16> Elts;
Devang Patelc478f212011-05-31 21:18:50 +00001936
1937 // First element is always return type. For 'void' functions it is NULL.
Devang Pateld127bcb2011-05-31 22:21:11 +00001938 Elts.push_back(getOrCreateType(OMethod->getResultType(), F));
Devang Patelc478f212011-05-31 21:18:50 +00001939 // "self" pointer is always first argument.
1940 Elts.push_back(getOrCreateType(OMethod->getSelfDecl()->getType(), F));
1941 // "cmd" pointer is always second argument.
1942 Elts.push_back(getOrCreateType(OMethod->getCmdDecl()->getType(), F));
Devang Pateld127bcb2011-05-31 22:21:11 +00001943 // Get rest of the arguments.
Argyrios Kyrtzidis491306a2011-10-03 06:37:04 +00001944 for (ObjCMethodDecl::param_const_iterator PI = OMethod->param_begin(),
Devang Pateld127bcb2011-05-31 22:21:11 +00001945 PE = OMethod->param_end(); PI != PE; ++PI)
1946 Elts.push_back(getOrCreateType((*PI)->getType(), F));
1947
Devang Patelc478f212011-05-31 21:18:50 +00001948 llvm::DIArray EltTypeArray = DBuilder.getOrCreateArray(Elts);
1949 return DBuilder.createSubroutineType(F, EltTypeArray);
1950 }
Devang Patel1c296522011-05-31 20:46:46 +00001951 return getOrCreateType(FnType, F);
1952}
1953
Eric Christopher451b4412012-03-20 23:28:32 +00001954/// EmitFunctionStart - Constructs the debug code for entering a function.
Devang Patel9c6c3a02010-01-14 00:36:21 +00001955void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, QualType FnType,
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +00001956 llvm::Function *Fn,
Chris Lattner9c85ba32008-11-10 06:08:34 +00001957 CGBuilderTy &Builder) {
Mike Stump1eb44332009-09-09 15:08:12 +00001958
Chris Lattner5f9e2722011-07-23 10:55:15 +00001959 StringRef Name;
1960 StringRef LinkageName;
Devang Patel9c6c3a02010-01-14 00:36:21 +00001961
Eric Christopheraa2164c2011-09-29 00:00:45 +00001962 FnBeginRegionCount.push_back(LexicalBlockStack.size());
Devang Patel5a6fbcf2010-07-22 22:29:16 +00001963
Devang Patel9c6c3a02010-01-14 00:36:21 +00001964 const Decl *D = GD.getDecl();
Eric Christopher73fb3502011-10-13 21:45:18 +00001965
Devang Patel3951e712010-10-07 22:03:49 +00001966 unsigned Flags = 0;
Devang Patel0692f832010-10-11 21:58:41 +00001967 llvm::DIFile Unit = getOrCreateFile(CurLoc);
1968 llvm::DIDescriptor FDContext(Unit);
Devang Patel5ecb1df2011-04-05 22:54:11 +00001969 llvm::DIArray TParamsArray;
Devang Patel9c6c3a02010-01-14 00:36:21 +00001970 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Eric Christopherbf979472011-11-14 18:55:02 +00001971 // If there is a DISubprogram for this function available then use it.
Devang Patel4125fd22010-01-19 01:54:44 +00001972 llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator
Eric Christopherdeae6a82011-11-17 23:45:00 +00001973 FI = SPCache.find(FD->getCanonicalDecl());
Devang Patel4125fd22010-01-19 01:54:44 +00001974 if (FI != SPCache.end()) {
Gabor Greif38c9b172010-09-18 13:00:17 +00001975 llvm::DIDescriptor SP(dyn_cast_or_null<llvm::MDNode>(&*FI->second));
Devang Patelab699792010-05-07 18:12:35 +00001976 if (SP.isSubprogram() && llvm::DISubprogram(SP).isDefinition()) {
1977 llvm::MDNode *SPN = SP;
Eric Christopheraa2164c2011-09-29 00:00:45 +00001978 LexicalBlockStack.push_back(SPN);
Devang Patelab699792010-05-07 18:12:35 +00001979 RegionMap[D] = llvm::WeakVH(SP);
Devang Patel4125fd22010-01-19 01:54:44 +00001980 return;
1981 }
1982 }
Devang Patel9c6c3a02010-01-14 00:36:21 +00001983 Name = getFunctionName(FD);
1984 // Use mangled name as linkage name for c/c++ functions.
Devang Patela87a2b22011-05-02 22:49:30 +00001985 if (!Fn->hasInternalLinkage())
Devang Patel2df74c02011-05-02 22:37:48 +00001986 LinkageName = CGM.getMangledName(GD);
Devang Patel58faf202010-10-22 17:11:50 +00001987 if (LinkageName == Name)
Chris Lattner5f9e2722011-07-23 10:55:15 +00001988 LinkageName = StringRef();
Devang Patel3951e712010-10-07 22:03:49 +00001989 if (FD->hasPrototype())
1990 Flags |= llvm::DIDescriptor::FlagPrototyped;
Devang Patel0692f832010-10-11 21:58:41 +00001991 if (const NamespaceDecl *NSDecl =
1992 dyn_cast_or_null<NamespaceDecl>(FD->getDeclContext()))
Devang Patel170cef32010-12-09 00:33:05 +00001993 FDContext = getOrCreateNameSpace(NSDecl);
Devang Patelbc6a1912011-05-17 00:20:09 +00001994 else if (const RecordDecl *RDecl =
1995 dyn_cast_or_null<RecordDecl>(FD->getDeclContext()))
1996 FDContext = getContextDescriptor(cast<Decl>(RDecl->getDeclContext()));
Devang Patel5ecb1df2011-04-05 22:54:11 +00001997
1998 // Collect template parameters.
1999 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
David Chisnall70b9b442010-09-02 17:16:32 +00002000 } else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D)) {
David Chisnall52044a22010-09-02 18:01:51 +00002001 Name = getObjCMethodName(OMD);
Devang Patel3951e712010-10-07 22:03:49 +00002002 Flags |= llvm::DIDescriptor::FlagPrototyped;
Devang Patel9c6c3a02010-01-14 00:36:21 +00002003 } else {
Devang Patel58faf202010-10-22 17:11:50 +00002004 // Use llvm function name.
Devang Patel9c6c3a02010-01-14 00:36:21 +00002005 Name = Fn->getName();
Devang Patel3951e712010-10-07 22:03:49 +00002006 Flags |= llvm::DIDescriptor::FlagPrototyped;
Devang Patel9c6c3a02010-01-14 00:36:21 +00002007 }
Benjamin Kramer48c70f62010-04-24 20:19:58 +00002008 if (!Name.empty() && Name[0] == '\01')
2009 Name = Name.substr(1);
Mike Stump1eb44332009-09-09 15:08:12 +00002010
Devang Patel970c6182010-04-24 00:49:16 +00002011 // It is expected that CurLoc is set before using EmitFunctionStart.
2012 // Usually, CurLoc points to the left bracket location of compound
2013 // statement representing function body.
Devang Patel8ab870d2010-05-12 23:46:38 +00002014 unsigned LineNo = getLineNumber(CurLoc);
Devang Patele2472482010-09-29 21:05:52 +00002015 if (D->isImplicit())
2016 Flags |= llvm::DIDescriptor::FlagArtificial;
Devang Patel120bf322011-04-23 00:08:01 +00002017 llvm::DISubprogram SPDecl = getFunctionDeclaration(D);
Chris Lattner9c85ba32008-11-10 06:08:34 +00002018 llvm::DISubprogram SP =
Devang Patel16674e82011-02-22 18:56:36 +00002019 DBuilder.createFunction(FDContext, Name, LinkageName, Unit,
Devang Patel1c296522011-05-31 20:46:46 +00002020 LineNo, getOrCreateFunctionType(D, FnType, Unit),
Devang Patel823d8e92010-12-08 22:42:58 +00002021 Fn->hasInternalLinkage(), true/*definition*/,
David Blaikie4e4d0842012-03-11 07:00:24 +00002022 Flags, CGM.getLangOpts().Optimize, Fn,
Devang Patel120bf322011-04-23 00:08:01 +00002023 TParamsArray, SPDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00002024
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +00002025 // Push function on region stack.
Devang Patelab699792010-05-07 18:12:35 +00002026 llvm::MDNode *SPN = SP;
Eric Christopheraa2164c2011-09-29 00:00:45 +00002027 LexicalBlockStack.push_back(SPN);
Devang Patelab699792010-05-07 18:12:35 +00002028 RegionMap[D] = llvm::WeakVH(SP);
Eric Christopher69a1b742011-09-29 00:00:37 +00002029}
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +00002030
Eric Christopher5321bc42011-09-29 00:00:41 +00002031/// EmitLocation - Emit metadata to indicate a change in line/column
2032/// information in the source file.
Eric Christopher73fb3502011-10-13 21:45:18 +00002033void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc) {
2034
2035 // Update our current location
2036 setLocation(Loc);
2037
Sanjiv Gupta1c6a38b2008-05-25 05:15:42 +00002038 if (CurLoc.isInvalid() || CurLoc.isMacroID()) return;
Mike Stump1eb44332009-09-09 15:08:12 +00002039
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +00002040 // Don't bother if things are the same as last time.
Anders Carlsson20f12a22009-12-06 18:00:51 +00002041 SourceManager &SM = CGM.getContext().getSourceManager();
Eric Christopher73fb3502011-10-13 21:45:18 +00002042 if (CurLoc == PrevLoc ||
Chandler Carruth40278532011-07-25 16:49:02 +00002043 SM.getExpansionLoc(CurLoc) == SM.getExpansionLoc(PrevLoc))
Devang Patel4800ea62010-04-05 21:09:15 +00002044 // New Builder may not be in sync with CGDebugInfo.
2045 if (!Builder.getCurrentDebugLocation().isUnknown())
2046 return;
Eric Christopher414ee4b2011-09-29 00:00:35 +00002047
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +00002048 // Update last state.
2049 PrevLoc = CurLoc;
2050
Eric Christopheraa2164c2011-09-29 00:00:45 +00002051 llvm::MDNode *Scope = LexicalBlockStack.back();
Devang Patel8ab870d2010-05-12 23:46:38 +00002052 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(getLineNumber(CurLoc),
2053 getColumnNumber(CurLoc),
Chris Lattnere541d012010-04-02 20:21:43 +00002054 Scope));
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +00002055}
2056
Eric Christopher73fb3502011-10-13 21:45:18 +00002057/// CreateLexicalBlock - Creates a new lexical block node and pushes it on
2058/// the stack.
2059void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) {
Devang Patel8fae0602009-11-13 19:10:24 +00002060 llvm::DIDescriptor D =
Eric Christopher73fb3502011-10-13 21:45:18 +00002061 DBuilder.createLexicalBlock(LexicalBlockStack.empty() ?
Devang Patel53bc5182012-02-08 00:10:20 +00002062 llvm::DIDescriptor() :
2063 llvm::DIDescriptor(LexicalBlockStack.back()),
2064 getOrCreateFile(CurLoc),
2065 getLineNumber(CurLoc),
2066 getColumnNumber(CurLoc));
Devang Patelab699792010-05-07 18:12:35 +00002067 llvm::MDNode *DN = D;
Eric Christopheraa2164c2011-09-29 00:00:45 +00002068 LexicalBlockStack.push_back(DN);
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +00002069}
2070
Eric Christopher73fb3502011-10-13 21:45:18 +00002071/// EmitLexicalBlockStart - Constructs the debug code for entering a declarative
2072/// region - beginning of a DW_TAG_lexical_block.
2073void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder, SourceLocation Loc) {
2074 // Set our current location.
2075 setLocation(Loc);
2076
2077 // Create a new lexical block and push it on the stack.
2078 CreateLexicalBlock(Loc);
2079
2080 // Emit a line table change for the current location inside the new scope.
2081 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(getLineNumber(Loc),
Devang Patel53bc5182012-02-08 00:10:20 +00002082 getColumnNumber(Loc),
2083 LexicalBlockStack.back()));
Eric Christopher73fb3502011-10-13 21:45:18 +00002084}
2085
Eric Christopheraa2164c2011-09-29 00:00:45 +00002086/// EmitLexicalBlockEnd - Constructs the debug code for exiting a declarative
Eric Christopher43202ae2011-09-26 15:03:22 +00002087/// region - end of a DW_TAG_lexical_block.
Eric Christopher73fb3502011-10-13 21:45:18 +00002088void CGDebugInfo::EmitLexicalBlockEnd(CGBuilderTy &Builder, SourceLocation Loc) {
Eric Christopheraa2164c2011-09-29 00:00:45 +00002089 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
Daniel Dunbar5273f512008-10-17 01:07:56 +00002090
Eric Christopher73fb3502011-10-13 21:45:18 +00002091 // Provide an entry in the line table for the end of the block.
2092 EmitLocation(Builder, Loc);
Mike Stump1eb44332009-09-09 15:08:12 +00002093
Eric Christopheraa2164c2011-09-29 00:00:45 +00002094 LexicalBlockStack.pop_back();
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +00002095}
2096
Devang Patel5a6fbcf2010-07-22 22:29:16 +00002097/// EmitFunctionEnd - Constructs the debug code for exiting a function.
2098void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder) {
Eric Christopheraa2164c2011-09-29 00:00:45 +00002099 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
Devang Patel5a6fbcf2010-07-22 22:29:16 +00002100 unsigned RCount = FnBeginRegionCount.back();
Eric Christopheraa2164c2011-09-29 00:00:45 +00002101 assert(RCount <= LexicalBlockStack.size() && "Region stack mismatch");
Devang Patel5a6fbcf2010-07-22 22:29:16 +00002102
2103 // Pop all regions for this function.
Eric Christopheraa2164c2011-09-29 00:00:45 +00002104 while (LexicalBlockStack.size() != RCount)
Eric Christopher73fb3502011-10-13 21:45:18 +00002105 EmitLexicalBlockEnd(Builder, CurLoc);
Devang Patel5a6fbcf2010-07-22 22:29:16 +00002106 FnBeginRegionCount.pop_back();
2107}
2108
Devang Patel809b9bb2010-02-10 18:49:08 +00002109// EmitTypeForVarWithBlocksAttr - Build up structure info for the byref.
2110// See BuildByRefType.
2111llvm::DIType CGDebugInfo::EmitTypeForVarWithBlocksAttr(const ValueDecl *VD,
2112 uint64_t *XOffset) {
2113
Chris Lattner5f9e2722011-07-23 10:55:15 +00002114 SmallVector<llvm::Value *, 5> EltTys;
Devang Patel809b9bb2010-02-10 18:49:08 +00002115 QualType FType;
2116 uint64_t FieldSize, FieldOffset;
2117 unsigned FieldAlign;
2118
Devang Patel17800552010-03-09 00:44:50 +00002119 llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
Devang Patel809b9bb2010-02-10 18:49:08 +00002120 QualType Type = VD->getType();
2121
2122 FieldOffset = 0;
2123 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Benjamin Kramer48c70f62010-04-24 20:19:58 +00002124 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
2125 EltTys.push_back(CreateMemberType(Unit, FType, "__forwarding", &FieldOffset));
Devang Patel809b9bb2010-02-10 18:49:08 +00002126 FType = CGM.getContext().IntTy;
Benjamin Kramer48c70f62010-04-24 20:19:58 +00002127 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
2128 EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset));
2129
John McCall6b5a61b2011-02-07 10:33:21 +00002130 bool HasCopyAndDispose = CGM.getContext().BlockRequiresCopying(Type);
Devang Patel809b9bb2010-02-10 18:49:08 +00002131 if (HasCopyAndDispose) {
2132 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Benjamin Kramer48c70f62010-04-24 20:19:58 +00002133 EltTys.push_back(CreateMemberType(Unit, FType, "__copy_helper",
2134 &FieldOffset));
2135 EltTys.push_back(CreateMemberType(Unit, FType, "__destroy_helper",
2136 &FieldOffset));
Devang Patel809b9bb2010-02-10 18:49:08 +00002137 }
2138
2139 CharUnits Align = CGM.getContext().getDeclAlign(VD);
Ken Dyck573be632011-04-22 17:34:18 +00002140 if (Align > CGM.getContext().toCharUnitsFromBits(
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00002141 CGM.getContext().getTargetInfo().getPointerAlign(0))) {
Ken Dyck573be632011-04-22 17:34:18 +00002142 CharUnits FieldOffsetInBytes
2143 = CGM.getContext().toCharUnitsFromBits(FieldOffset);
2144 CharUnits AlignedOffsetInBytes
2145 = FieldOffsetInBytes.RoundUpToAlignment(Align);
2146 CharUnits NumPaddingBytes
2147 = AlignedOffsetInBytes - FieldOffsetInBytes;
Devang Patel809b9bb2010-02-10 18:49:08 +00002148
Ken Dyck573be632011-04-22 17:34:18 +00002149 if (NumPaddingBytes.isPositive()) {
2150 llvm::APInt pad(32, NumPaddingBytes.getQuantity());
Devang Patel809b9bb2010-02-10 18:49:08 +00002151 FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy,
2152 pad, ArrayType::Normal, 0);
Benjamin Kramer48c70f62010-04-24 20:19:58 +00002153 EltTys.push_back(CreateMemberType(Unit, FType, "", &FieldOffset));
Devang Patel809b9bb2010-02-10 18:49:08 +00002154 }
2155 }
2156
2157 FType = Type;
Benjamin Kramer48c70f62010-04-24 20:19:58 +00002158 llvm::DIType FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Devang Patel809b9bb2010-02-10 18:49:08 +00002159 FieldSize = CGM.getContext().getTypeSize(FType);
Ken Dyck573be632011-04-22 17:34:18 +00002160 FieldAlign = CGM.getContext().toBits(Align);
Devang Patel809b9bb2010-02-10 18:49:08 +00002161
2162 *XOffset = FieldOffset;
Devang Patel1d323e02011-06-24 22:00:59 +00002163 FieldTy = DBuilder.createMemberType(Unit, VD->getName(), Unit,
Devang Patel823d8e92010-12-08 22:42:58 +00002164 0, FieldSize, FieldAlign,
2165 FieldOffset, 0, FieldTy);
Devang Patel809b9bb2010-02-10 18:49:08 +00002166 EltTys.push_back(FieldTy);
2167 FieldOffset += FieldSize;
2168
Jay Foadc556ef22011-04-24 10:11:03 +00002169 llvm::DIArray Elements = DBuilder.getOrCreateArray(EltTys);
Devang Patel809b9bb2010-02-10 18:49:08 +00002170
Devang Patele2472482010-09-29 21:05:52 +00002171 unsigned Flags = llvm::DIDescriptor::FlagBlockByrefStruct;
Devang Patel809b9bb2010-02-10 18:49:08 +00002172
Devang Patel16674e82011-02-22 18:56:36 +00002173 return DBuilder.createStructType(Unit, "", Unit, 0, FieldOffset, 0, Flags,
Devang Patel823d8e92010-12-08 22:42:58 +00002174 Elements);
Devang Patel809b9bb2010-02-10 18:49:08 +00002175}
Devang Patel823d8e92010-12-08 22:42:58 +00002176
Sanjiv Guptacc9b1632008-05-30 10:30:31 +00002177/// EmitDeclare - Emit local variable declaration debug info.
Devang Patel239cec62010-02-01 21:39:52 +00002178void CGDebugInfo::EmitDeclare(const VarDecl *VD, unsigned Tag,
Devang Patel093ac462011-03-03 20:13:15 +00002179 llvm::Value *Storage,
2180 unsigned ArgNo, CGBuilderTy &Builder) {
Eric Christopheraa2164c2011-09-29 00:00:45 +00002181 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
Daniel Dunbar5273f512008-10-17 01:07:56 +00002182
Devang Patel17800552010-03-09 00:44:50 +00002183 llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
Devang Patel809b9bb2010-02-10 18:49:08 +00002184 llvm::DIType Ty;
2185 uint64_t XOffset = 0;
2186 if (VD->hasAttr<BlocksAttr>())
2187 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
2188 else
2189 Ty = getOrCreateType(VD->getType(), Unit);
Chris Lattner650cea92009-05-05 04:57:08 +00002190
Devang Patelf4e54a22010-05-07 23:05:55 +00002191 // If there is not any debug info for type then do not emit debug info
2192 // for this variable.
2193 if (!Ty)
2194 return;
2195
Devang Patel34753802011-02-16 01:11:51 +00002196 if (llvm::Argument *Arg = dyn_cast<llvm::Argument>(Storage)) {
2197 // If Storage is an aggregate returned as 'sret' then let debugger know
2198 // about this.
Devang Patel0691f932011-02-10 00:40:52 +00002199 if (Arg->hasStructRetAttr())
Devang Patel16674e82011-02-22 18:56:36 +00002200 Ty = DBuilder.createReferenceType(Ty);
Devang Patel34753802011-02-16 01:11:51 +00002201 else if (CXXRecordDecl *Record = VD->getType()->getAsCXXRecordDecl()) {
2202 // If an aggregate variable has non trivial destructor or non trivial copy
2203 // constructor than it is pass indirectly. Let debug info know about this
2204 // by using reference of the aggregate type as a argument type.
Eric Christopherab5278e2011-10-11 23:00:51 +00002205 if (!Record->hasTrivialCopyConstructor() ||
2206 !Record->hasTrivialDestructor())
Devang Patel16674e82011-02-22 18:56:36 +00002207 Ty = DBuilder.createReferenceType(Ty);
Devang Patel34753802011-02-16 01:11:51 +00002208 }
2209 }
Devang Patel0691f932011-02-10 00:40:52 +00002210
Chris Lattner9c85ba32008-11-10 06:08:34 +00002211 // Get location information.
Devang Patel8ab870d2010-05-12 23:46:38 +00002212 unsigned Line = getLineNumber(VD->getLocation());
2213 unsigned Column = getColumnNumber(VD->getLocation());
Devang Patelaca745b2010-09-29 23:09:21 +00002214 unsigned Flags = 0;
2215 if (VD->isImplicit())
2216 Flags |= llvm::DIDescriptor::FlagArtificial;
Eric Christopheraa2164c2011-09-29 00:00:45 +00002217 llvm::MDNode *Scope = LexicalBlockStack.back();
Devang Patelcebbedd2010-10-12 23:24:54 +00002218
Chris Lattner5f9e2722011-07-23 10:55:15 +00002219 StringRef Name = VD->getName();
Devang Patelcebbedd2010-10-12 23:24:54 +00002220 if (!Name.empty()) {
Devang Patelb1fd0eb2011-01-11 00:30:27 +00002221 if (VD->hasAttr<BlocksAttr>()) {
2222 CharUnits offset = CharUnits::fromQuantity(32);
Chris Lattner5f9e2722011-07-23 10:55:15 +00002223 SmallVector<llvm::Value *, 9> addr;
Chris Lattner8b418682012-02-07 00:39:47 +00002224 llvm::Type *Int64Ty = CGM.Int64Ty;
Devang Patel4a4e2ef2011-02-18 23:29:22 +00002225 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus));
Devang Patelb1fd0eb2011-01-11 00:30:27 +00002226 // offset of __forwarding field
Ken Dyck0ebce0e2011-04-22 17:41:34 +00002227 offset = CGM.getContext().toCharUnitsFromBits(
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00002228 CGM.getContext().getTargetInfo().getPointerWidth(0));
Devang Patelb1fd0eb2011-01-11 00:30:27 +00002229 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
Devang Patel4a4e2ef2011-02-18 23:29:22 +00002230 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpDeref));
2231 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus));
Devang Patelb1fd0eb2011-01-11 00:30:27 +00002232 // offset of x field
Ken Dyck0ebce0e2011-04-22 17:41:34 +00002233 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
Devang Patelb1fd0eb2011-01-11 00:30:27 +00002234 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
2235
2236 // Create the descriptor for the variable.
2237 llvm::DIVariable D =
Devang Patel16674e82011-02-22 18:56:36 +00002238 DBuilder.createComplexVariable(Tag,
Eric Christopherab5278e2011-10-11 23:00:51 +00002239 llvm::DIDescriptor(Scope),
Devang Patelb1fd0eb2011-01-11 00:30:27 +00002240 VD->getName(), Unit, Line, Ty,
Jay Foadc556ef22011-04-24 10:11:03 +00002241 addr, ArgNo);
Devang Patelb1fd0eb2011-01-11 00:30:27 +00002242
2243 // Insert an llvm.dbg.declare into the current block.
2244 llvm::Instruction *Call =
Devang Patel16674e82011-02-22 18:56:36 +00002245 DBuilder.insertDeclare(Storage, D, Builder.GetInsertBlock());
Devang Patelb1fd0eb2011-01-11 00:30:27 +00002246 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope));
2247 return;
2248 }
2249 // Create the descriptor for the variable.
Devang Patelcebbedd2010-10-12 23:24:54 +00002250 llvm::DIVariable D =
Devang Patel16674e82011-02-22 18:56:36 +00002251 DBuilder.createLocalVariable(Tag, llvm::DIDescriptor(Scope),
Devang Patel823d8e92010-12-08 22:42:58 +00002252 Name, Unit, Line, Ty,
David Blaikie4e4d0842012-03-11 07:00:24 +00002253 CGM.getLangOpts().Optimize, Flags, ArgNo);
Devang Patelcebbedd2010-10-12 23:24:54 +00002254
2255 // Insert an llvm.dbg.declare into the current block.
2256 llvm::Instruction *Call =
Devang Patel16674e82011-02-22 18:56:36 +00002257 DBuilder.insertDeclare(Storage, D, Builder.GetInsertBlock());
Devang Patelcebbedd2010-10-12 23:24:54 +00002258 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope));
Devang Patelf4dd9622010-10-29 16:21:19 +00002259 return;
Devang Patelcebbedd2010-10-12 23:24:54 +00002260 }
2261
2262 // If VD is an anonymous union then Storage represents value for
2263 // all union fields.
John McCall8178df32011-02-22 22:38:33 +00002264 if (const RecordType *RT = dyn_cast<RecordType>(VD->getType())) {
2265 const RecordDecl *RD = cast<RecordDecl>(RT->getDecl());
2266 if (RD->isUnion()) {
2267 for (RecordDecl::field_iterator I = RD->field_begin(),
2268 E = RD->field_end();
2269 I != E; ++I) {
2270 FieldDecl *Field = *I;
2271 llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
Chris Lattner5f9e2722011-07-23 10:55:15 +00002272 StringRef FieldName = Field->getName();
Devang Patelcebbedd2010-10-12 23:24:54 +00002273
John McCall8178df32011-02-22 22:38:33 +00002274 // Ignore unnamed fields. Do not ignore unnamed records.
2275 if (FieldName.empty() && !isa<RecordType>(Field->getType()))
2276 continue;
Devang Patelcebbedd2010-10-12 23:24:54 +00002277
John McCall8178df32011-02-22 22:38:33 +00002278 // Use VarDecl's Tag, Scope and Line number.
2279 llvm::DIVariable D =
2280 DBuilder.createLocalVariable(Tag, llvm::DIDescriptor(Scope),
2281 FieldName, Unit, Line, FieldTy,
David Blaikie4e4d0842012-03-11 07:00:24 +00002282 CGM.getLangOpts().Optimize, Flags,
Devang Patel093ac462011-03-03 20:13:15 +00002283 ArgNo);
Devang Patelcebbedd2010-10-12 23:24:54 +00002284
John McCall8178df32011-02-22 22:38:33 +00002285 // Insert an llvm.dbg.declare into the current block.
2286 llvm::Instruction *Call =
2287 DBuilder.insertDeclare(Storage, D, Builder.GetInsertBlock());
John McCall8178df32011-02-22 22:38:33 +00002288 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope));
Devang Patelcebbedd2010-10-12 23:24:54 +00002289 }
John McCall8178df32011-02-22 22:38:33 +00002290 }
2291 }
Sanjiv Guptacc9b1632008-05-30 10:30:31 +00002292}
2293
Devang Patele2d01912011-04-25 23:43:36 +00002294void CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD,
2295 llvm::Value *Storage,
2296 CGBuilderTy &Builder) {
2297 EmitDeclare(VD, llvm::dwarf::DW_TAG_auto_variable, Storage, 0, Builder);
2298}
Mike Stumpb1a6e682009-09-30 02:43:10 +00002299
Devang Patele2d01912011-04-25 23:43:36 +00002300void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
2301 const VarDecl *VD, llvm::Value *Storage, CGBuilderTy &Builder,
2302 const CGBlockInfo &blockInfo) {
Eric Christopheraa2164c2011-09-29 00:00:45 +00002303 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
Devang Patele2d01912011-04-25 23:43:36 +00002304
Devang Patel2b594b92010-04-26 23:28:46 +00002305 if (Builder.GetInsertBlock() == 0)
Mike Stumpb1a6e682009-09-30 02:43:10 +00002306 return;
Devang Patele2d01912011-04-25 23:43:36 +00002307
John McCall6b5a61b2011-02-07 10:33:21 +00002308 bool isByRef = VD->hasAttr<BlocksAttr>();
Devang Patele2d01912011-04-25 23:43:36 +00002309
Mike Stumpb1a6e682009-09-30 02:43:10 +00002310 uint64_t XOffset = 0;
Devang Patel17800552010-03-09 00:44:50 +00002311 llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
Devang Patel809b9bb2010-02-10 18:49:08 +00002312 llvm::DIType Ty;
John McCall6b5a61b2011-02-07 10:33:21 +00002313 if (isByRef)
Devang Patel809b9bb2010-02-10 18:49:08 +00002314 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
2315 else
2316 Ty = getOrCreateType(VD->getType(), Unit);
Mike Stumpb1a6e682009-09-30 02:43:10 +00002317
2318 // Get location information.
Devang Patel8ab870d2010-05-12 23:46:38 +00002319 unsigned Line = getLineNumber(VD->getLocation());
2320 unsigned Column = getColumnNumber(VD->getLocation());
Mike Stumpb1a6e682009-09-30 02:43:10 +00002321
John McCall6b5a61b2011-02-07 10:33:21 +00002322 const llvm::TargetData &target = CGM.getTargetData();
2323
2324 CharUnits offset = CharUnits::fromQuantity(
2325 target.getStructLayout(blockInfo.StructureType)
2326 ->getElementOffset(blockInfo.getCapture(VD).getIndex()));
2327
Chris Lattner5f9e2722011-07-23 10:55:15 +00002328 SmallVector<llvm::Value *, 9> addr;
Chris Lattner8b418682012-02-07 00:39:47 +00002329 llvm::Type *Int64Ty = CGM.Int64Ty;
Devang Patel4a4e2ef2011-02-18 23:29:22 +00002330 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus));
Chris Lattner14b1a362010-01-25 03:29:35 +00002331 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
John McCall6b5a61b2011-02-07 10:33:21 +00002332 if (isByRef) {
Devang Patel4a4e2ef2011-02-18 23:29:22 +00002333 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpDeref));
2334 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus));
Ken Dyck199c3d62010-01-11 17:06:35 +00002335 // offset of __forwarding field
Eric Christopherab5278e2011-10-11 23:00:51 +00002336 offset = CGM.getContext()
2337 .toCharUnitsFromBits(target.getPointerSizeInBits());
Chris Lattner14b1a362010-01-25 03:29:35 +00002338 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
Devang Patel4a4e2ef2011-02-18 23:29:22 +00002339 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpDeref));
2340 addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpPlus));
Ken Dyck199c3d62010-01-11 17:06:35 +00002341 // offset of x field
Ken Dyck0ebce0e2011-04-22 17:41:34 +00002342 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
Chris Lattner14b1a362010-01-25 03:29:35 +00002343 addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
Mike Stumpb1a6e682009-09-30 02:43:10 +00002344 }
2345
2346 // Create the descriptor for the variable.
2347 llvm::DIVariable D =
Devang Patele2d01912011-04-25 23:43:36 +00002348 DBuilder.createComplexVariable(llvm::dwarf::DW_TAG_auto_variable,
Eric Christopheraa2164c2011-09-29 00:00:45 +00002349 llvm::DIDescriptor(LexicalBlockStack.back()),
Jay Foadc556ef22011-04-24 10:11:03 +00002350 VD->getName(), Unit, Line, Ty, addr);
Mike Stumpb1a6e682009-09-30 02:43:10 +00002351 // Insert an llvm.dbg.declare into the current block.
Eric Christopher73fb3502011-10-13 21:45:18 +00002352 llvm::Instruction *Call =
Devang Patel50811d22011-04-25 23:52:27 +00002353 DBuilder.insertDeclare(Storage, D, Builder.GetInsertPoint());
Eric Christopher73fb3502011-10-13 21:45:18 +00002354 Call->setDebugLoc(llvm::DebugLoc::get(Line, Column,
2355 LexicalBlockStack.back()));
Mike Stumpb1a6e682009-09-30 02:43:10 +00002356}
2357
Chris Lattner9c85ba32008-11-10 06:08:34 +00002358/// EmitDeclareOfArgVariable - Emit call to llvm.dbg.declare for an argument
2359/// variable declaration.
Devang Pateld6c5a262010-02-01 21:52:22 +00002360void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI,
Devang Patel093ac462011-03-03 20:13:15 +00002361 unsigned ArgNo,
Devang Patel34753802011-02-16 01:11:51 +00002362 CGBuilderTy &Builder) {
Devang Patel093ac462011-03-03 20:13:15 +00002363 EmitDeclare(VD, llvm::dwarf::DW_TAG_arg_variable, AI, ArgNo, Builder);
Chris Lattner9c85ba32008-11-10 06:08:34 +00002364}
2365
John McCall8178df32011-02-22 22:38:33 +00002366namespace {
2367 struct BlockLayoutChunk {
2368 uint64_t OffsetInBits;
2369 const BlockDecl::Capture *Capture;
2370 };
2371 bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) {
2372 return l.OffsetInBits < r.OffsetInBits;
2373 }
2374}
Chris Lattner9c85ba32008-11-10 06:08:34 +00002375
John McCall8178df32011-02-22 22:38:33 +00002376void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
2377 llvm::Value *addr,
2378 CGBuilderTy &Builder) {
2379 ASTContext &C = CGM.getContext();
2380 const BlockDecl *blockDecl = block.getBlockDecl();
2381
2382 // Collect some general information about the block's location.
2383 SourceLocation loc = blockDecl->getCaretLocation();
2384 llvm::DIFile tunit = getOrCreateFile(loc);
2385 unsigned line = getLineNumber(loc);
2386 unsigned column = getColumnNumber(loc);
2387
2388 // Build the debug-info type for the block literal.
Nick Lewycky7d4b1592011-05-02 01:41:48 +00002389 getContextDescriptor(cast<Decl>(blockDecl->getDeclContext()));
John McCall8178df32011-02-22 22:38:33 +00002390
2391 const llvm::StructLayout *blockLayout =
2392 CGM.getTargetData().getStructLayout(block.StructureType);
2393
Chris Lattner5f9e2722011-07-23 10:55:15 +00002394 SmallVector<llvm::Value*, 16> fields;
John McCall8178df32011-02-22 22:38:33 +00002395 fields.push_back(createFieldType("__isa", C.VoidPtrTy, 0, loc, AS_public,
2396 blockLayout->getElementOffsetInBits(0),
Devang Patel1d323e02011-06-24 22:00:59 +00002397 tunit, tunit));
John McCall8178df32011-02-22 22:38:33 +00002398 fields.push_back(createFieldType("__flags", C.IntTy, 0, loc, AS_public,
2399 blockLayout->getElementOffsetInBits(1),
Devang Patel1d323e02011-06-24 22:00:59 +00002400 tunit, tunit));
John McCall8178df32011-02-22 22:38:33 +00002401 fields.push_back(createFieldType("__reserved", C.IntTy, 0, loc, AS_public,
2402 blockLayout->getElementOffsetInBits(2),
Devang Patel1d323e02011-06-24 22:00:59 +00002403 tunit, tunit));
John McCall8178df32011-02-22 22:38:33 +00002404 fields.push_back(createFieldType("__FuncPtr", C.VoidPtrTy, 0, loc, AS_public,
2405 blockLayout->getElementOffsetInBits(3),
Devang Patel1d323e02011-06-24 22:00:59 +00002406 tunit, tunit));
John McCall8178df32011-02-22 22:38:33 +00002407 fields.push_back(createFieldType("__descriptor",
2408 C.getPointerType(block.NeedsCopyDispose ?
2409 C.getBlockDescriptorExtendedType() :
2410 C.getBlockDescriptorType()),
2411 0, loc, AS_public,
2412 blockLayout->getElementOffsetInBits(4),
Devang Patel1d323e02011-06-24 22:00:59 +00002413 tunit, tunit));
John McCall8178df32011-02-22 22:38:33 +00002414
2415 // We want to sort the captures by offset, not because DWARF
2416 // requires this, but because we're paranoid about debuggers.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002417 SmallVector<BlockLayoutChunk, 8> chunks;
John McCall8178df32011-02-22 22:38:33 +00002418
2419 // 'this' capture.
2420 if (blockDecl->capturesCXXThis()) {
2421 BlockLayoutChunk chunk;
2422 chunk.OffsetInBits =
2423 blockLayout->getElementOffsetInBits(block.CXXThisIndex);
2424 chunk.Capture = 0;
2425 chunks.push_back(chunk);
2426 }
2427
2428 // Variable captures.
2429 for (BlockDecl::capture_const_iterator
2430 i = blockDecl->capture_begin(), e = blockDecl->capture_end();
2431 i != e; ++i) {
2432 const BlockDecl::Capture &capture = *i;
2433 const VarDecl *variable = capture.getVariable();
2434 const CGBlockInfo::Capture &captureInfo = block.getCapture(variable);
2435
2436 // Ignore constant captures.
2437 if (captureInfo.isConstant())
2438 continue;
2439
2440 BlockLayoutChunk chunk;
2441 chunk.OffsetInBits =
2442 blockLayout->getElementOffsetInBits(captureInfo.getIndex());
2443 chunk.Capture = &capture;
2444 chunks.push_back(chunk);
2445 }
2446
2447 // Sort by offset.
2448 llvm::array_pod_sort(chunks.begin(), chunks.end());
2449
Chris Lattner5f9e2722011-07-23 10:55:15 +00002450 for (SmallVectorImpl<BlockLayoutChunk>::iterator
John McCall8178df32011-02-22 22:38:33 +00002451 i = chunks.begin(), e = chunks.end(); i != e; ++i) {
2452 uint64_t offsetInBits = i->OffsetInBits;
2453 const BlockDecl::Capture *capture = i->Capture;
2454
2455 // If we have a null capture, this must be the C++ 'this' capture.
2456 if (!capture) {
2457 const CXXMethodDecl *method =
2458 cast<CXXMethodDecl>(blockDecl->getNonClosureContext());
2459 QualType type = method->getThisType(C);
2460
2461 fields.push_back(createFieldType("this", type, 0, loc, AS_public,
Devang Patel1d323e02011-06-24 22:00:59 +00002462 offsetInBits, tunit, tunit));
John McCall8178df32011-02-22 22:38:33 +00002463 continue;
2464 }
2465
2466 const VarDecl *variable = capture->getVariable();
Chris Lattner5f9e2722011-07-23 10:55:15 +00002467 StringRef name = variable->getName();
John McCalld113a6f2011-03-02 06:57:14 +00002468
2469 llvm::DIType fieldType;
2470 if (capture->isByRef()) {
2471 std::pair<uint64_t,unsigned> ptrInfo = C.getTypeInfo(C.VoidPtrTy);
2472
2473 // FIXME: this creates a second copy of this type!
2474 uint64_t xoffset;
2475 fieldType = EmitTypeForVarWithBlocksAttr(variable, &xoffset);
2476 fieldType = DBuilder.createPointerType(fieldType, ptrInfo.first);
Devang Patel1d323e02011-06-24 22:00:59 +00002477 fieldType = DBuilder.createMemberType(tunit, name, tunit, line,
John McCalld113a6f2011-03-02 06:57:14 +00002478 ptrInfo.first, ptrInfo.second,
2479 offsetInBits, 0, fieldType);
2480 } else {
2481 fieldType = createFieldType(name, variable->getType(), 0,
Devang Patel1d323e02011-06-24 22:00:59 +00002482 loc, AS_public, offsetInBits, tunit, tunit);
John McCalld113a6f2011-03-02 06:57:14 +00002483 }
2484 fields.push_back(fieldType);
John McCall8178df32011-02-22 22:38:33 +00002485 }
2486
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00002487 SmallString<36> typeName;
John McCall8178df32011-02-22 22:38:33 +00002488 llvm::raw_svector_ostream(typeName)
2489 << "__block_literal_" << CGM.getUniqueBlockCount();
2490
Jay Foadc556ef22011-04-24 10:11:03 +00002491 llvm::DIArray fieldsArray = DBuilder.getOrCreateArray(fields);
John McCall8178df32011-02-22 22:38:33 +00002492
2493 llvm::DIType type =
2494 DBuilder.createStructType(tunit, typeName.str(), tunit, line,
2495 CGM.getContext().toBits(block.BlockSize),
2496 CGM.getContext().toBits(block.BlockAlign),
2497 0, fieldsArray);
2498 type = DBuilder.createPointerType(type, CGM.PointerWidthInBits);
2499
2500 // Get overall information about the block.
2501 unsigned flags = llvm::DIDescriptor::FlagArtificial;
Eric Christopheraa2164c2011-09-29 00:00:45 +00002502 llvm::MDNode *scope = LexicalBlockStack.back();
Chris Lattner5f9e2722011-07-23 10:55:15 +00002503 StringRef name = ".block_descriptor";
John McCall8178df32011-02-22 22:38:33 +00002504
2505 // Create the descriptor for the parameter.
2506 llvm::DIVariable debugVar =
2507 DBuilder.createLocalVariable(llvm::dwarf::DW_TAG_arg_variable,
2508 llvm::DIDescriptor(scope),
2509 name, tunit, line, type,
David Blaikie4e4d0842012-03-11 07:00:24 +00002510 CGM.getLangOpts().Optimize, flags,
Devang Patel093ac462011-03-03 20:13:15 +00002511 cast<llvm::Argument>(addr)->getArgNo() + 1);
John McCall8178df32011-02-22 22:38:33 +00002512
2513 // Insert an llvm.dbg.value into the current block.
2514 llvm::Instruction *declare =
2515 DBuilder.insertDbgValueIntrinsic(addr, 0, debugVar,
2516 Builder.GetInsertBlock());
2517 declare->setDebugLoc(llvm::DebugLoc::get(line, column, scope));
2518}
Chris Lattner9c85ba32008-11-10 06:08:34 +00002519
Sanjiv Gupta686226b2008-06-05 08:59:10 +00002520/// EmitGlobalVariable - Emit information about a global variable.
Mike Stump1eb44332009-09-09 15:08:12 +00002521void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
Devang Pateleb6d79b2010-02-01 21:34:11 +00002522 const VarDecl *D) {
Sanjiv Gupta686226b2008-06-05 08:59:10 +00002523 // Create global variable debug descriptor.
Devang Patel17800552010-03-09 00:44:50 +00002524 llvm::DIFile Unit = getOrCreateFile(D->getLocation());
Devang Patel8ab870d2010-05-12 23:46:38 +00002525 unsigned LineNo = getLineNumber(D->getLocation());
Chris Lattner8ec03f52008-11-24 03:54:41 +00002526
Eric Christopher73fb3502011-10-13 21:45:18 +00002527 setLocation(D->getLocation());
2528
Devang Pateleb6d79b2010-02-01 21:34:11 +00002529 QualType T = D->getType();
Anders Carlsson4d6e8dd2008-11-26 17:40:42 +00002530 if (T->isIncompleteArrayType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002531
Anders Carlsson4d6e8dd2008-11-26 17:40:42 +00002532 // CodeGen turns int[] into int[1] so we'll do the same here.
2533 llvm::APSInt ConstVal(32);
Mike Stump1eb44332009-09-09 15:08:12 +00002534
Anders Carlsson4d6e8dd2008-11-26 17:40:42 +00002535 ConstVal = 1;
Anders Carlsson20f12a22009-12-06 18:00:51 +00002536 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
Mike Stump1eb44332009-09-09 15:08:12 +00002537
Anders Carlsson20f12a22009-12-06 18:00:51 +00002538 T = CGM.getContext().getConstantArrayType(ET, ConstVal,
Nick Lewyckyd4c100e2011-11-09 04:25:21 +00002539 ArrayType::Normal, 0);
Anders Carlsson4d6e8dd2008-11-26 17:40:42 +00002540 }
Chris Lattner5f9e2722011-07-23 10:55:15 +00002541 StringRef DeclName = D->getName();
2542 StringRef LinkageName;
Devang Pateleb4c45b2011-02-09 19:16:38 +00002543 if (D->getDeclContext() && !isa<FunctionDecl>(D->getDeclContext())
2544 && !isa<ObjCMethodDecl>(D->getDeclContext()))
Devang Patel8b90a782010-05-13 23:52:37 +00002545 LinkageName = Var->getName();
Devang Patel58faf202010-10-22 17:11:50 +00002546 if (LinkageName == DeclName)
Chris Lattner5f9e2722011-07-23 10:55:15 +00002547 LinkageName = StringRef();
Devang Pateleb6d79b2010-02-01 21:34:11 +00002548 llvm::DIDescriptor DContext =
Devang Patel170cef32010-12-09 00:33:05 +00002549 getContextDescriptor(dyn_cast<Decl>(D->getDeclContext()));
Devang Patel16674e82011-02-22 18:56:36 +00002550 DBuilder.createStaticVariable(DContext, DeclName, LinkageName,
Devang Patel823d8e92010-12-08 22:42:58 +00002551 Unit, LineNo, getOrCreateType(T, Unit),
2552 Var->hasInternalLinkage(), Var);
Sanjiv Gupta686226b2008-06-05 08:59:10 +00002553}
2554
Devang Patel9ca36b62009-02-26 21:10:26 +00002555/// EmitGlobalVariable - Emit information about an objective-c interface.
Mike Stump1eb44332009-09-09 15:08:12 +00002556void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
Devang Pateld6c5a262010-02-01 21:52:22 +00002557 ObjCInterfaceDecl *ID) {
Devang Patel9ca36b62009-02-26 21:10:26 +00002558 // Create global variable debug descriptor.
Devang Patel17800552010-03-09 00:44:50 +00002559 llvm::DIFile Unit = getOrCreateFile(ID->getLocation());
Devang Patel8ab870d2010-05-12 23:46:38 +00002560 unsigned LineNo = getLineNumber(ID->getLocation());
Devang Patel9ca36b62009-02-26 21:10:26 +00002561
Chris Lattner5f9e2722011-07-23 10:55:15 +00002562 StringRef Name = ID->getName();
Devang Patel9ca36b62009-02-26 21:10:26 +00002563
Devang Pateld6c5a262010-02-01 21:52:22 +00002564 QualType T = CGM.getContext().getObjCInterfaceType(ID);
Devang Patel9ca36b62009-02-26 21:10:26 +00002565 if (T->isIncompleteArrayType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002566
Devang Patel9ca36b62009-02-26 21:10:26 +00002567 // CodeGen turns int[] into int[1] so we'll do the same here.
2568 llvm::APSInt ConstVal(32);
Mike Stump1eb44332009-09-09 15:08:12 +00002569
Devang Patel9ca36b62009-02-26 21:10:26 +00002570 ConstVal = 1;
Anders Carlsson20f12a22009-12-06 18:00:51 +00002571 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
Mike Stump1eb44332009-09-09 15:08:12 +00002572
Anders Carlsson20f12a22009-12-06 18:00:51 +00002573 T = CGM.getContext().getConstantArrayType(ET, ConstVal,
Devang Patel9ca36b62009-02-26 21:10:26 +00002574 ArrayType::Normal, 0);
2575 }
2576
Devang Patel16674e82011-02-22 18:56:36 +00002577 DBuilder.createGlobalVariable(Name, Unit, LineNo,
Devang Patel823d8e92010-12-08 22:42:58 +00002578 getOrCreateType(T, Unit),
2579 Var->hasInternalLinkage(), Var);
Devang Patel9ca36b62009-02-26 21:10:26 +00002580}
Devang Patelabb485f2010-02-01 19:16:32 +00002581
Devang Patel25c2c8f2010-08-10 17:53:33 +00002582/// EmitGlobalVariable - Emit global variable's debug info.
2583void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD,
John McCall189d6ef2010-10-09 01:34:31 +00002584 llvm::Constant *Init) {
Devang Patel8d308382010-08-10 07:24:25 +00002585 // Create the descriptor for the variable.
2586 llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
Chris Lattner5f9e2722011-07-23 10:55:15 +00002587 StringRef Name = VD->getName();
Devang Patel0317ab02010-08-10 18:27:15 +00002588 llvm::DIType Ty = getOrCreateType(VD->getType(), Unit);
Devang Patel6237cea2010-08-23 22:07:25 +00002589 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(VD)) {
2590 if (const EnumDecl *ED = dyn_cast<EnumDecl>(ECD->getDeclContext()))
Devang Patel31f7d022011-01-17 22:23:07 +00002591 Ty = CreateEnumType(ED);
Devang Patel6237cea2010-08-23 22:07:25 +00002592 }
Devang Patel0317ab02010-08-10 18:27:15 +00002593 // Do not use DIGlobalVariable for enums.
2594 if (Ty.getTag() == llvm::dwarf::DW_TAG_enumeration_type)
2595 return;
Devang Patel16674e82011-02-22 18:56:36 +00002596 DBuilder.createStaticVariable(Unit, Name, Name, Unit,
Devang Patel823d8e92010-12-08 22:42:58 +00002597 getLineNumber(VD->getLocation()),
2598 Ty, true, Init);
Devang Patel8d308382010-08-10 07:24:25 +00002599}
2600
Devang Patelabb485f2010-02-01 19:16:32 +00002601/// getOrCreateNamesSpace - Return namespace descriptor for the given
2602/// namespace decl.
2603llvm::DINameSpace
Devang Patel170cef32010-12-09 00:33:05 +00002604CGDebugInfo::getOrCreateNameSpace(const NamespaceDecl *NSDecl) {
Devang Patelabb485f2010-02-01 19:16:32 +00002605 llvm::DenseMap<const NamespaceDecl *, llvm::WeakVH>::iterator I =
2606 NameSpaceCache.find(NSDecl);
2607 if (I != NameSpaceCache.end())
2608 return llvm::DINameSpace(cast<llvm::MDNode>(I->second));
2609
Devang Patel8ab870d2010-05-12 23:46:38 +00002610 unsigned LineNo = getLineNumber(NSDecl->getLocation());
Devang Patel8c376682010-10-28 19:12:46 +00002611 llvm::DIFile FileD = getOrCreateFile(NSDecl->getLocation());
Devang Patelabb485f2010-02-01 19:16:32 +00002612 llvm::DIDescriptor Context =
Devang Patel170cef32010-12-09 00:33:05 +00002613 getContextDescriptor(dyn_cast<Decl>(NSDecl->getDeclContext()));
Devang Patelabb485f2010-02-01 19:16:32 +00002614 llvm::DINameSpace NS =
Devang Patel16674e82011-02-22 18:56:36 +00002615 DBuilder.createNameSpace(Context, NSDecl->getName(), FileD, LineNo);
Devang Patelab699792010-05-07 18:12:35 +00002616 NameSpaceCache[NSDecl] = llvm::WeakVH(NS);
Devang Patelabb485f2010-02-01 19:16:32 +00002617 return NS;
2618}
Eric Christopher7ff0c5d2012-02-18 00:50:17 +00002619
2620void CGDebugInfo::finalize(void) {
2621 for (std::vector<std::pair<void *, llvm::WeakVH> >::const_iterator VI
2622 = ReplaceMap.begin(), VE = ReplaceMap.end(); VI != VE; ++VI) {
2623 llvm::DIType Ty, RepTy;
2624 // Verify that the debug info still exists.
2625 if (&*VI->second)
2626 Ty = llvm::DIType(cast<llvm::MDNode>(VI->second));
2627
2628 llvm::DenseMap<void *, llvm::WeakVH>::iterator it =
2629 TypeCache.find(VI->first);
2630 if (it != TypeCache.end()) {
2631 // Verify that the debug info still exists.
2632 if (&*it->second)
2633 RepTy = llvm::DIType(cast<llvm::MDNode>(it->second));
2634 }
2635
Eric Christopher86211df2012-02-20 18:05:24 +00002636 if (Ty.Verify() && Ty.isForwardDecl() && RepTy.Verify()) {
Eric Christopher7ff0c5d2012-02-18 00:50:17 +00002637 Ty.replaceAllUsesWith(RepTy);
Eric Christopher86211df2012-02-20 18:05:24 +00002638 }
Eric Christopher7ff0c5d2012-02-18 00:50:17 +00002639 }
2640 DBuilder.finalize();
2641}