blob: 675df309e3f0f32d10e7935263b5a88d989cd4b6 [file] [log] [blame]
Guy Benyei11169dd2012-12-18 14:30:41 +00001//===--- CGDebugInfo.cpp - Emit Debug Information for a Module ------------===//
2//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Guy Benyei11169dd2012-12-18 14:30:41 +00006//
7//===----------------------------------------------------------------------===//
8//
9// This coordinates the debug information generation while generating code.
10//
11//===----------------------------------------------------------------------===//
12
13#include "CGDebugInfo.h"
14#include "CGBlocks.h"
David Blaikie38079fd2013-05-10 21:53:14 +000015#include "CGCXXABI.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000016#include "CGObjCRuntime.h"
Bob Haarmandff36732016-10-25 22:19:32 +000017#include "CGRecordLayout.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000018#include "CodeGenFunction.h"
19#include "CodeGenModule.h"
John McCallde0fe072017-08-15 21:42:52 +000020#include "ConstantEmitter.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000021#include "clang/AST/ASTContext.h"
Reid Kleckner98031782019-12-09 16:11:56 -080022#include "clang/AST/Attr.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000023#include "clang/AST/DeclFriend.h"
24#include "clang/AST/DeclObjC.h"
25#include "clang/AST/DeclTemplate.h"
26#include "clang/AST/Expr.h"
27#include "clang/AST/RecordLayout.h"
Richard Trieu63688182018-12-11 03:18:39 +000028#include "clang/Basic/CodeGenOptions.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000029#include "clang/Basic/FileManager.h"
30#include "clang/Basic/SourceManager.h"
31#include "clang/Basic/Version.h"
Taewook Oh0fb5b782017-08-16 19:36:24 +000032#include "clang/Frontend/FrontendOptions.h"
Adrian Prantlc4bb47e2015-06-30 17:39:51 +000033#include "clang/Lex/HeaderSearchOptions.h"
Adrian Prantl9402cef2015-09-20 16:51:35 +000034#include "clang/Lex/ModuleMap.h"
Adrian Prantlc4bb47e2015-06-30 17:39:51 +000035#include "clang/Lex/PreprocessorOptions.h"
Bob Haarmandff36732016-10-25 22:19:32 +000036#include "llvm/ADT/DenseSet.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000037#include "llvm/ADT/SmallVector.h"
38#include "llvm/ADT/StringExtras.h"
Chandler Carruthffd55512013-01-02 11:45:17 +000039#include "llvm/IR/Constants.h"
40#include "llvm/IR/DataLayout.h"
41#include "llvm/IR/DerivedTypes.h"
42#include "llvm/IR/Instructions.h"
43#include "llvm/IR/Intrinsics.h"
Matthew Voss20165362018-10-03 18:45:04 +000044#include "llvm/IR/Metadata.h"
Chandler Carruthffd55512013-01-02 11:45:17 +000045#include "llvm/IR/Module.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000046#include "llvm/Support/FileSystem.h"
Amjad Aboude2aab8c2016-12-25 10:12:27 +000047#include "llvm/Support/MD5.h"
Adrian Prantl0630eb72013-12-18 21:48:18 +000048#include "llvm/Support/Path.h"
Luboš Luňák4f2104c2019-11-02 16:39:59 +010049#include "llvm/Support/TimeProfiler.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000050using namespace clang;
51using namespace clang::CodeGen;
52
Victor Leschuka7ece032016-10-20 00:13:19 +000053static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx) {
54 auto TI = Ctx.getTypeInfo(Ty);
55 return TI.AlignIsRequired ? TI.Align : 0;
56}
57
58static uint32_t getTypeAlignIfRequired(QualType Ty, const ASTContext &Ctx) {
59 return getTypeAlignIfRequired(Ty.getTypePtr(), Ctx);
60}
61
62static uint32_t getDeclAlignIfRequired(const Decl *D, const ASTContext &Ctx) {
63 return D->hasAttr<AlignedAttr>() ? D->getMaxAlignment() : 0;
64}
65
Guy Benyei11169dd2012-12-18 14:30:41 +000066CGDebugInfo::CGDebugInfo(CodeGenModule &CGM)
Eric Christopher324bbbd2013-07-14 21:12:44 +000067 : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
Adrian Prantl6b21ab22015-08-27 19:46:20 +000068 DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),
Eric Christopher324bbbd2013-07-14 21:12:44 +000069 DBuilder(CGM.getModule()) {
Saleem Abdulrasool436256a2015-10-12 20:21:08 +000070 for (const auto &KV : CGM.getCodeGenOpts().DebugPrefixMap)
71 DebugPrefixMap[KV.first] = KV.second;
Guy Benyei11169dd2012-12-18 14:30:41 +000072 CreateCompileUnit();
73}
74
75CGDebugInfo::~CGDebugInfo() {
76 assert(LexicalBlockStack.empty() &&
77 "Region stack mismatch, stack not empty!");
78}
79
David Blaikie66e41972015-01-14 07:38:27 +000080ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
Calixte Denizetfcd661d2018-09-24 18:24:18 +000081 SourceLocation TemporaryLocation)
David Blaikied7057d92015-08-12 23:49:57 +000082 : CGF(&CGF) {
Calixte Denizetfcd661d2018-09-24 18:24:18 +000083 init(TemporaryLocation);
David Blaikie9b479662015-01-25 01:19:10 +000084}
85
Adrian Prantl39428e72015-02-03 18:40:42 +000086ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
Adrian Prantl95b24e92015-02-03 20:00:54 +000087 bool DefaultToEmpty,
Calixte Denizetfcd661d2018-09-24 18:24:18 +000088 SourceLocation TemporaryLocation)
David Blaikied7057d92015-08-12 23:49:57 +000089 : CGF(&CGF) {
Calixte Denizetfcd661d2018-09-24 18:24:18 +000090 init(TemporaryLocation, DefaultToEmpty);
Adrian Prantl39428e72015-02-03 18:40:42 +000091}
92
93void ApplyDebugLocation::init(SourceLocation TemporaryLocation,
Calixte Denizetfcd661d2018-09-24 18:24:18 +000094 bool DefaultToEmpty) {
David Blaikied7057d92015-08-12 23:49:57 +000095 auto *DI = CGF->getDebugInfo();
96 if (!DI) {
97 CGF = nullptr;
98 return;
David Blaikie66e41972015-01-14 07:38:27 +000099 }
David Blaikied7057d92015-08-12 23:49:57 +0000100
101 OriginalLocation = CGF->Builder.getCurrentDebugLocation();
Bob Haarmanc6c9b8f2017-09-11 22:11:57 +0000102
103 if (OriginalLocation && !DI->CGM.getExpressionLocationsEnabled())
104 return;
105
David Blaikied7057d92015-08-12 23:49:57 +0000106 if (TemporaryLocation.isValid()) {
Calixte Denizetfcd661d2018-09-24 18:24:18 +0000107 DI->EmitLocation(CGF->Builder, TemporaryLocation);
David Blaikied7057d92015-08-12 23:49:57 +0000108 return;
109 }
110
111 if (DefaultToEmpty) {
112 CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc());
113 return;
114 }
115
116 // Construct a location that has a valid scope, but no line info.
117 assert(!DI->LexicalBlockStack.empty());
Adrian Prantlb7acfc02017-02-27 21:30:05 +0000118 CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
119 0, 0, DI->LexicalBlockStack.back(), DI->getInlinedAt()));
Adrian Prantl2e0637f2013-07-18 00:28:02 +0000120}
121
David Blaikie9b479662015-01-25 01:19:10 +0000122ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E)
David Blaikied7057d92015-08-12 23:49:57 +0000123 : CGF(&CGF) {
David Blaikie9b479662015-01-25 01:19:10 +0000124 init(E->getExprLoc());
125}
126
David Blaikie66e41972015-01-14 07:38:27 +0000127ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, llvm::DebugLoc Loc)
David Blaikied7057d92015-08-12 23:49:57 +0000128 : CGF(&CGF) {
129 if (!CGF.getDebugInfo()) {
130 this->CGF = nullptr;
131 return;
David Blaikie66e41972015-01-14 07:38:27 +0000132 }
David Blaikied7057d92015-08-12 23:49:57 +0000133 OriginalLocation = CGF.Builder.getCurrentDebugLocation();
134 if (Loc)
135 CGF.Builder.SetCurrentDebugLocation(std::move(Loc));
David Blaikie66e41972015-01-14 07:38:27 +0000136}
137
138ApplyDebugLocation::~ApplyDebugLocation() {
139 // Query CGF so the location isn't overwritten when location updates are
140 // temporarily disabled (for C++ default function arguments)
David Blaikied7057d92015-08-12 23:49:57 +0000141 if (CGF)
142 CGF->Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
David Blaikie66e41972015-01-14 07:38:27 +0000143}
144
Adrian Prantlb7acfc02017-02-27 21:30:05 +0000145ApplyInlineDebugLocation::ApplyInlineDebugLocation(CodeGenFunction &CGF,
146 GlobalDecl InlinedFn)
147 : CGF(&CGF) {
148 if (!CGF.getDebugInfo()) {
149 this->CGF = nullptr;
150 return;
151 }
152 auto &DI = *CGF.getDebugInfo();
153 SavedLocation = DI.getLocation();
154 assert((DI.getInlinedAt() ==
155 CGF.Builder.getCurrentDebugLocation()->getInlinedAt()) &&
156 "CGDebugInfo and IRBuilder are out of sync");
157
158 DI.EmitInlineFunctionStart(CGF.Builder, InlinedFn);
159}
160
161ApplyInlineDebugLocation::~ApplyInlineDebugLocation() {
162 if (!CGF)
163 return;
164 auto &DI = *CGF->getDebugInfo();
165 DI.EmitInlineFunctionEnd(CGF->Builder);
166 DI.EmitLocation(CGF->Builder, SavedLocation);
167}
168
Guy Benyei11169dd2012-12-18 14:30:41 +0000169void CGDebugInfo::setLocation(SourceLocation Loc) {
170 // If the new location isn't valid return.
Eric Christophere7b87e52014-10-26 23:40:33 +0000171 if (Loc.isInvalid())
172 return;
Guy Benyei11169dd2012-12-18 14:30:41 +0000173
174 CurLoc = CGM.getContext().getSourceManager().getExpansionLoc(Loc);
175
176 // If we've changed files in the middle of a lexical scope go ahead
177 // and create a new lexical scope with file node if it's different
178 // from the one in the scope.
Eric Christophere7b87e52014-10-26 23:40:33 +0000179 if (LexicalBlockStack.empty())
180 return;
Guy Benyei11169dd2012-12-18 14:30:41 +0000181
182 SourceManager &SM = CGM.getContext().getSourceManager();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000183 auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
Guy Benyei11169dd2012-12-18 14:30:41 +0000184 PresumedLoc PCLoc = SM.getPresumedLoc(CurLoc);
Adrian Prantl212c1042018-12-06 18:44:50 +0000185 if (PCLoc.isInvalid() || Scope->getFile() == getOrCreateFile(CurLoc))
Guy Benyei11169dd2012-12-18 14:30:41 +0000186 return;
187
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000188 if (auto *LBF = dyn_cast<llvm::DILexicalBlockFile>(Scope)) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000189 LexicalBlockStack.pop_back();
Duncan P. N. Exon Smithd899f6e2015-04-18 00:07:30 +0000190 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlockFile(
191 LBF->getScope(), getOrCreateFile(CurLoc)));
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000192 } else if (isa<llvm::DILexicalBlock>(Scope) ||
193 isa<llvm::DISubprogram>(Scope)) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000194 LexicalBlockStack.pop_back();
Duncan P. N. Exon Smithd899f6e2015-04-18 00:07:30 +0000195 LexicalBlockStack.emplace_back(
196 DBuilder.createLexicalBlockFile(Scope, getOrCreateFile(CurLoc)));
Guy Benyei11169dd2012-12-18 14:30:41 +0000197 }
198}
199
Adrian Prantl6ec370a2015-09-10 18:39:45 +0000200llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(const Decl *D) {
Adrian Prantl5c8bd882015-09-11 17:23:08 +0000201 llvm::DIScope *Mod = getParentModuleOrNull(D);
202 return getContextDescriptor(cast<Decl>(D->getDeclContext()),
203 Mod ? Mod : TheCU);
Adrian Prantl6ec370a2015-09-10 18:39:45 +0000204}
205
206llvm::DIScope *CGDebugInfo::getContextDescriptor(const Decl *Context,
207 llvm::DIScope *Default) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000208 if (!Context)
Adrian Prantl6ec370a2015-09-10 18:39:45 +0000209 return Default;
Guy Benyei11169dd2012-12-18 14:30:41 +0000210
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +0000211 auto I = RegionMap.find(Context);
Guy Benyei11169dd2012-12-18 14:30:41 +0000212 if (I != RegionMap.end()) {
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +0000213 llvm::Metadata *V = I->second;
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000214 return dyn_cast_or_null<llvm::DIScope>(V);
Guy Benyei11169dd2012-12-18 14:30:41 +0000215 }
216
217 // Check namespace.
Adrian Prantlddb8e062017-05-12 16:23:53 +0000218 if (const auto *NSDecl = dyn_cast<NamespaceDecl>(Context))
219 return getOrCreateNamespace(NSDecl);
Guy Benyei11169dd2012-12-18 14:30:41 +0000220
David Majnemer58ed0f32016-07-17 00:39:12 +0000221 if (const auto *RDecl = dyn_cast<RecordDecl>(Context))
David Blaikiebfa52742013-04-19 06:56:38 +0000222 if (!RDecl->isDependentType())
223 return getOrCreateType(CGM.getContext().getTypeDeclType(RDecl),
Adrian Prantlc2a44ec2018-12-11 16:58:46 +0000224 TheCU->getFile());
Adrian Prantl6ec370a2015-09-10 18:39:45 +0000225 return Default;
Guy Benyei11169dd2012-12-18 14:30:41 +0000226}
227
Reid Kleckner59d12202017-08-08 01:33:53 +0000228PrintingPolicy CGDebugInfo::getPrintingPolicy() const {
229 PrintingPolicy PP = CGM.getContext().getPrintingPolicy();
230
231 // If we're emitting codeview, it's important to try to match MSVC's naming so
232 // that visualizers written for MSVC will trigger for our class names. In
233 // particular, we can't have spaces between arguments of standard templates
234 // like basic_string and vector.
235 if (CGM.getCodeGenOpts().EmitCodeView)
236 PP.MSVCFormatting = true;
237
Adrian Prantl56acd5a2018-12-05 18:37:44 +0000238 // Apply -fdebug-prefix-map.
Richard Smithdbcb6902019-10-15 17:51:08 -0700239 PP.Callbacks = &PrintCB;
Reid Kleckner59d12202017-08-08 01:33:53 +0000240 return PP;
241}
242
Guy Benyei11169dd2012-12-18 14:30:41 +0000243StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) {
Eric Christophere7b87e52014-10-26 23:40:33 +0000244 assert(FD && "Invalid FunctionDecl!");
Guy Benyei11169dd2012-12-18 14:30:41 +0000245 IdentifierInfo *FII = FD->getIdentifier();
Eric Christophere7b87e52014-10-26 23:40:33 +0000246 FunctionTemplateSpecializationInfo *Info =
247 FD->getTemplateSpecializationInfo();
Reid Kleckner60103382015-12-16 02:04:40 +0000248
Reid Kleckner31abd802016-06-30 17:41:31 +0000249 // Emit the unqualified name in normal operation. LLVM and the debugger can
250 // compute the fully qualified name from the scope chain. If we're only
251 // emitting line table info, there won't be any scope chains, so emit the
252 // fully qualified name here so that stack traces are more accurate.
253 // FIXME: Do this when emitting DWARF as well as when emitting CodeView after
254 // evaluating the size impact.
255 bool UseQualifiedName = DebugKind == codegenoptions::DebugLineTablesOnly &&
256 CGM.getCodeGenOpts().EmitCodeView;
257
258 if (!Info && FII && !UseQualifiedName)
Guy Benyei11169dd2012-12-18 14:30:41 +0000259 return FII->getName();
260
Benjamin Kramer9170e912013-02-22 15:46:01 +0000261 SmallString<128> NS;
262 llvm::raw_svector_ostream OS(NS);
Reid Kleckner31abd802016-06-30 17:41:31 +0000263 if (!UseQualifiedName)
264 FD->printName(OS);
265 else
Reid Kleckner59d12202017-08-08 01:33:53 +0000266 FD->printQualifiedName(OS, getPrintingPolicy());
Guy Benyei11169dd2012-12-18 14:30:41 +0000267
Reid Kleckner829398e2016-06-17 16:11:20 +0000268 // Add any template specialization args.
269 if (Info) {
270 const TemplateArgumentList *TArgs = Info->TemplateArguments;
Serge Pavlov03e672c2017-11-28 16:14:14 +0000271 printTemplateArgumentList(OS, TArgs->asArray(), getPrintingPolicy());
Guy Benyei11169dd2012-12-18 14:30:41 +0000272 }
273
274 // Copy this name on the side and use its reference.
Benjamin Kramer1b18a5e2013-09-09 16:39:06 +0000275 return internString(OS.str());
Guy Benyei11169dd2012-12-18 14:30:41 +0000276}
277
278StringRef CGDebugInfo::getObjCMethodName(const ObjCMethodDecl *OMD) {
279 SmallString<256> MethodName;
280 llvm::raw_svector_ostream OS(MethodName);
281 OS << (OMD->isInstanceMethod() ? '-' : '+') << '[';
282 const DeclContext *DC = OMD->getDeclContext();
David Majnemer58ed0f32016-07-17 00:39:12 +0000283 if (const auto *OID = dyn_cast<ObjCImplementationDecl>(DC)) {
Eric Christophere7b87e52014-10-26 23:40:33 +0000284 OS << OID->getName();
David Majnemer58ed0f32016-07-17 00:39:12 +0000285 } else if (const auto *OID = dyn_cast<ObjCInterfaceDecl>(DC)) {
Eric Christophere7b87e52014-10-26 23:40:33 +0000286 OS << OID->getName();
David Majnemer58ed0f32016-07-17 00:39:12 +0000287 } else if (const auto *OC = dyn_cast<ObjCCategoryDecl>(DC)) {
Douglas Gregoracf4fd32015-11-03 01:15:46 +0000288 if (OC->IsClassExtension()) {
289 OS << OC->getClassInterface()->getName();
290 } else {
David Majnemer58ed0f32016-07-17 00:39:12 +0000291 OS << OC->getIdentifier()->getNameStart() << '('
Douglas Gregoracf4fd32015-11-03 01:15:46 +0000292 << OC->getIdentifier()->getNameStart() << ')';
293 }
David Majnemer58ed0f32016-07-17 00:39:12 +0000294 } else if (const auto *OCD = dyn_cast<ObjCCategoryImplDecl>(DC)) {
Jonas Devlieghere9ef49652018-06-28 10:56:40 +0000295 OS << OCD->getClassInterface()->getName() << '(' << OCD->getName() << ')';
Guy Benyei11169dd2012-12-18 14:30:41 +0000296 }
297 OS << ' ' << OMD->getSelector().getAsString() << ']';
298
Benjamin Kramer1b18a5e2013-09-09 16:39:06 +0000299 return internString(OS.str());
Guy Benyei11169dd2012-12-18 14:30:41 +0000300}
301
Guy Benyei11169dd2012-12-18 14:30:41 +0000302StringRef CGDebugInfo::getSelectorName(Selector S) {
Benjamin Kramer1b18a5e2013-09-09 16:39:06 +0000303 return internString(S.getAsString());
Guy Benyei11169dd2012-12-18 14:30:41 +0000304}
305
Eric Christophere7b87e52014-10-26 23:40:33 +0000306StringRef CGDebugInfo::getClassName(const RecordDecl *RD) {
David Majnemerbc5976a2016-07-01 23:12:54 +0000307 if (isa<ClassTemplateSpecializationDecl>(RD)) {
308 SmallString<128> Name;
David Blaikie65813a32014-04-02 18:21:09 +0000309 llvm::raw_svector_ostream OS(Name);
David Blaikie9fdd09a2019-10-18 23:58:34 +0000310 PrintingPolicy PP = getPrintingPolicy();
311 PP.PrintCanonicalTypes = true;
312 RD->getNameForDiagnostic(OS, PP,
David Blaikie65813a32014-04-02 18:21:09 +0000313 /*Qualified*/ false);
David Majnemerbc5976a2016-07-01 23:12:54 +0000314
315 // Copy this name on the side and use its reference.
316 return internString(Name);
Benjamin Kramer9170e912013-02-22 15:46:01 +0000317 }
Guy Benyei11169dd2012-12-18 14:30:41 +0000318
David Majnemerbc5976a2016-07-01 23:12:54 +0000319 // quick optimization to avoid having to intern strings that are already
320 // stored reliably elsewhere
321 if (const IdentifierInfo *II = RD->getIdentifier())
322 return II->getName();
323
324 // The CodeView printer in LLVM wants to see the names of unnamed types: it is
325 // used to reconstruct the fully qualified type names.
326 if (CGM.getCodeGenOpts().EmitCodeView) {
327 if (const TypedefNameDecl *D = RD->getTypedefNameForAnonDecl()) {
328 assert(RD->getDeclContext() == D->getDeclContext() &&
329 "Typedef should not be in another decl context!");
330 assert(D->getDeclName().getAsIdentifierInfo() &&
331 "Typedef was not named!");
332 return D->getDeclName().getAsIdentifierInfo()->getName();
333 }
334
335 if (CGM.getLangOpts().CPlusPlus) {
336 StringRef Name;
337
338 ASTContext &Context = CGM.getContext();
339 if (const DeclaratorDecl *DD = Context.getDeclaratorForUnnamedTagDecl(RD))
340 // Anonymous types without a name for linkage purposes have their
341 // declarator mangled in if they have one.
342 Name = DD->getName();
343 else if (const TypedefNameDecl *TND =
344 Context.getTypedefNameForUnnamedTagDecl(RD))
345 // Anonymous types without a name for linkage purposes have their
346 // associate typedef mangled in if they have one.
347 Name = TND->getName();
348
349 if (!Name.empty()) {
350 SmallString<256> UnnamedType("<unnamed-type-");
351 UnnamedType += Name;
352 UnnamedType += '>';
353 return internString(UnnamedType);
354 }
355 }
356 }
357
358 return StringRef();
Guy Benyei11169dd2012-12-18 14:30:41 +0000359}
360
Scott Linder94834f12018-02-12 19:47:05 +0000361Optional<llvm::DIFile::ChecksumKind>
Amjad Aboude2aab8c2016-12-25 10:12:27 +0000362CGDebugInfo::computeChecksum(FileID FID, SmallString<32> &Checksum) const {
363 Checksum.clear();
364
Paul Robinson76178632018-05-25 22:35:59 +0000365 if (!CGM.getCodeGenOpts().EmitCodeView &&
366 CGM.getCodeGenOpts().DwarfVersion < 5)
Scott Linder94834f12018-02-12 19:47:05 +0000367 return None;
Amjad Aboude2aab8c2016-12-25 10:12:27 +0000368
369 SourceManager &SM = CGM.getContext().getSourceManager();
370 bool Invalid;
Nico Weber04347d82019-04-04 21:06:41 +0000371 const llvm::MemoryBuffer *MemBuffer = SM.getBuffer(FID, &Invalid);
Paul Robinson76178632018-05-25 22:35:59 +0000372 if (Invalid)
Scott Linder94834f12018-02-12 19:47:05 +0000373 return None;
Amjad Aboude2aab8c2016-12-25 10:12:27 +0000374
375 llvm::MD5 Hash;
376 llvm::MD5::MD5Result Result;
377
378 Hash.update(MemBuffer->getBuffer());
379 Hash.final(Result);
380
381 Hash.stringifyResult(Result, Checksum);
382 return llvm::DIFile::CSK_MD5;
383}
384
Jonas Devlieghere9ef49652018-06-28 10:56:40 +0000385Optional<StringRef> CGDebugInfo::getSource(const SourceManager &SM,
386 FileID FID) {
Scott Lindera2fbcef2018-02-26 17:32:31 +0000387 if (!CGM.getCodeGenOpts().EmbedSource)
388 return None;
389
390 bool SourceInvalid = false;
391 StringRef Source = SM.getBufferData(FID, &SourceInvalid);
392
393 if (SourceInvalid)
394 return None;
395
396 return Source;
397}
398
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000399llvm::DIFile *CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000400 if (!Loc.isValid())
401 // If Location is not valid then use main input file.
Adrian Prantlc2a44ec2018-12-11 16:58:46 +0000402 return TheCU->getFile();
Guy Benyei11169dd2012-12-18 14:30:41 +0000403
404 SourceManager &SM = CGM.getContext().getSourceManager();
405 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
406
Adrian Prantl212c1042018-12-06 18:44:50 +0000407 StringRef FileName = PLoc.getFilename();
408 if (PLoc.isInvalid() || FileName.empty())
Guy Benyei11169dd2012-12-18 14:30:41 +0000409 // If the location is not valid then use main input file.
Adrian Prantlc2a44ec2018-12-11 16:58:46 +0000410 return TheCU->getFile();
Guy Benyei11169dd2012-12-18 14:30:41 +0000411
412 // Cache the results.
Adrian Prantl212c1042018-12-06 18:44:50 +0000413 auto It = DIFileCache.find(FileName.data());
Jonas Devlieghere9ef49652018-06-28 10:56:40 +0000414 if (It != DIFileCache.end()) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000415 // Verify that the information still exists.
Jonas Devlieghere9ef49652018-06-28 10:56:40 +0000416 if (llvm::Metadata *V = It->second)
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000417 return cast<llvm::DIFile>(V);
Guy Benyei11169dd2012-12-18 14:30:41 +0000418 }
419
Amjad Aboude2aab8c2016-12-25 10:12:27 +0000420 SmallString<32> Checksum;
Alexandre Ganea047e65d2019-05-21 19:40:28 +0000421
422 // Compute the checksum if possible. If the location is affected by a #line
423 // directive that refers to a file, PLoc will have an invalid FileID, and we
424 // will correctly get no checksum.
Scott Linder94834f12018-02-12 19:47:05 +0000425 Optional<llvm::DIFile::ChecksumKind> CSKind =
Alexandre Ganea047e65d2019-05-21 19:40:28 +0000426 computeChecksum(PLoc.getFileID(), Checksum);
Scott Linder94834f12018-02-12 19:47:05 +0000427 Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo;
428 if (CSKind)
429 CSInfo.emplace(*CSKind, Checksum);
Adrian Prantlaa5bad42018-12-11 16:58:43 +0000430 return createFile(FileName, CSInfo, getSource(SM, SM.getFileID(Loc)));
431}
Amjad Aboude2aab8c2016-12-25 10:12:27 +0000432
Adrian Prantlaa5bad42018-12-11 16:58:43 +0000433llvm::DIFile *
434CGDebugInfo::createFile(StringRef FileName,
435 Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo,
436 Optional<StringRef> Source) {
Adrian Prantl212c1042018-12-06 18:44:50 +0000437 StringRef Dir;
438 StringRef File;
439 std::string RemappedFile = remapDIPath(FileName);
440 std::string CurDir = remapDIPath(getCurrentDirname());
441 SmallString<128> DirBuf;
442 SmallString<128> FileBuf;
443 if (llvm::sys::path::is_absolute(RemappedFile)) {
444 // Strip the common prefix (if it is more than just "/") from current
445 // directory and FileName for a more space-efficient encoding.
446 auto FileIt = llvm::sys::path::begin(RemappedFile);
447 auto FileE = llvm::sys::path::end(RemappedFile);
448 auto CurDirIt = llvm::sys::path::begin(CurDir);
449 auto CurDirE = llvm::sys::path::end(CurDir);
450 for (; CurDirIt != CurDirE && *CurDirIt == *FileIt; ++CurDirIt, ++FileIt)
451 llvm::sys::path::append(DirBuf, *CurDirIt);
452 if (std::distance(llvm::sys::path::begin(CurDir), CurDirIt) == 1) {
Adrian Prantl0feb7b72019-02-05 21:21:01 +0000453 // Don't strip the common prefix if it is only the root "/"
454 // since that would make LLVM diagnostic locations confusing.
Adrian Prantl212c1042018-12-06 18:44:50 +0000455 Dir = {};
456 File = RemappedFile;
457 } else {
458 for (; FileIt != FileE; ++FileIt)
459 llvm::sys::path::append(FileBuf, *FileIt);
460 Dir = DirBuf;
461 File = FileBuf;
462 }
463 } else {
464 Dir = CurDir;
465 File = RemappedFile;
466 }
Adrian Prantlaa5bad42018-12-11 16:58:43 +0000467 llvm::DIFile *F = DBuilder.createFile(File, Dir, CSInfo, Source);
Adrian Prantl212c1042018-12-06 18:44:50 +0000468 DIFileCache[FileName.data()].reset(F);
Guy Benyei11169dd2012-12-18 14:30:41 +0000469 return F;
470}
471
Saleem Abdulrasool436256a2015-10-12 20:21:08 +0000472std::string CGDebugInfo::remapDIPath(StringRef Path) const {
473 for (const auto &Entry : DebugPrefixMap)
Fangrui Song3bb24bf2019-11-26 16:09:22 -0800474 if (Path.startswith(Entry.first))
475 return (Twine(Entry.second) + Path.substr(Entry.first.size())).str();
476 return Path.str();
Guy Benyei11169dd2012-12-18 14:30:41 +0000477}
478
Guy Benyei11169dd2012-12-18 14:30:41 +0000479unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) {
480 if (Loc.isInvalid() && CurLoc.isInvalid())
481 return 0;
482 SourceManager &SM = CGM.getContext().getSourceManager();
483 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
Eric Christophere7b87e52014-10-26 23:40:33 +0000484 return PLoc.isValid() ? PLoc.getLine() : 0;
Guy Benyei11169dd2012-12-18 14:30:41 +0000485}
486
Adrian Prantlc7822422013-03-12 20:43:25 +0000487unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc, bool Force) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000488 // We may not want column information at all.
Adrian Prantlc7822422013-03-12 20:43:25 +0000489 if (!Force && !CGM.getCodeGenOpts().DebugColumnInfo)
Guy Benyei11169dd2012-12-18 14:30:41 +0000490 return 0;
491
492 // If the location is invalid then use the current column.
493 if (Loc.isInvalid() && CurLoc.isInvalid())
494 return 0;
495 SourceManager &SM = CGM.getContext().getSourceManager();
496 PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
Eric Christophere7b87e52014-10-26 23:40:33 +0000497 return PLoc.isValid() ? PLoc.getColumn() : 0;
Guy Benyei11169dd2012-12-18 14:30:41 +0000498}
499
500StringRef CGDebugInfo::getCurrentDirname() {
501 if (!CGM.getCodeGenOpts().DebugCompilationDir.empty())
502 return CGM.getCodeGenOpts().DebugCompilationDir;
503
504 if (!CWDName.empty())
505 return CWDName;
506 SmallString<256> CWD;
507 llvm::sys::fs::current_path(CWD);
Benjamin Kramer1b18a5e2013-09-09 16:39:06 +0000508 return CWDName = internString(CWD);
Guy Benyei11169dd2012-12-18 14:30:41 +0000509}
510
Guy Benyei11169dd2012-12-18 14:30:41 +0000511void CGDebugInfo::CreateCompileUnit() {
Amjad Aboude2aab8c2016-12-25 10:12:27 +0000512 SmallString<32> Checksum;
Scott Linder94834f12018-02-12 19:47:05 +0000513 Optional<llvm::DIFile::ChecksumKind> CSKind;
514 Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo;
Guy Benyei11169dd2012-12-18 14:30:41 +0000515
David Blaikieaabde052014-05-14 00:29:00 +0000516 // Should we be asking the SourceManager for the main file name, instead of
517 // accepting it as an argument? This just causes the main file name to
518 // mismatch with source locations and create extra lexical scopes or
519 // mismatched debug info (a CU with a DW_AT_file of "-", because that's what
520 // the driver passed, but functions/other things have DW_AT_file of "<stdin>"
521 // because that's what the SourceManager says)
522
Guy Benyei11169dd2012-12-18 14:30:41 +0000523 // Get absolute path name.
524 SourceManager &SM = CGM.getContext().getSourceManager();
525 std::string MainFileName = CGM.getCodeGenOpts().MainFileName;
526 if (MainFileName.empty())
David Blaikieaabde052014-05-14 00:29:00 +0000527 MainFileName = "<stdin>";
Guy Benyei11169dd2012-12-18 14:30:41 +0000528
529 // The main file name provided via the "-main-file-name" option contains just
530 // the file name itself with no path information. This file name may have had
531 // a relative path, so we look into the actual file entry for the main
532 // file to determine the real absolute path for the file.
533 std::string MainFileDir;
534 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
Adrian Prantl122e7af2019-10-21 16:44:37 +0000535 MainFileDir = MainFile->getDir()->getName();
536 if (!llvm::sys::path::is_absolute(MainFileName)) {
Eric Christopher0a1301f2014-02-26 02:49:36 +0000537 llvm::SmallString<1024> MainFileDirSS(MainFileDir);
538 llvm::sys::path::append(MainFileDirSS, MainFileName);
Adrian Prantl122e7af2019-10-21 16:44:37 +0000539 MainFileName = llvm::sys::path::remove_leading_dotslash(MainFileDirSS);
Yaron Keren9fb7e902013-10-21 20:07:37 +0000540 }
Taewook Oh0fb5b782017-08-16 19:36:24 +0000541 // If the main file name provided is identical to the input file name, and
542 // if the input file is a preprocessed source, use the module name for
543 // debug info. The module name comes from the name specified in the first
544 // linemarker if the input is a preprocessed source.
545 if (MainFile->getName() == MainFileName &&
546 FrontendOptions::getInputKindForExtension(
547 MainFile->getName().rsplit('.').second)
548 .isPreprocessed())
549 MainFileName = CGM.getModule().getName().str();
550
Amjad Aboude2aab8c2016-12-25 10:12:27 +0000551 CSKind = computeChecksum(SM.getMainFileID(), Checksum);
Guy Benyei11169dd2012-12-18 14:30:41 +0000552 }
553
Ed Masteda706022014-05-07 12:49:30 +0000554 llvm::dwarf::SourceLanguage LangTag;
Guy Benyei11169dd2012-12-18 14:30:41 +0000555 const LangOptions &LO = CGM.getLangOpts();
556 if (LO.CPlusPlus) {
Erik Pilkingtonfa983902018-10-30 20:31:30 +0000557 if (LO.ObjC)
Guy Benyei11169dd2012-12-18 14:30:41 +0000558 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
Adrian Prantl350de4f2019-09-24 00:38:49 +0000559 else if (LO.CPlusPlus14)
560 LangTag = llvm::dwarf::DW_LANG_C_plus_plus_14;
561 else if (LO.CPlusPlus11)
562 LangTag = llvm::dwarf::DW_LANG_C_plus_plus_11;
Guy Benyei11169dd2012-12-18 14:30:41 +0000563 else
564 LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
Erik Pilkingtonfa983902018-10-30 20:31:30 +0000565 } else if (LO.ObjC) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000566 LangTag = llvm::dwarf::DW_LANG_ObjC;
Pirama Arumuga Nainara7484c92016-06-21 21:35:11 +0000567 } else if (LO.RenderScript) {
568 LangTag = llvm::dwarf::DW_LANG_GOOGLE_RenderScript;
Guy Benyei11169dd2012-12-18 14:30:41 +0000569 } else if (LO.C99) {
570 LangTag = llvm::dwarf::DW_LANG_C99;
571 } else {
572 LangTag = llvm::dwarf::DW_LANG_C89;
573 }
574
575 std::string Producer = getClangFullVersion();
576
577 // Figure out which version of the ObjC runtime we have.
578 unsigned RuntimeVers = 0;
Erik Pilkingtonfa983902018-10-30 20:31:30 +0000579 if (LO.ObjC)
Guy Benyei11169dd2012-12-18 14:30:41 +0000580 RuntimeVers = LO.ObjCRuntime.isNonFragile() ? 2 : 1;
581
Adrian Prantl826824e2016-04-08 22:43:06 +0000582 llvm::DICompileUnit::DebugEmissionKind EmissionKind;
583 switch (DebugKind) {
584 case codegenoptions::NoDebugInfo:
585 case codegenoptions::LocTrackingOnly:
586 EmissionKind = llvm::DICompileUnit::NoDebug;
587 break;
588 case codegenoptions::DebugLineTablesOnly:
589 EmissionKind = llvm::DICompileUnit::LineTablesOnly;
590 break;
Alexey Bataev80e1b5e2018-08-31 13:56:14 +0000591 case codegenoptions::DebugDirectivesOnly:
592 EmissionKind = llvm::DICompileUnit::DebugDirectivesOnly;
593 break;
Adrian Prantl826824e2016-04-08 22:43:06 +0000594 case codegenoptions::LimitedDebugInfo:
595 case codegenoptions::FullDebugInfo:
596 EmissionKind = llvm::DICompileUnit::FullDebug;
597 break;
598 }
599
Adrian Prantl046d1002018-12-13 17:53:29 +0000600 uint64_t DwoId = 0;
601 auto &CGOpts = CGM.getCodeGenOpts();
602 // The DIFile used by the CU is distinct from the main source
603 // file. Its directory part specifies what becomes the
604 // DW_AT_comp_dir (the compilation directory), even if the source
605 // file was specified with an absolute path.
Scott Linder94834f12018-02-12 19:47:05 +0000606 if (CSKind)
607 CSInfo.emplace(*CSKind, Checksum);
Adrian Prantl046d1002018-12-13 17:53:29 +0000608 llvm::DIFile *CUFile = DBuilder.createFile(
609 remapDIPath(MainFileName), remapDIPath(getCurrentDirname()), CSInfo,
610 getSource(SM, SM.getMainFileID()));
Scott Linder94834f12018-02-12 19:47:05 +0000611
Guy Benyei11169dd2012-12-18 14:30:41 +0000612 // Create new compile unit.
Eric Christophere4200a22014-02-27 01:25:08 +0000613 TheCU = DBuilder.createCompileUnit(
Adrian Prantl046d1002018-12-13 17:53:29 +0000614 LangTag, CUFile, CGOpts.EmitVersionIdentMetadata ? Producer : "",
Tobias Edler von Koch7609cb82018-06-22 20:23:21 +0000615 LO.Optimize || CGOpts.PrepareForLTO || CGOpts.PrepareForThinLTO,
Aaron Puchert45611612019-06-26 21:39:19 +0000616 CGOpts.DwarfDebugFlags, RuntimeVers, CGOpts.SplitDwarfFile, EmissionKind,
617 DwoId, CGOpts.SplitDwarfInlining, CGOpts.DebugInfoForProfiling,
David Blaikie9982bb82018-08-16 23:56:32 +0000618 CGM.getTarget().getTriple().isNVPTX()
619 ? llvm::DICompileUnit::DebugNameTableKind::None
David Blaikie65864522018-08-20 20:14:08 +0000620 : static_cast<llvm::DICompileUnit::DebugNameTableKind>(
David Blaikie27692de2018-11-13 20:08:13 +0000621 CGOpts.DebugNameTable),
622 CGOpts.DebugRangesBaseAddress);
Guy Benyei11169dd2012-12-18 14:30:41 +0000623}
624
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000625llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
Ed Masteda706022014-05-07 12:49:30 +0000626 llvm::dwarf::TypeKind Encoding;
Guy Benyei11169dd2012-12-18 14:30:41 +0000627 StringRef BTName;
628 switch (BT->getKind()) {
629#define BUILTIN_TYPE(Id, SingletonId)
Eric Christophere7b87e52014-10-26 23:40:33 +0000630#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
Guy Benyei11169dd2012-12-18 14:30:41 +0000631#include "clang/AST/BuiltinTypes.def"
632 case BuiltinType::Dependent:
633 llvm_unreachable("Unexpected builtin type");
634 case BuiltinType::NullPtr:
Peter Collingbourne5c5e6172013-06-27 22:51:01 +0000635 return DBuilder.createNullPtrType();
Guy Benyei11169dd2012-12-18 14:30:41 +0000636 case BuiltinType::Void:
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +0000637 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +0000638 case BuiltinType::ObjCClass:
David Blaikief427b002014-05-06 03:42:01 +0000639 if (!ClassTy)
Adrian Prantlc2a44ec2018-12-11 16:58:46 +0000640 ClassTy =
641 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
642 "objc_class", TheCU, TheCU->getFile(), 0);
Guy Benyei11169dd2012-12-18 14:30:41 +0000643 return ClassTy;
644 case BuiltinType::ObjCId: {
645 // typedef struct objc_class *Class;
646 // typedef struct objc_object {
647 // Class isa;
648 // } *id;
649
Eric Christopherf8bc4d82013-07-18 00:52:50 +0000650 if (ObjTy)
Guy Benyei11169dd2012-12-18 14:30:41 +0000651 return ObjTy;
652
Eric Christopherf8bc4d82013-07-18 00:52:50 +0000653 if (!ClassTy)
Adrian Prantlc2a44ec2018-12-11 16:58:46 +0000654 ClassTy =
655 DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
656 "objc_class", TheCU, TheCU->getFile(), 0);
Guy Benyei11169dd2012-12-18 14:30:41 +0000657
658 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
Eric Christopherb2a008c2013-05-16 00:45:12 +0000659
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +0000660 auto *ISATy = DBuilder.createPointerType(ClassTy, Size);
Guy Benyei11169dd2012-12-18 14:30:41 +0000661
Adrian Prantlc2a44ec2018-12-11 16:58:46 +0000662 ObjTy = DBuilder.createStructType(TheCU, "objc_object", TheCU->getFile(), 0,
663 0, 0, llvm::DINode::FlagZero, nullptr,
664 llvm::DINodeArray());
Guy Benyei11169dd2012-12-18 14:30:41 +0000665
Duncan P. N. Exon Smithc8ee63e2014-12-18 00:48:56 +0000666 DBuilder.replaceArrays(
Leny Kholodovdf050fd2016-09-06 17:06:14 +0000667 ObjTy, DBuilder.getOrCreateArray(&*DBuilder.createMemberType(
Adrian Prantlc2a44ec2018-12-11 16:58:46 +0000668 ObjTy, "isa", TheCU->getFile(), 0, Size, 0, 0,
Leny Kholodovdf050fd2016-09-06 17:06:14 +0000669 llvm::DINode::FlagZero, ISATy)));
Guy Benyei11169dd2012-12-18 14:30:41 +0000670 return ObjTy;
671 }
672 case BuiltinType::ObjCSel: {
David Blaikief427b002014-05-06 03:42:01 +0000673 if (!SelTy)
674 SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
675 "objc_selector", TheCU,
Adrian Prantlc2a44ec2018-12-11 16:58:46 +0000676 TheCU->getFile(), 0);
Guy Benyei11169dd2012-12-18 14:30:41 +0000677 return SelTy;
678 }
Guy Benyeid8a08ea2012-12-18 14:38:23 +0000679
Jonas Devlieghere9ef49652018-06-28 10:56:40 +0000680#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
681 case BuiltinType::Id: \
682 return getOrCreateStructPtrType("opencl_" #ImgType "_" #Suffix "_t", \
Alexey Bader954ba212016-04-08 13:40:33 +0000683 SingletonId);
Alexey Baderb62f1442016-04-13 08:33:41 +0000684#include "clang/Basic/OpenCLImageTypes.def"
Guy Benyei61054192013-02-07 10:55:47 +0000685 case BuiltinType::OCLSampler:
Jonas Devlieghere9ef49652018-06-28 10:56:40 +0000686 return getOrCreateStructPtrType("opencl_sampler_t", OCLSamplerDITy);
Guy Benyei1b4fb3e2013-01-20 12:31:11 +0000687 case BuiltinType::OCLEvent:
Eric Christophere7b87e52014-10-26 23:40:33 +0000688 return getOrCreateStructPtrType("opencl_event_t", OCLEventDITy);
Alexey Bader9c8453f2015-09-15 11:18:52 +0000689 case BuiltinType::OCLClkEvent:
690 return getOrCreateStructPtrType("opencl_clk_event_t", OCLClkEventDITy);
691 case BuiltinType::OCLQueue:
692 return getOrCreateStructPtrType("opencl_queue_t", OCLQueueDITy);
Alexey Bader9c8453f2015-09-15 11:18:52 +0000693 case BuiltinType::OCLReserveID:
694 return getOrCreateStructPtrType("opencl_reserve_id_t", OCLReserveIDDITy);
Andrew Savonichev3fee3512018-11-08 11:25:41 +0000695#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
696 case BuiltinType::Id: \
697 return getOrCreateStructPtrType("opencl_" #ExtType, Id##Ty);
698#include "clang/Basic/OpenCLExtensionTypes.def"
Richard Sandifordeb485fb2019-08-09 08:52:54 +0000699 // TODO: real support for SVE types requires more infrastructure
700 // to be added first. The types have a variable length and are
701 // represented in debug info as types whose length depends on a
702 // target-specific pseudo register.
703#define SVE_TYPE(Name, Id, SingletonId) \
704 case BuiltinType::Id:
705#include "clang/Basic/AArch64SVEACLETypes.def"
706 {
707 unsigned DiagID = CGM.getDiags().getCustomDiagID(
708 DiagnosticsEngine::Error,
709 "cannot yet generate debug info for SVE type '%0'");
710 auto Name = BT->getName(CGM.getContext().getPrintingPolicy());
711 CGM.getDiags().Report(DiagID) << Name;
712 // Return something safe.
713 return CreateType(cast<const BuiltinType>(CGM.getContext().IntTy));
714 }
Guy Benyeid8a08ea2012-12-18 14:38:23 +0000715
Guy Benyei11169dd2012-12-18 14:30:41 +0000716 case BuiltinType::UChar:
Eric Christophere7b87e52014-10-26 23:40:33 +0000717 case BuiltinType::Char_U:
718 Encoding = llvm::dwarf::DW_ATE_unsigned_char;
719 break;
Guy Benyei11169dd2012-12-18 14:30:41 +0000720 case BuiltinType::Char_S:
Eric Christophere7b87e52014-10-26 23:40:33 +0000721 case BuiltinType::SChar:
722 Encoding = llvm::dwarf::DW_ATE_signed_char;
723 break;
Richard Smith3a8244d2018-05-01 05:02:45 +0000724 case BuiltinType::Char8:
Guy Benyei11169dd2012-12-18 14:30:41 +0000725 case BuiltinType::Char16:
Eric Christophere7b87e52014-10-26 23:40:33 +0000726 case BuiltinType::Char32:
727 Encoding = llvm::dwarf::DW_ATE_UTF;
728 break;
Guy Benyei11169dd2012-12-18 14:30:41 +0000729 case BuiltinType::UShort:
730 case BuiltinType::UInt:
731 case BuiltinType::UInt128:
732 case BuiltinType::ULong:
733 case BuiltinType::WChar_U:
Eric Christophere7b87e52014-10-26 23:40:33 +0000734 case BuiltinType::ULongLong:
735 Encoding = llvm::dwarf::DW_ATE_unsigned;
736 break;
Guy Benyei11169dd2012-12-18 14:30:41 +0000737 case BuiltinType::Short:
738 case BuiltinType::Int:
739 case BuiltinType::Int128:
740 case BuiltinType::Long:
741 case BuiltinType::WChar_S:
Eric Christophere7b87e52014-10-26 23:40:33 +0000742 case BuiltinType::LongLong:
743 Encoding = llvm::dwarf::DW_ATE_signed;
744 break;
745 case BuiltinType::Bool:
746 Encoding = llvm::dwarf::DW_ATE_boolean;
747 break;
Guy Benyei11169dd2012-12-18 14:30:41 +0000748 case BuiltinType::Half:
749 case BuiltinType::Float:
750 case BuiltinType::LongDouble:
Sjoerd Meijercc623ad2017-09-08 15:15:00 +0000751 case BuiltinType::Float16:
Nemanja Ivanovicbb1ea2d2016-05-09 08:52:33 +0000752 case BuiltinType::Float128:
Eric Christophere7b87e52014-10-26 23:40:33 +0000753 case BuiltinType::Double:
Nemanja Ivanovicbb1ea2d2016-05-09 08:52:33 +0000754 // FIXME: For targets where long double and __float128 have the same size,
755 // they are currently indistinguishable in the debugger without some
756 // special treatment. However, there is currently no consensus on encoding
757 // and this should be updated once a DWARF encoding exists for distinct
758 // floating point types of the same size.
Eric Christophere7b87e52014-10-26 23:40:33 +0000759 Encoding = llvm::dwarf::DW_ATE_float;
760 break;
Leonard Chanf921d852018-06-04 16:07:52 +0000761 case BuiltinType::ShortAccum:
762 case BuiltinType::Accum:
763 case BuiltinType::LongAccum:
Leonard Chanab80f3c2018-06-14 14:53:51 +0000764 case BuiltinType::ShortFract:
765 case BuiltinType::Fract:
766 case BuiltinType::LongFract:
767 case BuiltinType::SatShortFract:
768 case BuiltinType::SatFract:
769 case BuiltinType::SatLongFract:
770 case BuiltinType::SatShortAccum:
771 case BuiltinType::SatAccum:
772 case BuiltinType::SatLongAccum:
Leonard Chanf921d852018-06-04 16:07:52 +0000773 Encoding = llvm::dwarf::DW_ATE_signed_fixed;
774 break;
775 case BuiltinType::UShortAccum:
776 case BuiltinType::UAccum:
777 case BuiltinType::ULongAccum:
Leonard Chanab80f3c2018-06-14 14:53:51 +0000778 case BuiltinType::UShortFract:
779 case BuiltinType::UFract:
780 case BuiltinType::ULongFract:
781 case BuiltinType::SatUShortAccum:
782 case BuiltinType::SatUAccum:
783 case BuiltinType::SatULongAccum:
784 case BuiltinType::SatUShortFract:
785 case BuiltinType::SatUFract:
786 case BuiltinType::SatULongFract:
Leonard Chanf921d852018-06-04 16:07:52 +0000787 Encoding = llvm::dwarf::DW_ATE_unsigned_fixed;
788 break;
Guy Benyei11169dd2012-12-18 14:30:41 +0000789 }
790
791 switch (BT->getKind()) {
Eric Christophere7b87e52014-10-26 23:40:33 +0000792 case BuiltinType::Long:
793 BTName = "long int";
794 break;
795 case BuiltinType::LongLong:
796 BTName = "long long int";
797 break;
798 case BuiltinType::ULong:
799 BTName = "long unsigned int";
800 break;
801 case BuiltinType::ULongLong:
802 BTName = "long long unsigned int";
803 break;
Guy Benyei11169dd2012-12-18 14:30:41 +0000804 default:
805 BTName = BT->getName(CGM.getLangOpts());
806 break;
807 }
Victor Leschuka7ece032016-10-20 00:13:19 +0000808 // Bit size and offset of the type.
Guy Benyei11169dd2012-12-18 14:30:41 +0000809 uint64_t Size = CGM.getContext().getTypeSize(BT);
Victor Leschuka7ece032016-10-20 00:13:19 +0000810 return DBuilder.createBasicType(BTName, Size, Encoding);
Guy Benyei11169dd2012-12-18 14:30:41 +0000811}
812
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000813llvm::DIType *CGDebugInfo::CreateType(const ComplexType *Ty) {
Victor Leschuka7ece032016-10-20 00:13:19 +0000814 // Bit size and offset of the type.
Ed Masteda706022014-05-07 12:49:30 +0000815 llvm::dwarf::TypeKind Encoding = llvm::dwarf::DW_ATE_complex_float;
Guy Benyei11169dd2012-12-18 14:30:41 +0000816 if (Ty->isComplexIntegerType())
817 Encoding = llvm::dwarf::DW_ATE_lo_user;
818
819 uint64_t Size = CGM.getContext().getTypeSize(Ty);
Victor Leschuka7ece032016-10-20 00:13:19 +0000820 return DBuilder.createBasicType("complex", Size, Encoding);
Guy Benyei11169dd2012-12-18 14:30:41 +0000821}
822
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000823llvm::DIType *CGDebugInfo::CreateQualifiedType(QualType Ty,
824 llvm::DIFile *Unit) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000825 QualifierCollector Qc;
826 const Type *T = Qc.strip(Ty);
827
828 // Ignore these qualifiers for now.
829 Qc.removeObjCGCAttr();
830 Qc.removeAddressSpace();
831 Qc.removeObjCLifetime();
832
833 // We will create one Derived type for one qualifier and recurse to handle any
834 // additional ones.
Ed Masteda706022014-05-07 12:49:30 +0000835 llvm::dwarf::Tag Tag;
Guy Benyei11169dd2012-12-18 14:30:41 +0000836 if (Qc.hasConst()) {
837 Tag = llvm::dwarf::DW_TAG_const_type;
838 Qc.removeConst();
839 } else if (Qc.hasVolatile()) {
840 Tag = llvm::dwarf::DW_TAG_volatile_type;
841 Qc.removeVolatile();
842 } else if (Qc.hasRestrict()) {
843 Tag = llvm::dwarf::DW_TAG_restrict_type;
844 Qc.removeRestrict();
845 } else {
846 assert(Qc.empty() && "Unknown type qualifier for debug info");
847 return getOrCreateType(QualType(T, 0), Unit);
848 }
849
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +0000850 auto *FromTy = getOrCreateType(Qc.apply(CGM.getContext(), T), Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +0000851
852 // No need to fill in the Name, Line, Size, Alignment, Offset in case of
853 // CVR derived types.
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +0000854 return DBuilder.createQualifiedType(Tag, FromTy);
Guy Benyei11169dd2012-12-18 14:30:41 +0000855}
856
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000857llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty,
858 llvm::DIFile *Unit) {
Fariborz Jahanian65f1fa12013-02-21 20:42:11 +0000859
860 // The frontend treats 'id' as a typedef to an ObjCObjectType,
861 // whereas 'id<protocol>' is treated as an ObjCPointerType. For the
862 // debug info, we want to emit 'id' in both cases.
863 if (Ty->isObjCQualifiedIdType())
Eric Christophere7b87e52014-10-26 23:40:33 +0000864 return getOrCreateType(CGM.getContext().getObjCIdType(), Unit);
Fariborz Jahanian65f1fa12013-02-21 20:42:11 +0000865
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +0000866 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
867 Ty->getPointeeType(), Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +0000868}
869
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000870llvm::DIType *CGDebugInfo::CreateType(const PointerType *Ty,
871 llvm::DIFile *Unit) {
Eric Christopherb2a008c2013-05-16 00:45:12 +0000872 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
Guy Benyei11169dd2012-12-18 14:30:41 +0000873 Ty->getPointeeType(), Unit);
874}
875
Adrian Prantlc6f91a22015-06-15 23:18:16 +0000876/// \return whether a C++ mangling exists for the type defined by TD.
877static bool hasCXXMangling(const TagDecl *TD, llvm::DICompileUnit *TheCU) {
878 switch (TheCU->getSourceLanguage()) {
879 case llvm::dwarf::DW_LANG_C_plus_plus:
Adrian Prantl350de4f2019-09-24 00:38:49 +0000880 case llvm::dwarf::DW_LANG_C_plus_plus_11:
881 case llvm::dwarf::DW_LANG_C_plus_plus_14:
Adrian Prantlc6f91a22015-06-15 23:18:16 +0000882 return true;
883 case llvm::dwarf::DW_LANG_ObjC_plus_plus:
884 return isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD);
885 default:
886 return false;
887 }
888}
889
Reid Kleckner59320fc2018-08-17 20:59:52 +0000890// Determines if the debug info for this tag declaration needs a type
891// identifier. The purpose of the unique identifier is to deduplicate type
892// information for identical types across TUs. Because of the C++ one definition
893// rule (ODR), it is valid to assume that the type is defined the same way in
894// every TU and its debug info is equivalent.
895//
896// C does not have the ODR, and it is common for codebases to contain multiple
897// different definitions of a struct with the same name in different TUs.
898// Therefore, if the type doesn't have a C++ mangling, don't give it an
899// identifer. Type information in C is smaller and simpler than C++ type
900// information, so the increase in debug info size is negligible.
901//
902// If the type is not externally visible, it should be unique to the current TU,
903// and should not need an identifier to participate in type deduplication.
904// However, when emitting CodeView, the format internally uses these
905// unique type name identifers for references between debug info. For example,
906// the method of a class in an anonymous namespace uses the identifer to refer
907// to its parent class. The Microsoft C++ ABI attempts to provide unique names
908// for such types, so when emitting CodeView, always use identifiers for C++
909// types. This may create problems when attempting to emit CodeView when the MS
910// C++ ABI is not in use.
Jonas Devlieghere9ef49652018-06-28 10:56:40 +0000911static bool needsTypeIdentifier(const TagDecl *TD, CodeGenModule &CGM,
Brock Wyma8557ec52018-05-22 12:41:19 +0000912 llvm::DICompileUnit *TheCU) {
913 // We only add a type identifier for types with C++ name mangling.
914 if (!hasCXXMangling(TD, TheCU))
915 return false;
916
Brock Wyma8557ec52018-05-22 12:41:19 +0000917 // Externally visible types with C++ mangling need a type identifier.
918 if (TD->isExternallyVisible())
919 return true;
920
Reid Kleckner59320fc2018-08-17 20:59:52 +0000921 // CodeView types with C++ mangling need a type identifier.
922 if (CGM.getCodeGenOpts().EmitCodeView)
923 return true;
924
Brock Wyma8557ec52018-05-22 12:41:19 +0000925 return false;
926}
927
Reid Kleckner59320fc2018-08-17 20:59:52 +0000928// Returns a unique type identifier string if one exists, or an empty string.
Jonas Devlieghere9ef49652018-06-28 10:56:40 +0000929static SmallString<256> getTypeIdentifier(const TagType *Ty, CodeGenModule &CGM,
Brock Wyma8557ec52018-05-22 12:41:19 +0000930 llvm::DICompileUnit *TheCU) {
931 SmallString<256> Identifier;
Manman Rene0064d82013-08-29 23:19:58 +0000932 const TagDecl *TD = Ty->getDecl();
Adrian Prantlc6f91a22015-06-15 23:18:16 +0000933
Brock Wyma8557ec52018-05-22 12:41:19 +0000934 if (!needsTypeIdentifier(TD, CGM, TheCU))
935 return Identifier;
David Blaikief0d66552019-04-25 20:05:47 +0000936 if (const auto *RD = dyn_cast<CXXRecordDecl>(TD))
937 if (RD->getDefinition())
938 if (RD->isDynamicClass() &&
939 CGM.getVTableLinkage(RD) == llvm::GlobalValue::ExternalLinkage)
940 return Identifier;
Adrian Prantlc6f91a22015-06-15 23:18:16 +0000941
Manman Rene0064d82013-08-29 23:19:58 +0000942 // TODO: This is using the RTTI name. Is there a better way to get
943 // a unique string for a type?
Brock Wyma8557ec52018-05-22 12:41:19 +0000944 llvm::raw_svector_ostream Out(Identifier);
Manman Rene0064d82013-08-29 23:19:58 +0000945 CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(QualType(Ty, 0), Out);
Brock Wyma8557ec52018-05-22 12:41:19 +0000946 return Identifier;
Manman Rene0064d82013-08-29 23:19:58 +0000947}
948
Alexander Kornienko2a8c18d2018-04-06 15:14:32 +0000949/// \return the appropriate DWARF tag for a composite type.
Adrian Prantl5f66bae2015-02-11 17:45:15 +0000950static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD) {
Jonas Devlieghere9ef49652018-06-28 10:56:40 +0000951 llvm::dwarf::Tag Tag;
Adrian Prantl5f66bae2015-02-11 17:45:15 +0000952 if (RD->isStruct() || RD->isInterface())
953 Tag = llvm::dwarf::DW_TAG_structure_type;
954 else if (RD->isUnion())
955 Tag = llvm::dwarf::DW_TAG_union_type;
956 else {
957 // FIXME: This could be a struct type giving a default visibility different
958 // than C++ class type, but needs llvm metadata changes first.
959 assert(RD->isClass());
960 Tag = llvm::dwarf::DW_TAG_class_type;
961 }
962 return Tag;
963}
964
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000965llvm::DICompositeType *
Manman Ren1b457022013-08-28 21:20:28 +0000966CGDebugInfo::getOrCreateRecordFwdDecl(const RecordType *Ty,
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000967 llvm::DIScope *Ctx) {
Manman Ren1b457022013-08-28 21:20:28 +0000968 const RecordDecl *RD = Ty->getDecl();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000969 if (llvm::DIType *T = getTypeOrNull(CGM.getContext().getRecordType(RD)))
970 return cast<llvm::DICompositeType>(T);
971 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
Guy Benyei11169dd2012-12-18 14:30:41 +0000972 unsigned Line = getLineNumber(RD->getLocation());
973 StringRef RDName = getClassName(RD);
974
Peter Collingbourned251b0a2015-03-01 22:07:04 +0000975 uint64_t Size = 0;
Victor Leschuk802e4a52016-10-19 22:11:07 +0000976 uint32_t Align = 0;
Peter Collingbourned251b0a2015-03-01 22:07:04 +0000977
Guy Benyei11169dd2012-12-18 14:30:41 +0000978 // Create the type.
Brock Wyma8557ec52018-05-22 12:41:19 +0000979 SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU);
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000980 llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
Peter Collingbourned251b0a2015-03-01 22:07:04 +0000981 getTagForRecord(RD), RDName, Ctx, DefUnit, Line, 0, Size, Align,
Brock Wyma8557ec52018-05-22 12:41:19 +0000982 llvm::DINode::FlagFwdDecl, Identifier);
Paul Robinson1787f812017-09-28 18:37:02 +0000983 if (CGM.getCodeGenOpts().DebugFwdTemplateParams)
984 if (auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
985 DBuilder.replaceArrays(RetTy, llvm::DINodeArray(),
986 CollectCXXTemplateParams(TSpecial, DefUnit));
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +0000987 ReplaceMap.emplace_back(
988 std::piecewise_construct, std::make_tuple(Ty),
989 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
David Blaikief427b002014-05-06 03:42:01 +0000990 return RetTy;
Guy Benyei11169dd2012-12-18 14:30:41 +0000991}
992
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000993llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +0000994 const Type *Ty,
995 QualType PointeeTy,
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +0000996 llvm::DIFile *Unit) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000997 // Bit size, align and offset of the type.
998 // Size is always the size of a pointer. We can't use getTypeSize here
999 // because that does not return the correct value for references.
Konstantin Zhuravlyovd1ba16e2017-03-08 23:56:48 +00001000 unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(PointeeTy);
1001 uint64_t Size = CGM.getTarget().getPointerWidth(AddressSpace);
Victor Leschuka7ece032016-10-20 00:13:19 +00001002 auto Align = getTypeAlignIfRequired(Ty, CGM.getContext());
Konstantin Zhuravlyovd1ba16e2017-03-08 23:56:48 +00001003 Optional<unsigned> DWARFAddressSpace =
1004 CGM.getTarget().getDWARFAddressSpace(AddressSpace);
Guy Benyei11169dd2012-12-18 14:30:41 +00001005
Keno Fischer87842f32015-11-16 09:04:13 +00001006 if (Tag == llvm::dwarf::DW_TAG_reference_type ||
1007 Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)
1008 return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit),
Konstantin Zhuravlyovd1ba16e2017-03-08 23:56:48 +00001009 Size, Align, DWARFAddressSpace);
Keno Fischer87842f32015-11-16 09:04:13 +00001010 else
1011 return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
Konstantin Zhuravlyovd1ba16e2017-03-08 23:56:48 +00001012 Align, DWARFAddressSpace);
Guy Benyei11169dd2012-12-18 14:30:41 +00001013}
1014
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001015llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
1016 llvm::DIType *&Cache) {
Eric Christopherf8bc4d82013-07-18 00:52:50 +00001017 if (Cache)
Guy Benyeid8a08ea2012-12-18 14:38:23 +00001018 return Cache;
David Blaikiefefc7f72013-05-21 17:58:54 +00001019 Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
Adrian Prantlc2a44ec2018-12-11 16:58:46 +00001020 TheCU, TheCU->getFile(), 0);
David Blaikiefefc7f72013-05-21 17:58:54 +00001021 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
1022 Cache = DBuilder.createPointerType(Cache, Size);
1023 return Cache;
Guy Benyeid8a08ea2012-12-18 14:38:23 +00001024}
1025
Scott Linder58df0e42018-08-08 15:56:12 +00001026uint64_t CGDebugInfo::collectDefaultElementTypesForBlockPointer(
1027 const BlockPointerType *Ty, llvm::DIFile *Unit, llvm::DIDerivedType *DescTy,
1028 unsigned LineNo, SmallVectorImpl<llvm::Metadata *> &EltTys) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001029 QualType FType;
Guy Benyei11169dd2012-12-18 14:30:41 +00001030
Scott Linder58df0e42018-08-08 15:56:12 +00001031 // Advanced by calls to CreateMemberType in increments of FType, then
1032 // returned as the overall size of the default elements.
1033 uint64_t FieldOffset = 0;
Guy Benyei11169dd2012-12-18 14:30:41 +00001034
Scott Linder58df0e42018-08-08 15:56:12 +00001035 // Blocks in OpenCL have unique constraints which make the standard fields
1036 // redundant while requiring size and align fields for enqueue_kernel. See
1037 // initializeForBlockHeader in CGBlocks.cpp
Scott Linder2b5cf042018-07-30 20:31:11 +00001038 if (CGM.getLangOpts().OpenCL) {
1039 FType = CGM.getContext().IntTy;
1040 EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset));
1041 EltTys.push_back(CreateMemberType(Unit, FType, "__align", &FieldOffset));
1042 } else {
1043 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
1044 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
1045 FType = CGM.getContext().IntTy;
1046 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
1047 EltTys.push_back(CreateMemberType(Unit, FType, "__reserved", &FieldOffset));
1048 FType = CGM.getContext().getPointerType(Ty->getPointeeType());
1049 EltTys.push_back(CreateMemberType(Unit, FType, "__FuncPtr", &FieldOffset));
1050 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Scott Linder58df0e42018-08-08 15:56:12 +00001051 uint64_t FieldSize = CGM.getContext().getTypeSize(Ty);
1052 uint32_t FieldAlign = CGM.getContext().getTypeAlign(Ty);
Scott Linder2b5cf042018-07-30 20:31:11 +00001053 EltTys.push_back(DBuilder.createMemberType(
Scott Linder58df0e42018-08-08 15:56:12 +00001054 Unit, "__descriptor", nullptr, LineNo, FieldSize, FieldAlign,
1055 FieldOffset, llvm::DINode::FlagZero, DescTy));
Scott Lindera7c45682018-07-30 22:52:07 +00001056 FieldOffset += FieldSize;
Scott Linder2b5cf042018-07-30 20:31:11 +00001057 }
Guy Benyei11169dd2012-12-18 14:30:41 +00001058
Scott Linder58df0e42018-08-08 15:56:12 +00001059 return FieldOffset;
1060}
1061
1062llvm::DIType *CGDebugInfo::CreateType(const BlockPointerType *Ty,
1063 llvm::DIFile *Unit) {
1064 SmallVector<llvm::Metadata *, 8> EltTys;
1065 QualType FType;
1066 uint64_t FieldOffset;
1067 llvm::DINodeArray Elements;
1068
1069 FieldOffset = 0;
1070 FType = CGM.getContext().UnsignedLongTy;
1071 EltTys.push_back(CreateMemberType(Unit, FType, "reserved", &FieldOffset));
1072 EltTys.push_back(CreateMemberType(Unit, FType, "Size", &FieldOffset));
1073
1074 Elements = DBuilder.getOrCreateArray(EltTys);
1075 EltTys.clear();
1076
1077 llvm::DINode::DIFlags Flags = llvm::DINode::FlagAppleBlock;
1078
1079 auto *EltTy =
1080 DBuilder.createStructType(Unit, "__block_descriptor", nullptr, 0,
1081 FieldOffset, 0, Flags, nullptr, Elements);
1082
1083 // Bit size, align and offset of the type.
1084 uint64_t Size = CGM.getContext().getTypeSize(Ty);
1085
1086 auto *DescTy = DBuilder.createPointerType(EltTy, Size);
1087
1088 FieldOffset = collectDefaultElementTypesForBlockPointer(Ty, Unit, DescTy,
1089 0, EltTys);
1090
Guy Benyei11169dd2012-12-18 14:30:41 +00001091 Elements = DBuilder.getOrCreateArray(EltTys);
1092
Adrian Prantl3d2c0512015-07-07 00:49:35 +00001093 // The __block_literal_generic structs are marked with a special
1094 // DW_AT_APPLE_BLOCK attribute and are an implementation detail only
1095 // the debugger needs to know about. To allow type uniquing, emit
1096 // them without a name or a location.
Scott Linder58df0e42018-08-08 15:56:12 +00001097 EltTy = DBuilder.createStructType(Unit, "", nullptr, 0, FieldOffset, 0,
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00001098 Flags, nullptr, Elements);
Guy Benyei11169dd2012-12-18 14:30:41 +00001099
Adrian Prantl3d2c0512015-07-07 00:49:35 +00001100 return DBuilder.createPointerType(EltTy, Size);
Guy Benyei11169dd2012-12-18 14:30:41 +00001101}
1102
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001103llvm::DIType *CGDebugInfo::CreateType(const TemplateSpecializationType *Ty,
1104 llvm::DIFile *Unit) {
David Blaikief1b382e2014-04-06 17:14:06 +00001105 assert(Ty->isTypeAlias());
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001106 llvm::DIType *Src = getOrCreateType(Ty->getAliasedType(), Unit);
David Blaikief1b382e2014-04-06 17:14:06 +00001107
David Blaikie8472fa62019-06-08 00:01:21 +00001108 auto *AliasDecl =
1109 cast<TypeAliasTemplateDecl>(Ty->getTemplateName().getAsTemplateDecl())
1110 ->getTemplatedDecl();
1111
1112 if (AliasDecl->hasAttr<NoDebugAttr>())
1113 return Src;
1114
David Blaikief1b382e2014-04-06 17:14:06 +00001115 SmallString<128> NS;
1116 llvm::raw_svector_ostream OS(NS);
Serge Pavlov03e672c2017-11-28 16:14:14 +00001117 Ty->getTemplateName().print(OS, getPrintingPolicy(), /*qualified*/ false);
1118 printTemplateArgumentList(OS, Ty->template_arguments(), getPrintingPolicy());
David Blaikief1b382e2014-04-06 17:14:06 +00001119
David Blaikief1b382e2014-04-06 17:14:06 +00001120 SourceLocation Loc = AliasDecl->getLocation();
Adrian Prantlb67dbce2015-09-11 18:45:02 +00001121 return DBuilder.createTypedef(Src, OS.str(), getOrCreateFile(Loc),
1122 getLineNumber(Loc),
Sam McCalld27a16e2019-11-18 15:53:22 +01001123 getDeclContextDescriptor(AliasDecl));
David Blaikief1b382e2014-04-06 17:14:06 +00001124}
1125
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001126llvm::DIType *CGDebugInfo::CreateType(const TypedefType *Ty,
1127 llvm::DIFile *Unit) {
David Blaikie8472fa62019-06-08 00:01:21 +00001128 llvm::DIType *Underlying =
1129 getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit);
1130
1131 if (Ty->getDecl()->hasAttr<NoDebugAttr>())
1132 return Underlying;
1133
Guy Benyei11169dd2012-12-18 14:30:41 +00001134 // We don't set size information, but do specify where the typedef was
1135 // declared.
Amjad Abouddc4531e2016-04-30 01:44:38 +00001136 SourceLocation Loc = Ty->getDecl()->getLocation();
Eric Christopherb2a008c2013-05-16 00:45:12 +00001137
Sourabh Singh Tomarf1e39882019-12-03 09:29:54 +05301138 uint32_t Align = getDeclAlignIfRequired(Ty->getDecl(), CGM.getContext());
Duncan P. N. Exon Smith4078ad42015-04-16 16:36:45 +00001139 // Typedefs are derived from some other type.
Sam McCalld27a16e2019-11-18 15:53:22 +01001140 return DBuilder.createTypedef(Underlying, Ty->getDecl()->getName(),
1141 getOrCreateFile(Loc), getLineNumber(Loc),
Sourabh Singh Tomarf1e39882019-12-03 09:29:54 +05301142 getDeclContextDescriptor(Ty->getDecl()), Align);
Guy Benyei11169dd2012-12-18 14:30:41 +00001143}
1144
Reid Klecknerf00f8032016-06-08 20:41:54 +00001145static unsigned getDwarfCC(CallingConv CC) {
1146 switch (CC) {
1147 case CC_C:
1148 // Avoid emitting DW_AT_calling_convention if the C convention was used.
1149 return 0;
1150
1151 case CC_X86StdCall:
1152 return llvm::dwarf::DW_CC_BORLAND_stdcall;
1153 case CC_X86FastCall:
1154 return llvm::dwarf::DW_CC_BORLAND_msfastcall;
1155 case CC_X86ThisCall:
1156 return llvm::dwarf::DW_CC_BORLAND_thiscall;
1157 case CC_X86VectorCall:
1158 return llvm::dwarf::DW_CC_LLVM_vectorcall;
1159 case CC_X86Pascal:
1160 return llvm::dwarf::DW_CC_BORLAND_pascal;
Martin Storsjo022e7822017-07-17 20:49:45 +00001161 case CC_Win64:
Jonas Devliegheref0702682018-03-22 13:53:30 +00001162 return llvm::dwarf::DW_CC_LLVM_Win64;
Reid Klecknerf00f8032016-06-08 20:41:54 +00001163 case CC_X86_64SysV:
Jonas Devliegheref0702682018-03-22 13:53:30 +00001164 return llvm::dwarf::DW_CC_LLVM_X86_64SysV;
Reid Klecknerf00f8032016-06-08 20:41:54 +00001165 case CC_AAPCS:
Sander de Smalen44a22532018-11-26 16:38:37 +00001166 case CC_AArch64VectorCall:
Jonas Devliegheref0702682018-03-22 13:53:30 +00001167 return llvm::dwarf::DW_CC_LLVM_AAPCS;
Reid Klecknerf00f8032016-06-08 20:41:54 +00001168 case CC_AAPCS_VFP:
Jonas Devliegheref0702682018-03-22 13:53:30 +00001169 return llvm::dwarf::DW_CC_LLVM_AAPCS_VFP;
Reid Klecknerf00f8032016-06-08 20:41:54 +00001170 case CC_IntelOclBicc:
Jonas Devliegheref0702682018-03-22 13:53:30 +00001171 return llvm::dwarf::DW_CC_LLVM_IntelOclBicc;
Reid Klecknerf00f8032016-06-08 20:41:54 +00001172 case CC_SpirFunction:
Jonas Devliegheref0702682018-03-22 13:53:30 +00001173 return llvm::dwarf::DW_CC_LLVM_SpirFunction;
Nikolay Haustov8c6538b2016-06-30 09:06:33 +00001174 case CC_OpenCLKernel:
Jonas Devliegheref0702682018-03-22 13:53:30 +00001175 return llvm::dwarf::DW_CC_LLVM_OpenCLKernel;
Reid Klecknerf00f8032016-06-08 20:41:54 +00001176 case CC_Swift:
Jonas Devliegheref0702682018-03-22 13:53:30 +00001177 return llvm::dwarf::DW_CC_LLVM_Swift;
Reid Klecknerf00f8032016-06-08 20:41:54 +00001178 case CC_PreserveMost:
Jonas Devliegheref0702682018-03-22 13:53:30 +00001179 return llvm::dwarf::DW_CC_LLVM_PreserveMost;
Reid Klecknerf00f8032016-06-08 20:41:54 +00001180 case CC_PreserveAll:
Jonas Devliegheref0702682018-03-22 13:53:30 +00001181 return llvm::dwarf::DW_CC_LLVM_PreserveAll;
Erich Keane757d3172016-11-02 18:29:35 +00001182 case CC_X86RegCall:
Jonas Devliegheref0702682018-03-22 13:53:30 +00001183 return llvm::dwarf::DW_CC_LLVM_X86RegCall;
Reid Klecknerf00f8032016-06-08 20:41:54 +00001184 }
1185 return 0;
1186}
1187
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001188llvm::DIType *CGDebugInfo::CreateType(const FunctionType *Ty,
1189 llvm::DIFile *Unit) {
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001190 SmallVector<llvm::Metadata *, 16> EltTys;
Guy Benyei11169dd2012-12-18 14:30:41 +00001191
1192 // Add the result type at least.
Alp Toker314cc812014-01-25 16:55:45 +00001193 EltTys.push_back(getOrCreateType(Ty->getReturnType(), Unit));
Guy Benyei11169dd2012-12-18 14:30:41 +00001194
1195 // Set up remainder of arguments if there is a prototype.
Adrian Prantl800faef2014-02-25 23:42:18 +00001196 // otherwise emit it as a variadic function.
Guy Benyei11169dd2012-12-18 14:30:41 +00001197 if (isa<FunctionNoProtoType>(Ty))
1198 EltTys.push_back(DBuilder.createUnspecifiedParameter());
David Majnemer58ed0f32016-07-17 00:39:12 +00001199 else if (const auto *FPT = dyn_cast<FunctionProtoType>(Ty)) {
1200 for (const QualType &ParamType : FPT->param_types())
1201 EltTys.push_back(getOrCreateType(ParamType, Unit));
Adrian Prantld45ba252014-02-25 19:38:11 +00001202 if (FPT->isVariadic())
1203 EltTys.push_back(DBuilder.createUnspecifiedParameter());
Guy Benyei11169dd2012-12-18 14:30:41 +00001204 }
1205
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001206 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
Leny Kholodov80c047d2016-09-06 10:48:04 +00001207 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
Reid Klecknerf00f8032016-06-08 20:41:54 +00001208 getDwarfCC(Ty->getCallConv()));
Guy Benyei11169dd2012-12-18 14:30:41 +00001209}
1210
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001211/// Convert an AccessSpecifier into the corresponding DINode flag.
Adrian Prantl21361fb2014-08-29 22:44:27 +00001212/// As an optimization, return 0 if the access specifier equals the
1213/// default for the containing type.
Leny Kholodovdf050fd2016-09-06 17:06:14 +00001214static llvm::DINode::DIFlags getAccessFlag(AccessSpecifier Access,
1215 const RecordDecl *RD) {
Adrian Prantl21361fb2014-08-29 22:44:27 +00001216 AccessSpecifier Default = clang::AS_none;
1217 if (RD && RD->isClass())
1218 Default = clang::AS_private;
1219 else if (RD && (RD->isStruct() || RD->isUnion()))
1220 Default = clang::AS_public;
1221
1222 if (Access == Default)
Leny Kholodov80c047d2016-09-06 10:48:04 +00001223 return llvm::DINode::FlagZero;
Adrian Prantl21361fb2014-08-29 22:44:27 +00001224
Eric Christophere7b87e52014-10-26 23:40:33 +00001225 switch (Access) {
1226 case clang::AS_private:
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001227 return llvm::DINode::FlagPrivate;
Eric Christophere7b87e52014-10-26 23:40:33 +00001228 case clang::AS_protected:
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001229 return llvm::DINode::FlagProtected;
Eric Christophere7b87e52014-10-26 23:40:33 +00001230 case clang::AS_public:
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001231 return llvm::DINode::FlagPublic;
Eric Christophere7b87e52014-10-26 23:40:33 +00001232 case clang::AS_none:
Leny Kholodov80c047d2016-09-06 10:48:04 +00001233 return llvm::DINode::FlagZero;
Adrian Prantl21361fb2014-08-29 22:44:27 +00001234 }
1235 llvm_unreachable("unexpected access enumerator");
1236}
Guy Benyei11169dd2012-12-18 14:30:41 +00001237
David Majnemerb4b671e2016-06-30 03:01:59 +00001238llvm::DIType *CGDebugInfo::createBitFieldType(const FieldDecl *BitFieldDecl,
1239 llvm::DIScope *RecordTy,
1240 const RecordDecl *RD) {
1241 StringRef Name = BitFieldDecl->getName();
1242 QualType Ty = BitFieldDecl->getType();
1243 SourceLocation Loc = BitFieldDecl->getLocation();
1244 llvm::DIFile *VUnit = getOrCreateFile(Loc);
1245 llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);
1246
1247 // Get the location for the field.
1248 llvm::DIFile *File = getOrCreateFile(Loc);
1249 unsigned Line = getLineNumber(Loc);
1250
1251 const CGBitFieldInfo &BitFieldInfo =
1252 CGM.getTypes().getCGRecordLayout(RD).getBitFieldInfo(BitFieldDecl);
1253 uint64_t SizeInBits = BitFieldInfo.Size;
1254 assert(SizeInBits > 0 && "found named 0-width bitfield");
David Majnemerb4b671e2016-06-30 03:01:59 +00001255 uint64_t StorageOffsetInBits =
1256 CGM.getContext().toBits(BitFieldInfo.StorageOffset);
Reid Kleckner06a4b2a2017-06-12 19:57:56 +00001257 uint64_t Offset = BitFieldInfo.Offset;
1258 // The bit offsets for big endian machines are reversed for big
1259 // endian target, compensate for that as the DIDerivedType requires
1260 // un-reversed offsets.
1261 if (CGM.getDataLayout().isBigEndian())
1262 Offset = BitFieldInfo.StorageSize - BitFieldInfo.Size - Offset;
1263 uint64_t OffsetInBits = StorageOffsetInBits + Offset;
Leny Kholodov80c047d2016-09-06 10:48:04 +00001264 llvm::DINode::DIFlags Flags = getAccessFlag(BitFieldDecl->getAccess(), RD);
David Majnemerb4b671e2016-06-30 03:01:59 +00001265 return DBuilder.createBitFieldMemberType(
Victor Leschuka7ece032016-10-20 00:13:19 +00001266 RecordTy, Name, File, Line, SizeInBits, OffsetInBits, StorageOffsetInBits,
1267 Flags, DebugType);
David Majnemerb4b671e2016-06-30 03:01:59 +00001268}
1269
1270llvm::DIType *
1271CGDebugInfo::createFieldType(StringRef name, QualType type, SourceLocation loc,
1272 AccessSpecifier AS, uint64_t offsetInBits,
Victor Leschuka7ece032016-10-20 00:13:19 +00001273 uint32_t AlignInBits, llvm::DIFile *tunit,
1274 llvm::DIScope *scope, const RecordDecl *RD) {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001275 llvm::DIType *debugType = getOrCreateType(type, tunit);
Guy Benyei11169dd2012-12-18 14:30:41 +00001276
1277 // Get the location for the field.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001278 llvm::DIFile *file = getOrCreateFile(loc);
Guy Benyei11169dd2012-12-18 14:30:41 +00001279 unsigned line = getLineNumber(loc);
1280
David Majnemer34b57492014-07-30 01:30:47 +00001281 uint64_t SizeInBits = 0;
Victor Leschuka7ece032016-10-20 00:13:19 +00001282 auto Align = AlignInBits;
Guy Benyei11169dd2012-12-18 14:30:41 +00001283 if (!type->isIncompleteArrayType()) {
David Majnemer34b57492014-07-30 01:30:47 +00001284 TypeInfo TI = CGM.getContext().getTypeInfo(type);
1285 SizeInBits = TI.Width;
Victor Leschuka7ece032016-10-20 00:13:19 +00001286 if (!Align)
1287 Align = getTypeAlignIfRequired(type, CGM.getContext());
Guy Benyei11169dd2012-12-18 14:30:41 +00001288 }
1289
Leny Kholodov80c047d2016-09-06 10:48:04 +00001290 llvm::DINode::DIFlags flags = getAccessFlag(AS, RD);
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00001291 return DBuilder.createMemberType(scope, name, file, line, SizeInBits, Align,
1292 offsetInBits, flags, debugType);
Guy Benyei11169dd2012-12-18 14:30:41 +00001293}
1294
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001295void CGDebugInfo::CollectRecordLambdaFields(
1296 const CXXRecordDecl *CXXDecl, SmallVectorImpl<llvm::Metadata *> &elements,
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001297 llvm::DIType *RecordTy) {
Eric Christopher91a31902013-01-16 01:22:32 +00001298 // For C++11 Lambdas a Field will be the same as a Capture, but the Capture
1299 // has the name and the location of the variable so we should iterate over
1300 // both concurrently.
1301 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(CXXDecl);
1302 RecordDecl::field_iterator Field = CXXDecl->field_begin();
1303 unsigned fieldno = 0;
1304 for (CXXRecordDecl::capture_const_iterator I = CXXDecl->captures_begin(),
Eric Christophere7b87e52014-10-26 23:40:33 +00001305 E = CXXDecl->captures_end();
1306 I != E; ++I, ++Field, ++fieldno) {
Benjamin Kramerf3ca26982014-05-10 16:31:55 +00001307 const LambdaCapture &C = *I;
Eric Christopher91a31902013-01-16 01:22:32 +00001308 if (C.capturesVariable()) {
David Majnemerb4b671e2016-06-30 03:01:59 +00001309 SourceLocation Loc = C.getLocation();
1310 assert(!Field->isBitField() && "lambdas don't have bitfield members!");
Eric Christopher91a31902013-01-16 01:22:32 +00001311 VarDecl *V = C.getCapturedVar();
Eric Christopher91a31902013-01-16 01:22:32 +00001312 StringRef VName = V->getName();
David Majnemerb4b671e2016-06-30 03:01:59 +00001313 llvm::DIFile *VUnit = getOrCreateFile(Loc);
Victor Leschuka7ece032016-10-20 00:13:19 +00001314 auto Align = getDeclAlignIfRequired(V, CGM.getContext());
David Majnemerb4b671e2016-06-30 03:01:59 +00001315 llvm::DIType *FieldType = createFieldType(
1316 VName, Field->getType(), Loc, Field->getAccess(),
Victor Leschuka7ece032016-10-20 00:13:19 +00001317 layout.getFieldOffset(fieldno), Align, VUnit, RecordTy, CXXDecl);
David Majnemerb4b671e2016-06-30 03:01:59 +00001318 elements.push_back(FieldType);
Alexey Bataev39c81e22014-08-28 04:28:19 +00001319 } else if (C.capturesThis()) {
Eric Christopher91a31902013-01-16 01:22:32 +00001320 // TODO: Need to handle 'this' in some way by probably renaming the
1321 // this of the lambda class and having a field member of 'this' or
1322 // by using AT_object_pointer for the function and having that be
1323 // used as 'this' for semantic references.
Eric Christopher91a31902013-01-16 01:22:32 +00001324 FieldDecl *f = *Field;
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001325 llvm::DIFile *VUnit = getOrCreateFile(f->getLocation());
Eric Christopher91a31902013-01-16 01:22:32 +00001326 QualType type = f->getType();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001327 llvm::DIType *fieldType = createFieldType(
David Majnemerb4b671e2016-06-30 03:01:59 +00001328 "this", type, f->getLocation(), f->getAccess(),
Eric Christophere7b87e52014-10-26 23:40:33 +00001329 layout.getFieldOffset(fieldno), VUnit, RecordTy, CXXDecl);
Eric Christopher91a31902013-01-16 01:22:32 +00001330
1331 elements.push_back(fieldType);
1332 }
1333 }
1334}
1335
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001336llvm::DIDerivedType *
1337CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy,
Duncan P. N. Exon Smithc09c5482015-04-20 21:17:26 +00001338 const RecordDecl *RD) {
Eric Christopher91a31902013-01-16 01:22:32 +00001339 // Create the descriptor for the static variable, with or without
1340 // constant initializers.
David Blaikie8e707bb2014-10-14 22:22:17 +00001341 Var = Var->getCanonicalDecl();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001342 llvm::DIFile *VUnit = getOrCreateFile(Var->getLocation());
1343 llvm::DIType *VTy = getOrCreateType(Var->getType(), VUnit);
Eric Christopher91a31902013-01-16 01:22:32 +00001344
Eric Christopher91a31902013-01-16 01:22:32 +00001345 unsigned LineNumber = getLineNumber(Var->getLocation());
1346 StringRef VName = Var->getName();
Craig Topper8a13c412014-05-21 05:09:00 +00001347 llvm::Constant *C = nullptr;
Eric Christopher91a31902013-01-16 01:22:32 +00001348 if (Var->getInit()) {
1349 const APValue *Value = Var->evaluateValue();
David Blaikied42917f2013-01-20 01:19:17 +00001350 if (Value) {
1351 if (Value->isInt())
1352 C = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->getInt());
1353 if (Value->isFloat())
1354 C = llvm::ConstantFP::get(CGM.getLLVMContext(), Value->getFloat());
1355 }
Eric Christopher91a31902013-01-16 01:22:32 +00001356 }
1357
Leny Kholodov80c047d2016-09-06 10:48:04 +00001358 llvm::DINode::DIFlags Flags = getAccessFlag(Var->getAccess(), RD);
Victor Leschuka7ece032016-10-20 00:13:19 +00001359 auto Align = getDeclAlignIfRequired(Var, CGM.getContext());
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001360 llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
Victor Leschuka7ece032016-10-20 00:13:19 +00001361 RecordTy, VName, VUnit, LineNumber, VTy, Flags, C, Align);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001362 StaticDataMemberCache[Var->getCanonicalDecl()].reset(GV);
David Blaikieae019462013-08-15 22:50:29 +00001363 return GV;
Eric Christopher91a31902013-01-16 01:22:32 +00001364}
1365
Eric Christophere7b87e52014-10-26 23:40:33 +00001366void CGDebugInfo::CollectRecordNormalField(
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001367 const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit,
1368 SmallVectorImpl<llvm::Metadata *> &elements, llvm::DIType *RecordTy,
Eric Christophere7b87e52014-10-26 23:40:33 +00001369 const RecordDecl *RD) {
Eric Christopher91a31902013-01-16 01:22:32 +00001370 StringRef name = field->getName();
1371 QualType type = field->getType();
1372
1373 // Ignore unnamed fields unless they're anonymous structs/unions.
1374 if (name.empty() && !type->isRecordType())
1375 return;
1376
David Majnemerb4b671e2016-06-30 03:01:59 +00001377 llvm::DIType *FieldType;
Eric Christopher91a31902013-01-16 01:22:32 +00001378 if (field->isBitField()) {
David Majnemerb4b671e2016-06-30 03:01:59 +00001379 FieldType = createBitFieldType(field, RecordTy, RD);
1380 } else {
Victor Leschuka7ece032016-10-20 00:13:19 +00001381 auto Align = getDeclAlignIfRequired(field, CGM.getContext());
David Majnemerb4b671e2016-06-30 03:01:59 +00001382 FieldType =
1383 createFieldType(name, type, field->getLocation(), field->getAccess(),
Victor Leschuka7ece032016-10-20 00:13:19 +00001384 OffsetInBits, Align, tunit, RecordTy, RD);
Eric Christopher91a31902013-01-16 01:22:32 +00001385 }
1386
David Majnemerb4b671e2016-06-30 03:01:59 +00001387 elements.push_back(FieldType);
Eric Christopher91a31902013-01-16 01:22:32 +00001388}
1389
Reid Klecknere2e82062017-08-08 20:30:14 +00001390void CGDebugInfo::CollectRecordNestedType(
1391 const TypeDecl *TD, SmallVectorImpl<llvm::Metadata *> &elements) {
1392 QualType Ty = CGM.getContext().getTypeDeclType(TD);
Reid Kleckner755220b2016-08-01 18:56:13 +00001393 // Injected class names are not considered nested records.
1394 if (isa<InjectedClassNameType>(Ty))
1395 return;
Reid Klecknere2e82062017-08-08 20:30:14 +00001396 SourceLocation Loc = TD->getLocation();
Adrian McCarthyab1e7862016-07-21 18:43:20 +00001397 llvm::DIType *nestedType = getOrCreateType(Ty, getOrCreateFile(Loc));
1398 elements.push_back(nestedType);
1399}
1400
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001401void CGDebugInfo::CollectRecordFields(
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001402 const RecordDecl *record, llvm::DIFile *tunit,
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001403 SmallVectorImpl<llvm::Metadata *> &elements,
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001404 llvm::DICompositeType *RecordTy) {
David Majnemer58ed0f32016-07-17 00:39:12 +00001405 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(record);
Guy Benyei11169dd2012-12-18 14:30:41 +00001406
Eric Christopher91a31902013-01-16 01:22:32 +00001407 if (CXXDecl && CXXDecl->isLambda())
1408 CollectRecordLambdaFields(CXXDecl, elements, RecordTy);
1409 else {
1410 const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(record);
Guy Benyei11169dd2012-12-18 14:30:41 +00001411
Eric Christopher91a31902013-01-16 01:22:32 +00001412 // Field number for non-static fields.
Eric Christopher0f7594372013-01-04 17:59:07 +00001413 unsigned fieldNo = 0;
Eric Christopher91a31902013-01-16 01:22:32 +00001414
Eric Christopher91a31902013-01-16 01:22:32 +00001415 // Static and non-static members should appear in the same order as
1416 // the corresponding declarations in the source program.
Aaron Ballman629afae2014-03-07 19:56:05 +00001417 for (const auto *I : record->decls())
1418 if (const auto *V = dyn_cast<VarDecl>(I)) {
Paul Robinsonb17327d2016-04-27 17:37:12 +00001419 if (V->hasAttr<NoDebugAttr>())
1420 continue;
Reid Kleckner891b2712018-07-20 20:55:00 +00001421
1422 // Skip variable template specializations when emitting CodeView. MSVC
1423 // doesn't emit them.
1424 if (CGM.getCodeGenOpts().EmitCodeView &&
1425 isa<VarTemplateSpecializationDecl>(V))
1426 continue;
1427
David Blaikie4f3b7362019-06-17 19:40:52 +00001428 if (isa<VarTemplatePartialSpecializationDecl>(V))
1429 continue;
1430
David Blaikiece763042013-08-20 21:49:21 +00001431 // Reuse the existing static member declaration if one exists
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001432 auto MI = StaticDataMemberCache.find(V->getCanonicalDecl());
David Blaikiece763042013-08-20 21:49:21 +00001433 if (MI != StaticDataMemberCache.end()) {
1434 assert(MI->second &&
1435 "Static data member declaration should still exist");
Duncan P. N. Exon Smithac346ba2015-07-24 18:05:58 +00001436 elements.push_back(MI->second);
Adrian Prantl21361fb2014-08-29 22:44:27 +00001437 } else {
1438 auto Field = CreateRecordStaticField(V, RecordTy, record);
1439 elements.push_back(Field);
1440 }
Aaron Ballman629afae2014-03-07 19:56:05 +00001441 } else if (const auto *field = dyn_cast<FieldDecl>(I)) {
Eric Christophere7b87e52014-10-26 23:40:33 +00001442 CollectRecordNormalField(field, layout.getFieldOffset(fieldNo), tunit,
1443 elements, RecordTy, record);
Eric Christopher91a31902013-01-16 01:22:32 +00001444
1445 // Bump field number for next field.
1446 ++fieldNo;
Reid Kleckner891b2712018-07-20 20:55:00 +00001447 } else if (CGM.getCodeGenOpts().EmitCodeView) {
1448 // Debug info for nested types is included in the member list only for
1449 // CodeView.
Reid Klecknere2e82062017-08-08 20:30:14 +00001450 if (const auto *nestedType = dyn_cast<TypeDecl>(I))
1451 if (!nestedType->isImplicit() &&
1452 nestedType->getDeclContext() == record)
1453 CollectRecordNestedType(nestedType, elements);
1454 }
Guy Benyei11169dd2012-12-18 14:30:41 +00001455 }
1456}
1457
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001458llvm::DISubroutineType *
Guy Benyei11169dd2012-12-18 14:30:41 +00001459CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method,
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001460 llvm::DIFile *Unit) {
David Blaikie7eb06852013-01-07 23:06:35 +00001461 const FunctionProtoType *Func = Method->getType()->getAs<FunctionProtoType>();
David Blaikie2aaf0652013-01-07 22:24:59 +00001462 if (Method->isStatic())
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001463 return cast_or_null<llvm::DISubroutineType>(
Duncan P. N. Exon Smithc7551282015-04-06 23:21:33 +00001464 getOrCreateType(QualType(Func, 0), Unit));
Brian Gesiak5488ab42019-01-11 01:54:53 +00001465 return getOrCreateInstanceMethodType(Method->getThisType(), Func, Unit);
David Blaikie7eb06852013-01-07 23:06:35 +00001466}
David Blaikie2aaf0652013-01-07 22:24:59 +00001467
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001468llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType(
1469 QualType ThisPtr, const FunctionProtoType *Func, llvm::DIFile *Unit) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001470 // Add "this" pointer.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001471 llvm::DITypeRefArray Args(
1472 cast<llvm::DISubroutineType>(getOrCreateType(QualType(Func, 0), Unit))
Duncan P. N. Exon Smithc7551282015-04-06 23:21:33 +00001473 ->getTypeArray());
Duncan P. N. Exon Smitha98fac62015-04-07 04:14:45 +00001474 assert(Args.size() && "Invalid number of arguments!");
Guy Benyei11169dd2012-12-18 14:30:41 +00001475
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001476 SmallVector<llvm::Metadata *, 16> Elts;
Guy Benyei11169dd2012-12-18 14:30:41 +00001477
1478 // First element is always return type. For 'void' functions it is NULL.
Duncan P. N. Exon Smith37328582015-04-07 18:41:26 +00001479 Elts.push_back(Args[0]);
Guy Benyei11169dd2012-12-18 14:30:41 +00001480
David Blaikie2aaf0652013-01-07 22:24:59 +00001481 // "this" pointer is always first argument.
David Blaikie7eb06852013-01-07 23:06:35 +00001482 const CXXRecordDecl *RD = ThisPtr->getPointeeCXXRecordDecl();
David Blaikie2aaf0652013-01-07 22:24:59 +00001483 if (isa<ClassTemplateSpecializationDecl>(RD)) {
1484 // Create pointer type directly in this case.
1485 const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr);
1486 QualType PointeeTy = ThisPtrTy->getPointeeType();
1487 unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
John McCallc8e01702013-04-16 22:48:15 +00001488 uint64_t Size = CGM.getTarget().getPointerWidth(AS);
Victor Leschuka7ece032016-10-20 00:13:19 +00001489 auto Align = getTypeAlignIfRequired(ThisPtrTy, CGM.getContext());
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001490 llvm::DIType *PointeeType = getOrCreateType(PointeeTy, Unit);
1491 llvm::DIType *ThisPtrType =
Eric Christophere7b87e52014-10-26 23:40:33 +00001492 DBuilder.createPointerType(PointeeType, Size, Align);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001493 TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
David Blaikie2aaf0652013-01-07 22:24:59 +00001494 // TODO: This and the artificial type below are misleading, the
1495 // types aren't artificial the argument is, but the current
1496 // metadata doesn't represent that.
1497 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1498 Elts.push_back(ThisPtrType);
1499 } else {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001500 llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001501 TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
David Blaikie2aaf0652013-01-07 22:24:59 +00001502 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1503 Elts.push_back(ThisPtrType);
Guy Benyei11169dd2012-12-18 14:30:41 +00001504 }
1505
1506 // Copy rest of the arguments.
Duncan P. N. Exon Smitha98fac62015-04-07 04:14:45 +00001507 for (unsigned i = 1, e = Args.size(); i != e; ++i)
1508 Elts.push_back(Args[i]);
Guy Benyei11169dd2012-12-18 14:30:41 +00001509
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001510 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
Guy Benyei11169dd2012-12-18 14:30:41 +00001511
Leny Kholodov80c047d2016-09-06 10:48:04 +00001512 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
Adrian Prantl0630eb72013-12-18 21:48:18 +00001513 if (Func->getExtProtoInfo().RefQualifier == RQ_LValue)
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001514 Flags |= llvm::DINode::FlagLValueReference;
Adrian Prantl0630eb72013-12-18 21:48:18 +00001515 if (Func->getExtProtoInfo().RefQualifier == RQ_RValue)
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001516 Flags |= llvm::DINode::FlagRValueReference;
Adrian Prantl0630eb72013-12-18 21:48:18 +00001517
Reid Klecknerf00f8032016-06-08 20:41:54 +00001518 return DBuilder.createSubroutineType(EltTypeArray, Flags,
1519 getDwarfCC(Func->getCallConv()));
Guy Benyei11169dd2012-12-18 14:30:41 +00001520}
1521
Eric Christopherb2a008c2013-05-16 00:45:12 +00001522/// isFunctionLocalClass - Return true if CXXRecordDecl is defined
Guy Benyei11169dd2012-12-18 14:30:41 +00001523/// inside a function.
1524static bool isFunctionLocalClass(const CXXRecordDecl *RD) {
David Majnemer58ed0f32016-07-17 00:39:12 +00001525 if (const auto *NRD = dyn_cast<CXXRecordDecl>(RD->getDeclContext()))
Guy Benyei11169dd2012-12-18 14:30:41 +00001526 return isFunctionLocalClass(NRD);
1527 if (isa<FunctionDecl>(RD->getDeclContext()))
1528 return true;
1529 return false;
1530}
1531
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001532llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
1533 const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {
Eric Christopherb2a008c2013-05-16 00:45:12 +00001534 bool IsCtorOrDtor =
Eric Christophere7b87e52014-10-26 23:40:33 +00001535 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
Eric Christopherb2a008c2013-05-16 00:45:12 +00001536
Guy Benyei11169dd2012-12-18 14:30:41 +00001537 StringRef MethodName = getFunctionName(Method);
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001538 llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +00001539
1540 // Since a single ctor/dtor corresponds to multiple functions, it doesn't
1541 // make sense to give a single ctor/dtor a linkage name.
1542 StringRef MethodLinkageName;
David Blaikie71647672016-04-12 21:22:48 +00001543 // FIXME: 'isFunctionLocalClass' seems like an arbitrary/unintentional
1544 // property to use here. It may've been intended to model "is non-external
1545 // type" but misses cases of non-function-local but non-external classes such
1546 // as those in anonymous namespaces as well as the reverse - external types
1547 // that are function local, such as those in (non-local) inline functions.
Guy Benyei11169dd2012-12-18 14:30:41 +00001548 if (!IsCtorOrDtor && !isFunctionLocalClass(Method->getParent()))
1549 MethodLinkageName = CGM.getMangledName(Method);
1550
1551 // Get the location for the method.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001552 llvm::DIFile *MethodDefUnit = nullptr;
David Blaikie7fceebf2013-08-19 03:37:48 +00001553 unsigned MethodLine = 0;
1554 if (!Method->isImplicit()) {
1555 MethodDefUnit = getOrCreateFile(Method->getLocation());
1556 MethodLine = getLineNumber(Method->getLocation());
1557 }
Guy Benyei11169dd2012-12-18 14:30:41 +00001558
1559 // Collect virtual method info.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001560 llvm::DIType *ContainingType = nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00001561 unsigned VIndex = 0;
Leny Kholodov80c047d2016-09-06 10:48:04 +00001562 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
Paul Robinsoncda54212018-11-19 18:29:28 +00001563 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
Reid Kleckner0358cbf2016-07-01 02:41:25 +00001564 int ThisAdjustment = 0;
Eric Christopherb2a008c2013-05-16 00:45:12 +00001565
Guy Benyei11169dd2012-12-18 14:30:41 +00001566 if (Method->isVirtual()) {
1567 if (Method->isPure())
Paul Robinsoncda54212018-11-19 18:29:28 +00001568 SPFlags |= llvm::DISubprogram::SPFlagPureVirtual;
Guy Benyei11169dd2012-12-18 14:30:41 +00001569 else
Paul Robinsoncda54212018-11-19 18:29:28 +00001570 SPFlags |= llvm::DISubprogram::SPFlagVirtual;
Eric Christopherb2a008c2013-05-16 00:45:12 +00001571
Reid Kleckner216d0a12016-06-16 20:08:51 +00001572 if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1573 // It doesn't make sense to give a virtual destructor a vtable index,
1574 // since a single destructor has two entries in the vtable.
1575 if (!isa<CXXDestructorDecl>(Method))
1576 VIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(Method);
1577 } else {
1578 // Emit MS ABI vftable information. There is only one entry for the
1579 // deleting dtor.
1580 const auto *DD = dyn_cast<CXXDestructorDecl>(Method);
1581 GlobalDecl GD = DD ? GlobalDecl(DD, Dtor_Deleting) : GlobalDecl(Method);
Reid Klecknercbec0262018-04-02 20:00:39 +00001582 MethodVFTableLocation ML =
Reid Kleckner216d0a12016-06-16 20:08:51 +00001583 CGM.getMicrosoftVTableContext().getMethodVFTableLocation(GD);
1584 VIndex = ML.Index;
Reid Klecknerc4871ed2016-06-22 18:34:45 +00001585
1586 // CodeView only records the vftable offset in the class that introduces
1587 // the virtual method. This is possible because, unlike Itanium, the MS
1588 // C++ ABI does not include all virtual methods from non-primary bases in
1589 // the vtable for the most derived class. For example, if C inherits from
1590 // A and B, C's primary vftable will not include B's virtual methods.
Benjamin Krameracfa3392017-12-17 23:52:45 +00001591 if (Method->size_overridden_methods() == 0)
Reid Klecknerc4871ed2016-06-22 18:34:45 +00001592 Flags |= llvm::DINode::FlagIntroducedVirtual;
1593
Reid Kleckner0358cbf2016-07-01 02:41:25 +00001594 // The 'this' adjustment accounts for both the virtual and non-virtual
1595 // portions of the adjustment. Presumably the debugger only uses it when
1596 // it knows the dynamic type of an object.
1597 ThisAdjustment = CGM.getCXXABI()
1598 .getVirtualFunctionPrologueThisAdjustment(GD)
1599 .getQuantity();
Reid Kleckner216d0a12016-06-16 20:08:51 +00001600 }
Guy Benyei11169dd2012-12-18 14:30:41 +00001601 ContainingType = RecordTy;
1602 }
1603
Adrian Prantlf919be32019-10-29 09:20:14 -07001604 // We're checking for deleted C++ special member functions
1605 // [Ctors,Dtors, Copy/Move]
Sourabh Singh Tomar52ea3082019-11-02 01:28:40 +05301606 auto checkAttrDeleted = [&](const auto *Method) {
Adrian Prantlf919be32019-10-29 09:20:14 -07001607 if (Method->getCanonicalDecl()->isDeleted())
1608 SPFlags |= llvm::DISubprogram::SPFlagDeleted;
1609 };
1610
1611 switch (Method->getKind()) {
1612
1613 case Decl::CXXConstructor:
1614 case Decl::CXXDestructor:
1615 checkAttrDeleted(Method);
1616 break;
1617 case Decl::CXXMethod:
1618 if (Method->isCopyAssignmentOperator() ||
1619 Method->isMoveAssignmentOperator())
1620 checkAttrDeleted(Method);
1621 break;
1622 default:
1623 break;
1624 }
1625
Adrian Prantla9cfde12019-10-16 16:30:38 +00001626 if (Method->isNoReturn())
1627 Flags |= llvm::DINode::FlagNoReturn;
Adrian Prantlf919be32019-10-29 09:20:14 -07001628
Adrian McCarthyd91bf392017-09-13 20:53:55 +00001629 if (Method->isStatic())
1630 Flags |= llvm::DINode::FlagStaticMember;
Guy Benyei11169dd2012-12-18 14:30:41 +00001631 if (Method->isImplicit())
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001632 Flags |= llvm::DINode::FlagArtificial;
Adrian Prantl21361fb2014-08-29 22:44:27 +00001633 Flags |= getAccessFlag(Method->getAccess(), Method->getParent());
David Majnemer58ed0f32016-07-17 00:39:12 +00001634 if (const auto *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001635 if (CXXC->isExplicit())
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001636 Flags |= llvm::DINode::FlagExplicit;
David Majnemer58ed0f32016-07-17 00:39:12 +00001637 } else if (const auto *CXXC = dyn_cast<CXXConversionDecl>(Method)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001638 if (CXXC->isExplicit())
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001639 Flags |= llvm::DINode::FlagExplicit;
Guy Benyei11169dd2012-12-18 14:30:41 +00001640 }
1641 if (Method->hasPrototype())
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001642 Flags |= llvm::DINode::FlagPrototyped;
Adrian Prantl0630eb72013-12-18 21:48:18 +00001643 if (Method->getRefQualifier() == RQ_LValue)
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001644 Flags |= llvm::DINode::FlagLValueReference;
Adrian Prantl0630eb72013-12-18 21:48:18 +00001645 if (Method->getRefQualifier() == RQ_RValue)
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001646 Flags |= llvm::DINode::FlagRValueReference;
Paul Robinsoncda54212018-11-19 18:29:28 +00001647 if (CGM.getLangOpts().Optimize)
1648 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
Guy Benyei11169dd2012-12-18 14:30:41 +00001649
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001650 llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
1651 llvm::DISubprogram *SP = DBuilder.createMethod(
Eric Christophere7b87e52014-10-26 23:40:33 +00001652 RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
Paul Robinsoncda54212018-11-19 18:29:28 +00001653 MethodTy, VIndex, ThisAdjustment, ContainingType, Flags, SPFlags,
Reid Kleckner0358cbf2016-07-01 02:41:25 +00001654 TParamsArray.get());
Eric Christopherb2a008c2013-05-16 00:45:12 +00001655
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001656 SPCache[Method->getCanonicalDecl()].reset(SP);
Guy Benyei11169dd2012-12-18 14:30:41 +00001657
1658 return SP;
1659}
1660
Eric Christophere7b87e52014-10-26 23:40:33 +00001661void CGDebugInfo::CollectCXXMemberFunctions(
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001662 const CXXRecordDecl *RD, llvm::DIFile *Unit,
1663 SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001664
1665 // Since we want more than just the individual member decls if we
1666 // have templated functions iterate over every declaration to gather
1667 // the functions.
Eric Christophere7b87e52014-10-26 23:40:33 +00001668 for (const auto *I : RD->decls()) {
David Blaikiefd580722014-10-06 05:18:55 +00001669 const auto *Method = dyn_cast<CXXMethodDecl>(I);
1670 // If the member is implicit, don't add it to the member list. This avoids
1671 // the member being added to type units by LLVM, while still allowing it
1672 // to be emitted into the type declaration/reference inside the compile
1673 // unit.
Paul Robinson6a7511b2015-06-25 17:50:43 +00001674 // Ditto 'nodebug' methods, for consistency with CodeGenFunction.cpp.
David Blaikie6dddfe32014-10-06 05:52:27 +00001675 // FIXME: Handle Using(Shadow?)Decls here to create
1676 // DW_TAG_imported_declarations inside the class for base decls brought into
1677 // derived classes. GDB doesn't seem to notice/leverage these when I tried
1678 // it, so I'm not rushing to fix this. (GCC seems to produce them, if
1679 // referenced)
Paul Robinson6a7511b2015-06-25 17:50:43 +00001680 if (!Method || Method->isImplicit() || Method->hasAttr<NoDebugAttr>())
David Blaikiefd580722014-10-06 05:18:55 +00001681 continue;
David Blaikie42edade2014-11-11 20:44:45 +00001682
Simon Pilgrim7e38f0c2019-10-07 16:42:25 +00001683 if (Method->getType()->castAs<FunctionProtoType>()->getContainedAutoType())
David Blaikie42edade2014-11-11 20:44:45 +00001684 continue;
1685
David Blaikiefd580722014-10-06 05:18:55 +00001686 // Reuse the existing member function declaration if it exists.
1687 // It may be associated with the declaration of the type & should be
1688 // reused as we're building the definition.
1689 //
1690 // This situation can arise in the vtable-based debug info reduction where
1691 // implicit members are emitted in a non-vtable TU.
1692 auto MI = SPCache.find(Method->getCanonicalDecl());
1693 EltTys.push_back(MI == SPCache.end()
1694 ? CreateCXXMemberFunction(Method, Unit, RecordTy)
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001695 : static_cast<llvm::Metadata *>(MI->second));
Guy Benyei11169dd2012-12-18 14:30:41 +00001696 }
Eric Christopherb2a008c2013-05-16 00:45:12 +00001697}
Guy Benyei11169dd2012-12-18 14:30:41 +00001698
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001699void CGDebugInfo::CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile *Unit,
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001700 SmallVectorImpl<llvm::Metadata *> &EltTys,
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001701 llvm::DIType *RecordTy) {
Bob Haarmandff36732016-10-25 22:19:32 +00001702 llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> SeenTypes;
1703 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->bases(), SeenTypes,
1704 llvm::DINode::FlagZero);
Eric Christopherb2a008c2013-05-16 00:45:12 +00001705
Bob Haarmandff36732016-10-25 22:19:32 +00001706 // If we are generating CodeView debug info, we also need to emit records for
1707 // indirect virtual base classes.
1708 if (CGM.getCodeGenOpts().EmitCodeView) {
1709 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->vbases(), SeenTypes,
1710 llvm::DINode::FlagIndirectVirtualBase);
1711 }
1712}
1713
1714void CGDebugInfo::CollectCXXBasesAux(
1715 const CXXRecordDecl *RD, llvm::DIFile *Unit,
1716 SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy,
1717 const CXXRecordDecl::base_class_const_range &Bases,
1718 llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> &SeenTypes,
1719 llvm::DINode::DIFlags StartingFlags) {
1720 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1721 for (const auto &BI : Bases) {
David Majnemer58ed0f32016-07-17 00:39:12 +00001722 const auto *Base =
Simon Pilgrim1cd399c2019-10-03 11:22:48 +00001723 cast<CXXRecordDecl>(BI.getType()->castAs<RecordType>()->getDecl());
Bob Haarmandff36732016-10-25 22:19:32 +00001724 if (!SeenTypes.insert(Base).second)
1725 continue;
1726 auto *BaseTy = getOrCreateType(BI.getType(), Unit);
1727 llvm::DINode::DIFlags BFlags = StartingFlags;
1728 uint64_t BaseOffset;
Brock Wyma3db2b102018-05-14 21:21:22 +00001729 uint32_t VBPtrOffset = 0;
Eric Christopherb2a008c2013-05-16 00:45:12 +00001730
Aaron Ballman574705e2014-03-13 15:41:46 +00001731 if (BI.isVirtual()) {
Reid Klecknerd3b23d62014-08-07 21:29:25 +00001732 if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1733 // virtual base offset offset is -ve. The code generator emits dwarf
1734 // expression where it expects +ve number.
Eric Christophere7b87e52014-10-26 23:40:33 +00001735 BaseOffset = 0 - CGM.getItaniumVTableContext()
1736 .getVirtualBaseOffsetOffset(RD, Base)
1737 .getQuantity();
Reid Klecknerd3b23d62014-08-07 21:29:25 +00001738 } else {
1739 // In the MS ABI, store the vbtable offset, which is analogous to the
1740 // vbase offset offset in Itanium.
1741 BaseOffset =
1742 4 * CGM.getMicrosoftVTableContext().getVBTableIndex(RD, Base);
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00001743 VBPtrOffset = CGM.getContext()
1744 .getASTRecordLayout(RD)
1745 .getVBPtrOffset()
1746 .getQuantity();
Reid Klecknerd3b23d62014-08-07 21:29:25 +00001747 }
Bob Haarmandff36732016-10-25 22:19:32 +00001748 BFlags |= llvm::DINode::FlagVirtual;
Guy Benyei11169dd2012-12-18 14:30:41 +00001749 } else
1750 BaseOffset = CGM.getContext().toBits(RL.getBaseClassOffset(Base));
1751 // FIXME: Inconsistent units for BaseOffset. It is in bytes when
1752 // BI->isVirtual() and bits when not.
Eric Christopherb2a008c2013-05-16 00:45:12 +00001753
Adrian Prantl21361fb2014-08-29 22:44:27 +00001754 BFlags |= getAccessFlag(BI.getAccessSpecifier(), RD);
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00001755 llvm::DIType *DTy = DBuilder.createInheritance(RecordTy, BaseTy, BaseOffset,
1756 VBPtrOffset, BFlags);
Guy Benyei11169dd2012-12-18 14:30:41 +00001757 EltTys.push_back(DTy);
1758 }
1759}
1760
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001761llvm::DINodeArray
Eric Christophere7b87e52014-10-26 23:40:33 +00001762CGDebugInfo::CollectTemplateParams(const TemplateParameterList *TPList,
1763 ArrayRef<TemplateArgument> TAList,
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001764 llvm::DIFile *Unit) {
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001765 SmallVector<llvm::Metadata *, 16> TemplateParams;
Guy Benyei11169dd2012-12-18 14:30:41 +00001766 for (unsigned i = 0, e = TAList.size(); i != e; ++i) {
1767 const TemplateArgument &TA = TAList[i];
David Blaikie47c11502013-06-22 18:59:18 +00001768 StringRef Name;
1769 if (TPList)
1770 Name = TPList->getParam(i)->getName();
David Blaikie38079fd2013-05-10 21:53:14 +00001771 switch (TA.getKind()) {
1772 case TemplateArgument::Type: {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001773 llvm::DIType *TTy = getOrCreateType(TA.getAsType(), Unit);
Duncan P. N. Exon Smithdadc2b62015-04-21 18:43:54 +00001774 TemplateParams.push_back(
1775 DBuilder.createTemplateTypeParameter(TheCU, Name, TTy));
David Blaikie38079fd2013-05-10 21:53:14 +00001776 } break;
1777 case TemplateArgument::Integral: {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001778 llvm::DIType *TTy = getOrCreateType(TA.getIntegralType(), Unit);
Duncan P. N. Exon Smithdadc2b62015-04-21 18:43:54 +00001779 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1780 TheCU, Name, TTy,
1781 llvm::ConstantInt::get(CGM.getLLVMContext(), TA.getAsIntegral())));
David Blaikie38079fd2013-05-10 21:53:14 +00001782 } break;
1783 case TemplateArgument::Declaration: {
1784 const ValueDecl *D = TA.getAsDecl();
David Blaikieb5c7e6a2014-10-18 02:21:26 +00001785 QualType T = TA.getParamTypeForDecl().getDesugaredType(CGM.getContext());
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001786 llvm::DIType *TTy = getOrCreateType(T, Unit);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001787 llvm::Constant *V = nullptr;
Michael Liao982cbb62019-03-06 21:16:27 +00001788 // Skip retrieve the value if that template parameter has cuda device
1789 // attribute, i.e. that value is not available at the host side.
1790 if (!CGM.getLangOpts().CUDA || CGM.getLangOpts().CUDAIsDevice ||
1791 !D->hasAttr<CUDADeviceAttr>()) {
1792 const CXXMethodDecl *MD;
1793 // Variable pointer template parameters have a value that is the address
1794 // of the variable.
1795 if (const auto *VD = dyn_cast<VarDecl>(D))
1796 V = CGM.GetAddrOfGlobalVar(VD);
1797 // Member function pointers have special support for building them,
1798 // though this is currently unsupported in LLVM CodeGen.
1799 else if ((MD = dyn_cast<CXXMethodDecl>(D)) && MD->isInstance())
1800 V = CGM.getCXXABI().EmitMemberFunctionPointer(MD);
1801 else if (const auto *FD = dyn_cast<FunctionDecl>(D))
1802 V = CGM.GetAddrOfFunction(FD);
1803 // Member data pointers have special handling too to compute the fixed
1804 // offset within the object.
1805 else if (const auto *MPT =
1806 dyn_cast<MemberPointerType>(T.getTypePtr())) {
1807 // These five lines (& possibly the above member function pointer
1808 // handling) might be able to be refactored to use similar code in
1809 // CodeGenModule::getMemberPointerConstant
1810 uint64_t fieldOffset = CGM.getContext().getFieldOffset(D);
1811 CharUnits chars =
1812 CGM.getContext().toCharUnitsFromBits((int64_t)fieldOffset);
1813 V = CGM.getCXXABI().EmitMemberDataPointer(MPT, chars);
1814 }
Simon Pilgrimcfee2ef2019-10-16 10:38:49 +00001815 assert(V && "Failed to find template parameter pointer");
Michael Liao982cbb62019-03-06 21:16:27 +00001816 V = V->stripPointerCasts();
David Blaikie38079fd2013-05-10 21:53:14 +00001817 }
Duncan P. N. Exon Smithdadc2b62015-04-21 18:43:54 +00001818 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
Michael Liao982cbb62019-03-06 21:16:27 +00001819 TheCU, Name, TTy, cast_or_null<llvm::Constant>(V)));
David Blaikie38079fd2013-05-10 21:53:14 +00001820 } break;
1821 case TemplateArgument::NullPtr: {
1822 QualType T = TA.getNullPtrType();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001823 llvm::DIType *TTy = getOrCreateType(T, Unit);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001824 llvm::Constant *V = nullptr;
David Blaikie38079fd2013-05-10 21:53:14 +00001825 // Special case member data pointer null values since they're actually -1
1826 // instead of zero.
David Majnemer58ed0f32016-07-17 00:39:12 +00001827 if (const auto *MPT = dyn_cast<MemberPointerType>(T.getTypePtr()))
David Blaikie38079fd2013-05-10 21:53:14 +00001828 // But treat member function pointers as simple zero integers because
1829 // it's easier than having a special case in LLVM's CodeGen. If LLVM
1830 // CodeGen grows handling for values of non-null member function
1831 // pointers then perhaps we could remove this special case and rely on
1832 // EmitNullMemberPointer for member function pointers.
1833 if (MPT->isMemberDataPointer())
1834 V = CGM.getCXXABI().EmitNullMemberPointer(MPT);
1835 if (!V)
1836 V = llvm::ConstantInt::get(CGM.Int8Ty, 0);
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00001837 TemplateParams.push_back(
1838 DBuilder.createTemplateValueParameter(TheCU, Name, TTy, V));
David Blaikie38079fd2013-05-10 21:53:14 +00001839 } break;
Duncan P. N. Exon Smithdadc2b62015-04-21 18:43:54 +00001840 case TemplateArgument::Template:
1841 TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00001842 TheCU, Name, nullptr,
Duncan P. N. Exon Smithdadc2b62015-04-21 18:43:54 +00001843 TA.getAsTemplate().getAsTemplateDecl()->getQualifiedNameAsString()));
1844 break;
1845 case TemplateArgument::Pack:
1846 TemplateParams.push_back(DBuilder.createTemplateParameterPack(
1847 TheCU, Name, nullptr,
1848 CollectTemplateParams(nullptr, TA.getPackAsArray(), Unit)));
1849 break;
David Majnemer5559d472013-08-24 08:21:10 +00001850 case TemplateArgument::Expression: {
1851 const Expr *E = TA.getAsExpr();
1852 QualType T = E->getType();
David Majnemer922ad9f2014-10-24 19:49:04 +00001853 if (E->isGLValue())
1854 T = CGM.getContext().getLValueReferenceType(T);
John McCallde0fe072017-08-15 21:42:52 +00001855 llvm::Constant *V = ConstantEmitter(CGM).emitAbstract(E, T);
David Majnemer5559d472013-08-24 08:21:10 +00001856 assert(V && "Expression in template argument isn't constant");
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001857 llvm::DIType *TTy = getOrCreateType(T, Unit);
Duncan P. N. Exon Smithdadc2b62015-04-21 18:43:54 +00001858 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
David Majnemer58ed0f32016-07-17 00:39:12 +00001859 TheCU, Name, TTy, V->stripPointerCasts()));
David Majnemer5559d472013-08-24 08:21:10 +00001860 } break;
David Blaikie2b93c542013-05-10 23:36:06 +00001861 // And the following should never occur:
David Blaikie38079fd2013-05-10 21:53:14 +00001862 case TemplateArgument::TemplateExpansion:
David Blaikie38079fd2013-05-10 21:53:14 +00001863 case TemplateArgument::Null:
1864 llvm_unreachable(
1865 "These argument types shouldn't exist in concrete types");
Guy Benyei11169dd2012-12-18 14:30:41 +00001866 }
1867 }
1868 return DBuilder.getOrCreateArray(TemplateParams);
1869}
1870
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001871llvm::DINodeArray
Duncan P. N. Exon Smith8e47da42015-04-21 20:07:29 +00001872CGDebugInfo::CollectFunctionTemplateParams(const FunctionDecl *FD,
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001873 llvm::DIFile *Unit) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001874 if (FD->getTemplatedKind() ==
1875 FunctionDecl::TK_FunctionTemplateSpecialization) {
Eric Christophere7b87e52014-10-26 23:40:33 +00001876 const TemplateParameterList *TList = FD->getTemplateSpecializationInfo()
1877 ->getTemplate()
1878 ->getTemplateParameters();
David Blaikie47c11502013-06-22 18:59:18 +00001879 return CollectTemplateParams(
1880 TList, FD->getTemplateSpecializationArgs()->asArray(), Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +00001881 }
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001882 return llvm::DINodeArray();
Guy Benyei11169dd2012-12-18 14:30:41 +00001883}
1884
Matthew Voss20165362018-10-03 18:45:04 +00001885llvm::DINodeArray CGDebugInfo::CollectVarTemplateParams(const VarDecl *VL,
Reid Kleckner2dbd5d82019-05-02 17:45:54 +00001886 llvm::DIFile *Unit) {
1887 // Always get the full list of parameters, not just the ones from the
1888 // specialization. A partial specialization may have fewer parameters than
1889 // there are arguments.
1890 auto *TS = dyn_cast<VarTemplateSpecializationDecl>(VL);
1891 if (!TS)
1892 return llvm::DINodeArray();
1893 VarTemplateDecl *T = TS->getSpecializedTemplate();
1894 const TemplateParameterList *TList = T->getTemplateParameters();
1895 auto TA = TS->getTemplateArgs().asArray();
1896 return CollectTemplateParams(TList, TA, Unit);
Matthew Voss20165362018-10-03 18:45:04 +00001897}
1898
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001899llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(
1900 const ClassTemplateSpecializationDecl *TSpecial, llvm::DIFile *Unit) {
Reid Kleckner2dbd5d82019-05-02 17:45:54 +00001901 // Always get the full list of parameters, not just the ones from the
1902 // specialization. A partial specialization may have fewer parameters than
1903 // there are arguments.
Adrian Prantl649f0302014-04-17 01:04:01 +00001904 TemplateParameterList *TPList =
Eric Christophere7b87e52014-10-26 23:40:33 +00001905 TSpecial->getSpecializedTemplate()->getTemplateParameters();
Adrian Prantl2c92e9c2014-04-17 00:30:48 +00001906 const TemplateArgumentList &TAList = TSpecial->getTemplateArgs();
David Blaikie47c11502013-06-22 18:59:18 +00001907 return CollectTemplateParams(TPList, TAList.asArray(), Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +00001908}
1909
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001910llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
Duncan P. N. Exon Smithb7470232015-04-15 23:48:50 +00001911 if (VTablePtrType)
Guy Benyei11169dd2012-12-18 14:30:41 +00001912 return VTablePtrType;
1913
1914 ASTContext &Context = CGM.getContext();
1915
1916 /* Function type */
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00001917 llvm::Metadata *STy = getOrCreateType(Context.IntTy, Unit);
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001918 llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);
Eric Christopher28a6db52015-10-15 06:56:08 +00001919 llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements);
Guy Benyei11169dd2012-12-18 14:30:41 +00001920 unsigned Size = Context.getTypeSize(Context.VoidPtrTy);
Konstantin Zhuravlyovd1ba16e2017-03-08 23:56:48 +00001921 unsigned VtblPtrAddressSpace = CGM.getTarget().getVtblPtrAddressSpace();
1922 Optional<unsigned> DWARFAddressSpace =
1923 CGM.getTarget().getDWARFAddressSpace(VtblPtrAddressSpace);
1924
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00001925 llvm::DIType *vtbl_ptr_type = DBuilder.createPointerType(
1926 SubTy, Size, 0, DWARFAddressSpace, "__vtbl_ptr_type");
Guy Benyei11169dd2012-12-18 14:30:41 +00001927 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
1928 return VTablePtrType;
1929}
1930
Guy Benyei11169dd2012-12-18 14:30:41 +00001931StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) {
Benjamin Kramer1b18a5e2013-09-09 16:39:06 +00001932 // Copy the gdb compatible name on the side and use its reference.
1933 return internString("_vptr$", RD->getNameAsString());
Guy Benyei11169dd2012-12-18 14:30:41 +00001934}
1935
Reid Kleckner105c5652019-04-24 22:45:44 +00001936StringRef CGDebugInfo::getDynamicInitializerName(const VarDecl *VD,
1937 DynamicInitKind StubKind,
1938 llvm::Function *InitFn) {
1939 // If we're not emitting codeview, use the mangled name. For Itanium, this is
1940 // arbitrary.
Alexandre Ganeacaf31662019-11-15 16:21:17 -05001941 if (!CGM.getCodeGenOpts().EmitCodeView)
Reid Kleckner105c5652019-04-24 22:45:44 +00001942 return InitFn->getName();
1943
1944 // Print the normal qualified name for the variable, then break off the last
1945 // NNS, and add the appropriate other text. Clang always prints the global
1946 // variable name without template arguments, so we can use rsplit("::") and
1947 // then recombine the pieces.
1948 SmallString<128> QualifiedGV;
1949 StringRef Quals;
1950 StringRef GVName;
1951 {
1952 llvm::raw_svector_ostream OS(QualifiedGV);
1953 VD->printQualifiedName(OS, getPrintingPolicy());
1954 std::tie(Quals, GVName) = OS.str().rsplit("::");
1955 if (GVName.empty())
1956 std::swap(Quals, GVName);
1957 }
1958
1959 SmallString<128> InitName;
1960 llvm::raw_svector_ostream OS(InitName);
1961 if (!Quals.empty())
1962 OS << Quals << "::";
1963
1964 switch (StubKind) {
1965 case DynamicInitKind::NoStub:
1966 llvm_unreachable("not an initializer");
1967 case DynamicInitKind::Initializer:
1968 OS << "`dynamic initializer for '";
1969 break;
1970 case DynamicInitKind::AtExit:
1971 OS << "`dynamic atexit destructor for '";
1972 break;
1973 }
1974
1975 OS << GVName;
1976
1977 // Add any template specialization args.
1978 if (const auto *VTpl = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
1979 printTemplateArgumentList(OS, VTpl->getTemplateArgs().asArray(),
1980 getPrintingPolicy());
1981 }
1982
1983 OS << '\'';
1984
1985 return internString(OS.str());
1986}
1987
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00001988void CGDebugInfo::CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile *Unit,
Reid Klecknerdc124992016-08-31 16:11:43 +00001989 SmallVectorImpl<llvm::Metadata *> &EltTys,
1990 llvm::DICompositeType *RecordTy) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001991 // If this class is not dynamic then there is not any vtable info to collect.
1992 if (!RD->isDynamicClass())
1993 return;
1994
Reid Kleckner59812422016-08-31 20:35:01 +00001995 // Don't emit any vtable shape or vptr info if this class doesn't have an
1996 // extendable vfptr. This can happen if the class doesn't have virtual
1997 // methods, or in the MS ABI if those virtual methods only come from virtually
1998 // inherited bases.
1999 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2000 if (!RL.hasExtendableVFPtr())
2001 return;
2002
Reid Klecknerdc124992016-08-31 16:11:43 +00002003 // CodeView needs to know how large the vtable of every dynamic class is, so
2004 // emit a special named pointer type into the element list. The vptr type
2005 // points to this type as well.
2006 llvm::DIType *VPtrTy = nullptr;
2007 bool NeedVTableShape = CGM.getCodeGenOpts().EmitCodeView &&
2008 CGM.getTarget().getCXXABI().isMicrosoft();
2009 if (NeedVTableShape) {
2010 uint64_t PtrWidth =
2011 CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
2012 const VTableLayout &VFTLayout =
2013 CGM.getMicrosoftVTableContext().getVFTableLayout(RD, CharUnits::Zero());
2014 unsigned VSlotCount =
Peter Collingbournee53683f2016-09-08 01:14:39 +00002015 VFTLayout.vtable_components().size() - CGM.getLangOpts().RTTIData;
Reid Klecknerdc124992016-08-31 16:11:43 +00002016 unsigned VTableWidth = PtrWidth * VSlotCount;
Konstantin Zhuravlyovd1ba16e2017-03-08 23:56:48 +00002017 unsigned VtblPtrAddressSpace = CGM.getTarget().getVtblPtrAddressSpace();
2018 Optional<unsigned> DWARFAddressSpace =
2019 CGM.getTarget().getDWARFAddressSpace(VtblPtrAddressSpace);
Reid Klecknerdc124992016-08-31 16:11:43 +00002020
2021 // Create a very wide void* type and insert it directly in the element list.
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00002022 llvm::DIType *VTableType = DBuilder.createPointerType(
2023 nullptr, VTableWidth, 0, DWARFAddressSpace, "__vtbl_ptr_type");
Reid Klecknerdc124992016-08-31 16:11:43 +00002024 EltTys.push_back(VTableType);
2025
2026 // The vptr is a pointer to this special vtable type.
2027 VPtrTy = DBuilder.createPointerType(VTableType, PtrWidth);
2028 }
2029
2030 // If there is a primary base then the artificial vptr member lives there.
Reid Klecknerdc124992016-08-31 16:11:43 +00002031 if (RL.getPrimaryBase())
2032 return;
2033
2034 if (!VPtrTy)
2035 VPtrTy = getOrCreateVTablePtrType(Unit);
2036
Guy Benyei11169dd2012-12-18 14:30:41 +00002037 unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00002038 llvm::DIType *VPtrMember =
2039 DBuilder.createMemberType(Unit, getVTableName(RD), Unit, 0, Size, 0, 0,
2040 llvm::DINode::FlagArtificial, VPtrTy);
Reid Klecknerdc124992016-08-31 16:11:43 +00002041 EltTys.push_back(VPtrMember);
Guy Benyei11169dd2012-12-18 14:30:41 +00002042}
2043
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002044llvm::DIType *CGDebugInfo::getOrCreateRecordType(QualType RTy,
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00002045 SourceLocation Loc) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00002046 assert(DebugKind >= codegenoptions::LimitedDebugInfo);
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002047 llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
Guy Benyei11169dd2012-12-18 14:30:41 +00002048 return T;
2049}
2050
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002051llvm::DIType *CGDebugInfo::getOrCreateInterfaceType(QualType D,
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00002052 SourceLocation Loc) {
Adrian Prantlad9a195e2015-08-27 21:21:19 +00002053 return getOrCreateStandaloneType(D, Loc);
2054}
2055
2056llvm::DIType *CGDebugInfo::getOrCreateStandaloneType(QualType D,
2057 SourceLocation Loc) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00002058 assert(DebugKind >= codegenoptions::LimitedDebugInfo);
Adrian Prantlad9a195e2015-08-27 21:21:19 +00002059 assert(!D.isNull() && "null type");
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002060 llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc));
Adrian Prantlad9a195e2015-08-27 21:21:19 +00002061 assert(T && "could not create debug info for type");
Adrian Prantl3a884fa2015-08-27 22:56:46 +00002062
Adrian Prantl73409ce2013-03-11 18:33:46 +00002063 RetainedTypes.push_back(D.getAsOpaquePtr());
Guy Benyei11169dd2012-12-18 14:30:41 +00002064 return T;
2065}
2066
Amy Huang0d0334f2019-04-12 20:25:30 +00002067void CGDebugInfo::addHeapAllocSiteMetadata(llvm::Instruction *CI,
2068 QualType D,
2069 SourceLocation Loc) {
2070 llvm::MDNode *node;
2071 if (D.getTypePtr()->isVoidPointerType()) {
2072 node = llvm::MDNode::get(CGM.getLLVMContext(), None);
2073 } else {
2074 QualType PointeeTy = D.getTypePtr()->getPointeeType();
2075 node = getOrCreateType(PointeeTy, getOrCreateFile(Loc));
2076 }
Amy Huangfc79ab92019-04-23 21:12:58 +00002077
Amy Huang0d0334f2019-04-12 20:25:30 +00002078 CI->setMetadata("heapallocsite", node);
2079}
2080
David Blaikie483a9da2014-05-06 18:35:21 +00002081void CGDebugInfo::completeType(const EnumDecl *ED) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00002082 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
David Blaikie483a9da2014-05-06 18:35:21 +00002083 return;
2084 QualType Ty = CGM.getContext().getEnumType(ED);
Eric Christophere7b87e52014-10-26 23:40:33 +00002085 void *TyPtr = Ty.getAsOpaquePtr();
David Blaikie483a9da2014-05-06 18:35:21 +00002086 auto I = TypeCache.find(TyPtr);
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002087 if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())
David Blaikie483a9da2014-05-06 18:35:21 +00002088 return;
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002089 llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<EnumType>());
Duncan P. N. Exon Smith4caa7f22015-04-16 01:00:56 +00002090 assert(!Res->isForwardDecl());
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002091 TypeCache[TyPtr].reset(Res);
David Blaikie483a9da2014-05-06 18:35:21 +00002092}
2093
David Blaikieb2e86eb2013-08-15 20:49:17 +00002094void CGDebugInfo::completeType(const RecordDecl *RD) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00002095 if (DebugKind > codegenoptions::LimitedDebugInfo ||
David Blaikieb2e86eb2013-08-15 20:49:17 +00002096 !CGM.getLangOpts().CPlusPlus)
2097 completeRequiredType(RD);
2098}
2099
David Blaikieb11c8732017-01-30 06:36:08 +00002100/// Return true if the class or any of its methods are marked dllimport.
2101static bool isClassOrMethodDLLImport(const CXXRecordDecl *RD) {
2102 if (RD->hasAttr<DLLImportAttr>())
2103 return true;
2104 for (const CXXMethodDecl *MD : RD->methods())
2105 if (MD->hasAttr<DLLImportAttr>())
2106 return true;
2107 return false;
2108}
2109
Adrian Prantla43acdc2017-07-24 23:48:51 +00002110/// Does a type definition exist in an imported clang module?
2111static bool isDefinedInClangModule(const RecordDecl *RD) {
2112 // Only definitions that where imported from an AST file come from a module.
2113 if (!RD || !RD->isFromASTFile())
2114 return false;
2115 // Anonymous entities cannot be addressed. Treat them as not from module.
2116 if (!RD->isExternallyVisible() && RD->getName().empty())
2117 return false;
2118 if (auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) {
2119 if (!CXXDecl->isCompleteDefinition())
2120 return false;
Adrian Prantlba6fdc52018-10-24 00:06:02 +00002121 // Check wether RD is a template.
Adrian Prantla43acdc2017-07-24 23:48:51 +00002122 auto TemplateKind = CXXDecl->getTemplateSpecializationKind();
2123 if (TemplateKind != TSK_Undeclared) {
Adrian Prantlba6fdc52018-10-24 00:06:02 +00002124 // Unfortunately getOwningModule() isn't accurate enough to find the
2125 // owning module of a ClassTemplateSpecializationDecl that is inside a
2126 // namespace spanning multiple modules.
2127 bool Explicit = false;
2128 if (auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(CXXDecl))
2129 Explicit = TD->isExplicitInstantiationOrSpecialization();
2130 if (!Explicit && CXXDecl->getEnclosingNamespaceContext())
2131 return false;
Adrian Prantla43acdc2017-07-24 23:48:51 +00002132 // This is a template, check the origin of the first member.
2133 if (CXXDecl->field_begin() == CXXDecl->field_end())
2134 return TemplateKind == TSK_ExplicitInstantiationDeclaration;
2135 if (!CXXDecl->field_begin()->isFromASTFile())
2136 return false;
2137 }
2138 }
2139 return true;
2140}
2141
David Blaikie6943dea2013-08-20 01:28:15 +00002142void CGDebugInfo::completeClassData(const RecordDecl *RD) {
David Blaikieb11c8732017-01-30 06:36:08 +00002143 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
2144 if (CXXRD->isDynamicClass() &&
2145 CGM.getVTableLinkage(CXXRD) ==
2146 llvm::GlobalValue::AvailableExternallyLinkage &&
2147 !isClassOrMethodDLLImport(CXXRD))
2148 return;
Adrian Prantla43acdc2017-07-24 23:48:51 +00002149
2150 if (DebugTypeExtRefs && isDefinedInClangModule(RD->getDefinition()))
2151 return;
2152
David Blaikieb11c8732017-01-30 06:36:08 +00002153 completeClass(RD);
2154}
2155
2156void CGDebugInfo::completeClass(const RecordDecl *RD) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00002157 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
Michael Gottesman349542b2013-08-19 18:46:16 +00002158 return;
David Blaikie6943dea2013-08-20 01:28:15 +00002159 QualType Ty = CGM.getContext().getRecordType(RD);
Eric Christophere7b87e52014-10-26 23:40:33 +00002160 void *TyPtr = Ty.getAsOpaquePtr();
David Blaikieef8a9512014-05-05 23:23:53 +00002161 auto I = TypeCache.find(TyPtr);
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002162 if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
David Blaikieb2e86eb2013-08-15 20:49:17 +00002163 return;
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002164 llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<RecordType>());
Duncan P. N. Exon Smith4caa7f22015-04-16 01:00:56 +00002165 assert(!Res->isForwardDecl());
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002166 TypeCache[TyPtr].reset(Res);
David Blaikieb2e86eb2013-08-15 20:49:17 +00002167}
2168
David Blaikie0e716b42014-03-03 23:48:23 +00002169static bool hasExplicitMemberDefinition(CXXRecordDecl::method_iterator I,
2170 CXXRecordDecl::method_iterator End) {
David Majnemer58ed0f32016-07-17 00:39:12 +00002171 for (CXXMethodDecl *MD : llvm::make_range(I, End))
2172 if (FunctionDecl *Tmpl = MD->getInstantiatedFromMemberFunction())
David Blaikief7f21852014-03-04 03:08:14 +00002173 if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&
David Majnemer58ed0f32016-07-17 00:39:12 +00002174 !MD->getMemberSpecializationInfo()->isExplicitSpecialization())
David Blaikie0e716b42014-03-03 23:48:23 +00002175 return true;
2176 return false;
2177}
2178
Benjamin Kramer8c305922016-02-02 11:06:51 +00002179static bool shouldOmitDefinition(codegenoptions::DebugInfoKind DebugKind,
2180 bool DebugTypeExtRefs, const RecordDecl *RD,
David Blaikie0e716b42014-03-03 23:48:23 +00002181 const LangOptions &LangOpts) {
Adrian Prantl88d79172016-04-26 21:58:18 +00002182 if (DebugTypeExtRefs && isDefinedInClangModule(RD->getDefinition()))
Adrian Prantl43e00812016-01-19 23:42:53 +00002183 return true;
Adrian Prantl5c8bd882015-09-11 17:23:08 +00002184
David Blaikie1ac9c982017-04-11 21:13:37 +00002185 if (auto *ES = RD->getASTContext().getExternalSource())
2186 if (ES->hasExternalDefinitions(RD) == ExternalASTSource::EK_Always)
2187 return true;
2188
Benjamin Kramer8c305922016-02-02 11:06:51 +00002189 if (DebugKind > codegenoptions::LimitedDebugInfo)
David Blaikie0e716b42014-03-03 23:48:23 +00002190 return false;
2191
2192 if (!LangOpts.CPlusPlus)
2193 return false;
2194
2195 if (!RD->isCompleteDefinitionRequired())
2196 return true;
2197
David Majnemer58ed0f32016-07-17 00:39:12 +00002198 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
David Blaikie0e716b42014-03-03 23:48:23 +00002199
2200 if (!CXXDecl)
2201 return false;
2202
Adrian McCarthy99242982016-08-16 22:11:18 +00002203 // Only emit complete debug info for a dynamic class when its vtable is
2204 // emitted. However, Microsoft debuggers don't resolve type information
Reid Klecknerc9404e12016-09-09 16:27:04 +00002205 // across DLL boundaries, so skip this optimization if the class or any of its
2206 // methods are marked dllimport. This isn't a complete solution, since objects
2207 // without any dllimport methods can be used in one DLL and constructed in
2208 // another, but it is the current behavior of LimitedDebugInfo.
Adrian McCarthy99242982016-08-16 22:11:18 +00002209 if (CXXDecl->hasDefinition() && CXXDecl->isDynamicClass() &&
Reid Klecknerc9404e12016-09-09 16:27:04 +00002210 !isClassOrMethodDLLImport(CXXDecl))
David Blaikie0e716b42014-03-03 23:48:23 +00002211 return true;
2212
2213 TemplateSpecializationKind Spec = TSK_Undeclared;
David Majnemer58ed0f32016-07-17 00:39:12 +00002214 if (const auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
David Blaikie0e716b42014-03-03 23:48:23 +00002215 Spec = SD->getSpecializationKind();
2216
2217 if (Spec == TSK_ExplicitInstantiationDeclaration &&
2218 hasExplicitMemberDefinition(CXXDecl->method_begin(),
2219 CXXDecl->method_end()))
2220 return true;
2221
2222 return false;
2223}
2224
Reid Kleckner6c7b1c62016-09-13 00:01:23 +00002225void CGDebugInfo::completeRequiredType(const RecordDecl *RD) {
2226 if (shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD, CGM.getLangOpts()))
2227 return;
2228
2229 QualType Ty = CGM.getContext().getRecordType(RD);
2230 llvm::DIType *T = getTypeOrNull(Ty);
2231 if (T && T->isForwardDecl())
2232 completeClassData(RD);
2233}
2234
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002235llvm::DIType *CGDebugInfo::CreateType(const RecordType *Ty) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002236 RecordDecl *RD = Ty->getDecl();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002237 llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(QualType(Ty, 0)));
Adrian Prantl5c8bd882015-09-11 17:23:08 +00002238 if (T || shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD,
2239 CGM.getLangOpts())) {
David Blaikie3b1cc9b2013-09-06 06:45:04 +00002240 if (!T)
Adrian Prantl6ec370a2015-09-10 18:39:45 +00002241 T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));
David Blaikie3b1cc9b2013-09-06 06:45:04 +00002242 return T;
David Blaikiee36464c2013-06-05 05:32:23 +00002243 }
Guy Benyei11169dd2012-12-18 14:30:41 +00002244
David Blaikieb2e86eb2013-08-15 20:49:17 +00002245 return CreateTypeDefinition(Ty);
2246}
2247
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002248llvm::DIType *CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) {
David Blaikieb2e86eb2013-08-15 20:49:17 +00002249 RecordDecl *RD = Ty->getDecl();
2250
Guy Benyei11169dd2012-12-18 14:30:41 +00002251 // Get overall information about the record type for the debug info.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002252 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
Guy Benyei11169dd2012-12-18 14:30:41 +00002253
2254 // Records and classes and unions can all be recursive. To handle them, we
2255 // first generate a debug descriptor for the struct as a forward declaration.
2256 // Then (if it is a definition) we go through and get debug info for all of
2257 // its members. Finally, we create a descriptor for the complete type (which
2258 // may refer to the forward decl if the struct is recursive) and replace all
2259 // uses of the forward declaration with the final definition.
Duncan P. N. Exon Smithbd210e62015-07-24 20:34:41 +00002260 llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty, DefUnit);
Guy Benyei11169dd2012-12-18 14:30:41 +00002261
Adrian Prantl5f66bae2015-02-11 17:45:15 +00002262 const RecordDecl *D = RD->getDefinition();
2263 if (!D || !D->isCompleteDefinition())
Guy Benyei11169dd2012-12-18 14:30:41 +00002264 return FwdDecl;
2265
David Majnemer58ed0f32016-07-17 00:39:12 +00002266 if (const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
David Blaikieadfbf992013-08-18 16:55:33 +00002267 CollectContainingType(CXXDecl, FwdDecl);
2268
Guy Benyei11169dd2012-12-18 14:30:41 +00002269 // Push the struct on region stack.
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002270 LexicalBlockStack.emplace_back(&*FwdDecl);
2271 RegionMap[Ty->getDecl()].reset(FwdDecl);
Guy Benyei11169dd2012-12-18 14:30:41 +00002272
Guy Benyei11169dd2012-12-18 14:30:41 +00002273 // Convert all the elements.
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002274 SmallVector<llvm::Metadata *, 16> EltTys;
David Blaikie6943dea2013-08-20 01:28:15 +00002275 // what about nested types?
Guy Benyei11169dd2012-12-18 14:30:41 +00002276
2277 // Note: The split of CXXDecl information here is intentional, the
2278 // gdb tests will depend on a certain ordering at printout. The debug
2279 // information offsets are still correct if we merge them all together
2280 // though.
David Majnemer58ed0f32016-07-17 00:39:12 +00002281 const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
Guy Benyei11169dd2012-12-18 14:30:41 +00002282 if (CXXDecl) {
2283 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
Reid Klecknerdc124992016-08-31 16:11:43 +00002284 CollectVTableInfo(CXXDecl, DefUnit, EltTys, FwdDecl);
Guy Benyei11169dd2012-12-18 14:30:41 +00002285 }
2286
Eric Christopher91a31902013-01-16 01:22:32 +00002287 // Collect data fields (including static variables and any initializers).
Guy Benyei11169dd2012-12-18 14:30:41 +00002288 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
Eric Christopher2df080e2013-10-11 18:16:51 +00002289 if (CXXDecl)
Guy Benyei11169dd2012-12-18 14:30:41 +00002290 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
Guy Benyei11169dd2012-12-18 14:30:41 +00002291
2292 LexicalBlockStack.pop_back();
2293 RegionMap.erase(Ty->getDecl());
2294
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002295 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
Duncan P. N. Exon Smithc8ee63e2014-12-18 00:48:56 +00002296 DBuilder.replaceArrays(FwdDecl, Elements);
Guy Benyei11169dd2012-12-18 14:30:41 +00002297
Adrian Prantl5f66bae2015-02-11 17:45:15 +00002298 if (FwdDecl->isTemporary())
Duncan P. N. Exon Smith4078ad42015-04-16 16:36:45 +00002299 FwdDecl =
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002300 llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
Adrian Prantl5f66bae2015-02-11 17:45:15 +00002301
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002302 RegionMap[Ty->getDecl()].reset(FwdDecl);
Eric Christopher5c7ee8b2013-04-02 22:59:11 +00002303 return FwdDecl;
Guy Benyei11169dd2012-12-18 14:30:41 +00002304}
2305
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002306llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectType *Ty,
2307 llvm::DIFile *Unit) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002308 // Ignore protocols.
2309 return getOrCreateType(Ty->getBaseType(), Unit);
2310}
2311
Manman Rene6be26c2016-09-13 17:25:08 +00002312llvm::DIType *CGDebugInfo::CreateType(const ObjCTypeParamType *Ty,
2313 llvm::DIFile *Unit) {
2314 // Ignore protocols.
2315 SourceLocation Loc = Ty->getDecl()->getLocation();
2316
2317 // Use Typedefs to represent ObjCTypeParamType.
2318 return DBuilder.createTypedef(
2319 getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit),
2320 Ty->getDecl()->getName(), getOrCreateFile(Loc), getLineNumber(Loc),
Sam McCalld27a16e2019-11-18 15:53:22 +01002321 getDeclContextDescriptor(Ty->getDecl()));
Manman Rene6be26c2016-09-13 17:25:08 +00002322}
2323
Adrian Prantlb8fad1a2013-06-07 01:10:45 +00002324/// \return true if Getter has the default name for the property PD.
2325static bool hasDefaultGetterName(const ObjCPropertyDecl *PD,
2326 const ObjCMethodDecl *Getter) {
2327 assert(PD);
2328 if (!Getter)
2329 return true;
2330
2331 assert(Getter->getDeclName().isObjCZeroArgSelector());
2332 return PD->getName() ==
Eric Christophere7b87e52014-10-26 23:40:33 +00002333 Getter->getDeclName().getObjCSelector().getNameForSlot(0);
Adrian Prantlb8fad1a2013-06-07 01:10:45 +00002334}
2335
2336/// \return true if Setter has the default name for the property PD.
2337static bool hasDefaultSetterName(const ObjCPropertyDecl *PD,
2338 const ObjCMethodDecl *Setter) {
2339 assert(PD);
2340 if (!Setter)
2341 return true;
2342
2343 assert(Setter->getDeclName().isObjCOneArgSelector());
Adrian Prantla4ce9062013-06-07 22:29:12 +00002344 return SelectorTable::constructSetterName(PD->getName()) ==
Eric Christophere7b87e52014-10-26 23:40:33 +00002345 Setter->getDeclName().getObjCSelector().getNameForSlot(0);
Adrian Prantlb8fad1a2013-06-07 01:10:45 +00002346}
2347
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002348llvm::DIType *CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
2349 llvm::DIFile *Unit) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002350 ObjCInterfaceDecl *ID = Ty->getDecl();
2351 if (!ID)
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00002352 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00002353
Adrian Prantl50fd1a82016-04-20 23:59:32 +00002354 // Return a forward declaration if this type was imported from a clang module,
2355 // and this is not the compile unit with the implementation of the type (which
2356 // may contain hidden ivars).
2357 if (DebugTypeExtRefs && ID->isFromASTFile() && ID->getDefinition() &&
2358 !ID->getImplementation())
Adrian Prantl5c8bd882015-09-11 17:23:08 +00002359 return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
2360 ID->getName(),
2361 getDeclContextDescriptor(ID), Unit, 0);
2362
Guy Benyei11169dd2012-12-18 14:30:41 +00002363 // Get overall information about the record type for the debug info.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002364 llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation());
Guy Benyei11169dd2012-12-18 14:30:41 +00002365 unsigned Line = getLineNumber(ID->getLocation());
Duncan P. N. Exon Smith798d5652015-04-15 23:19:15 +00002366 auto RuntimeLang =
2367 static_cast<llvm::dwarf::SourceLanguage>(TheCU->getSourceLanguage());
Guy Benyei11169dd2012-12-18 14:30:41 +00002368
2369 // If this is just a forward declaration return a special forward-declaration
2370 // debug type since we won't be able to lay out the entire type.
2371 ObjCInterfaceDecl *Def = ID->getDefinition();
David Blaikieef8a9512014-05-05 23:23:53 +00002372 if (!Def || !Def->getImplementation()) {
Adrian Prantl42ce2d32015-10-01 16:57:02 +00002373 llvm::DIScope *Mod = getParentModuleOrNull(ID);
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002374 llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(
Adrian Prantl42ce2d32015-10-01 16:57:02 +00002375 llvm::dwarf::DW_TAG_structure_type, ID->getName(), Mod ? Mod : TheCU,
2376 DefUnit, Line, RuntimeLang);
David Blaikieef8a9512014-05-05 23:23:53 +00002377 ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit));
Guy Benyei11169dd2012-12-18 14:30:41 +00002378 return FwdDecl;
2379 }
2380
David Blaikieef8a9512014-05-05 23:23:53 +00002381 return CreateTypeDefinition(Ty, Unit);
2382}
2383
Adrian Prantlc4bb47e2015-06-30 17:39:51 +00002384llvm::DIModule *
Adrian Prantl66689202015-09-18 23:01:45 +00002385CGDebugInfo::getOrCreateModuleRef(ExternalASTSource::ASTSourceDescriptor Mod,
2386 bool CreateSkeletonCU) {
Adrian Prantleb66a262015-09-24 16:10:04 +00002387 // Use the Module pointer as the key into the cache. This is a
2388 // nullptr if the "Module" is a PCH, which is safe because we don't
2389 // support chained PCH debug info, so there can only be a single PCH.
2390 const Module *M = Mod.getModuleOrNull();
Adrian Prantl9e8ea352015-09-29 20:44:46 +00002391 auto ModRef = ModuleCache.find(M);
2392 if (ModRef != ModuleCache.end())
2393 return cast<llvm::DIModule>(ModRef->second);
Adrian Prantl2388ead2015-06-30 18:01:05 +00002394
2395 // Macro definitions that were defined with "-D" on the command line.
2396 SmallString<128> ConfigMacros;
2397 {
2398 llvm::raw_svector_ostream OS(ConfigMacros);
2399 const auto &PPOpts = CGM.getPreprocessorOpts();
2400 unsigned I = 0;
Alexander Kornienko2a8c18d2018-04-06 15:14:32 +00002401 // Translate the macro definitions back into a command line.
Adrian Prantl2388ead2015-06-30 18:01:05 +00002402 for (auto &M : PPOpts.Macros) {
2403 if (++I > 1)
2404 OS << " ";
2405 const std::string &Macro = M.first;
2406 bool Undef = M.second;
2407 OS << "\"-" << (Undef ? 'U' : 'D');
2408 for (char c : Macro)
2409 switch (c) {
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00002410 case '\\':
2411 OS << "\\\\";
2412 break;
2413 case '"':
2414 OS << "\\\"";
2415 break;
2416 default:
2417 OS << c;
Adrian Prantl2388ead2015-06-30 18:01:05 +00002418 }
2419 OS << '\"';
Adrian Prantlc4bb47e2015-06-30 17:39:51 +00002420 }
Adrian Prantlc4bb47e2015-06-30 17:39:51 +00002421 }
Adrian Prantl66689202015-09-18 23:01:45 +00002422
Adrian Prantl835e6632015-09-24 16:10:10 +00002423 bool IsRootModule = M ? !M->Parent : true;
Adrian Prantl7b6b9a12019-02-08 23:15:42 +00002424 // When a module name is specified as -fmodule-name, that module gets a
2425 // clang::Module object, but it won't actually be built or imported; it will
2426 // be textual.
Adrian Prantle308e422019-02-15 20:24:26 +00002427 if (CreateSkeletonCU && IsRootModule && Mod.getASTFile().empty() && M)
2428 assert(StringRef(M->Name).startswith(CGM.getLangOpts().ModuleName) &&
Adrian Prantl7b6b9a12019-02-08 23:15:42 +00002429 "clang module without ASTFile must be specified by -fmodule-name");
2430
2431 if (CreateSkeletonCU && IsRootModule && !Mod.getASTFile().empty()) {
Adrian Prantlc96da8f2016-01-22 17:43:43 +00002432 // PCH files don't have a signature field in the control block,
2433 // but LLVM detects skeleton CUs by looking for a non-zero DWO id.
Duncan P. N. Exon Smith60fa2882017-03-13 18:45:08 +00002434 // We use the lower 64 bits for debug info.
2435 uint64_t Signature =
2436 Mod.getSignature()
2437 ? (uint64_t)Mod.getSignature()[1] << 32 | Mod.getSignature()[0]
2438 : ~1ULL;
Adrian Prantl66689202015-09-18 23:01:45 +00002439 llvm::DIBuilder DIB(CGM.getModule());
Amjad Aboudfa9a17e2016-12-14 20:24:40 +00002440 DIB.createCompileUnit(TheCU->getSourceLanguage(),
Scott Lindera2fbcef2018-02-26 17:32:31 +00002441 // TODO: Support "Source" from external AST providers?
Amjad Aboudfa9a17e2016-12-14 20:24:40 +00002442 DIB.createFile(Mod.getModuleName(), Mod.getPath()),
2443 TheCU->getProducer(), true, StringRef(), 0,
2444 Mod.getASTFile(), llvm::DICompileUnit::FullDebug,
2445 Signature);
Adrian Prantl66689202015-09-18 23:01:45 +00002446 DIB.finalize();
Adrian Prantl2f957ac2015-09-19 00:59:22 +00002447 }
Adrian Prantl7b6b9a12019-02-08 23:15:42 +00002448
Adrian Prantl835e6632015-09-24 16:10:10 +00002449 llvm::DIModule *Parent =
2450 IsRootModule ? nullptr
2451 : getOrCreateModuleRef(
2452 ExternalASTSource::ASTSourceDescriptor(*M->Parent),
2453 CreateSkeletonCU);
Adrian Prantleb66a262015-09-24 16:10:04 +00002454 llvm::DIModule *DIMod =
Adrian Prantl835e6632015-09-24 16:10:10 +00002455 DBuilder.createModule(Parent, Mod.getModuleName(), ConfigMacros,
2456 Mod.getPath(), CGM.getHeaderSearchOpts().Sysroot);
Adrian Prantl9e8ea352015-09-29 20:44:46 +00002457 ModuleCache[M].reset(DIMod);
Adrian Prantleb66a262015-09-24 16:10:04 +00002458 return DIMod;
Adrian Prantlc4bb47e2015-06-30 17:39:51 +00002459}
2460
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002461llvm::DIType *CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty,
2462 llvm::DIFile *Unit) {
David Blaikieef8a9512014-05-05 23:23:53 +00002463 ObjCInterfaceDecl *ID = Ty->getDecl();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002464 llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation());
David Blaikieef8a9512014-05-05 23:23:53 +00002465 unsigned Line = getLineNumber(ID->getLocation());
Duncan P. N. Exon Smith798d5652015-04-15 23:19:15 +00002466 unsigned RuntimeLang = TheCU->getSourceLanguage();
Guy Benyei11169dd2012-12-18 14:30:41 +00002467
2468 // Bit size, align and offset of the type.
2469 uint64_t Size = CGM.getContext().getTypeSize(Ty);
Victor Leschuka7ece032016-10-20 00:13:19 +00002470 auto Align = getTypeAlignIfRequired(Ty, CGM.getContext());
Guy Benyei11169dd2012-12-18 14:30:41 +00002471
Leny Kholodov80c047d2016-09-06 10:48:04 +00002472 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
Guy Benyei11169dd2012-12-18 14:30:41 +00002473 if (ID->getImplementation())
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002474 Flags |= llvm::DINode::FlagObjcClassComplete;
Guy Benyei11169dd2012-12-18 14:30:41 +00002475
Adrian Prantlfd696112015-10-01 00:48:51 +00002476 llvm::DIScope *Mod = getParentModuleOrNull(ID);
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002477 llvm::DICompositeType *RealDecl = DBuilder.createStructType(
Adrian Prantlfd696112015-10-01 00:48:51 +00002478 Mod ? Mod : Unit, ID->getName(), DefUnit, Line, Size, Align, Flags,
2479 nullptr, llvm::DINodeArray(), RuntimeLang);
Guy Benyei11169dd2012-12-18 14:30:41 +00002480
David Blaikieef8a9512014-05-05 23:23:53 +00002481 QualType QTy(Ty, 0);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002482 TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl);
Guy Benyei11169dd2012-12-18 14:30:41 +00002483
Eric Christopher35f1f9f2013-07-14 21:00:07 +00002484 // Push the struct on region stack.
Duncan P. N. Exon Smith4078ad42015-04-16 16:36:45 +00002485 LexicalBlockStack.emplace_back(RealDecl);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002486 RegionMap[Ty->getDecl()].reset(RealDecl);
Guy Benyei11169dd2012-12-18 14:30:41 +00002487
2488 // Convert all the elements.
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002489 SmallVector<llvm::Metadata *, 16> EltTys;
Guy Benyei11169dd2012-12-18 14:30:41 +00002490
2491 ObjCInterfaceDecl *SClass = ID->getSuperClass();
2492 if (SClass) {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002493 llvm::DIType *SClassTy =
Eric Christophere7b87e52014-10-26 23:40:33 +00002494 getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit);
Duncan P. N. Exon Smithb7470232015-04-15 23:48:50 +00002495 if (!SClassTy)
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00002496 return nullptr;
Eric Christopherb2a008c2013-05-16 00:45:12 +00002497
Brock Wyma3db2b102018-05-14 21:21:22 +00002498 llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0, 0,
Leny Kholodovdf050fd2016-09-06 17:06:14 +00002499 llvm::DINode::FlagZero);
Guy Benyei11169dd2012-12-18 14:30:41 +00002500 EltTys.push_back(InhTag);
2501 }
2502
Eric Christopher35f1f9f2013-07-14 21:00:07 +00002503 // Create entries for all of the properties.
Nico Weber7123bca2015-12-04 19:14:14 +00002504 auto AddProperty = [&](const ObjCPropertyDecl *PD) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002505 SourceLocation Loc = PD->getLocation();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002506 llvm::DIFile *PUnit = getOrCreateFile(Loc);
Guy Benyei11169dd2012-12-18 14:30:41 +00002507 unsigned PLine = getLineNumber(Loc);
2508 ObjCMethodDecl *Getter = PD->getGetterMethodDecl();
2509 ObjCMethodDecl *Setter = PD->getSetterMethodDecl();
Eric Christophere7b87e52014-10-26 23:40:33 +00002510 llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(
2511 PD->getName(), PUnit, PLine,
2512 hasDefaultGetterName(PD, Getter) ? ""
2513 : getSelectorName(PD->getGetterName()),
2514 hasDefaultSetterName(PD, Setter) ? ""
2515 : getSelectorName(PD->getSetterName()),
2516 PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit));
Guy Benyei11169dd2012-12-18 14:30:41 +00002517 EltTys.push_back(PropertyNode);
Nico Weber7123bca2015-12-04 19:14:14 +00002518 };
2519 {
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00002520 llvm::SmallPtrSet<const IdentifierInfo *, 16> PropertySet;
Nico Weberde059e12015-12-04 19:35:45 +00002521 for (const ObjCCategoryDecl *ClassExt : ID->known_extensions())
Manman Renefe1bac2016-01-27 20:00:32 +00002522 for (auto *PD : ClassExt->properties()) {
Nico Weberde059e12015-12-04 19:35:45 +00002523 PropertySet.insert(PD->getIdentifier());
2524 AddProperty(PD);
2525 }
Manman Renefe1bac2016-01-27 20:00:32 +00002526 for (const auto *PD : ID->properties()) {
Nico Weber7123bca2015-12-04 19:14:14 +00002527 // Don't emit duplicate metadata for properties that were already in a
2528 // class extension.
2529 if (!PropertySet.insert(PD->getIdentifier()).second)
2530 continue;
2531 AddProperty(PD);
2532 }
Guy Benyei11169dd2012-12-18 14:30:41 +00002533 }
2534
2535 const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(ID);
2536 unsigned FieldNo = 0;
2537 for (ObjCIvarDecl *Field = ID->all_declared_ivar_begin(); Field;
2538 Field = Field->getNextIvar(), ++FieldNo) {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002539 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
Duncan P. N. Exon Smithb7470232015-04-15 23:48:50 +00002540 if (!FieldTy)
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00002541 return nullptr;
Eric Christopherb2a008c2013-05-16 00:45:12 +00002542
Guy Benyei11169dd2012-12-18 14:30:41 +00002543 StringRef FieldName = Field->getName();
2544
2545 // Ignore unnamed fields.
2546 if (FieldName.empty())
2547 continue;
2548
2549 // Get the location for the field.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002550 llvm::DIFile *FieldDefUnit = getOrCreateFile(Field->getLocation());
Guy Benyei11169dd2012-12-18 14:30:41 +00002551 unsigned FieldLine = getLineNumber(Field->getLocation());
2552 QualType FType = Field->getType();
2553 uint64_t FieldSize = 0;
Victor Leschuk802e4a52016-10-19 22:11:07 +00002554 uint32_t FieldAlign = 0;
Guy Benyei11169dd2012-12-18 14:30:41 +00002555
2556 if (!FType->isIncompleteArrayType()) {
2557
2558 // Bit size, align and offset of the type.
2559 FieldSize = Field->isBitField()
Eric Christopher35f1f9f2013-07-14 21:00:07 +00002560 ? Field->getBitWidthValue(CGM.getContext())
2561 : CGM.getContext().getTypeSize(FType);
Victor Leschuka7ece032016-10-20 00:13:19 +00002562 FieldAlign = getTypeAlignIfRequired(FType, CGM.getContext());
Guy Benyei11169dd2012-12-18 14:30:41 +00002563 }
2564
2565 uint64_t FieldOffset;
2566 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
2567 // We don't know the runtime offset of an ivar if we're using the
2568 // non-fragile ABI. For bitfields, use the bit offset into the first
2569 // byte of storage of the bitfield. For other fields, use zero.
2570 if (Field->isBitField()) {
Eric Christophere7b87e52014-10-26 23:40:33 +00002571 FieldOffset =
2572 CGM.getObjCRuntime().ComputeBitfieldBitOffset(CGM, ID, Field);
Guy Benyei11169dd2012-12-18 14:30:41 +00002573 FieldOffset %= CGM.getContext().getCharWidth();
2574 } else {
2575 FieldOffset = 0;
2576 }
2577 } else {
2578 FieldOffset = RL.getFieldOffset(FieldNo);
2579 }
2580
Leny Kholodov80c047d2016-09-06 10:48:04 +00002581 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
Guy Benyei11169dd2012-12-18 14:30:41 +00002582 if (Field->getAccessControl() == ObjCIvarDecl::Protected)
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002583 Flags = llvm::DINode::FlagProtected;
Guy Benyei11169dd2012-12-18 14:30:41 +00002584 else if (Field->getAccessControl() == ObjCIvarDecl::Private)
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002585 Flags = llvm::DINode::FlagPrivate;
Adrian Prantl21361fb2014-08-29 22:44:27 +00002586 else if (Field->getAccessControl() == ObjCIvarDecl::Public)
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002587 Flags = llvm::DINode::FlagPublic;
Guy Benyei11169dd2012-12-18 14:30:41 +00002588
Craig Topper8a13c412014-05-21 05:09:00 +00002589 llvm::MDNode *PropertyNode = nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00002590 if (ObjCImplementationDecl *ImpD = ID->getImplementation()) {
Eric Christopherb2a008c2013-05-16 00:45:12 +00002591 if (ObjCPropertyImplDecl *PImpD =
Eric Christophere7b87e52014-10-26 23:40:33 +00002592 ImpD->FindPropertyImplIvarDecl(Field->getIdentifier())) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002593 if (ObjCPropertyDecl *PD = PImpD->getPropertyDecl()) {
Eric Christopherc0c5d462013-02-21 22:35:08 +00002594 SourceLocation Loc = PD->getLocation();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002595 llvm::DIFile *PUnit = getOrCreateFile(Loc);
Eric Christopherc0c5d462013-02-21 22:35:08 +00002596 unsigned PLine = getLineNumber(Loc);
Adrian Prantl901cc4a2019-11-08 09:24:31 -08002597 ObjCMethodDecl *Getter = PImpD->getGetterMethodDecl();
2598 ObjCMethodDecl *Setter = PImpD->getSetterMethodDecl();
Eric Christophere7b87e52014-10-26 23:40:33 +00002599 PropertyNode = DBuilder.createObjCProperty(
2600 PD->getName(), PUnit, PLine,
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00002601 hasDefaultGetterName(PD, Getter)
2602 ? ""
2603 : getSelectorName(PD->getGetterName()),
2604 hasDefaultSetterName(PD, Setter)
2605 ? ""
2606 : getSelectorName(PD->getSetterName()),
Eric Christophere7b87e52014-10-26 23:40:33 +00002607 PD->getPropertyAttributes(),
2608 getOrCreateType(PD->getType(), PUnit));
Guy Benyei11169dd2012-12-18 14:30:41 +00002609 }
2610 }
2611 }
Eric Christophere7b87e52014-10-26 23:40:33 +00002612 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine,
2613 FieldSize, FieldAlign, FieldOffset, Flags,
2614 FieldTy, PropertyNode);
Guy Benyei11169dd2012-12-18 14:30:41 +00002615 EltTys.push_back(FieldTy);
2616 }
2617
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002618 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
Duncan P. N. Exon Smithc8ee63e2014-12-18 00:48:56 +00002619 DBuilder.replaceArrays(RealDecl, Elements);
Adrian Prantla03a85a2013-03-06 22:03:30 +00002620
Guy Benyei11169dd2012-12-18 14:30:41 +00002621 LexicalBlockStack.pop_back();
Eric Christopher5c7ee8b2013-04-02 22:59:11 +00002622 return RealDecl;
Guy Benyei11169dd2012-12-18 14:30:41 +00002623}
2624
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002625llvm::DIType *CGDebugInfo::CreateType(const VectorType *Ty,
2626 llvm::DIFile *Unit) {
2627 llvm::DIType *ElementTy = getOrCreateType(Ty->getElementType(), Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +00002628 int64_t Count = Ty->getNumElements();
Guy Benyei11169dd2012-12-18 14:30:41 +00002629
Sander de Smalen891af03a2018-02-03 13:55:59 +00002630 llvm::Metadata *Subscript;
2631 QualType QTy(Ty, 0);
2632 auto SizeExpr = SizeExprCache.find(QTy);
2633 if (SizeExpr != SizeExprCache.end())
2634 Subscript = DBuilder.getOrCreateSubrange(0, SizeExpr->getSecond());
2635 else
2636 Subscript = DBuilder.getOrCreateSubrange(0, Count ? Count : -1);
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002637 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
Guy Benyei11169dd2012-12-18 14:30:41 +00002638
2639 uint64_t Size = CGM.getContext().getTypeSize(Ty);
Victor Leschuka7ece032016-10-20 00:13:19 +00002640 auto Align = getTypeAlignIfRequired(Ty, CGM.getContext());
Guy Benyei11169dd2012-12-18 14:30:41 +00002641
2642 return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
2643}
2644
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002645llvm::DIType *CGDebugInfo::CreateType(const ArrayType *Ty, llvm::DIFile *Unit) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002646 uint64_t Size;
Victor Leschuk802e4a52016-10-19 22:11:07 +00002647 uint32_t Align;
Guy Benyei11169dd2012-12-18 14:30:41 +00002648
2649 // FIXME: make getTypeAlign() aware of VLAs and incomplete array types
David Majnemer58ed0f32016-07-17 00:39:12 +00002650 if (const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002651 Size = 0;
Victor Leschuka7ece032016-10-20 00:13:19 +00002652 Align = getTypeAlignIfRequired(CGM.getContext().getBaseElementType(VAT),
2653 CGM.getContext());
Guy Benyei11169dd2012-12-18 14:30:41 +00002654 } else if (Ty->isIncompleteArrayType()) {
2655 Size = 0;
2656 if (Ty->getElementType()->isIncompleteType())
2657 Align = 0;
2658 else
Victor Leschuka7ece032016-10-20 00:13:19 +00002659 Align = getTypeAlignIfRequired(Ty->getElementType(), CGM.getContext());
David Blaikief03b2e82013-05-09 20:48:12 +00002660 } else if (Ty->isIncompleteType()) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002661 Size = 0;
2662 Align = 0;
2663 } else {
2664 // Size and align of the whole array, not the element type.
2665 Size = CGM.getContext().getTypeSize(Ty);
Victor Leschuka7ece032016-10-20 00:13:19 +00002666 Align = getTypeAlignIfRequired(Ty, CGM.getContext());
Guy Benyei11169dd2012-12-18 14:30:41 +00002667 }
2668
2669 // Add the dimensions of the array. FIXME: This loses CV qualifiers from
2670 // interior arrays, do we care? Why aren't nested arrays represented the
2671 // obvious/recursive way?
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002672 SmallVector<llvm::Metadata *, 8> Subscripts;
Guy Benyei11169dd2012-12-18 14:30:41 +00002673 QualType EltTy(Ty, 0);
2674 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
2675 // If the number of elements is known, then count is that number. Otherwise,
2676 // it's -1. This allows us to represent a subrange with an array of 0
2677 // elements, like this:
2678 //
2679 // struct foo {
2680 // int x[0];
2681 // };
Eric Christophere7b87e52014-10-26 23:40:33 +00002682 int64_t Count = -1; // Count == -1 is an unbounded array.
David Majnemer58ed0f32016-07-17 00:39:12 +00002683 if (const auto *CAT = dyn_cast<ConstantArrayType>(Ty))
Guy Benyei11169dd2012-12-18 14:30:41 +00002684 Count = CAT->getSize().getZExtValue();
David Blaikie87173f12016-08-22 17:49:56 +00002685 else if (const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
Eli Friedman01d6b962016-10-19 22:16:32 +00002686 if (Expr *Size = VAT->getSizeExpr()) {
Fangrui Song407659a2018-11-30 23:41:18 +00002687 Expr::EvalResult Result;
2688 if (Size->EvaluateAsInt(Result, CGM.getContext()))
2689 Count = Result.Val.getInt().getExtValue();
Eli Friedman01d6b962016-10-19 22:16:32 +00002690 }
David Blaikie87173f12016-08-22 17:49:56 +00002691 }
Eric Christopherb2a008c2013-05-16 00:45:12 +00002692
Sander de Smalen891af03a2018-02-03 13:55:59 +00002693 auto SizeNode = SizeExprCache.find(EltTy);
2694 if (SizeNode != SizeExprCache.end())
2695 Subscripts.push_back(
2696 DBuilder.getOrCreateSubrange(0, SizeNode->getSecond()));
2697 else
2698 Subscripts.push_back(DBuilder.getOrCreateSubrange(0, Count));
Guy Benyei11169dd2012-12-18 14:30:41 +00002699 EltTy = Ty->getElementType();
2700 }
2701
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002702 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
Guy Benyei11169dd2012-12-18 14:30:41 +00002703
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00002704 return DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
2705 SubscriptArray);
Guy Benyei11169dd2012-12-18 14:30:41 +00002706}
2707
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002708llvm::DIType *CGDebugInfo::CreateType(const LValueReferenceType *Ty,
2709 llvm::DIFile *Unit) {
Eric Christophere7b87e52014-10-26 23:40:33 +00002710 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty,
2711 Ty->getPointeeType(), Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +00002712}
2713
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002714llvm::DIType *CGDebugInfo::CreateType(const RValueReferenceType *Ty,
2715 llvm::DIFile *Unit) {
Eric Christophere7b87e52014-10-26 23:40:33 +00002716 return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type, Ty,
2717 Ty->getPointeeType(), Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +00002718}
2719
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002720llvm::DIType *CGDebugInfo::CreateType(const MemberPointerType *Ty,
2721 llvm::DIFile *U) {
Leny Kholodov80c047d2016-09-06 10:48:04 +00002722 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
Reid Klecknerfb727182016-06-17 22:27:59 +00002723 uint64_t Size = 0;
2724
2725 if (!Ty->isIncompleteType()) {
2726 Size = CGM.getContext().getTypeSize(Ty);
2727
2728 // Set the MS inheritance model. There is no flag for the unspecified model.
2729 if (CGM.getTarget().getCXXABI().isMicrosoft()) {
2730 switch (Ty->getMostRecentCXXRecordDecl()->getMSInheritanceModel()) {
Reid Klecknera9cc64e2019-11-15 18:49:32 -08002731 case MSInheritanceModel::Single:
Reid Klecknerfb727182016-06-17 22:27:59 +00002732 Flags |= llvm::DINode::FlagSingleInheritance;
2733 break;
Reid Klecknera9cc64e2019-11-15 18:49:32 -08002734 case MSInheritanceModel::Multiple:
Reid Klecknerfb727182016-06-17 22:27:59 +00002735 Flags |= llvm::DINode::FlagMultipleInheritance;
2736 break;
Reid Klecknera9cc64e2019-11-15 18:49:32 -08002737 case MSInheritanceModel::Virtual:
Reid Klecknerfb727182016-06-17 22:27:59 +00002738 Flags |= llvm::DINode::FlagVirtualInheritance;
2739 break;
Reid Klecknera9cc64e2019-11-15 18:49:32 -08002740 case MSInheritanceModel::Unspecified:
Reid Klecknerfb727182016-06-17 22:27:59 +00002741 break;
2742 }
2743 }
2744 }
2745
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002746 llvm::DIType *ClassType = getOrCreateType(QualType(Ty->getClass(), 0), U);
David Majnemer5fd33e02015-04-24 01:25:08 +00002747 if (Ty->isMemberDataPointerType())
David Blaikie2c705ca2013-01-19 19:20:56 +00002748 return DBuilder.createMemberPointerType(
Reid Klecknerfb727182016-06-17 22:27:59 +00002749 getOrCreateType(Ty->getPointeeType(), U), ClassType, Size, /*Align=*/0,
2750 Flags);
Adrian Prantl0866acd2013-12-19 01:38:47 +00002751
2752 const FunctionProtoType *FPT =
Eric Christophere7b87e52014-10-26 23:40:33 +00002753 Ty->getPointeeType()->getAs<FunctionProtoType>();
2754 return DBuilder.createMemberPointerType(
Mikael Nilsson9d2872d2018-12-13 10:15:27 +00002755 getOrCreateInstanceMethodType(
2756 CXXMethodDecl::getThisType(FPT, Ty->getMostRecentCXXRecordDecl()),
2757 FPT, U),
Reid Klecknerfb727182016-06-17 22:27:59 +00002758 ClassType, Size, /*Align=*/0, Flags);
Guy Benyei11169dd2012-12-18 14:30:41 +00002759}
2760
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002761llvm::DIType *CGDebugInfo::CreateType(const AtomicType *Ty, llvm::DIFile *U) {
Victor Leschuk0df190372016-10-31 19:09:47 +00002762 auto *FromTy = getOrCreateType(Ty->getValueType(), U);
2763 return DBuilder.createQualifiedType(llvm::dwarf::DW_TAG_atomic_type, FromTy);
Guy Benyei11169dd2012-12-18 14:30:41 +00002764}
2765
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00002766llvm::DIType *CGDebugInfo::CreateType(const PipeType *Ty, llvm::DIFile *U) {
Xiuli Pan9c14e282016-01-09 12:53:17 +00002767 return getOrCreateType(Ty->getElementType(), U);
2768}
2769
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002770llvm::DIType *CGDebugInfo::CreateEnumType(const EnumType *Ty) {
Manman Ren1b457022013-08-28 21:20:28 +00002771 const EnumDecl *ED = Ty->getDecl();
Adrian Prantl5c8bd882015-09-11 17:23:08 +00002772
Guy Benyei11169dd2012-12-18 14:30:41 +00002773 uint64_t Size = 0;
Victor Leschuk802e4a52016-10-19 22:11:07 +00002774 uint32_t Align = 0;
Guy Benyei11169dd2012-12-18 14:30:41 +00002775 if (!ED->getTypeForDecl()->isIncompleteType()) {
2776 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
Victor Leschuka7ece032016-10-20 00:13:19 +00002777 Align = getDeclAlignIfRequired(ED, CGM.getContext());
Guy Benyei11169dd2012-12-18 14:30:41 +00002778 }
2779
Brock Wyma8557ec52018-05-22 12:41:19 +00002780 SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU);
Manman Rene0064d82013-08-29 23:19:58 +00002781
Adrian Prantl5c8bd882015-09-11 17:23:08 +00002782 bool isImportedFromModule =
2783 DebugTypeExtRefs && ED->isFromASTFile() && ED->getDefinition();
2784
Guy Benyei11169dd2012-12-18 14:30:41 +00002785 // If this is just a forward declaration, construct an appropriately
2786 // marked node and just return it.
Adrian Prantl5c8bd882015-09-11 17:23:08 +00002787 if (isImportedFromModule || !ED->getDefinition()) {
Adrian Prantl45946062016-02-23 19:30:08 +00002788 // Note that it is possible for enums to be created as part of
2789 // their own declcontext. In this case a FwdDecl will be created
2790 // twice. This doesn't cause a problem because both FwdDecls are
2791 // entered into the ReplaceMap: finalize() will replace the first
2792 // FwdDecl with the second and then replace the second with
2793 // complete type.
Amjad Abouddc4531e2016-04-30 01:44:38 +00002794 llvm::DIScope *EDContext = getDeclContextDescriptor(ED);
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002795 llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
Adrian Prantlff9d83c2016-02-08 17:03:28 +00002796 llvm::TempDIScope TmpContext(DBuilder.createReplaceableCompositeType(
2797 llvm::dwarf::DW_TAG_enumeration_type, "", TheCU, DefUnit, 0));
Adrian Prantla40030f2016-02-06 01:59:09 +00002798
Guy Benyei11169dd2012-12-18 14:30:41 +00002799 unsigned Line = getLineNumber(ED->getLocation());
2800 StringRef EDName = ED->getName();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002801 llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType(
Adrian Prantl45946062016-02-23 19:30:08 +00002802 llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit, Line,
Brock Wyma8557ec52018-05-22 12:41:19 +00002803 0, Size, Align, llvm::DINode::FlagFwdDecl, Identifier);
Adrian Prantla40030f2016-02-06 01:59:09 +00002804
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002805 ReplaceMap.emplace_back(
2806 std::piecewise_construct, std::make_tuple(Ty),
2807 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
David Blaikief427b002014-05-06 03:42:01 +00002808 return RetTy;
Guy Benyei11169dd2012-12-18 14:30:41 +00002809 }
2810
David Blaikie483a9da2014-05-06 18:35:21 +00002811 return CreateTypeDefinition(Ty);
2812}
2813
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002814llvm::DIType *CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) {
David Blaikie483a9da2014-05-06 18:35:21 +00002815 const EnumDecl *ED = Ty->getDecl();
2816 uint64_t Size = 0;
Victor Leschuk802e4a52016-10-19 22:11:07 +00002817 uint32_t Align = 0;
David Blaikie483a9da2014-05-06 18:35:21 +00002818 if (!ED->getTypeForDecl()->isIncompleteType()) {
2819 Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
Victor Leschuka7ece032016-10-20 00:13:19 +00002820 Align = getDeclAlignIfRequired(ED, CGM.getContext());
David Blaikie483a9da2014-05-06 18:35:21 +00002821 }
2822
Brock Wyma8557ec52018-05-22 12:41:19 +00002823 SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU);
David Blaikie483a9da2014-05-06 18:35:21 +00002824
Duncan P. N. Exon Smithdadc2b62015-04-21 18:43:54 +00002825 // Create elements for each enumerator.
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002826 SmallVector<llvm::Metadata *, 16> Enumerators;
Guy Benyei11169dd2012-12-18 14:30:41 +00002827 ED = ED->getDefinition();
Momchil Velikov25f6be52018-02-12 16:12:52 +00002828 bool IsSigned = ED->getIntegerType()->isSignedIntegerType();
Aaron Ballman23a6dcb2014-03-08 18:45:14 +00002829 for (const auto *Enum : ED->enumerators()) {
Momchil Velikov25f6be52018-02-12 16:12:52 +00002830 const auto &InitVal = Enum->getInitVal();
2831 auto Value = IsSigned ? InitVal.getSExtValue() : InitVal.getZExtValue();
2832 Enumerators.push_back(
2833 DBuilder.createEnumerator(Enum->getName(), Value, !IsSigned));
Guy Benyei11169dd2012-12-18 14:30:41 +00002834 }
2835
2836 // Return a CompositeType for the enum itself.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002837 llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
Guy Benyei11169dd2012-12-18 14:30:41 +00002838
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002839 llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
Guy Benyei11169dd2012-12-18 14:30:41 +00002840 unsigned Line = getLineNumber(ED->getLocation());
Amjad Abouddc4531e2016-04-30 01:44:38 +00002841 llvm::DIScope *EnumContext = getDeclContextDescriptor(ED);
Momchil Velikov25f6be52018-02-12 16:12:52 +00002842 llvm::DIType *ClassTy = getOrCreateType(ED->getIntegerType(), DefUnit);
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00002843 return DBuilder.createEnumerationType(EnumContext, ED->getName(), DefUnit,
2844 Line, Size, Align, EltArray, ClassTy,
Paul Robinsonb1ce7c82019-01-08 16:28:11 +00002845 Identifier, ED->isScoped());
Guy Benyei11169dd2012-12-18 14:30:41 +00002846}
2847
Amjad Aboud546bc112017-02-09 22:07:24 +00002848llvm::DIMacro *CGDebugInfo::CreateMacro(llvm::DIMacroFile *Parent,
2849 unsigned MType, SourceLocation LineLoc,
2850 StringRef Name, StringRef Value) {
2851 unsigned Line = LineLoc.isInvalid() ? 0 : getLineNumber(LineLoc);
2852 return DBuilder.createMacro(Parent, Line, MType, Name, Value);
2853}
2854
2855llvm::DIMacroFile *CGDebugInfo::CreateTempMacroFile(llvm::DIMacroFile *Parent,
2856 SourceLocation LineLoc,
2857 SourceLocation FileLoc) {
2858 llvm::DIFile *FName = getOrCreateFile(FileLoc);
2859 unsigned Line = LineLoc.isInvalid() ? 0 : getLineNumber(LineLoc);
2860 return DBuilder.createTempMacroFile(Parent, Line, FName);
2861}
2862
David Blaikie05491062013-01-21 04:37:12 +00002863static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C) {
2864 Qualifiers Quals;
Guy Benyei11169dd2012-12-18 14:30:41 +00002865 do {
Adrian Prantl179af902013-09-26 21:35:50 +00002866 Qualifiers InnerQuals = T.getLocalQualifiers();
2867 // Qualifiers::operator+() doesn't like it if you add a Qualifier
2868 // that is already there.
2869 Quals += Qualifiers::removeCommonQualifiers(Quals, InnerQuals);
2870 Quals += InnerQuals;
Guy Benyei11169dd2012-12-18 14:30:41 +00002871 QualType LastT = T;
2872 switch (T->getTypeClass()) {
2873 default:
David Blaikie05491062013-01-21 04:37:12 +00002874 return C.getQualifiedType(T.getTypePtr(), Quals);
David Blaikief1b382e2014-04-06 17:14:06 +00002875 case Type::TemplateSpecialization: {
2876 const auto *Spec = cast<TemplateSpecializationType>(T);
2877 if (Spec->isTypeAlias())
2878 return C.getQualifiedType(T.getTypePtr(), Quals);
2879 T = Spec->desugar();
Eric Christophere7b87e52014-10-26 23:40:33 +00002880 break;
2881 }
Guy Benyei11169dd2012-12-18 14:30:41 +00002882 case Type::TypeOfExpr:
2883 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
2884 break;
2885 case Type::TypeOf:
2886 T = cast<TypeOfType>(T)->getUnderlyingType();
2887 break;
2888 case Type::Decltype:
2889 T = cast<DecltypeType>(T)->getUnderlyingType();
2890 break;
2891 case Type::UnaryTransform:
2892 T = cast<UnaryTransformType>(T)->getUnderlyingType();
2893 break;
2894 case Type::Attributed:
2895 T = cast<AttributedType>(T)->getEquivalentType();
2896 break;
2897 case Type::Elaborated:
2898 T = cast<ElaboratedType>(T)->getNamedType();
2899 break;
2900 case Type::Paren:
2901 T = cast<ParenType>(T)->getInnerType();
2902 break;
Leonard Chanc72aaf62019-05-07 03:20:17 +00002903 case Type::MacroQualified:
2904 T = cast<MacroQualifiedType>(T)->getUnderlyingType();
2905 break;
David Blaikie05491062013-01-21 04:37:12 +00002906 case Type::SubstTemplateTypeParm:
Guy Benyei11169dd2012-12-18 14:30:41 +00002907 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
Guy Benyei11169dd2012-12-18 14:30:41 +00002908 break;
Richard Smitha0abc422017-02-22 00:13:14 +00002909 case Type::Auto:
2910 case Type::DeducedTemplateSpecialization: {
2911 QualType DT = cast<DeducedType>(T)->getDeducedType();
David Blaikie42edade2014-11-11 20:44:45 +00002912 assert(!DT.isNull() && "Undeduced types shouldn't reach here.");
David Blaikie22c460a02013-05-24 21:24:35 +00002913 T = DT;
Guy Benyei11169dd2012-12-18 14:30:41 +00002914 break;
2915 }
Jordan Rose303e2f12016-11-10 23:28:17 +00002916 case Type::Adjusted:
2917 case Type::Decayed:
2918 // Decayed and adjusted types use the adjusted type in LLVM and DWARF.
2919 T = cast<AdjustedType>(T)->getAdjustedType();
2920 break;
2921 }
Eric Christopherb2a008c2013-05-16 00:45:12 +00002922
Guy Benyei11169dd2012-12-18 14:30:41 +00002923 assert(T != LastT && "Type unwrapping failed to unwrap!");
NAKAMURA Takumi3e0a3632013-01-21 10:51:28 +00002924 (void)LastT;
Guy Benyei11169dd2012-12-18 14:30:41 +00002925 } while (true);
2926}
2927
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002928llvm::DIType *CGDebugInfo::getTypeOrNull(QualType Ty) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002929
2930 // Unwrap the type as needed for debug information.
David Blaikie05491062013-01-21 04:37:12 +00002931 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
Eric Christopherb2a008c2013-05-16 00:45:12 +00002932
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00002933 auto It = TypeCache.find(Ty.getAsOpaquePtr());
2934 if (It != TypeCache.end()) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002935 // Verify that the debug info still exists.
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00002936 if (llvm::Metadata *V = It->second)
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002937 return cast<llvm::DIType>(V);
Guy Benyei11169dd2012-12-18 14:30:41 +00002938 }
2939
Duncan P. N. Exon Smithc7551282015-04-06 23:21:33 +00002940 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00002941}
2942
David Blaikie0e716b42014-03-03 23:48:23 +00002943void CGDebugInfo::completeTemplateDefinition(
2944 const ClassTemplateSpecializationDecl &SD) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00002945 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
David Blaikie0856f662014-03-04 22:01:08 +00002946 return;
David Blaikie1ac9c982017-04-11 21:13:37 +00002947 completeUnusedClass(SD);
2948}
David Blaikie0856f662014-03-04 22:01:08 +00002949
David Blaikie1ac9c982017-04-11 21:13:37 +00002950void CGDebugInfo::completeUnusedClass(const CXXRecordDecl &D) {
2951 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
2952 return;
2953
2954 completeClassData(&D);
David Blaikie0e716b42014-03-03 23:48:23 +00002955 // In case this type has no member function definitions being emitted, ensure
2956 // it is retained
David Blaikie1ac9c982017-04-11 21:13:37 +00002957 RetainedTypes.push_back(CGM.getContext().getRecordType(&D).getAsOpaquePtr());
David Blaikie0e716b42014-03-03 23:48:23 +00002958}
2959
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00002960llvm::DIType *CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile *Unit) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002961 if (Ty.isNull())
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00002962 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00002963
Luboš Luňák4f2104c2019-11-02 16:39:59 +01002964 llvm::TimeTraceScope TimeScope("DebugType", [&]() {
2965 std::string Name;
2966 llvm::raw_string_ostream OS(Name);
2967 Ty.print(OS, getPrintingPolicy());
2968 return Name;
2969 });
2970
Guy Benyei11169dd2012-12-18 14:30:41 +00002971 // Unwrap the type as needed for debug information.
David Blaikie05491062013-01-21 04:37:12 +00002972 Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
Guy Benyei11169dd2012-12-18 14:30:41 +00002973
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00002974 if (auto *T = getTypeOrNull(Ty))
Guy Benyei11169dd2012-12-18 14:30:41 +00002975 return T;
2976
Adrian Prantlca844182015-09-11 17:23:03 +00002977 llvm::DIType *Res = CreateTypeNode(Ty, Unit);
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00002978 void *TyPtr = Ty.getAsOpaquePtr();
Adrian Prantl73409ce2013-03-11 18:33:46 +00002979
2980 // And update the type cache.
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00002981 TypeCache[TyPtr].reset(Res);
Guy Benyei11169dd2012-12-18 14:30:41 +00002982
Guy Benyei11169dd2012-12-18 14:30:41 +00002983 return Res;
2984}
2985
Adrian Prantl5c8bd882015-09-11 17:23:08 +00002986llvm::DIModule *CGDebugInfo::getParentModuleOrNull(const Decl *D) {
Adrian Prantl335f5c72015-10-02 17:36:14 +00002987 // A forward declaration inside a module header does not belong to the module.
2988 if (isa<RecordDecl>(D) && !cast<RecordDecl>(D)->getDefinition())
2989 return nullptr;
Adrian Prantl85d938a2015-09-21 17:48:37 +00002990 if (DebugTypeExtRefs && D->isFromASTFile()) {
2991 // Record a reference to an imported clang module or precompiled header.
2992 auto *Reader = CGM.getContext().getExternalSource();
2993 auto Idx = D->getOwningModuleID();
2994 auto Info = Reader->getSourceDescriptor(Idx);
2995 if (Info)
2996 return getOrCreateModuleRef(*Info, /*SkeletonCU=*/true);
2997 } else if (ClangModuleMap) {
Adrian Prantl9402cef2015-09-20 16:51:35 +00002998 // We are building a clang module or a precompiled header.
2999 //
3000 // TODO: When D is a CXXRecordDecl or a C++ Enum, the ODR applies
3001 // and it wouldn't be necessary to specify the parent scope
3002 // because the type is already unique by definition (it would look
3003 // like the output of -fno-standalone-debug). On the other hand,
3004 // the parent scope helps a consumer to quickly locate the object
3005 // file where the type's definition is located, so it might be
3006 // best to make this behavior a command line or debugger tuning
3007 // option.
Richard Smith54f04402017-05-18 02:29:20 +00003008 if (Module *M = D->getOwningModule()) {
Adrian Prantlaa5d08d2016-01-22 21:14:41 +00003009 // This is a (sub-)module.
Adrian Prantl9402cef2015-09-20 16:51:35 +00003010 auto Info = ExternalASTSource::ASTSourceDescriptor(*M);
3011 return getOrCreateModuleRef(Info, /*SkeletonCU=*/false);
Adrian Prantlaa5d08d2016-01-22 21:14:41 +00003012 } else {
3013 // This the precompiled header being built.
3014 return getOrCreateModuleRef(PCHDescriptor, /*SkeletonCU=*/false);
Adrian Prantl9402cef2015-09-20 16:51:35 +00003015 }
3016 }
Adrian Prantl5c8bd882015-09-11 17:23:08 +00003017
Adrian Prantl9402cef2015-09-20 16:51:35 +00003018 return nullptr;
Adrian Prantl5c8bd882015-09-11 17:23:08 +00003019}
3020
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003021llvm::DIType *CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile *Unit) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003022 // Handle qualifiers, which recursively handles what they refer to.
3023 if (Ty.hasLocalQualifiers())
David Blaikie99dab3b2013-09-04 22:03:57 +00003024 return CreateQualifiedType(Ty, Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +00003025
Guy Benyei11169dd2012-12-18 14:30:41 +00003026 // Work out details of type.
3027 switch (Ty->getTypeClass()) {
3028#define TYPE(Class, Base)
3029#define ABSTRACT_TYPE(Class, Base)
3030#define NON_CANONICAL_TYPE(Class, Base)
3031#define DEPENDENT_TYPE(Class, Base) case Type::Class:
John McCall36b12a82019-10-02 06:35:23 +00003032#include "clang/AST/TypeNodes.inc"
Guy Benyei11169dd2012-12-18 14:30:41 +00003033 llvm_unreachable("Dependent types cannot show up in debug information");
3034
3035 case Type::ExtVector:
3036 case Type::Vector:
3037 return CreateType(cast<VectorType>(Ty), Unit);
3038 case Type::ObjCObjectPointer:
3039 return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
3040 case Type::ObjCObject:
3041 return CreateType(cast<ObjCObjectType>(Ty), Unit);
Manman Rene6be26c2016-09-13 17:25:08 +00003042 case Type::ObjCTypeParam:
3043 return CreateType(cast<ObjCTypeParamType>(Ty), Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +00003044 case Type::ObjCInterface:
3045 return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
3046 case Type::Builtin:
3047 return CreateType(cast<BuiltinType>(Ty));
3048 case Type::Complex:
3049 return CreateType(cast<ComplexType>(Ty));
3050 case Type::Pointer:
3051 return CreateType(cast<PointerType>(Ty), Unit);
3052 case Type::BlockPointer:
3053 return CreateType(cast<BlockPointerType>(Ty), Unit);
3054 case Type::Typedef:
David Blaikie99dab3b2013-09-04 22:03:57 +00003055 return CreateType(cast<TypedefType>(Ty), Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +00003056 case Type::Record:
David Blaikie99dab3b2013-09-04 22:03:57 +00003057 return CreateType(cast<RecordType>(Ty));
Guy Benyei11169dd2012-12-18 14:30:41 +00003058 case Type::Enum:
Manman Ren1b457022013-08-28 21:20:28 +00003059 return CreateEnumType(cast<EnumType>(Ty));
Guy Benyei11169dd2012-12-18 14:30:41 +00003060 case Type::FunctionProto:
3061 case Type::FunctionNoProto:
3062 return CreateType(cast<FunctionType>(Ty), Unit);
3063 case Type::ConstantArray:
3064 case Type::VariableArray:
3065 case Type::IncompleteArray:
3066 return CreateType(cast<ArrayType>(Ty), Unit);
3067
3068 case Type::LValueReference:
3069 return CreateType(cast<LValueReferenceType>(Ty), Unit);
3070 case Type::RValueReference:
3071 return CreateType(cast<RValueReferenceType>(Ty), Unit);
3072
3073 case Type::MemberPointer:
3074 return CreateType(cast<MemberPointerType>(Ty), Unit);
3075
3076 case Type::Atomic:
3077 return CreateType(cast<AtomicType>(Ty), Unit);
3078
Xiuli Pan9c14e282016-01-09 12:53:17 +00003079 case Type::Pipe:
3080 return CreateType(cast<PipeType>(Ty), Unit);
3081
Guy Benyei11169dd2012-12-18 14:30:41 +00003082 case Type::TemplateSpecialization:
David Blaikief1b382e2014-04-06 17:14:06 +00003083 return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
3084
David Blaikie42edade2014-11-11 20:44:45 +00003085 case Type::Auto:
David Blaikief1b382e2014-04-06 17:14:06 +00003086 case Type::Attributed:
Jordan Rose303e2f12016-11-10 23:28:17 +00003087 case Type::Adjusted:
3088 case Type::Decayed:
Richard Smith600b5262017-01-26 20:40:47 +00003089 case Type::DeducedTemplateSpecialization:
Guy Benyei11169dd2012-12-18 14:30:41 +00003090 case Type::Elaborated:
3091 case Type::Paren:
Leonard Chanc72aaf62019-05-07 03:20:17 +00003092 case Type::MacroQualified:
Guy Benyei11169dd2012-12-18 14:30:41 +00003093 case Type::SubstTemplateTypeParm:
3094 case Type::TypeOfExpr:
3095 case Type::TypeOf:
3096 case Type::Decltype:
3097 case Type::UnaryTransform:
David Blaikie66ed89d2013-07-13 21:08:08 +00003098 case Type::PackExpansion:
David Blaikie22c460a02013-05-24 21:24:35 +00003099 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00003100 }
Eric Christopherb2a008c2013-05-16 00:45:12 +00003101
David Blaikie42edade2014-11-11 20:44:45 +00003102 llvm_unreachable("type should have been unwrapped!");
Guy Benyei11169dd2012-12-18 14:30:41 +00003103}
3104
Duncan P. N. Exon Smithbd210e62015-07-24 20:34:41 +00003105llvm::DICompositeType *CGDebugInfo::getOrCreateLimitedType(const RecordType *Ty,
3106 llvm::DIFile *Unit) {
David Blaikie4a2b5ef2013-08-12 22:24:20 +00003107 QualType QTy(Ty, 0);
Guy Benyei11169dd2012-12-18 14:30:41 +00003108
Duncan P. N. Exon Smithbd210e62015-07-24 20:34:41 +00003109 auto *T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));
Guy Benyei11169dd2012-12-18 14:30:41 +00003110
3111 // We may have cached a forward decl when we could have created
3112 // a non-forward decl. Go ahead and create a non-forward decl
3113 // now.
Duncan P. N. Exon Smith4caa7f22015-04-16 01:00:56 +00003114 if (T && !T->isForwardDecl())
Eric Christophere7b87e52014-10-26 23:40:33 +00003115 return T;
Guy Benyei11169dd2012-12-18 14:30:41 +00003116
3117 // Otherwise create the type.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003118 llvm::DICompositeType *Res = CreateLimitedType(Ty);
David Blaikie8d5e1282013-08-20 21:03:29 +00003119
3120 // Propagate members from the declaration to the definition
3121 // CreateType(const RecordType*) will overwrite this with the members in the
3122 // correct order if the full type is needed.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003123 DBuilder.replaceArrays(Res, T ? T->getElements() : llvm::DINodeArray());
Guy Benyei11169dd2012-12-18 14:30:41 +00003124
Guy Benyei11169dd2012-12-18 14:30:41 +00003125 // And update the type cache.
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00003126 TypeCache[QTy.getAsOpaquePtr()].reset(Res);
Guy Benyei11169dd2012-12-18 14:30:41 +00003127 return Res;
3128}
3129
3130// TODO: Currently used for context chains when limiting debug info.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003131llvm::DICompositeType *CGDebugInfo::CreateLimitedType(const RecordType *Ty) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003132 RecordDecl *RD = Ty->getDecl();
Eric Christopherb2a008c2013-05-16 00:45:12 +00003133
Guy Benyei11169dd2012-12-18 14:30:41 +00003134 // Get overall information about the record type for the debug info.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003135 llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
Guy Benyei11169dd2012-12-18 14:30:41 +00003136 unsigned Line = getLineNumber(RD->getLocation());
3137 StringRef RDName = getClassName(RD);
3138
Amjad Abouddc4531e2016-04-30 01:44:38 +00003139 llvm::DIScope *RDContext = getDeclContextDescriptor(RD);
Guy Benyei11169dd2012-12-18 14:30:41 +00003140
David Blaikied2785892013-08-18 17:36:19 +00003141 // If we ended up creating the type during the context chain construction,
3142 // just return that.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003143 auto *T = cast_or_null<llvm::DICompositeType>(
Duncan P. N. Exon Smithc7551282015-04-06 23:21:33 +00003144 getTypeOrNull(CGM.getContext().getRecordType(RD)));
Duncan P. N. Exon Smith4caa7f22015-04-16 01:00:56 +00003145 if (T && (!T->isForwardDecl() || !RD->getDefinition()))
Eric Christophere7b87e52014-10-26 23:40:33 +00003146 return T;
David Blaikied2785892013-08-18 17:36:19 +00003147
Adrian Prantl381e7552014-02-04 21:29:50 +00003148 // If this is just a forward or incomplete declaration, construct an
3149 // appropriately marked node and just return it.
3150 const RecordDecl *D = RD->getDefinition();
3151 if (!D || !D->isCompleteDefinition())
Manman Ren1b457022013-08-28 21:20:28 +00003152 return getOrCreateRecordFwdDecl(Ty, RDContext);
Guy Benyei11169dd2012-12-18 14:30:41 +00003153
3154 uint64_t Size = CGM.getContext().getTypeSize(Ty);
Victor Leschuka7ece032016-10-20 00:13:19 +00003155 auto Align = getDeclAlignIfRequired(D, CGM.getContext());
Eric Christopherb2a008c2013-05-16 00:45:12 +00003156
Brock Wyma8557ec52018-05-22 12:41:19 +00003157 SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU);
Manman Rene0064d82013-08-29 23:19:58 +00003158
Shafik Yaghmour528f5da2019-08-27 20:17:35 +00003159 // Explicitly record the calling convention and export symbols for C++
3160 // records.
Adrian Prantl6c5f03a2018-01-05 01:13:52 +00003161 auto Flags = llvm::DINode::FlagZero;
3162 if (auto CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3163 if (CGM.getCXXABI().getRecordArgABI(CXXRD) == CGCXXABI::RAA_Indirect)
3164 Flags |= llvm::DINode::FlagTypePassByReference;
3165 else
3166 Flags |= llvm::DINode::FlagTypePassByValue;
Aaron Smith044326c2018-07-23 20:49:07 +00003167
Aaron Smithfa7745b2019-04-11 20:24:54 +00003168 // Record if a C++ record is non-trivial type.
3169 if (!CXXRD->isTrivial())
Aaron Smithf0d27332019-02-26 03:49:05 +00003170 Flags |= llvm::DINode::FlagNonTrivial;
Shafik Yaghmour528f5da2019-08-27 20:17:35 +00003171
3172 // Record exports it symbols to the containing structure.
3173 if (CXXRD->isAnonymousStructOrUnion())
3174 Flags |= llvm::DINode::FlagExportSymbols;
Adrian Prantl6c5f03a2018-01-05 01:13:52 +00003175 }
3176
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003177 llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
Leny Kholodov80c047d2016-09-06 10:48:04 +00003178 getTagForRecord(RD), RDName, RDContext, DefUnit, Line, 0, Size, Align,
Brock Wyma8557ec52018-05-22 12:41:19 +00003179 Flags, Identifier);
Guy Benyei11169dd2012-12-18 14:30:41 +00003180
Duncan P. N. Exon Smithf9521b02016-04-17 07:45:08 +00003181 // Elements of composite types usually have back to the type, creating
3182 // uniquing cycles. Distinct nodes are more efficient.
3183 switch (RealDecl->getTag()) {
3184 default:
3185 llvm_unreachable("invalid composite type tag");
3186
3187 case llvm::dwarf::DW_TAG_array_type:
3188 case llvm::dwarf::DW_TAG_enumeration_type:
3189 // Array elements and most enumeration elements don't have back references,
3190 // so they don't tend to be involved in uniquing cycles and there is some
3191 // chance of merging them when linking together two modules. Only make
3192 // them distinct if they are ODR-uniqued.
Brock Wyma8557ec52018-05-22 12:41:19 +00003193 if (Identifier.empty())
Duncan P. N. Exon Smithf9521b02016-04-17 07:45:08 +00003194 break;
Galina Kistanova0872d6c2017-06-03 06:30:46 +00003195 LLVM_FALLTHROUGH;
Duncan P. N. Exon Smithf9521b02016-04-17 07:45:08 +00003196
3197 case llvm::dwarf::DW_TAG_structure_type:
3198 case llvm::dwarf::DW_TAG_union_type:
3199 case llvm::dwarf::DW_TAG_class_type:
Alexander Kornienko2a8c18d2018-04-06 15:14:32 +00003200 // Immediately resolve to a distinct node.
Duncan P. N. Exon Smithf9521b02016-04-17 07:45:08 +00003201 RealDecl =
3202 llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
3203 break;
3204 }
3205
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00003206 RegionMap[Ty->getDecl()].reset(RealDecl);
3207 TypeCache[QualType(Ty, 0).getAsOpaquePtr()].reset(RealDecl);
Guy Benyei11169dd2012-12-18 14:30:41 +00003208
David Majnemer58ed0f32016-07-17 00:39:12 +00003209 if (const auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003210 DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),
Duncan P. N. Exon Smithc8ee63e2014-12-18 00:48:56 +00003211 CollectCXXTemplateParams(TSpecial, DefUnit));
David Blaikie952dac32013-08-15 22:42:12 +00003212 return RealDecl;
Guy Benyei11169dd2012-12-18 14:30:41 +00003213}
3214
David Blaikieadfbf992013-08-18 16:55:33 +00003215void CGDebugInfo::CollectContainingType(const CXXRecordDecl *RD,
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003216 llvm::DICompositeType *RealDecl) {
David Blaikieadfbf992013-08-18 16:55:33 +00003217 // A class's primary base or the class itself contains the vtable.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003218 llvm::DICompositeType *ContainingType = nullptr;
David Blaikieadfbf992013-08-18 16:55:33 +00003219 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
3220 if (const CXXRecordDecl *PBase = RL.getPrimaryBase()) {
Alp Tokerd4733632013-12-05 04:47:09 +00003221 // Seek non-virtual primary base root.
David Blaikieadfbf992013-08-18 16:55:33 +00003222 while (1) {
3223 const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase);
3224 const CXXRecordDecl *PBT = BRL.getPrimaryBase();
3225 if (PBT && !BRL.isPrimaryBaseVirtual())
3226 PBase = PBT;
3227 else
3228 break;
3229 }
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003230 ContainingType = cast<llvm::DICompositeType>(
David Blaikieadfbf992013-08-18 16:55:33 +00003231 getOrCreateType(QualType(PBase->getTypeForDecl(), 0),
3232 getOrCreateFile(RD->getLocation())));
3233 } else if (RD->isDynamicClass())
3234 ContainingType = RealDecl;
3235
Duncan P. N. Exon Smithc8ee63e2014-12-18 00:48:56 +00003236 DBuilder.replaceVTableHolder(RealDecl, ContainingType);
David Blaikieadfbf992013-08-18 16:55:33 +00003237}
3238
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003239llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit, QualType FType,
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00003240 StringRef Name, uint64_t *Offset) {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003241 llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +00003242 uint64_t FieldSize = CGM.getContext().getTypeSize(FType);
Victor Leschuka7ece032016-10-20 00:13:19 +00003243 auto FieldAlign = getTypeAlignIfRequired(FType, CGM.getContext());
Leny Kholodovdf050fd2016-09-06 17:06:14 +00003244 llvm::DIType *Ty =
3245 DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize, FieldAlign,
3246 *Offset, llvm::DINode::FlagZero, FieldTy);
Guy Benyei11169dd2012-12-18 14:30:41 +00003247 *Offset += FieldSize;
3248 return Ty;
3249}
3250
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003251void CGDebugInfo::collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit,
Duncan P. N. Exon Smith8e47da42015-04-21 20:07:29 +00003252 StringRef &Name,
3253 StringRef &LinkageName,
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003254 llvm::DIScope *&FDContext,
3255 llvm::DINodeArray &TParamsArray,
Leny Kholodov80c047d2016-09-06 10:48:04 +00003256 llvm::DINode::DIFlags &Flags) {
David Majnemer58ed0f32016-07-17 00:39:12 +00003257 const auto *FD = cast<FunctionDecl>(GD.getDecl());
Frederic Riss9db79f12014-11-18 03:40:46 +00003258 Name = getFunctionName(FD);
3259 // Use mangled name as linkage name for C/C++ functions.
3260 if (FD->hasPrototype()) {
3261 LinkageName = CGM.getMangledName(GD);
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003262 Flags |= llvm::DINode::FlagPrototyped;
Frederic Riss9db79f12014-11-18 03:40:46 +00003263 }
3264 // No need to replicate the linkage name if it isn't different from the
3265 // subprogram name, no need to have it at all unless coverage is enabled or
Dehao Chenb3a70de2017-01-19 00:44:21 +00003266 // debug is set to more than just line tables or extra debug info is needed.
Benjamin Kramer8c305922016-02-02 11:06:51 +00003267 if (LinkageName == Name || (!CGM.getCodeGenOpts().EmitGcovArcs &&
3268 !CGM.getCodeGenOpts().EmitGcovNotes &&
Dehao Chenb3a70de2017-01-19 00:44:21 +00003269 !CGM.getCodeGenOpts().DebugInfoForProfiling &&
Benjamin Kramer8c305922016-02-02 11:06:51 +00003270 DebugKind <= codegenoptions::DebugLineTablesOnly))
Frederic Riss9db79f12014-11-18 03:40:46 +00003271 LinkageName = StringRef();
3272
Benjamin Kramer8c305922016-02-02 11:06:51 +00003273 if (DebugKind >= codegenoptions::LimitedDebugInfo) {
Frederic Riss9db79f12014-11-18 03:40:46 +00003274 if (const NamespaceDecl *NSDecl =
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00003275 dyn_cast_or_null<NamespaceDecl>(FD->getDeclContext()))
Adrian Prantlddb8e062017-05-12 16:23:53 +00003276 FDContext = getOrCreateNamespace(NSDecl);
Frederic Riss9db79f12014-11-18 03:40:46 +00003277 else if (const RecordDecl *RDecl =
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00003278 dyn_cast_or_null<RecordDecl>(FD->getDeclContext())) {
Adrian Prantl5c8bd882015-09-11 17:23:08 +00003279 llvm::DIScope *Mod = getParentModuleOrNull(RDecl);
3280 FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU);
3281 }
Adrian Prantlfd5ac8a2016-08-17 16:20:32 +00003282 // Check if it is a noreturn-marked function
3283 if (FD->isNoReturn())
3284 Flags |= llvm::DINode::FlagNoReturn;
Frederic Riss9db79f12014-11-18 03:40:46 +00003285 // Collect template parameters.
3286 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
3287 }
3288}
3289
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003290void CGDebugInfo::collectVarDeclProps(const VarDecl *VD, llvm::DIFile *&Unit,
Frederic Riss9db79f12014-11-18 03:40:46 +00003291 unsigned &LineNo, QualType &T,
3292 StringRef &Name, StringRef &LinkageName,
Matthew Voss20165362018-10-03 18:45:04 +00003293 llvm::MDTuple *&TemplateParameters,
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003294 llvm::DIScope *&VDContext) {
Frederic Riss9db79f12014-11-18 03:40:46 +00003295 Unit = getOrCreateFile(VD->getLocation());
3296 LineNo = getLineNumber(VD->getLocation());
3297
3298 setLocation(VD->getLocation());
3299
3300 T = VD->getType();
3301 if (T->isIncompleteArrayType()) {
3302 // CodeGen turns int[] into int[1] so we'll do the same here.
3303 llvm::APInt ConstVal(32, 1);
3304 QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
3305
Richard Smith772e2662019-10-04 01:25:59 +00003306 T = CGM.getContext().getConstantArrayType(ET, ConstVal, nullptr,
3307 ArrayType::Normal, 0);
Frederic Riss9db79f12014-11-18 03:40:46 +00003308 }
3309
3310 Name = VD->getName();
3311 if (VD->getDeclContext() && !isa<FunctionDecl>(VD->getDeclContext()) &&
3312 !isa<ObjCMethodDecl>(VD->getDeclContext()))
3313 LinkageName = CGM.getMangledName(VD);
3314 if (LinkageName == Name)
3315 LinkageName = StringRef();
3316
Matthew Voss20165362018-10-03 18:45:04 +00003317 if (isa<VarTemplateSpecializationDecl>(VD)) {
3318 llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VD, &*Unit);
3319 TemplateParameters = parameterNodes.get();
3320 } else {
3321 TemplateParameters = nullptr;
3322 }
3323
Frederic Riss9db79f12014-11-18 03:40:46 +00003324 // Since we emit declarations (DW_AT_members) for static members, place the
3325 // definition of those static members in the namespace they were declared in
3326 // in the source code (the lexical decl context).
3327 // FIXME: Generalize this for even non-member global variables where the
3328 // declaration and definition may have different lexical decl contexts, once
3329 // we have support for emitting declarations of (non-member) global variables.
Saleem Abdulrasoolcd187f02015-02-28 00:13:13 +00003330 const DeclContext *DC = VD->isStaticDataMember() ? VD->getLexicalDeclContext()
3331 : VD->getDeclContext();
3332 // When a record type contains an in-line initialization of a static data
3333 // member, and the record type is marked as __declspec(dllexport), an implicit
3334 // definition of the member will be created in the record context. DWARF
3335 // doesn't seem to have a nice way to describe this in a form that consumers
3336 // are likely to understand, so fake the "normal" situation of a definition
3337 // outside the class by putting it in the global scope.
3338 if (DC->isRecord())
3339 DC = CGM.getContext().getTranslationUnitDecl();
Adrian Prantl5c8bd882015-09-11 17:23:08 +00003340
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00003341 llvm::DIScope *Mod = getParentModuleOrNull(VD);
3342 VDContext = getContextDescriptor(cast<Decl>(DC), Mod ? Mod : TheCU);
Frederic Riss9db79f12014-11-18 03:40:46 +00003343}
3344
Adrian Prantlb7acfc02017-02-27 21:30:05 +00003345llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(GlobalDecl GD,
3346 bool Stub) {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003347 llvm::DINodeArray TParamsArray;
Frederic Rissd253ed62014-11-18 03:40:51 +00003348 StringRef Name, LinkageName;
Leny Kholodov80c047d2016-09-06 10:48:04 +00003349 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
Paul Robinsoncda54212018-11-19 18:29:28 +00003350 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
Adrian Prantlb7acfc02017-02-27 21:30:05 +00003351 SourceLocation Loc = GD.getDecl()->getLocation();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003352 llvm::DIFile *Unit = getOrCreateFile(Loc);
3353 llvm::DIScope *DContext = Unit;
Frederic Rissd253ed62014-11-18 03:40:51 +00003354 unsigned Line = getLineNumber(Loc);
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00003355 collectFunctionDeclProps(GD, Unit, Name, LinkageName, DContext, TParamsArray,
3356 Flags);
Simon Pilgrimcfee2ef2019-10-16 10:38:49 +00003357 auto *FD = cast<FunctionDecl>(GD.getDecl());
Adrian Prantlb7acfc02017-02-27 21:30:05 +00003358
Frederic Rissd253ed62014-11-18 03:40:51 +00003359 // Build function type.
3360 SmallVector<QualType, 16> ArgTypes;
Simon Pilgrimcfee2ef2019-10-16 10:38:49 +00003361 for (const ParmVarDecl *Parm : FD->parameters())
3362 ArgTypes.push_back(Parm->getType());
3363
Reid Klecknerf00f8032016-06-08 20:41:54 +00003364 CallingConv CC = FD->getType()->castAs<FunctionType>()->getCallConv();
3365 QualType FnType = CGM.getContext().getFunctionType(
3366 FD->getReturnType(), ArgTypes, FunctionProtoType::ExtProtoInfo(CC));
Paul Robinsoncda54212018-11-19 18:29:28 +00003367 if (!FD->isExternallyVisible())
3368 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
3369 if (CGM.getLangOpts().Optimize)
3370 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
3371
Adrian Prantlb7acfc02017-02-27 21:30:05 +00003372 if (Stub) {
Vedant Kumar5931b4e2018-10-05 20:37:17 +00003373 Flags |= getCallSiteRelatedAttrs();
Paul Robinsoncda54212018-11-19 18:29:28 +00003374 SPFlags |= llvm::DISubprogram::SPFlagDefinition;
Adrian Prantlb7acfc02017-02-27 21:30:05 +00003375 return DBuilder.createFunction(
3376 DContext, Name, LinkageName, Unit, Line,
Paul Robinsoncda54212018-11-19 18:29:28 +00003377 getOrCreateFunctionType(GD.getDecl(), FnType, Unit), 0, Flags, SPFlags,
Adrian Prantlb7acfc02017-02-27 21:30:05 +00003378 TParamsArray.get(), getFunctionDeclaration(FD));
3379 }
3380
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003381 llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
Duncan P. N. Exon Smithebad0aa2015-04-07 16:50:49 +00003382 DContext, Name, LinkageName, Unit, Line,
Paul Robinsoncda54212018-11-19 18:29:28 +00003383 getOrCreateFunctionType(GD.getDecl(), FnType, Unit), 0, Flags, SPFlags,
Duncan P. N. Exon Smithebad0aa2015-04-07 16:50:49 +00003384 TParamsArray.get(), getFunctionDeclaration(FD));
George Burgess IV00f70bd2018-03-01 05:43:23 +00003385 const FunctionDecl *CanonDecl = FD->getCanonicalDecl();
Duncan P. N. Exon Smith4078ad42015-04-16 16:36:45 +00003386 FwdDeclReplaceMap.emplace_back(std::piecewise_construct,
3387 std::make_tuple(CanonDecl),
3388 std::make_tuple(SP));
Frederic Rissd253ed62014-11-18 03:40:51 +00003389 return SP;
3390}
3391
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00003392llvm::DISubprogram *CGDebugInfo::getFunctionForwardDeclaration(GlobalDecl GD) {
Adrian Prantlb7acfc02017-02-27 21:30:05 +00003393 return getFunctionFwdDeclOrStub(GD, /* Stub = */ false);
3394}
3395
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00003396llvm::DISubprogram *CGDebugInfo::getFunctionStub(GlobalDecl GD) {
Adrian Prantlb7acfc02017-02-27 21:30:05 +00003397 return getFunctionFwdDeclOrStub(GD, /* Stub = */ true);
3398}
3399
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003400llvm::DIGlobalVariable *
Frederic Rissd253ed62014-11-18 03:40:51 +00003401CGDebugInfo::getGlobalVariableForwardDeclaration(const VarDecl *VD) {
3402 QualType T;
3403 StringRef Name, LinkageName;
3404 SourceLocation Loc = VD->getLocation();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003405 llvm::DIFile *Unit = getOrCreateFile(Loc);
3406 llvm::DIScope *DContext = Unit;
Frederic Rissd253ed62014-11-18 03:40:51 +00003407 unsigned Line = getLineNumber(Loc);
Matthew Voss20165362018-10-03 18:45:04 +00003408 llvm::MDTuple *TemplateParameters = nullptr;
Frederic Rissd253ed62014-11-18 03:40:51 +00003409
Matthew Voss20165362018-10-03 18:45:04 +00003410 collectVarDeclProps(VD, Unit, Line, T, Name, LinkageName, TemplateParameters,
3411 DContext);
Victor Leschuka7ece032016-10-20 00:13:19 +00003412 auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
Duncan P. N. Exon Smithdadc2b62015-04-21 18:43:54 +00003413 auto *GV = DBuilder.createTempGlobalVariableFwdDecl(
3414 DContext, Name, LinkageName, Unit, Line, getOrCreateType(T, Unit),
Matthew Voss20165362018-10-03 18:45:04 +00003415 !VD->isExternallyVisible(), nullptr, TemplateParameters, Align);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00003416 FwdDeclReplaceMap.emplace_back(
3417 std::piecewise_construct,
3418 std::make_tuple(cast<VarDecl>(VD->getCanonicalDecl())),
3419 std::make_tuple(static_cast<llvm::Metadata *>(GV)));
Frederic Rissd253ed62014-11-18 03:40:51 +00003420 return GV;
3421}
3422
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003423llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(const Decl *D) {
David Blaikiebd483762013-05-20 04:58:53 +00003424 // We only need a declaration (not a definition) of the type - so use whatever
3425 // we would otherwise do to get a type for a pointee. (forward declarations in
3426 // limited debug info, full definitions (if the type definition is available)
3427 // in unlimited debug info)
David Majnemer58ed0f32016-07-17 00:39:12 +00003428 if (const auto *TD = dyn_cast<TypeDecl>(D))
David Blaikie6b7d060c2013-08-12 23:14:36 +00003429 return getOrCreateType(CGM.getContext().getTypeDeclType(TD),
David Blaikie99dab3b2013-09-04 22:03:57 +00003430 getOrCreateFile(TD->getLocation()));
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00003431 auto I = DeclCache.find(D->getCanonicalDecl());
Frederic Rissd253ed62014-11-18 03:40:51 +00003432
Adrian Prantl5f4740d2016-12-20 02:10:02 +00003433 if (I != DeclCache.end()) {
3434 auto N = I->second;
3435 if (auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(N))
3436 return GVE->getVariable();
3437 return dyn_cast_or_null<llvm::DINode>(N);
3438 }
Frederic Rissd253ed62014-11-18 03:40:51 +00003439
3440 // No definition for now. Emit a forward definition that might be
3441 // merged with a potential upcoming definition.
David Majnemer58ed0f32016-07-17 00:39:12 +00003442 if (const auto *FD = dyn_cast<FunctionDecl>(D))
Frederic Rissd253ed62014-11-18 03:40:51 +00003443 return getFunctionForwardDeclaration(FD);
3444 else if (const auto *VD = dyn_cast<VarDecl>(D))
3445 return getGlobalVariableForwardDeclaration(VD);
3446
Duncan P. N. Exon Smith4078ad42015-04-16 16:36:45 +00003447 return nullptr;
David Blaikiebd483762013-05-20 04:58:53 +00003448}
3449
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003450llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(const Decl *D) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00003451 if (!D || DebugKind <= codegenoptions::DebugLineTablesOnly)
Duncan P. N. Exon Smitha7fbcbf2015-04-20 22:09:57 +00003452 return nullptr;
David Blaikie18cfbc52013-06-22 00:09:36 +00003453
David Majnemer58ed0f32016-07-17 00:39:12 +00003454 const auto *FD = dyn_cast<FunctionDecl>(D);
Eric Christophere7b87e52014-10-26 23:40:33 +00003455 if (!FD)
Duncan P. N. Exon Smitha7fbcbf2015-04-20 22:09:57 +00003456 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00003457
3458 // Setup context.
Adrian Prantl6ec370a2015-09-10 18:39:45 +00003459 auto *S = getDeclContextDescriptor(D);
Guy Benyei11169dd2012-12-18 14:30:41 +00003460
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00003461 auto MI = SPCache.find(FD->getCanonicalDecl());
David Blaikiefd07c602013-08-09 17:20:05 +00003462 if (MI == SPCache.end()) {
David Majnemer58ed0f32016-07-17 00:39:12 +00003463 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD->getCanonicalDecl())) {
Duncan P. N. Exon Smithc09c5482015-04-20 21:17:26 +00003464 return CreateCXXMemberFunction(MD, getOrCreateFile(MD->getLocation()),
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003465 cast<llvm::DICompositeType>(S));
David Blaikiefd07c602013-08-09 17:20:05 +00003466 }
3467 }
Guy Benyei11169dd2012-12-18 14:30:41 +00003468 if (MI != SPCache.end()) {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003469 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
Duncan P. N. Exon Smith87afdeb2015-04-14 03:24:14 +00003470 if (SP && !SP->isDefinition())
Guy Benyei11169dd2012-12-18 14:30:41 +00003471 return SP;
3472 }
3473
Aaron Ballman86c93902014-03-06 23:45:36 +00003474 for (auto NextFD : FD->redecls()) {
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00003475 auto MI = SPCache.find(NextFD->getCanonicalDecl());
Guy Benyei11169dd2012-12-18 14:30:41 +00003476 if (MI != SPCache.end()) {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003477 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
Duncan P. N. Exon Smith87afdeb2015-04-14 03:24:14 +00003478 if (SP && !SP->isDefinition())
Guy Benyei11169dd2012-12-18 14:30:41 +00003479 return SP;
3480 }
3481 }
Duncan P. N. Exon Smitha7fbcbf2015-04-20 22:09:57 +00003482 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00003483}
3484
Adrian Prantl901cc4a2019-11-08 09:24:31 -08003485llvm::DISubprogram *CGDebugInfo::getObjCMethodDeclaration(
3486 const Decl *D, llvm::DISubroutineType *FnType, unsigned LineNo,
3487 llvm::DINode::DIFlags Flags, llvm::DISubprogram::DISPFlags SPFlags) {
3488 if (!D || DebugKind <= codegenoptions::DebugLineTablesOnly)
3489 return nullptr;
3490
Adrian Prantle0cabe22019-11-21 09:56:01 -08003491 const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
3492 if (!OMD)
3493 return nullptr;
3494
3495 if (CGM.getCodeGenOpts().DwarfVersion < 5 && !OMD->isDirectMethod())
Adrian Prantl901cc4a2019-11-08 09:24:31 -08003496 return nullptr;
3497
Raphael Isemannccfab8e2019-12-17 09:36:57 +01003498 if (OMD->isDirectMethod())
3499 SPFlags |= llvm::DISubprogram::SPFlagObjCDirect;
3500
Adrian Prantl901cc4a2019-11-08 09:24:31 -08003501 // Starting with DWARF V5 method declarations are emitted as children of
3502 // the interface type.
Adrian Prantl901cc4a2019-11-08 09:24:31 -08003503 auto *ID = dyn_cast_or_null<ObjCInterfaceDecl>(D->getDeclContext());
3504 if (!ID)
3505 ID = OMD->getClassInterface();
3506 if (!ID)
3507 return nullptr;
3508 QualType QTy(ID->getTypeForDecl(), 0);
3509 auto It = TypeCache.find(QTy.getAsOpaquePtr());
3510 if (It == TypeCache.end())
3511 return nullptr;
3512 auto *InterfaceType = cast<llvm::DICompositeType>(It->second);
3513 llvm::DISubprogram *FD = DBuilder.createFunction(
3514 InterfaceType, getObjCMethodName(OMD), StringRef(),
3515 InterfaceType->getFile(), LineNo, FnType, LineNo, Flags, SPFlags);
3516 DBuilder.finalizeSubprogram(FD);
Adrian Prantle0cabe22019-11-21 09:56:01 -08003517 ObjCMethodCache[ID].push_back({FD, OMD->isDirectMethod()});
Adrian Prantl901cc4a2019-11-08 09:24:31 -08003518 return FD;
3519}
3520
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00003521// getOrCreateFunctionType - Construct type. If it is a c++ method, include
Guy Benyei11169dd2012-12-18 14:30:41 +00003522// implicit parameter "this".
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003523llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(const Decl *D,
Duncan P. N. Exon Smith4078ad42015-04-16 16:36:45 +00003524 QualType FnType,
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003525 llvm::DIFile *F) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00003526 if (!D || DebugKind <= codegenoptions::DebugLineTablesOnly)
Duncan P. N. Exon Smitha7fbcbf2015-04-20 22:09:57 +00003527 // Create fake but valid subroutine type. Otherwise -verify would fail, and
3528 // subprogram DIE will miss DW_AT_decl_file and DW_AT_decl_line fields.
Eric Christopher28a6db52015-10-15 06:56:08 +00003529 return DBuilder.createSubroutineType(DBuilder.getOrCreateTypeArray(None));
Guy Benyei11169dd2012-12-18 14:30:41 +00003530
David Majnemer58ed0f32016-07-17 00:39:12 +00003531 if (const auto *Method = dyn_cast<CXXMethodDecl>(D))
Guy Benyei11169dd2012-12-18 14:30:41 +00003532 return getOrCreateMethodType(Method, F);
Reid Klecknerf00f8032016-06-08 20:41:54 +00003533
3534 const auto *FTy = FnType->getAs<FunctionType>();
3535 CallingConv CC = FTy ? FTy->getCallConv() : CallingConv::CC_C;
3536
David Majnemer58ed0f32016-07-17 00:39:12 +00003537 if (const auto *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003538 // Add "self" and "_cmd"
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00003539 SmallVector<llvm::Metadata *, 16> Elts;
Guy Benyei11169dd2012-12-18 14:30:41 +00003540
3541 // First element is always return type. For 'void' functions it is NULL.
Alp Toker314cc812014-01-25 16:55:45 +00003542 QualType ResultTy = OMethod->getReturnType();
Adrian Prantl5f360102013-05-22 21:37:49 +00003543
3544 // Replace the instancetype keyword with the actual type.
3545 if (ResultTy == CGM.getContext().getObjCInstanceType())
3546 ResultTy = CGM.getContext().getPointerType(
Eric Christophere7b87e52014-10-26 23:40:33 +00003547 QualType(OMethod->getClassInterface()->getTypeForDecl(), 0));
Adrian Prantl5f360102013-05-22 21:37:49 +00003548
Adrian Prantl7bec9032013-05-10 21:08:31 +00003549 Elts.push_back(getOrCreateType(ResultTy, F));
Guy Benyei11169dd2012-12-18 14:30:41 +00003550 // "self" pointer is always first argument.
Adrian Prantl748a6cd2015-09-08 20:41:52 +00003551 QualType SelfDeclTy;
3552 if (auto *SelfDecl = OMethod->getSelfDecl())
3553 SelfDeclTy = SelfDecl->getType();
3554 else if (auto *FPT = dyn_cast<FunctionProtoType>(FnType))
3555 if (FPT->getNumParams() > 1)
3556 SelfDeclTy = FPT->getParamType(0);
3557 if (!SelfDeclTy.isNull())
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00003558 Elts.push_back(
3559 CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F)));
Guy Benyei11169dd2012-12-18 14:30:41 +00003560 // "_cmd" pointer is always second argument.
Duncan P. N. Exon Smith0b6c3692015-04-20 18:51:48 +00003561 Elts.push_back(DBuilder.createArtificialType(
Adrian Prantl748a6cd2015-09-08 20:41:52 +00003562 getOrCreateType(CGM.getContext().getObjCSelType(), F)));
Guy Benyei11169dd2012-12-18 14:30:41 +00003563 // Get rest of the arguments.
David Majnemer59f77922016-06-24 04:05:48 +00003564 for (const auto *PI : OMethod->parameters())
Aaron Ballman43b68be2014-03-07 17:50:17 +00003565 Elts.push_back(getOrCreateType(PI->getType(), F));
Frederic Riss787d9d62014-08-12 04:42:23 +00003566 // Variadic methods need a special marker at the end of the type list.
3567 if (OMethod->isVariadic())
3568 Elts.push_back(DBuilder.createUnspecifiedParameter());
Guy Benyei11169dd2012-12-18 14:30:41 +00003569
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003570 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
Leny Kholodov80c047d2016-09-06 10:48:04 +00003571 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
3572 getDwarfCC(CC));
Guy Benyei11169dd2012-12-18 14:30:41 +00003573 }
Adrian Prantld45ba252014-02-25 19:38:11 +00003574
Adrian Prantl800faef2014-02-25 23:42:18 +00003575 // Handle variadic function types; they need an additional
3576 // unspecified parameter.
David Majnemer58ed0f32016-07-17 00:39:12 +00003577 if (const auto *FD = dyn_cast<FunctionDecl>(D))
Adrian Prantld45ba252014-02-25 19:38:11 +00003578 if (FD->isVariadic()) {
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00003579 SmallVector<llvm::Metadata *, 16> EltTys;
Adrian Prantld45ba252014-02-25 19:38:11 +00003580 EltTys.push_back(getOrCreateType(FD->getReturnType(), F));
David Majnemer58ed0f32016-07-17 00:39:12 +00003581 if (const auto *FPT = dyn_cast<FunctionProtoType>(FnType))
3582 for (QualType ParamType : FPT->param_types())
3583 EltTys.push_back(getOrCreateType(ParamType, F));
Adrian Prantld45ba252014-02-25 19:38:11 +00003584 EltTys.push_back(DBuilder.createUnspecifiedParameter());
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003585 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
Leny Kholodov80c047d2016-09-06 10:48:04 +00003586 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
3587 getDwarfCC(CC));
Adrian Prantld45ba252014-02-25 19:38:11 +00003588 }
3589
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003590 return cast<llvm::DISubroutineType>(getOrCreateType(FnType, F));
Guy Benyei11169dd2012-12-18 14:30:41 +00003591}
3592
Eric Christophere7b87e52014-10-26 23:40:33 +00003593void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, SourceLocation Loc,
3594 SourceLocation ScopeLoc, QualType FnType,
Brock Wyma94ece8f2018-04-16 16:53:57 +00003595 llvm::Function *Fn, bool CurFuncIsThunk,
3596 CGBuilderTy &Builder) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003597
3598 StringRef Name;
3599 StringRef LinkageName;
3600
3601 FnBeginRegionCount.push_back(LexicalBlockStack.size());
3602
3603 const Decl *D = GD.getDecl();
Craig Topper8a13c412014-05-21 05:09:00 +00003604 bool HasDecl = (D != nullptr);
Eric Christopher885c41b2014-04-01 22:25:28 +00003605
Leny Kholodov80c047d2016-09-06 10:48:04 +00003606 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
Paul Robinsoncda54212018-11-19 18:29:28 +00003607 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003608 llvm::DIFile *Unit = getOrCreateFile(Loc);
3609 llvm::DIScope *FDContext = Unit;
3610 llvm::DINodeArray TParamsArray;
Guy Benyei11169dd2012-12-18 14:30:41 +00003611 if (!HasDecl) {
3612 // Use llvm function name.
David Blaikieebe87e12013-08-27 23:57:18 +00003613 LinkageName = Fn->getName();
David Majnemer58ed0f32016-07-17 00:39:12 +00003614 } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
Duncan P. N. Exon Smitha7fbcbf2015-04-20 22:09:57 +00003615 // If there is a subprogram for this function available then use it.
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00003616 auto FI = SPCache.find(FD->getCanonicalDecl());
Guy Benyei11169dd2012-12-18 14:30:41 +00003617 if (FI != SPCache.end()) {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003618 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
Duncan P. N. Exon Smith87afdeb2015-04-14 03:24:14 +00003619 if (SP && SP->isDefinition()) {
Duncan P. N. Exon Smithd899f6e2015-04-18 00:07:30 +00003620 LexicalBlockStack.emplace_back(SP);
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00003621 RegionMap[D].reset(SP);
Guy Benyei11169dd2012-12-18 14:30:41 +00003622 return;
3623 }
3624 }
Frederic Riss9db79f12014-11-18 03:40:46 +00003625 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
3626 TParamsArray, Flags);
David Majnemer58ed0f32016-07-17 00:39:12 +00003627 } else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003628 Name = getObjCMethodName(OMD);
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003629 Flags |= llvm::DINode::FlagPrototyped;
Reid Kleckner105c5652019-04-24 22:45:44 +00003630 } else if (isa<VarDecl>(D) &&
3631 GD.getDynamicInitKind() != DynamicInitKind::NoStub) {
3632 // This is a global initializer or atexit destructor for a global variable.
3633 Name = getDynamicInitializerName(cast<VarDecl>(D), GD.getDynamicInitKind(),
3634 Fn);
Guy Benyei11169dd2012-12-18 14:30:41 +00003635 } else {
3636 // Use llvm function name.
3637 Name = Fn->getName();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003638 Flags |= llvm::DINode::FlagPrototyped;
Guy Benyei11169dd2012-12-18 14:30:41 +00003639 }
David Majnemer58ed0f32016-07-17 00:39:12 +00003640 if (Name.startswith("\01"))
Guy Benyei11169dd2012-12-18 14:30:41 +00003641 Name = Name.substr(1);
3642
Alexandre Ganeacaf31662019-11-15 16:21:17 -05003643 if (!HasDecl || D->isImplicit() || D->hasAttr<ArtificialAttr>()) {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003644 Flags |= llvm::DINode::FlagArtificial;
Adrian Prantldb763572016-11-09 21:43:51 +00003645 // Artificial functions should not silently reuse CurLoc.
3646 CurLoc = SourceLocation();
Adrian Prantl42d71b92014-04-10 23:21:53 +00003647 }
Brock Wyma94ece8f2018-04-16 16:53:57 +00003648
3649 if (CurFuncIsThunk)
3650 Flags |= llvm::DINode::FlagThunk;
3651
Paul Robinsoncda54212018-11-19 18:29:28 +00003652 if (Fn->hasLocalLinkage())
3653 SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit;
3654 if (CGM.getLangOpts().Optimize)
3655 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
3656
Vedant Kumar5931b4e2018-10-05 20:37:17 +00003657 llvm::DINode::DIFlags FlagsForDef = Flags | getCallSiteRelatedAttrs();
Paul Robinsoncda54212018-11-19 18:29:28 +00003658 llvm::DISubprogram::DISPFlags SPFlagsForDef =
3659 SPFlags | llvm::DISubprogram::SPFlagDefinition;
Vedant Kumar5931b4e2018-10-05 20:37:17 +00003660
Adrian Prantl42d71b92014-04-10 23:21:53 +00003661 unsigned LineNo = getLineNumber(Loc);
3662 unsigned ScopeLine = getLineNumber(ScopeLoc);
Adrian Prantl901cc4a2019-11-08 09:24:31 -08003663 llvm::DISubroutineType *DIFnType = getOrCreateFunctionType(D, FnType, Unit);
3664 llvm::DISubprogram *Decl = nullptr;
3665 if (D)
3666 Decl = isa<ObjCMethodDecl>(D)
3667 ? getObjCMethodDeclaration(D, DIFnType, LineNo, Flags, SPFlags)
3668 : getFunctionDeclaration(D);
Guy Benyei11169dd2012-12-18 14:30:41 +00003669
Eric Christopher8018e412014-03-27 18:50:35 +00003670 // FIXME: The function declaration we're constructing here is mostly reusing
3671 // declarations from CXXMethodDecl and not constructing new ones for arbitrary
3672 // FunctionDecls. When/if we fix this we can have FDContext be TheCU/null for
3673 // all subprograms instead of the actual context since subprogram definitions
3674 // are emitted as CU level entities by the backend.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003675 llvm::DISubprogram *SP = DBuilder.createFunction(
Adrian Prantl901cc4a2019-11-08 09:24:31 -08003676 FDContext, Name, LinkageName, Unit, LineNo, DIFnType, ScopeLine,
3677 FlagsForDef, SPFlagsForDef, TParamsArray.get(), Decl);
Peter Collingbourne0900fe02015-11-05 22:04:14 +00003678 Fn->setSubprogram(SP);
Frederic Rissb1ab28c2014-11-05 19:19:04 +00003679 // We might get here with a VarDecl in the case we're generating
3680 // code for the initialization of globals. Do not record these decls
3681 // as they will overwrite the actual VarDecl Decl in the cache.
3682 if (HasDecl && isa<FunctionDecl>(D))
David Majnemer58ed0f32016-07-17 00:39:12 +00003683 DeclCache[D->getCanonicalDecl()].reset(SP);
Guy Benyei11169dd2012-12-18 14:30:41 +00003684
Adrian Prantlbebb8932014-03-21 21:01:58 +00003685 // Push the function onto the lexical block stack.
Duncan P. N. Exon Smithd899f6e2015-04-18 00:07:30 +00003686 LexicalBlockStack.emplace_back(SP);
Adrian Prantlbebb8932014-03-21 21:01:58 +00003687
Guy Benyei11169dd2012-12-18 14:30:41 +00003688 if (HasDecl)
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00003689 RegionMap[D].reset(SP);
Guy Benyei11169dd2012-12-18 14:30:41 +00003690}
3691
Vedant Kumar8bd52142019-07-11 19:28:07 +00003692void CGDebugInfo::EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc,
3693 QualType FnType, llvm::Function *Fn) {
Adrian Prantl748a6cd2015-09-08 20:41:52 +00003694 StringRef Name;
3695 StringRef LinkageName;
3696
3697 const Decl *D = GD.getDecl();
3698 if (!D)
Vedant Kumar8bd52142019-07-11 19:28:07 +00003699 return;
Adrian Prantl748a6cd2015-09-08 20:41:52 +00003700
Luboš Luňák4f2104c2019-11-02 16:39:59 +01003701 llvm::TimeTraceScope TimeScope("DebugFunction", [&]() {
3702 std::string Name;
3703 llvm::raw_string_ostream OS(Name);
3704 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
3705 ND->getNameForDiagnostic(OS, getPrintingPolicy(),
3706 /*Qualified=*/true);
3707 return Name;
3708 });
3709
Leny Kholodov80c047d2016-09-06 10:48:04 +00003710 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
Adrian Prantl748a6cd2015-09-08 20:41:52 +00003711 llvm::DIFile *Unit = getOrCreateFile(Loc);
Vedant Kumar8bd52142019-07-11 19:28:07 +00003712 bool IsDeclForCallSite = Fn ? true : false;
Djordje Todorovic0f651682019-06-27 06:44:44 +00003713 llvm::DIScope *FDContext =
3714 IsDeclForCallSite ? Unit : getDeclContextDescriptor(D);
Adrian Prantl748a6cd2015-09-08 20:41:52 +00003715 llvm::DINodeArray TParamsArray;
3716 if (isa<FunctionDecl>(D)) {
3717 // If there is a DISubprogram for this function available then use it.
3718 collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
3719 TParamsArray, Flags);
David Majnemer58ed0f32016-07-17 00:39:12 +00003720 } else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
Adrian Prantl748a6cd2015-09-08 20:41:52 +00003721 Name = getObjCMethodName(OMD);
3722 Flags |= llvm::DINode::FlagPrototyped;
3723 } else {
3724 llvm_unreachable("not a function or ObjC method");
3725 }
3726 if (!Name.empty() && Name[0] == '\01')
3727 Name = Name.substr(1);
3728
3729 if (D->isImplicit()) {
3730 Flags |= llvm::DINode::FlagArtificial;
3731 // Artificial functions without a location should not silently reuse CurLoc.
3732 if (Loc.isInvalid())
3733 CurLoc = SourceLocation();
3734 }
3735 unsigned LineNo = getLineNumber(Loc);
3736 unsigned ScopeLine = 0;
Paul Robinsoncda54212018-11-19 18:29:28 +00003737 llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
3738 if (CGM.getLangOpts().Optimize)
3739 SPFlags |= llvm::DISubprogram::SPFlagOptimized;
Adrian Prantl748a6cd2015-09-08 20:41:52 +00003740
Djordje Todorovic0f651682019-06-27 06:44:44 +00003741 llvm::DISubprogram *SP = DBuilder.createFunction(
Adrian Prantle76bda52016-04-15 15:55:45 +00003742 FDContext, Name, LinkageName, Unit, LineNo,
Paul Robinsoncda54212018-11-19 18:29:28 +00003743 getOrCreateFunctionType(D, FnType, Unit), ScopeLine, Flags, SPFlags,
Djordje Todorovic0f651682019-06-27 06:44:44 +00003744 TParamsArray.get(), getFunctionDeclaration(D));
Vedant Kumar8bd52142019-07-11 19:28:07 +00003745
3746 if (IsDeclForCallSite)
3747 Fn->setSubprogram(SP);
3748
Djordje Todorovic0f651682019-06-27 06:44:44 +00003749 DBuilder.retainType(SP);
3750}
3751
3752void CGDebugInfo::EmitFuncDeclForCallSite(llvm::CallBase *CallOrInvoke,
3753 QualType CalleeType,
3754 const FunctionDecl *CalleeDecl) {
Vedant Kumar568db782019-11-13 18:19:32 -08003755 if (!CallOrInvoke)
Djordje Todorovic0f651682019-06-27 06:44:44 +00003756 return;
Djordje Todorovic0f651682019-06-27 06:44:44 +00003757 auto *Func = CallOrInvoke->getCalledFunction();
3758 if (!Func)
3759 return;
Vedant Kumar568db782019-11-13 18:19:32 -08003760 if (Func->getSubprogram())
3761 return;
3762
3763 // Do not emit a declaration subprogram for a builtin or if call site info
3764 // isn't required. Also, elide declarations for functions with reserved names,
3765 // as call site-related features aren't interesting in this case (& also, the
3766 // compiler may emit calls to these functions without debug locations, which
3767 // makes the verifier complain).
3768 if (CalleeDecl->getBuiltinID() != 0 ||
3769 getCallSiteRelatedAttrs() == llvm::DINode::FlagZero)
3770 return;
3771 if (const auto *Id = CalleeDecl->getIdentifier())
3772 if (Id->isReservedName())
3773 return;
Djordje Todorovic0f651682019-06-27 06:44:44 +00003774
3775 // If there is no DISubprogram attached to the function being called,
3776 // create the one describing the function in order to have complete
3777 // call site debug info.
Vedant Kumar8bd52142019-07-11 19:28:07 +00003778 if (!CalleeDecl->isStatic() && !CalleeDecl->isInlined())
3779 EmitFunctionDecl(CalleeDecl, CalleeDecl->getLocation(), CalleeType, Func);
Adrian Prantl748a6cd2015-09-08 20:41:52 +00003780}
3781
Adrian Prantlb7acfc02017-02-27 21:30:05 +00003782void CGDebugInfo::EmitInlineFunctionStart(CGBuilderTy &Builder, GlobalDecl GD) {
3783 const auto *FD = cast<FunctionDecl>(GD.getDecl());
3784 // If there is a subprogram for this function available then use it.
3785 auto FI = SPCache.find(FD->getCanonicalDecl());
3786 llvm::DISubprogram *SP = nullptr;
3787 if (FI != SPCache.end())
3788 SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
Adrian Prantl8040a212017-08-23 21:24:12 +00003789 if (!SP || !SP->isDefinition())
Adrian Prantlb7acfc02017-02-27 21:30:05 +00003790 SP = getFunctionStub(GD);
3791 FnBeginRegionCount.push_back(LexicalBlockStack.size());
3792 LexicalBlockStack.emplace_back(SP);
3793 setInlinedAt(Builder.getCurrentDebugLocation());
3794 EmitLocation(Builder, FD->getLocation());
3795}
3796
3797void CGDebugInfo::EmitInlineFunctionEnd(CGBuilderTy &Builder) {
3798 assert(CurInlinedAt && "unbalanced inline scope stack");
Keno Fischer41d4b4e2017-06-01 21:14:03 +00003799 EmitFunctionEnd(Builder, nullptr);
Adrian Prantlb7acfc02017-02-27 21:30:05 +00003800 setInlinedAt(llvm::DebugLoc(CurInlinedAt).getInlinedAt());
3801}
3802
Calixte Denizetfcd661d2018-09-24 18:24:18 +00003803void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003804 // Update our current location
3805 setLocation(Loc);
3806
Adrian Prantl42ab39f2018-11-09 21:17:38 +00003807 if (CurLoc.isInvalid() || CurLoc.isMacroID() || LexicalBlockStack.empty())
Eric Christophere7b87e52014-10-26 23:40:33 +00003808 return;
Guy Benyei11169dd2012-12-18 14:30:41 +00003809
Adrian Prantle83b1302014-01-07 22:05:52 +00003810 llvm::MDNode *Scope = LexicalBlockStack.back();
Calixte Denizetfcd661d2018-09-24 18:24:18 +00003811 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
3812 getLineNumber(CurLoc), getColumnNumber(CurLoc), Scope, CurInlinedAt));
Guy Benyei11169dd2012-12-18 14:30:41 +00003813}
3814
Guy Benyei11169dd2012-12-18 14:30:41 +00003815void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) {
Duncan P. N. Exon Smitha66e3052014-12-09 19:22:40 +00003816 llvm::MDNode *Back = nullptr;
3817 if (!LexicalBlockStack.empty())
3818 Back = LexicalBlockStack.back().get();
Duncan P. N. Exon Smithd899f6e2015-04-18 00:07:30 +00003819 LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003820 cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
Duncan P. N. Exon Smithd899f6e2015-04-18 00:07:30 +00003821 getColumnNumber(CurLoc)));
Guy Benyei11169dd2012-12-18 14:30:41 +00003822}
3823
Konstantin Zhuravlyov2b4917f2017-03-09 18:06:23 +00003824void CGDebugInfo::AppendAddressSpaceXDeref(
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00003825 unsigned AddressSpace, SmallVectorImpl<int64_t> &Expr) const {
Konstantin Zhuravlyov2b4917f2017-03-09 18:06:23 +00003826 Optional<unsigned> DWARFAddressSpace =
3827 CGM.getTarget().getDWARFAddressSpace(AddressSpace);
3828 if (!DWARFAddressSpace)
3829 return;
3830
3831 Expr.push_back(llvm::dwarf::DW_OP_constu);
3832 Expr.push_back(DWARFAddressSpace.getValue());
3833 Expr.push_back(llvm::dwarf::DW_OP_swap);
3834 Expr.push_back(llvm::dwarf::DW_OP_xderef);
3835}
3836
Eric Christopher0fdcb312013-05-16 00:52:20 +00003837void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder,
3838 SourceLocation Loc) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003839 // Set our current location.
3840 setLocation(Loc);
3841
Guy Benyei11169dd2012-12-18 14:30:41 +00003842 // Emit a line table change for the current location inside the new scope.
Adrian Prantlb7acfc02017-02-27 21:30:05 +00003843 Builder.SetCurrentDebugLocation(
3844 llvm::DebugLoc::get(getLineNumber(Loc), getColumnNumber(Loc),
3845 LexicalBlockStack.back(), CurInlinedAt));
David Blaikie60a877b2014-10-22 19:34:33 +00003846
Benjamin Kramer8c305922016-02-02 11:06:51 +00003847 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
David Blaikie60a877b2014-10-22 19:34:33 +00003848 return;
3849
3850 // Create a new lexical block and push it on the stack.
3851 CreateLexicalBlock(Loc);
Guy Benyei11169dd2012-12-18 14:30:41 +00003852}
3853
Eric Christopher0fdcb312013-05-16 00:52:20 +00003854void CGDebugInfo::EmitLexicalBlockEnd(CGBuilderTy &Builder,
3855 SourceLocation Loc) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003856 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
3857
3858 // Provide an entry in the line table for the end of the block.
Calixte Denizetfcd661d2018-09-24 18:24:18 +00003859 EmitLocation(Builder, Loc);
Guy Benyei11169dd2012-12-18 14:30:41 +00003860
Benjamin Kramer8c305922016-02-02 11:06:51 +00003861 if (DebugKind <= codegenoptions::DebugLineTablesOnly)
David Blaikie60a877b2014-10-22 19:34:33 +00003862 return;
3863
Guy Benyei11169dd2012-12-18 14:30:41 +00003864 LexicalBlockStack.pop_back();
3865}
3866
Keno Fischer41d4b4e2017-06-01 21:14:03 +00003867void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder, llvm::Function *Fn) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003868 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
3869 unsigned RCount = FnBeginRegionCount.back();
3870 assert(RCount <= LexicalBlockStack.size() && "Region stack mismatch");
3871
3872 // Pop all regions for this function.
David Blaikie60a877b2014-10-22 19:34:33 +00003873 while (LexicalBlockStack.size() != RCount) {
3874 // Provide an entry in the line table for the end of the block.
Calixte Denizetfcd661d2018-09-24 18:24:18 +00003875 EmitLocation(Builder, CurLoc);
David Blaikie60a877b2014-10-22 19:34:33 +00003876 LexicalBlockStack.pop_back();
3877 }
Guy Benyei11169dd2012-12-18 14:30:41 +00003878 FnBeginRegionCount.pop_back();
Keno Fischer41d4b4e2017-06-01 21:14:03 +00003879
3880 if (Fn && Fn->getSubprogram())
3881 DBuilder.finalizeSubprogram(Fn->getSubprogram());
Guy Benyei11169dd2012-12-18 14:30:41 +00003882}
3883
Adrian Prantl05a623e2018-09-10 16:14:28 +00003884CGDebugInfo::BlockByRefType
3885CGDebugInfo::EmitTypeForVarWithBlocksAttr(const VarDecl *VD,
3886 uint64_t *XOffset) {
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00003887 SmallVector<llvm::Metadata *, 5> EltTys;
Guy Benyei11169dd2012-12-18 14:30:41 +00003888 QualType FType;
3889 uint64_t FieldSize, FieldOffset;
Victor Leschuk802e4a52016-10-19 22:11:07 +00003890 uint32_t FieldAlign;
Eric Christopherb2a008c2013-05-16 00:45:12 +00003891
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003892 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
Eric Christopherb2a008c2013-05-16 00:45:12 +00003893 QualType Type = VD->getType();
Guy Benyei11169dd2012-12-18 14:30:41 +00003894
3895 FieldOffset = 0;
3896 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
3897 EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
3898 EltTys.push_back(CreateMemberType(Unit, FType, "__forwarding", &FieldOffset));
3899 FType = CGM.getContext().IntTy;
3900 EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
3901 EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset));
3902
3903 bool HasCopyAndDispose = CGM.getContext().BlockRequiresCopying(Type, VD);
3904 if (HasCopyAndDispose) {
3905 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Eric Christophere7b87e52014-10-26 23:40:33 +00003906 EltTys.push_back(
3907 CreateMemberType(Unit, FType, "__copy_helper", &FieldOffset));
3908 EltTys.push_back(
3909 CreateMemberType(Unit, FType, "__destroy_helper", &FieldOffset));
Guy Benyei11169dd2012-12-18 14:30:41 +00003910 }
3911 bool HasByrefExtendedLayout;
3912 Qualifiers::ObjCLifetime Lifetime;
Eric Christophere7b87e52014-10-26 23:40:33 +00003913 if (CGM.getContext().getByrefLifetime(Type, Lifetime,
3914 HasByrefExtendedLayout) &&
3915 HasByrefExtendedLayout) {
Adrian Prantlead2ba42013-07-23 00:12:14 +00003916 FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
Eric Christophere7b87e52014-10-26 23:40:33 +00003917 EltTys.push_back(
3918 CreateMemberType(Unit, FType, "__byref_variable_layout", &FieldOffset));
Adrian Prantlead2ba42013-07-23 00:12:14 +00003919 }
Eric Christopherb2a008c2013-05-16 00:45:12 +00003920
Guy Benyei11169dd2012-12-18 14:30:41 +00003921 CharUnits Align = CGM.getContext().getDeclAlign(VD);
3922 if (Align > CGM.getContext().toCharUnitsFromBits(
Eric Christophere7b87e52014-10-26 23:40:33 +00003923 CGM.getTarget().getPointerAlign(0))) {
3924 CharUnits FieldOffsetInBytes =
3925 CGM.getContext().toCharUnitsFromBits(FieldOffset);
Rui Ueyama83aa9792016-01-14 21:00:27 +00003926 CharUnits AlignedOffsetInBytes = FieldOffsetInBytes.alignTo(Align);
Eric Christophere7b87e52014-10-26 23:40:33 +00003927 CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;
Eric Christopherb2a008c2013-05-16 00:45:12 +00003928
Guy Benyei11169dd2012-12-18 14:30:41 +00003929 if (NumPaddingBytes.isPositive()) {
3930 llvm::APInt pad(32, NumPaddingBytes.getQuantity());
Richard Smith772e2662019-10-04 01:25:59 +00003931 FType = CGM.getContext().getConstantArrayType(
3932 CGM.getContext().CharTy, pad, nullptr, ArrayType::Normal, 0);
Guy Benyei11169dd2012-12-18 14:30:41 +00003933 EltTys.push_back(CreateMemberType(Unit, FType, "", &FieldOffset));
3934 }
3935 }
Eric Christopherb2a008c2013-05-16 00:45:12 +00003936
Guy Benyei11169dd2012-12-18 14:30:41 +00003937 FType = Type;
Adrian Prantl05a623e2018-09-10 16:14:28 +00003938 llvm::DIType *WrappedTy = getOrCreateType(FType, Unit);
Guy Benyei11169dd2012-12-18 14:30:41 +00003939 FieldSize = CGM.getContext().getTypeSize(FType);
3940 FieldAlign = CGM.getContext().toBits(Align);
3941
Eric Christopherb2a008c2013-05-16 00:45:12 +00003942 *XOffset = FieldOffset;
Adrian Prantl05a623e2018-09-10 16:14:28 +00003943 llvm::DIType *FieldTy = DBuilder.createMemberType(
3944 Unit, VD->getName(), Unit, 0, FieldSize, FieldAlign, FieldOffset,
3945 llvm::DINode::FlagZero, WrappedTy);
Guy Benyei11169dd2012-12-18 14:30:41 +00003946 EltTys.push_back(FieldTy);
3947 FieldOffset += FieldSize;
Eric Christopherb2a008c2013-05-16 00:45:12 +00003948
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003949 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
Adrian Prantl05a623e2018-09-10 16:14:28 +00003950 return {DBuilder.createStructType(Unit, "", Unit, 0, FieldOffset, 0,
3951 llvm::DINode::FlagZero, nullptr, Elements),
3952 WrappedTy};
Guy Benyei11169dd2012-12-18 14:30:41 +00003953}
3954
Sander de Smalen891af03a2018-02-03 13:55:59 +00003955llvm::DILocalVariable *CGDebugInfo::EmitDeclare(const VarDecl *VD,
3956 llvm::Value *Storage,
3957 llvm::Optional<unsigned> ArgNo,
Amy Huang7fac5c82019-06-20 17:15:21 +00003958 CGBuilderTy &Builder,
3959 const bool UsePointerValue) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00003960 assert(DebugKind >= codegenoptions::LimitedDebugInfo);
Guy Benyei11169dd2012-12-18 14:30:41 +00003961 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
Paul Robinsonafd2dde2016-06-16 00:42:36 +00003962 if (VD->hasAttr<NoDebugAttr>())
Sander de Smalen891af03a2018-02-03 13:55:59 +00003963 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00003964
David Blaikie7fceebf2013-08-19 03:37:48 +00003965 bool Unwritten =
3966 VD->isImplicit() || (isa<Decl>(VD->getDeclContext()) &&
3967 cast<Decl>(VD->getDeclContext())->isImplicit());
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003968 llvm::DIFile *Unit = nullptr;
David Blaikie7fceebf2013-08-19 03:37:48 +00003969 if (!Unwritten)
3970 Unit = getOrCreateFile(VD->getLocation());
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003971 llvm::DIType *Ty;
Guy Benyei11169dd2012-12-18 14:30:41 +00003972 uint64_t XOffset = 0;
3973 if (VD->hasAttr<BlocksAttr>())
Adrian Prantl05a623e2018-09-10 16:14:28 +00003974 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;
Eric Christopherb2a008c2013-05-16 00:45:12 +00003975 else
Guy Benyei11169dd2012-12-18 14:30:41 +00003976 Ty = getOrCreateType(VD->getType(), Unit);
3977
3978 // If there is no debug info for this type then do not emit debug info
3979 // for this variable.
3980 if (!Ty)
Sander de Smalen891af03a2018-02-03 13:55:59 +00003981 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00003982
Guy Benyei11169dd2012-12-18 14:30:41 +00003983 // Get location information.
David Blaikie7fceebf2013-08-19 03:37:48 +00003984 unsigned Line = 0;
3985 unsigned Column = 0;
3986 if (!Unwritten) {
3987 Line = getLineNumber(VD->getLocation());
3988 Column = getColumnNumber(VD->getLocation());
3989 }
Konstantin Zhuravlyov2b4917f2017-03-09 18:06:23 +00003990 SmallVector<int64_t, 13> Expr;
Leny Kholodov80c047d2016-09-06 10:48:04 +00003991 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
Guy Benyei11169dd2012-12-18 14:30:41 +00003992 if (VD->isImplicit())
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00003993 Flags |= llvm::DINode::FlagArtificial;
Victor Leschuka7ece032016-10-20 00:13:19 +00003994
3995 auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
3996
Konstantin Zhuravlyov2b4917f2017-03-09 18:06:23 +00003997 unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(VD->getType());
3998 AppendAddressSpaceXDeref(AddressSpace, Expr);
3999
Alexey Bataev24f710182017-06-09 13:55:08 +00004000 // If this is implicit parameter of CXXThis or ObjCSelf kind, then give it an
4001 // object pointer flag.
Alexey Bataev56223232017-06-09 13:40:18 +00004002 if (const auto *IPD = dyn_cast<ImplicitParamDecl>(VD)) {
4003 if (IPD->getParameterKind() == ImplicitParamDecl::CXXThis ||
4004 IPD->getParameterKind() == ImplicitParamDecl::ObjCSelf)
4005 Flags |= llvm::DINode::FlagObjectPointer;
4006 }
Guy Benyei11169dd2012-12-18 14:30:41 +00004007
Adrian Prantlc3782a12017-04-18 01:22:01 +00004008 // Note: Older versions of clang used to emit byval references with an extra
4009 // DW_OP_deref, because they referenced the IR arg directly instead of
4010 // referencing an alloca. Newer versions of LLVM don't treat allocas
4011 // differently from other function arguments when used in a dbg.declare.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004012 auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
Guy Benyei11169dd2012-12-18 14:30:41 +00004013 StringRef Name = VD->getName();
4014 if (!Name.empty()) {
4015 if (VD->hasAttr<BlocksAttr>()) {
Adrian Prantlc3782a12017-04-18 01:22:01 +00004016 // Here, we need an offset *into* the alloca.
Guy Benyei11169dd2012-12-18 14:30:41 +00004017 CharUnits offset = CharUnits::fromQuantity(32);
Florian Hahn3dbcced2017-06-13 18:06:15 +00004018 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
Guy Benyei11169dd2012-12-18 14:30:41 +00004019 // offset of __forwarding field
4020 offset = CGM.getContext().toCharUnitsFromBits(
Eric Christophere7b87e52014-10-26 23:40:33 +00004021 CGM.getTarget().getPointerWidth(0));
Adrian Prantl7c6f9442015-01-19 17:51:58 +00004022 Expr.push_back(offset.getQuantity());
4023 Expr.push_back(llvm::dwarf::DW_OP_deref);
Florian Hahn3dbcced2017-06-13 18:06:15 +00004024 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
Guy Benyei11169dd2012-12-18 14:30:41 +00004025 // offset of x field
4026 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
Adrian Prantl7c6f9442015-01-19 17:51:58 +00004027 Expr.push_back(offset.getQuantity());
Adrian Prantlc3782a12017-04-18 01:22:01 +00004028 }
David Majnemer58ed0f32016-07-17 00:39:12 +00004029 } else if (const auto *RT = dyn_cast<RecordType>(VD->getType())) {
Adrian Prantl0d820892015-04-29 15:05:50 +00004030 // If VD is an anonymous union then Storage represents value for
4031 // all union fields.
George Burgess IV00f70bd2018-03-01 05:43:23 +00004032 const RecordDecl *RD = RT->getDecl();
Adrian Prantl0d820892015-04-29 15:05:50 +00004033 if (RD->isUnion() && RD->isAnonymousStructOrUnion()) {
Adrian Prantl00820ab2015-04-29 16:52:31 +00004034 // GDB has trouble finding local variables in anonymous unions, so we emit
Alexander Kornienko2a8c18d2018-04-06 15:14:32 +00004035 // artificial local variables for each of the members.
Adrian Prantl00820ab2015-04-29 16:52:31 +00004036 //
4037 // FIXME: Remove this code as soon as GDB supports this.
4038 // The debug info verifier in LLVM operates based on the assumption that a
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004039 // variable has the same size as its storage and we had to disable the
4040 // check for artificial variables.
Adrian Prantl0d820892015-04-29 15:05:50 +00004041 for (const auto *Field : RD->fields()) {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004042 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
Adrian Prantl0d820892015-04-29 15:05:50 +00004043 StringRef FieldName = Field->getName();
4044
4045 // Ignore unnamed fields. Do not ignore unnamed records.
4046 if (FieldName.empty() && !isa<RecordType>(Field->getType()))
4047 continue;
4048
4049 // Use VarDecl's Tag, Scope and Line number.
Victor Leschuka7ece032016-10-20 00:13:19 +00004050 auto FieldAlign = getDeclAlignIfRequired(Field, CGM.getContext());
Duncan P. N. Exon Smithe4306542015-07-31 17:56:14 +00004051 auto *D = DBuilder.createAutoVariable(
4052 Scope, FieldName, Unit, Line, FieldTy, CGM.getLangOpts().Optimize,
Victor Leschuka7ece032016-10-20 00:13:19 +00004053 Flags | llvm::DINode::FlagArtificial, FieldAlign);
Adrian Prantl0d820892015-04-29 15:05:50 +00004054
4055 // Insert an llvm.dbg.declare into the current block.
Adrian Prantlb7acfc02017-02-27 21:30:05 +00004056 DBuilder.insertDeclare(
4057 Storage, D, DBuilder.createExpression(Expr),
4058 llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
4059 Builder.GetInsertBlock());
Adrian Prantl0d820892015-04-29 15:05:50 +00004060 }
Adrian Prantl0d820892015-04-29 15:05:50 +00004061 }
Guy Benyei11169dd2012-12-18 14:30:41 +00004062 }
David Blaikiea76a7c92013-01-05 05:58:35 +00004063
Amy Huang7fac5c82019-06-20 17:15:21 +00004064 // Clang stores the sret pointer provided by the caller in a static alloca.
4065 // Use DW_OP_deref to tell the debugger to load the pointer and treat it as
4066 // the address of the variable.
4067 if (UsePointerValue) {
4068 assert(std::find(Expr.begin(), Expr.end(), llvm::dwarf::DW_OP_deref) ==
4069 Expr.end() &&
4070 "Debug info already contains DW_OP_deref.");
4071 Expr.push_back(llvm::dwarf::DW_OP_deref);
4072 }
4073
David Blaikiea76a7c92013-01-05 05:58:35 +00004074 // Create the descriptor for the variable.
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004075 auto *D = ArgNo ? DBuilder.createParameterVariable(
4076 Scope, Name, *ArgNo, Unit, Line, Ty,
4077 CGM.getLangOpts().Optimize, Flags)
4078 : DBuilder.createAutoVariable(Scope, Name, Unit, Line, Ty,
4079 CGM.getLangOpts().Optimize,
4080 Flags, Align);
David Blaikiea76a7c92013-01-05 05:58:35 +00004081
4082 // Insert an llvm.dbg.declare into the current block.
Duncan P. N. Exon Smithfe88b482015-04-15 21:18:30 +00004083 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
Adrian Prantlb7acfc02017-02-27 21:30:05 +00004084 llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
Duncan P. N. Exon Smithfe88b482015-04-15 21:18:30 +00004085 Builder.GetInsertBlock());
Sander de Smalen891af03a2018-02-03 13:55:59 +00004086
4087 return D;
Guy Benyei11169dd2012-12-18 14:30:41 +00004088}
4089
Sander de Smalen891af03a2018-02-03 13:55:59 +00004090llvm::DILocalVariable *
4091CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD, llvm::Value *Storage,
Amy Huang7fac5c82019-06-20 17:15:21 +00004092 CGBuilderTy &Builder,
4093 const bool UsePointerValue) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004094 assert(DebugKind >= codegenoptions::LimitedDebugInfo);
Amy Huang7fac5c82019-06-20 17:15:21 +00004095 return EmitDeclare(VD, Storage, llvm::None, Builder, UsePointerValue);
Guy Benyei11169dd2012-12-18 14:30:41 +00004096}
4097
Hsiangkai Wang35751492019-01-24 05:34:29 +00004098void CGDebugInfo::EmitLabel(const LabelDecl *D, CGBuilderTy &Builder) {
4099 assert(DebugKind >= codegenoptions::LimitedDebugInfo);
4100 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
4101
4102 if (D->hasAttr<NoDebugAttr>())
4103 return;
4104
4105 auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
4106 llvm::DIFile *Unit = getOrCreateFile(D->getLocation());
4107
4108 // Get location information.
4109 unsigned Line = getLineNumber(D->getLocation());
4110 unsigned Column = getColumnNumber(D->getLocation());
4111
4112 StringRef Name = D->getName();
4113
4114 // Create the descriptor for the label.
4115 auto *L =
4116 DBuilder.createLabel(Scope, Name, Unit, Line, CGM.getLangOpts().Optimize);
4117
4118 // Insert an llvm.dbg.label into the current block.
4119 DBuilder.insertLabel(L,
4120 llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
4121 Builder.GetInsertBlock());
4122}
4123
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004124llvm::DIType *CGDebugInfo::CreateSelfType(const QualType &QualTy,
4125 llvm::DIType *Ty) {
4126 llvm::DIType *CachedTy = getTypeOrNull(QualTy);
Eric Christophere7b87e52014-10-26 23:40:33 +00004127 if (CachedTy)
4128 Ty = CachedTy;
Adrian Prantlde17db32013-03-29 19:20:29 +00004129 return DBuilder.createObjectPointerType(Ty);
4130}
4131
Eric Christophere7b87e52014-10-26 23:40:33 +00004132void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
4133 const VarDecl *VD, llvm::Value *Storage, CGBuilderTy &Builder,
Adrian Prantl88eec392014-11-21 00:35:25 +00004134 const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004135 assert(DebugKind >= codegenoptions::LimitedDebugInfo);
Guy Benyei11169dd2012-12-18 14:30:41 +00004136 assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
Eric Christopherb2a008c2013-05-16 00:45:12 +00004137
Craig Topper8a13c412014-05-21 05:09:00 +00004138 if (Builder.GetInsertBlock() == nullptr)
Guy Benyei11169dd2012-12-18 14:30:41 +00004139 return;
Paul Robinsonafd2dde2016-06-16 00:42:36 +00004140 if (VD->hasAttr<NoDebugAttr>())
4141 return;
Eric Christopherb2a008c2013-05-16 00:45:12 +00004142
Guy Benyei11169dd2012-12-18 14:30:41 +00004143 bool isByRef = VD->hasAttr<BlocksAttr>();
Eric Christopherb2a008c2013-05-16 00:45:12 +00004144
Guy Benyei11169dd2012-12-18 14:30:41 +00004145 uint64_t XOffset = 0;
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004146 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
4147 llvm::DIType *Ty;
Guy Benyei11169dd2012-12-18 14:30:41 +00004148 if (isByRef)
Adrian Prantl05a623e2018-09-10 16:14:28 +00004149 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType;
Eric Christopherb2a008c2013-05-16 00:45:12 +00004150 else
Guy Benyei11169dd2012-12-18 14:30:41 +00004151 Ty = getOrCreateType(VD->getType(), Unit);
4152
4153 // Self is passed along as an implicit non-arg variable in a
4154 // block. Mark it as the object pointer.
Alexey Bataev56223232017-06-09 13:40:18 +00004155 if (const auto *IPD = dyn_cast<ImplicitParamDecl>(VD))
4156 if (IPD->getParameterKind() == ImplicitParamDecl::ObjCSelf)
4157 Ty = CreateSelfType(VD->getType(), Ty);
Guy Benyei11169dd2012-12-18 14:30:41 +00004158
4159 // Get location information.
4160 unsigned Line = getLineNumber(VD->getLocation());
4161 unsigned Column = getColumnNumber(VD->getLocation());
4162
4163 const llvm::DataLayout &target = CGM.getDataLayout();
4164
4165 CharUnits offset = CharUnits::fromQuantity(
Eric Christophere7b87e52014-10-26 23:40:33 +00004166 target.getStructLayout(blockInfo.StructureType)
Guy Benyei11169dd2012-12-18 14:30:41 +00004167 ->getElementOffset(blockInfo.getCapture(VD).getIndex()));
4168
Duncan P. N. Exon Smithf3dc4292014-10-01 20:26:18 +00004169 SmallVector<int64_t, 9> addr;
Adrian Prantlc3782a12017-04-18 01:22:01 +00004170 addr.push_back(llvm::dwarf::DW_OP_deref);
Florian Hahn3dbcced2017-06-13 18:06:15 +00004171 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
Duncan P. N. Exon Smithf3dc4292014-10-01 20:26:18 +00004172 addr.push_back(offset.getQuantity());
Guy Benyei11169dd2012-12-18 14:30:41 +00004173 if (isByRef) {
Duncan P. N. Exon Smithf3dc4292014-10-01 20:26:18 +00004174 addr.push_back(llvm::dwarf::DW_OP_deref);
Florian Hahn3dbcced2017-06-13 18:06:15 +00004175 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
Guy Benyei11169dd2012-12-18 14:30:41 +00004176 // offset of __forwarding field
Eric Christophere7b87e52014-10-26 23:40:33 +00004177 offset =
4178 CGM.getContext().toCharUnitsFromBits(target.getPointerSizeInBits(0));
Duncan P. N. Exon Smithf3dc4292014-10-01 20:26:18 +00004179 addr.push_back(offset.getQuantity());
4180 addr.push_back(llvm::dwarf::DW_OP_deref);
Florian Hahn3dbcced2017-06-13 18:06:15 +00004181 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
Guy Benyei11169dd2012-12-18 14:30:41 +00004182 // offset of x field
4183 offset = CGM.getContext().toCharUnitsFromBits(XOffset);
Duncan P. N. Exon Smithf3dc4292014-10-01 20:26:18 +00004184 addr.push_back(offset.getQuantity());
Guy Benyei11169dd2012-12-18 14:30:41 +00004185 }
4186
4187 // Create the descriptor for the variable.
Victor Leschuka7ece032016-10-20 00:13:19 +00004188 auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
Duncan P. N. Exon Smithe4306542015-07-31 17:56:14 +00004189 auto *D = DBuilder.createAutoVariable(
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004190 cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->getName(), Unit,
Victor Leschuka7ece032016-10-20 00:13:19 +00004191 Line, Ty, false, llvm::DINode::FlagZero, Align);
Adrian Prantl0f6df002013-03-29 19:20:35 +00004192
Guy Benyei11169dd2012-12-18 14:30:41 +00004193 // Insert an llvm.dbg.declare into the current block.
Adrian Prantlb7acfc02017-02-27 21:30:05 +00004194 auto DL =
4195 llvm::DebugLoc::get(Line, Column, LexicalBlockStack.back(), CurInlinedAt);
Adrian Prantlc3782a12017-04-18 01:22:01 +00004196 auto *Expr = DBuilder.createExpression(addr);
Duncan P. N. Exon Smithfe88b482015-04-15 21:18:30 +00004197 if (InsertPoint)
Adrian Prantlc3782a12017-04-18 01:22:01 +00004198 DBuilder.insertDeclare(Storage, D, Expr, DL, InsertPoint);
Duncan P. N. Exon Smithfe88b482015-04-15 21:18:30 +00004199 else
Adrian Prantlc3782a12017-04-18 01:22:01 +00004200 DBuilder.insertDeclare(Storage, D, Expr, DL, Builder.GetInsertBlock());
Guy Benyei11169dd2012-12-18 14:30:41 +00004201}
4202
Guy Benyei11169dd2012-12-18 14:30:41 +00004203void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI,
4204 unsigned ArgNo,
4205 CGBuilderTy &Builder) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004206 assert(DebugKind >= codegenoptions::LimitedDebugInfo);
Duncan P. N. Exon Smithe4306542015-07-31 17:56:14 +00004207 EmitDeclare(VD, AI, ArgNo, Builder);
Guy Benyei11169dd2012-12-18 14:30:41 +00004208}
4209
4210namespace {
Eric Christophere7b87e52014-10-26 23:40:33 +00004211struct BlockLayoutChunk {
4212 uint64_t OffsetInBits;
4213 const BlockDecl::Capture *Capture;
4214};
4215bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) {
4216 return l.OffsetInBits < r.OffsetInBits;
4217}
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004218} // namespace
Guy Benyei11169dd2012-12-18 14:30:41 +00004219
Scott Linder58df0e42018-08-08 15:56:12 +00004220void CGDebugInfo::collectDefaultFieldsForBlockLiteralDeclare(
4221 const CGBlockInfo &Block, const ASTContext &Context, SourceLocation Loc,
4222 const llvm::StructLayout &BlockLayout, llvm::DIFile *Unit,
4223 SmallVectorImpl<llvm::Metadata *> &Fields) {
4224 // Blocks in OpenCL have unique constraints which make the standard fields
4225 // redundant while requiring size and align fields for enqueue_kernel. See
4226 // initializeForBlockHeader in CGBlocks.cpp
4227 if (CGM.getLangOpts().OpenCL) {
4228 Fields.push_back(createFieldType("__size", Context.IntTy, Loc, AS_public,
4229 BlockLayout.getElementOffsetInBits(0),
4230 Unit, Unit));
4231 Fields.push_back(createFieldType("__align", Context.IntTy, Loc, AS_public,
4232 BlockLayout.getElementOffsetInBits(1),
4233 Unit, Unit));
4234 } else {
4235 Fields.push_back(createFieldType("__isa", Context.VoidPtrTy, Loc, AS_public,
4236 BlockLayout.getElementOffsetInBits(0),
4237 Unit, Unit));
4238 Fields.push_back(createFieldType("__flags", Context.IntTy, Loc, AS_public,
4239 BlockLayout.getElementOffsetInBits(1),
4240 Unit, Unit));
4241 Fields.push_back(
4242 createFieldType("__reserved", Context.IntTy, Loc, AS_public,
4243 BlockLayout.getElementOffsetInBits(2), Unit, Unit));
4244 auto *FnTy = Block.getBlockExpr()->getFunctionType();
4245 auto FnPtrType = CGM.getContext().getPointerType(FnTy->desugar());
4246 Fields.push_back(createFieldType("__FuncPtr", FnPtrType, Loc, AS_public,
4247 BlockLayout.getElementOffsetInBits(3),
4248 Unit, Unit));
4249 Fields.push_back(createFieldType(
4250 "__descriptor",
4251 Context.getPointerType(Block.NeedsCopyDispose
4252 ? Context.getBlockDescriptorExtendedType()
4253 : Context.getBlockDescriptorType()),
4254 Loc, AS_public, BlockLayout.getElementOffsetInBits(4), Unit, Unit));
4255 }
4256}
4257
Guy Benyei11169dd2012-12-18 14:30:41 +00004258void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
Adrian Prantl356347b2017-10-26 20:08:52 +00004259 StringRef Name,
David Blaikie77bbb5f2014-08-08 17:10:14 +00004260 unsigned ArgNo,
Adrian Prantl356347b2017-10-26 20:08:52 +00004261 llvm::AllocaInst *Alloca,
Guy Benyei11169dd2012-12-18 14:30:41 +00004262 CGBuilderTy &Builder) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004263 assert(DebugKind >= codegenoptions::LimitedDebugInfo);
Guy Benyei11169dd2012-12-18 14:30:41 +00004264 ASTContext &C = CGM.getContext();
4265 const BlockDecl *blockDecl = block.getBlockDecl();
4266
4267 // Collect some general information about the block's location.
4268 SourceLocation loc = blockDecl->getCaretLocation();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004269 llvm::DIFile *tunit = getOrCreateFile(loc);
Guy Benyei11169dd2012-12-18 14:30:41 +00004270 unsigned line = getLineNumber(loc);
4271 unsigned column = getColumnNumber(loc);
Eric Christopherb2a008c2013-05-16 00:45:12 +00004272
Guy Benyei11169dd2012-12-18 14:30:41 +00004273 // Build the debug-info type for the block literal.
Adrian Prantl6ec370a2015-09-10 18:39:45 +00004274 getDeclContextDescriptor(blockDecl);
Guy Benyei11169dd2012-12-18 14:30:41 +00004275
4276 const llvm::StructLayout *blockLayout =
Eric Christophere7b87e52014-10-26 23:40:33 +00004277 CGM.getDataLayout().getStructLayout(block.StructureType);
Guy Benyei11169dd2012-12-18 14:30:41 +00004278
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00004279 SmallVector<llvm::Metadata *, 16> fields;
Scott Linder58df0e42018-08-08 15:56:12 +00004280 collectDefaultFieldsForBlockLiteralDeclare(block, C, loc, *blockLayout, tunit,
4281 fields);
Guy Benyei11169dd2012-12-18 14:30:41 +00004282
4283 // We want to sort the captures by offset, not because DWARF
4284 // requires this, but because we're paranoid about debuggers.
4285 SmallVector<BlockLayoutChunk, 8> chunks;
4286
4287 // 'this' capture.
4288 if (blockDecl->capturesCXXThis()) {
4289 BlockLayoutChunk chunk;
4290 chunk.OffsetInBits =
Eric Christophere7b87e52014-10-26 23:40:33 +00004291 blockLayout->getElementOffsetInBits(block.CXXThisIndex);
Craig Topper8a13c412014-05-21 05:09:00 +00004292 chunk.Capture = nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00004293 chunks.push_back(chunk);
4294 }
4295
4296 // Variable captures.
Aaron Ballman9371dd22014-03-14 18:34:04 +00004297 for (const auto &capture : blockDecl->captures()) {
Guy Benyei11169dd2012-12-18 14:30:41 +00004298 const VarDecl *variable = capture.getVariable();
4299 const CGBlockInfo::Capture &captureInfo = block.getCapture(variable);
4300
4301 // Ignore constant captures.
4302 if (captureInfo.isConstant())
4303 continue;
4304
4305 BlockLayoutChunk chunk;
4306 chunk.OffsetInBits =
Eric Christophere7b87e52014-10-26 23:40:33 +00004307 blockLayout->getElementOffsetInBits(captureInfo.getIndex());
Guy Benyei11169dd2012-12-18 14:30:41 +00004308 chunk.Capture = &capture;
4309 chunks.push_back(chunk);
4310 }
4311
4312 // Sort by offset.
4313 llvm::array_pod_sort(chunks.begin(), chunks.end());
4314
David Majnemer58ed0f32016-07-17 00:39:12 +00004315 for (const BlockLayoutChunk &Chunk : chunks) {
4316 uint64_t offsetInBits = Chunk.OffsetInBits;
4317 const BlockDecl::Capture *capture = Chunk.Capture;
Guy Benyei11169dd2012-12-18 14:30:41 +00004318
4319 // If we have a null capture, this must be the C++ 'this' capture.
4320 if (!capture) {
Adrian Prantl2526fca2016-04-18 23:48:16 +00004321 QualType type;
4322 if (auto *Method =
4323 cast_or_null<CXXMethodDecl>(blockDecl->getNonClosureContext()))
Brian Gesiak5488ab42019-01-11 01:54:53 +00004324 type = Method->getThisType();
Adrian Prantl2526fca2016-04-18 23:48:16 +00004325 else if (auto *RDecl = dyn_cast<CXXRecordDecl>(blockDecl->getParent()))
4326 type = QualType(RDecl->getTypeForDecl(), 0);
4327 else
4328 llvm_unreachable("unexpected block declcontext");
Guy Benyei11169dd2012-12-18 14:30:41 +00004329
David Majnemerb4b671e2016-06-30 03:01:59 +00004330 fields.push_back(createFieldType("this", type, loc, AS_public,
Guy Benyei11169dd2012-12-18 14:30:41 +00004331 offsetInBits, tunit, tunit));
4332 continue;
4333 }
4334
4335 const VarDecl *variable = capture->getVariable();
4336 StringRef name = variable->getName();
4337
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004338 llvm::DIType *fieldType;
Guy Benyei11169dd2012-12-18 14:30:41 +00004339 if (capture->isByRef()) {
David Majnemer34b57492014-07-30 01:30:47 +00004340 TypeInfo PtrInfo = C.getTypeInfo(C.VoidPtrTy);
Victor Leschuka7ece032016-10-20 00:13:19 +00004341 auto Align = PtrInfo.AlignIsRequired ? PtrInfo.Align : 0;
Adrian Prantl05a623e2018-09-10 16:14:28 +00004342 // FIXME: This recomputes the layout of the BlockByRefWrapper.
Guy Benyei11169dd2012-12-18 14:30:41 +00004343 uint64_t xoffset;
Adrian Prantl05a623e2018-09-10 16:14:28 +00004344 fieldType =
4345 EmitTypeForVarWithBlocksAttr(variable, &xoffset).BlockByRefWrapper;
David Majnemer34b57492014-07-30 01:30:47 +00004346 fieldType = DBuilder.createPointerType(fieldType, PtrInfo.Width);
Victor Leschuka7ece032016-10-20 00:13:19 +00004347 fieldType = DBuilder.createMemberType(tunit, name, tunit, line,
4348 PtrInfo.Width, Align, offsetInBits,
4349 llvm::DINode::FlagZero, fieldType);
Guy Benyei11169dd2012-12-18 14:30:41 +00004350 } else {
Victor Leschuka7ece032016-10-20 00:13:19 +00004351 auto Align = getDeclAlignIfRequired(variable, CGM.getContext());
David Majnemerb4b671e2016-06-30 03:01:59 +00004352 fieldType = createFieldType(name, variable->getType(), loc, AS_public,
Victor Leschuka7ece032016-10-20 00:13:19 +00004353 offsetInBits, Align, tunit, tunit);
Guy Benyei11169dd2012-12-18 14:30:41 +00004354 }
4355 fields.push_back(fieldType);
4356 }
4357
4358 SmallString<36> typeName;
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004359 llvm::raw_svector_ostream(typeName)
4360 << "__block_literal_" << CGM.getUniqueBlockCount();
Guy Benyei11169dd2012-12-18 14:30:41 +00004361
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004362 llvm::DINodeArray fieldsArray = DBuilder.getOrCreateArray(fields);
Guy Benyei11169dd2012-12-18 14:30:41 +00004363
Leny Kholodovdf050fd2016-09-06 17:06:14 +00004364 llvm::DIType *type =
4365 DBuilder.createStructType(tunit, typeName.str(), tunit, line,
Victor Leschuka7ece032016-10-20 00:13:19 +00004366 CGM.getContext().toBits(block.BlockSize), 0,
Leny Kholodovdf050fd2016-09-06 17:06:14 +00004367 llvm::DINode::FlagZero, nullptr, fieldsArray);
Guy Benyei11169dd2012-12-18 14:30:41 +00004368 type = DBuilder.createPointerType(type, CGM.PointerWidthInBits);
4369
4370 // Get overall information about the block.
Leny Kholodov80c047d2016-09-06 10:48:04 +00004371 llvm::DINode::DIFlags flags = llvm::DINode::FlagArtificial;
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004372 auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back());
Guy Benyei11169dd2012-12-18 14:30:41 +00004373
4374 // Create the descriptor for the parameter.
Duncan P. N. Exon Smithe4306542015-07-31 17:56:14 +00004375 auto *debugVar = DBuilder.createParameterVariable(
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004376 scope, Name, ArgNo, tunit, line, type, CGM.getLangOpts().Optimize, flags);
Adrian Prantl51936dd2013-03-14 17:53:33 +00004377
Adrian Prantl616bef42013-03-14 21:52:59 +00004378 // Insert an llvm.dbg.declare into the current block.
Adrian Prantl356347b2017-10-26 20:08:52 +00004379 DBuilder.insertDeclare(Alloca, debugVar, DBuilder.createExpression(),
Adrian Prantlb7acfc02017-02-27 21:30:05 +00004380 llvm::DebugLoc::get(line, column, scope, CurInlinedAt),
Duncan P. N. Exon Smithfe88b482015-04-15 21:18:30 +00004381 Builder.GetInsertBlock());
Guy Benyei11169dd2012-12-18 14:30:41 +00004382}
4383
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004384llvm::DIDerivedType *
David Blaikie6943dea2013-08-20 01:28:15 +00004385CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(const VarDecl *D) {
Amy Huangdd3a9ca2019-05-30 22:04:11 +00004386 if (!D || !D->isStaticDataMember())
Duncan P. N. Exon Smithc09c5482015-04-20 21:17:26 +00004387 return nullptr;
Saleem Abdulrasoolcd187f02015-02-28 00:13:13 +00004388
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00004389 auto MI = StaticDataMemberCache.find(D->getCanonicalDecl());
David Blaikie6943dea2013-08-20 01:28:15 +00004390 if (MI != StaticDataMemberCache.end()) {
4391 assert(MI->second && "Static data member declaration should still exist");
Duncan P. N. Exon Smithac346ba2015-07-24 18:05:58 +00004392 return MI->second;
Evgeniy Stepanov37b3f732013-08-16 10:35:31 +00004393 }
David Blaikiece763042013-08-20 21:49:21 +00004394
4395 // If the member wasn't found in the cache, lazily construct and add it to the
4396 // type (used when a limited form of the type is emitted).
Adrian Prantl21361fb2014-08-29 22:44:27 +00004397 auto DC = D->getDeclContext();
Adrian Prantl6ec370a2015-09-10 18:39:45 +00004398 auto *Ctxt = cast<llvm::DICompositeType>(getDeclContextDescriptor(D));
Adrian Prantl21361fb2014-08-29 22:44:27 +00004399 return CreateRecordStaticField(D, Ctxt, cast<RecordDecl>(DC));
David Blaikie6943dea2013-08-20 01:28:15 +00004400}
4401
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004402llvm::DIGlobalVariableExpression *CGDebugInfo::CollectAnonRecordDecls(
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004403 const RecordDecl *RD, llvm::DIFile *Unit, unsigned LineNo,
4404 StringRef LinkageName, llvm::GlobalVariable *Var, llvm::DIScope *DContext) {
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004405 llvm::DIGlobalVariableExpression *GVE = nullptr;
Eric Christophercab9fae2014-04-10 05:20:00 +00004406
4407 for (const auto *Field : RD->fields()) {
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004408 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
Eric Christophercab9fae2014-04-10 05:20:00 +00004409 StringRef FieldName = Field->getName();
4410
4411 // Ignore unnamed fields, but recurse into anonymous records.
4412 if (FieldName.empty()) {
David Majnemer58ed0f32016-07-17 00:39:12 +00004413 if (const auto *RT = dyn_cast<RecordType>(Field->getType()))
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004414 GVE = CollectAnonRecordDecls(RT->getDecl(), Unit, LineNo, LinkageName,
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004415 Var, DContext);
Eric Christophercab9fae2014-04-10 05:20:00 +00004416 continue;
4417 }
4418 // Use VarDecl's Tag, Scope and Line number.
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004419 GVE = DBuilder.createGlobalVariableExpression(
4420 DContext, FieldName, LinkageName, Unit, LineNo, FieldTy,
4421 Var->hasLocalLinkage());
4422 Var->addDebugInfo(GVE);
Eric Christophercab9fae2014-04-10 05:20:00 +00004423 }
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004424 return GVE;
Eric Christophercab9fae2014-04-10 05:20:00 +00004425}
4426
Yunzhong Gao0ebf1bb2013-08-30 08:53:09 +00004427void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
Guy Benyei11169dd2012-12-18 14:30:41 +00004428 const VarDecl *D) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004429 assert(DebugKind >= codegenoptions::LimitedDebugInfo);
Paul Robinsonb17327d2016-04-27 17:37:12 +00004430 if (D->hasAttr<NoDebugAttr>())
4431 return;
Adrian Prantl338ef7a2016-11-09 00:42:03 +00004432
Luboš Luňák4f2104c2019-11-02 16:39:59 +01004433 llvm::TimeTraceScope TimeScope("DebugGlobalVariable", [&]() {
4434 std::string Name;
4435 llvm::raw_string_ostream OS(Name);
4436 D->getNameForDiagnostic(OS, getPrintingPolicy(),
4437 /*Qualified=*/true);
4438 return Name;
4439 });
4440
Adrian Prantl338ef7a2016-11-09 00:42:03 +00004441 // If we already created a DIGlobalVariable for this declaration, just attach
4442 // it to the llvm::GlobalVariable.
4443 auto Cached = DeclCache.find(D->getCanonicalDecl());
4444 if (Cached != DeclCache.end())
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004445 return Var->addDebugInfo(
4446 cast<llvm::DIGlobalVariableExpression>(Cached->second));
Adrian Prantl338ef7a2016-11-09 00:42:03 +00004447
Guy Benyei11169dd2012-12-18 14:30:41 +00004448 // Create global variable debug descriptor.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004449 llvm::DIFile *Unit = nullptr;
4450 llvm::DIScope *DContext = nullptr;
Frederic Riss9db79f12014-11-18 03:40:46 +00004451 unsigned LineNo;
4452 StringRef DeclName, LinkageName;
4453 QualType T;
Matthew Voss20165362018-10-03 18:45:04 +00004454 llvm::MDTuple *TemplateParameters = nullptr;
4455 collectVarDeclProps(D, Unit, LineNo, T, DeclName, LinkageName,
4456 TemplateParameters, DContext);
Eric Christophercab9fae2014-04-10 05:20:00 +00004457
4458 // Attempt to store one global variable for the declaration - even if we
4459 // emit a lot of fields.
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004460 llvm::DIGlobalVariableExpression *GVE = nullptr;
Eric Christophercab9fae2014-04-10 05:20:00 +00004461
4462 // If this is an anonymous union then we'll want to emit a global
4463 // variable for each member of the anonymous union so that it's possible
4464 // to find the name of any field in the union.
4465 if (T->isUnionType() && DeclName.empty()) {
Reid Kleckner43ecd7c2015-11-20 17:41:12 +00004466 const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
Eric Christophere7b87e52014-10-26 23:40:33 +00004467 assert(RD->isAnonymousStructOrUnion() &&
4468 "unnamed non-anonymous struct or union?");
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004469 GVE = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
Eric Christophercab9fae2014-04-10 05:20:00 +00004470 } else {
Victor Leschuka7ece032016-10-20 00:13:19 +00004471 auto Align = getDeclAlignIfRequired(D, CGM.getContext());
Konstantin Zhuravlyov2b4917f2017-03-09 18:06:23 +00004472
4473 SmallVector<int64_t, 4> Expr;
4474 unsigned AddressSpace =
4475 CGM.getContext().getTargetAddressSpace(D->getType());
Alexey Bataev1a9e05d2019-02-05 19:45:57 +00004476 if (CGM.getLangOpts().CUDA && CGM.getLangOpts().CUDAIsDevice) {
4477 if (D->hasAttr<CUDASharedAttr>())
4478 AddressSpace =
4479 CGM.getContext().getTargetAddressSpace(LangAS::cuda_shared);
4480 else if (D->hasAttr<CUDAConstantAttr>())
4481 AddressSpace =
4482 CGM.getContext().getTargetAddressSpace(LangAS::cuda_constant);
4483 }
Konstantin Zhuravlyov2b4917f2017-03-09 18:06:23 +00004484 AppendAddressSpaceXDeref(AddressSpace, Expr);
4485
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004486 GVE = DBuilder.createGlobalVariableExpression(
Eric Christophercab9fae2014-04-10 05:20:00 +00004487 DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit),
Yonghong Songe3d8ee32019-11-22 08:45:37 -08004488 Var->hasLocalLinkage(), true,
Konstantin Zhuravlyov2b4917f2017-03-09 18:06:23 +00004489 Expr.empty() ? nullptr : DBuilder.createExpression(Expr),
Matthew Voss20165362018-10-03 18:45:04 +00004490 getOrCreateStaticDataMemberDeclarationOrNull(D), TemplateParameters,
4491 Align);
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004492 Var->addDebugInfo(GVE);
Eric Christophercab9fae2014-04-10 05:20:00 +00004493 }
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004494 DeclCache[D->getCanonicalDecl()].reset(GVE);
Guy Benyei11169dd2012-12-18 14:30:41 +00004495}
4496
Peter Collingbourneeeb56ab2016-09-13 01:13:19 +00004497void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004498 assert(DebugKind >= codegenoptions::LimitedDebugInfo);
Paul Robinsonb17327d2016-04-27 17:37:12 +00004499 if (VD->hasAttr<NoDebugAttr>())
4500 return;
Luboš Luňák4f2104c2019-11-02 16:39:59 +01004501 llvm::TimeTraceScope TimeScope("DebugConstGlobalVariable", [&]() {
4502 std::string Name;
4503 llvm::raw_string_ostream OS(Name);
4504 VD->getNameForDiagnostic(OS, getPrintingPolicy(),
4505 /*Qualified=*/true);
4506 return Name;
4507 });
4508
Victor Leschuka7ece032016-10-20 00:13:19 +00004509 auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
Yunzhong Gao0ebf1bb2013-08-30 08:53:09 +00004510 // Create the descriptor for the variable.
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004511 llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
Yunzhong Gao0ebf1bb2013-08-30 08:53:09 +00004512 StringRef Name = VD->getName();
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004513 llvm::DIType *Ty = getOrCreateType(VD->getType(), Unit);
Amy Huang63305c82019-05-22 15:48:59 +00004514
David Majnemer58ed0f32016-07-17 00:39:12 +00004515 if (const auto *ECD = dyn_cast<EnumConstantDecl>(VD)) {
4516 const auto *ED = cast<EnumDecl>(ECD->getDeclContext());
Yunzhong Gao0ebf1bb2013-08-30 08:53:09 +00004517 assert(isa<EnumType>(ED->getTypeForDecl()) && "Enum without EnumType?");
Amy Huangdd3a9ca2019-05-30 22:04:11 +00004518
Yuanfang Chen48c6fad2019-09-04 20:58:15 +00004519 if (CGM.getCodeGenOpts().EmitCodeView) {
4520 // If CodeView, emit enums as global variables, unless they are defined
4521 // inside a class. We do this because MSVC doesn't emit S_CONSTANTs for
4522 // enums in classes, and because it is difficult to attach this scope
4523 // information to the global variable.
4524 if (isa<RecordDecl>(ED->getDeclContext()))
4525 return;
4526 } else {
4527 // If not CodeView, emit DW_TAG_enumeration_type if necessary. For
4528 // example: for "enum { ZERO };", a DW_TAG_enumeration_type is created the
4529 // first time `ZERO` is referenced in a function.
4530 llvm::DIType *EDTy =
4531 getOrCreateType(QualType(ED->getTypeForDecl(), 0), Unit);
4532 assert (EDTy->getTag() == llvm::dwarf::DW_TAG_enumeration_type);
4533 (void)EDTy;
Amy Huangdd3a9ca2019-05-30 22:04:11 +00004534 return;
Yuanfang Chen48c6fad2019-09-04 20:58:15 +00004535 }
Amy Huang63305c82019-05-22 15:48:59 +00004536 }
4537
Amy Huang325003b2019-05-29 21:45:34 +00004538 llvm::DIScope *DContext = nullptr;
4539
4540 // Do not emit separate definitions for function local consts.
David Blaikiea15565562014-04-04 20:56:17 +00004541 if (isa<FunctionDecl>(VD->getDeclContext()))
4542 return;
Amy Huang325003b2019-05-29 21:45:34 +00004543
4544 // Emit definition for static members in CodeView.
David Blaikiebb113912014-04-05 07:23:17 +00004545 VD = cast<ValueDecl>(VD->getCanonicalDecl());
Amy Huangdd3a9ca2019-05-30 22:04:11 +00004546 auto *VarD = dyn_cast<VarDecl>(VD);
4547 if (VarD && VarD->isStaticDataMember()) {
David Blaikieaf080852014-11-21 00:20:58 +00004548 auto *RD = cast<RecordDecl>(VarD->getDeclContext());
Adrian Prantl6ec370a2015-09-10 18:39:45 +00004549 getDeclContextDescriptor(VarD);
David Blaikie423eb5a2014-11-19 19:42:40 +00004550 // Ensure that the type is retained even though it's otherwise unreferenced.
Duncan P. N. Exon Smith383f8412016-04-23 21:08:27 +00004551 //
4552 // FIXME: This is probably unnecessary, since Ty should reference RD
4553 // through its scope.
David Blaikie423eb5a2014-11-19 19:42:40 +00004554 RetainedTypes.push_back(
David Blaikieaf080852014-11-21 00:20:58 +00004555 CGM.getContext().getRecordType(RD).getAsOpaquePtr());
David Blaikie423eb5a2014-11-19 19:42:40 +00004556
Amy Huang325003b2019-05-29 21:45:34 +00004557 if (!CGM.getCodeGenOpts().EmitCodeView)
4558 return;
4559
4560 // Use the global scope for static members.
4561 DContext = getContextDescriptor(
4562 cast<Decl>(CGM.getContext().getTranslationUnitDecl()), TheCU);
4563 } else {
4564 DContext = getDeclContextDescriptor(VD);
4565 }
David Blaikieaf080852014-11-21 00:20:58 +00004566
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00004567 auto &GV = DeclCache[VD];
4568 if (GV)
David Blaikiebb113912014-04-05 07:23:17 +00004569 return;
Peter Collingbourneeeb56ab2016-09-13 01:13:19 +00004570 llvm::DIExpression *InitExpr = nullptr;
Peter Collingbourneb7013632016-12-16 22:10:52 +00004571 if (CGM.getContext().getTypeSize(VD->getType()) <= 64) {
4572 // FIXME: Add a representation for integer constants wider than 64 bits.
4573 if (Init.isInt())
4574 InitExpr =
4575 DBuilder.createConstantValueExpression(Init.getInt().getExtValue());
4576 else if (Init.isFloat())
4577 InitExpr = DBuilder.createConstantValueExpression(
4578 Init.getFloat().bitcastToAPInt().getZExtValue());
4579 }
Matthew Voss20165362018-10-03 18:45:04 +00004580
4581 llvm::MDTuple *TemplateParameters = nullptr;
4582
4583 if (isa<VarTemplateSpecializationDecl>(VD))
4584 if (VarD) {
4585 llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VarD, &*Unit);
4586 TemplateParameters = parameterNodes.get();
4587 }
4588
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004589 GV.reset(DBuilder.createGlobalVariableExpression(
David Blaikie506a7452014-04-05 07:46:57 +00004590 DContext, Name, StringRef(), Unit, getLineNumber(VD->getLocation()), Ty,
Yonghong Songe3d8ee32019-11-22 08:45:37 -08004591 true, true, InitExpr, getOrCreateStaticDataMemberDeclarationOrNull(VarD),
Matthew Voss20165362018-10-03 18:45:04 +00004592 TemplateParameters, Align));
David Blaikiebd483762013-05-20 04:58:53 +00004593}
4594
Yonghong Songe3d8ee32019-11-22 08:45:37 -08004595void CGDebugInfo::EmitExternalVariable(llvm::GlobalVariable *Var,
4596 const VarDecl *D) {
4597 assert(DebugKind >= codegenoptions::LimitedDebugInfo);
4598 if (D->hasAttr<NoDebugAttr>())
4599 return;
4600
4601 auto Align = getDeclAlignIfRequired(D, CGM.getContext());
4602 llvm::DIFile *Unit = getOrCreateFile(D->getLocation());
4603 StringRef Name = D->getName();
4604 llvm::DIType *Ty = getOrCreateType(D->getType(), Unit);
4605
4606 llvm::DIScope *DContext = getDeclContextDescriptor(D);
4607 llvm::DIGlobalVariableExpression *GVE =
4608 DBuilder.createGlobalVariableExpression(
4609 DContext, Name, StringRef(), Unit, getLineNumber(D->getLocation()),
4610 Ty, false, false, nullptr, nullptr, nullptr, Align);
4611 Var->addDebugInfo(GVE);
4612}
4613
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004614llvm::DIScope *CGDebugInfo::getCurrentContextDescriptor(const Decl *D) {
David Blaikiebd483762013-05-20 04:58:53 +00004615 if (!LexicalBlockStack.empty())
Duncan P. N. Exon Smithfc8d9d92015-04-20 18:32:15 +00004616 return LexicalBlockStack.back();
Adrian Prantl5c8bd882015-09-11 17:23:08 +00004617 llvm::DIScope *Mod = getParentModuleOrNull(D);
4618 return getContextDescriptor(D, Mod ? Mod : TheCU);
Guy Benyei11169dd2012-12-18 14:30:41 +00004619}
4620
David Blaikie9f88fe82013-04-22 06:13:21 +00004621void CGDebugInfo::EmitUsingDirective(const UsingDirectiveDecl &UD) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004622 if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
David Blaikiebd483762013-05-20 04:58:53 +00004623 return;
Ekaterina Romanova9218a3b2015-12-10 18:52:50 +00004624 const NamespaceDecl *NSDecl = UD.getNominatedNamespace();
Adrian McCarthyab1e7862016-07-21 18:43:20 +00004625 if (!NSDecl->isAnonymousNamespace() ||
4626 CGM.getCodeGenOpts().DebugExplicitImport) {
Adrian Prantl5649b0e2017-07-19 00:09:58 +00004627 auto Loc = UD.getLocation();
Ekaterina Romanova9218a3b2015-12-10 18:52:50 +00004628 DBuilder.createImportedModule(
4629 getCurrentContextDescriptor(cast<Decl>(UD.getDeclContext())),
Adrian Prantl5649b0e2017-07-19 00:09:58 +00004630 getOrCreateNamespace(NSDecl), getOrCreateFile(Loc), getLineNumber(Loc));
Ekaterina Romanova9218a3b2015-12-10 18:52:50 +00004631 }
David Blaikie9f88fe82013-04-22 06:13:21 +00004632}
4633
David Blaikiebd483762013-05-20 04:58:53 +00004634void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004635 if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
David Blaikiebd483762013-05-20 04:58:53 +00004636 return;
4637 assert(UD.shadow_size() &&
4638 "We shouldn't be codegening an invalid UsingDecl containing no decls");
4639 // Emitting one decl is sufficient - debuggers can detect that this is an
4640 // overloaded name & provide lookup for all the overloads.
4641 const UsingShadowDecl &USD = **UD.shadow_begin();
David Blaikie2a58a182016-08-05 19:03:01 +00004642
4643 // FIXME: Skip functions with undeduced auto return type for now since we
4644 // don't currently have the plumbing for separate declarations & definitions
4645 // of free functions and mismatched types (auto in the declaration, concrete
4646 // return type in the definition)
4647 if (const auto *FD = dyn_cast<FunctionDecl>(USD.getUnderlyingDecl()))
4648 if (const auto *AT =
Simon Pilgrim7e38f0c2019-10-07 16:42:25 +00004649 FD->getType()->castAs<FunctionProtoType>()->getContainedAutoType())
David Blaikie2a58a182016-08-05 19:03:01 +00004650 if (AT->getDeducedType().isNull())
4651 return;
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004652 if (llvm::DINode *Target =
Adrian Prantl5649b0e2017-07-19 00:09:58 +00004653 getDeclarationOrDefinition(USD.getUnderlyingDecl())) {
4654 auto Loc = USD.getLocation();
David Blaikiebd483762013-05-20 04:58:53 +00004655 DBuilder.createImportedDeclaration(
4656 getCurrentContextDescriptor(cast<Decl>(USD.getDeclContext())), Target,
Adrian Prantl5649b0e2017-07-19 00:09:58 +00004657 getOrCreateFile(Loc), getLineNumber(Loc));
4658 }
David Blaikiebd483762013-05-20 04:58:53 +00004659}
4660
Adrian Prantlc4bb47e2015-06-30 17:39:51 +00004661void CGDebugInfo::EmitImportDecl(const ImportDecl &ID) {
David Blaikieaf09f4a2016-05-03 23:06:40 +00004662 if (CGM.getCodeGenOpts().getDebuggerTuning() != llvm::DebuggerKind::LLDB)
4663 return;
Adrian Prantl8a634c12015-12-18 19:44:31 +00004664 if (Module *M = ID.getImportedModule()) {
Chad Rosiere5dafd12015-12-18 20:08:40 +00004665 auto Info = ExternalASTSource::ASTSourceDescriptor(*M);
Adrian Prantl5649b0e2017-07-19 00:09:58 +00004666 auto Loc = ID.getLocation();
Adrian Prantl8a634c12015-12-18 19:44:31 +00004667 DBuilder.createImportedDeclaration(
4668 getCurrentContextDescriptor(cast<Decl>(ID.getDeclContext())),
Adrian Prantl5649b0e2017-07-19 00:09:58 +00004669 getOrCreateModuleRef(Info, DebugTypeExtRefs), getOrCreateFile(Loc),
4670 getLineNumber(Loc));
Adrian Prantl8a634c12015-12-18 19:44:31 +00004671 }
Adrian Prantlc4bb47e2015-06-30 17:39:51 +00004672}
4673
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004674llvm::DIImportedEntity *
David Blaikief121b932013-05-20 22:50:41 +00004675CGDebugInfo::EmitNamespaceAlias(const NamespaceAliasDecl &NA) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004676 if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
Duncan P. N. Exon Smithdadc2b62015-04-21 18:43:54 +00004677 return nullptr;
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00004678 auto &VH = NamespaceAliasCache[&NA];
David Blaikief121b932013-05-20 22:50:41 +00004679 if (VH)
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004680 return cast<llvm::DIImportedEntity>(VH);
4681 llvm::DIImportedEntity *R;
Adrian Prantl5649b0e2017-07-19 00:09:58 +00004682 auto Loc = NA.getLocation();
David Majnemer58ed0f32016-07-17 00:39:12 +00004683 if (const auto *Underlying =
David Blaikief121b932013-05-20 22:50:41 +00004684 dyn_cast<NamespaceAliasDecl>(NA.getAliasedNamespace()))
4685 // This could cache & dedup here rather than relying on metadata deduping.
David Blaikie551fb0a2014-04-06 06:30:03 +00004686 R = DBuilder.createImportedDeclaration(
David Blaikief121b932013-05-20 22:50:41 +00004687 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
Adrian Prantl5649b0e2017-07-19 00:09:58 +00004688 EmitNamespaceAlias(*Underlying), getOrCreateFile(Loc),
4689 getLineNumber(Loc), NA.getName());
David Blaikief121b932013-05-20 22:50:41 +00004690 else
David Blaikie551fb0a2014-04-06 06:30:03 +00004691 R = DBuilder.createImportedDeclaration(
David Blaikief121b932013-05-20 22:50:41 +00004692 getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
Adrian Prantlddb8e062017-05-12 16:23:53 +00004693 getOrCreateNamespace(cast<NamespaceDecl>(NA.getAliasedNamespace())),
Adrian Prantl5649b0e2017-07-19 00:09:58 +00004694 getOrCreateFile(Loc), getLineNumber(Loc), NA.getName());
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00004695 VH.reset(R);
David Blaikief121b932013-05-20 22:50:41 +00004696 return R;
4697}
4698
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004699llvm::DINamespace *
Adrian Prantlddb8e062017-05-12 16:23:53 +00004700CGDebugInfo::getOrCreateNamespace(const NamespaceDecl *NSDecl) {
4701 // Don't canonicalize the NamespaceDecl here: The DINamespace will be uniqued
4702 // if necessary, and this way multiple declarations of the same namespace in
4703 // different parent modules stay distinct.
4704 auto I = NamespaceCache.find(NSDecl);
Adrian Prantld8870552017-05-11 22:59:19 +00004705 if (I != NamespaceCache.end())
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004706 return cast<llvm::DINamespace>(I->second);
Eric Christopherb2a008c2013-05-16 00:45:12 +00004707
Adrian Prantl6ec370a2015-09-10 18:39:45 +00004708 llvm::DIScope *Context = getDeclContextDescriptor(NSDecl);
Adrian Prantld8870552017-05-11 22:59:19 +00004709 // Don't trust the context if it is a DIModule (see comment above).
Adrian Prantlddb8e062017-05-12 16:23:53 +00004710 llvm::DINamespace *NS =
4711 DBuilder.createNameSpace(Context, NSDecl->getName(), NSDecl->isInline());
4712 NamespaceCache[NSDecl].reset(NS);
Guy Benyei11169dd2012-12-18 14:30:41 +00004713 return NS;
4714}
4715
Adrian Prantla5206ce2015-09-22 23:26:43 +00004716void CGDebugInfo::setDwoId(uint64_t Signature) {
4717 assert(TheCU && "no main compile unit");
4718 TheCU->setDWOId(Signature);
4719}
4720
Guy Benyei11169dd2012-12-18 14:30:41 +00004721void CGDebugInfo::finalize() {
David Blaikie87dab872014-05-07 16:56:58 +00004722 // Creating types might create further types - invalidating the current
4723 // element and the size(), so don't cache/reference them.
4724 for (size_t i = 0; i != ObjCInterfaceCache.size(); ++i) {
4725 ObjCInterfaceCacheEntry E = ObjCInterfaceCache[i];
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004726 llvm::DIType *Ty = E.Type->getDecl()->getDefinition()
Duncan P. N. Exon Smith497d4d462015-04-11 19:05:04 +00004727 ? CreateTypeDefinition(E.Type, E.Unit)
4728 : E.Decl;
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004729 DBuilder.replaceTemporary(llvm::TempDIType(E.Decl), Ty);
David Blaikie87dab872014-05-07 16:56:58 +00004730 }
4731
Adrian Prantle0cabe22019-11-21 09:56:01 -08004732 // Add methods to interface.
4733 for (const auto &P : ObjCMethodCache) {
4734 if (P.second.empty())
4735 continue;
Jonas Devlieghered8ba8ae2018-06-27 17:31:59 +00004736
Adrian Prantle0cabe22019-11-21 09:56:01 -08004737 QualType QTy(P.first->getTypeForDecl(), 0);
4738 auto It = TypeCache.find(QTy.getAsOpaquePtr());
4739 assert(It != TypeCache.end());
Jonas Devlieghered8ba8ae2018-06-27 17:31:59 +00004740
Adrian Prantle0cabe22019-11-21 09:56:01 -08004741 llvm::DICompositeType *InterfaceDecl =
4742 cast<llvm::DICompositeType>(It->second);
Jonas Devlieghered8ba8ae2018-06-27 17:31:59 +00004743
Adrian Prantle0cabe22019-11-21 09:56:01 -08004744 auto CurElts = InterfaceDecl->getElements();
4745 SmallVector<llvm::Metadata *, 16> EltTys(CurElts.begin(), CurElts.end());
4746
4747 // For DWARF v4 or earlier, only add objc_direct methods.
4748 for (auto &SubprogramDirect : P.second)
4749 if (CGM.getCodeGenOpts().DwarfVersion >= 5 || SubprogramDirect.getInt())
4750 EltTys.push_back(SubprogramDirect.getPointer());
4751
4752 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
4753 DBuilder.replaceArrays(InterfaceDecl, Elements);
Jonas Devlieghered8ba8ae2018-06-27 17:31:59 +00004754 }
4755
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004756 for (const auto &P : ReplaceMap) {
4757 assert(P.second);
4758 auto *Ty = cast<llvm::DIType>(P.second);
Duncan P. N. Exon Smith4caa7f22015-04-16 01:00:56 +00004759 assert(Ty->isForwardDecl());
Eric Christopherb2a008c2013-05-16 00:45:12 +00004760
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004761 auto It = TypeCache.find(P.first);
4762 assert(It != TypeCache.end());
4763 assert(It->second);
Adrian Prantl73409ce2013-03-11 18:33:46 +00004764
Duncan P. N. Exon Smith9dd4e4e2015-04-29 16:40:08 +00004765 DBuilder.replaceTemporary(llvm::TempDIType(Ty),
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004766 cast<llvm::DIType>(It->second));
Guy Benyei11169dd2012-12-18 14:30:41 +00004767 }
Adrian Prantl73409ce2013-03-11 18:33:46 +00004768
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004769 for (const auto &P : FwdDeclReplaceMap) {
4770 assert(P.second);
4771 llvm::TempMDNode FwdDecl(cast<llvm::MDNode>(P.second));
Duncan P. N. Exon Smithfb494912014-12-09 18:39:32 +00004772 llvm::Metadata *Repl;
Frederic Rissd253ed62014-11-18 03:40:51 +00004773
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004774 auto It = DeclCache.find(P.first);
Adrian Prantl97f76852014-12-19 01:02:11 +00004775 // If there has been no definition for the declaration, call RAUW
Frederic Rissd253ed62014-11-18 03:40:51 +00004776 // with ourselves, that will destroy the temporary MDNode and
4777 // replace it with a standard one, avoiding leaking memory.
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004778 if (It == DeclCache.end())
4779 Repl = P.second;
Frederic Rissd253ed62014-11-18 03:40:51 +00004780 else
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004781 Repl = It->second;
Frederic Rissdce60a72014-11-19 18:53:46 +00004782
Adrian Prantl5f4740d2016-12-20 02:10:02 +00004783 if (auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(Repl))
4784 Repl = GVE->getVariable();
Duncan P. N. Exon Smithd899f6e2015-04-18 00:07:30 +00004785 DBuilder.replaceTemporary(std::move(FwdDecl), cast<llvm::MDNode>(Repl));
Frederic Rissd253ed62014-11-18 03:40:51 +00004786 }
4787
Adrian Prantl73409ce2013-03-11 18:33:46 +00004788 // We keep our own list of retained types, because we need to look
4789 // up the final type in the type cache.
Adrian Prantl3a884fa2015-08-27 22:56:46 +00004790 for (auto &RT : RetainedTypes)
Adrian Prantlad9a195e2015-08-27 21:21:19 +00004791 if (auto MD = TypeCache[RT])
4792 DBuilder.retainType(cast<llvm::DIType>(MD));
Adrian Prantl73409ce2013-03-11 18:33:46 +00004793
Guy Benyei11169dd2012-12-18 14:30:41 +00004794 DBuilder.finalize();
4795}
David Blaikie66088d52014-09-24 17:01:27 +00004796
4797void CGDebugInfo::EmitExplicitCastType(QualType Ty) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00004798 if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
David Blaikie66088d52014-09-24 17:01:27 +00004799 return;
Duncan P. N. Exon Smith5043f912015-03-27 22:58:05 +00004800
Adrian Prantlc2a44ec2018-12-11 16:58:46 +00004801 if (auto *DieTy = getOrCreateType(Ty, TheCU->getFile()))
Duncan P. N. Exon Smith5043f912015-03-27 22:58:05 +00004802 // Don't ignore in case of explicit cast where it is referenced indirectly.
4803 DBuilder.retainType(DieTy);
David Blaikie66088d52014-09-24 17:01:27 +00004804}
Amara Emerson652795d2016-11-10 14:44:30 +00004805
4806llvm::DebugLoc CGDebugInfo::SourceLocToDebugLoc(SourceLocation Loc) {
4807 if (LexicalBlockStack.empty())
4808 return llvm::DebugLoc();
4809
4810 llvm::MDNode *Scope = LexicalBlockStack.back();
Jonas Devlieghere9ef49652018-06-28 10:56:40 +00004811 return llvm::DebugLoc::get(getLineNumber(Loc), getColumnNumber(Loc), Scope);
Amara Emerson652795d2016-11-10 14:44:30 +00004812}
Vedant Kumar5931b4e2018-10-05 20:37:17 +00004813
4814llvm::DINode::DIFlags CGDebugInfo::getCallSiteRelatedAttrs() const {
4815 // Call site-related attributes are only useful in optimized programs, and
4816 // when there's a possibility of debugging backtraces.
4817 if (!CGM.getLangOpts().Optimize || DebugKind == codegenoptions::NoDebugInfo ||
4818 DebugKind == codegenoptions::LocTrackingOnly)
4819 return llvm::DINode::FlagZero;
4820
4821 // Call site-related attributes are available in DWARF v5. Some debuggers,
4822 // while not fully DWARF v5-compliant, may accept these attributes as if they
4823 // were part of DWARF v4.
4824 bool SupportsDWARFv4Ext =
4825 CGM.getCodeGenOpts().DwarfVersion == 4 &&
Djordje Todorovic639d36b2019-06-26 09:38:09 +00004826 (CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB ||
Vedant Kumar568db782019-11-13 18:19:32 -08004827 CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::GDB);
Djordje Todorovic639d36b2019-06-26 09:38:09 +00004828
Vedant Kumar568db782019-11-13 18:19:32 -08004829 if (!SupportsDWARFv4Ext && CGM.getCodeGenOpts().DwarfVersion < 5 &&
4830 !CGM.getCodeGenOpts().EnableDebugEntryValues)
Vedant Kumar5931b4e2018-10-05 20:37:17 +00004831 return llvm::DINode::FlagZero;
4832
4833 return llvm::DINode::FlagAllCallsDescribed;
4834}