blob: 70fe1e233ba2fb0df39d6c91d2b7df2001e9bf3c [file] [log] [blame]
Bill Wendling2f921f82009-05-15 09:23:25 +00001//===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains support for writing dwarf debug info into asm files.
11//
12//===----------------------------------------------------------------------===//
Chris Lattnerb14490d2010-03-09 00:39:24 +000013
Bill Wendling2f921f82009-05-15 09:23:25 +000014#include "DwarfDebug.h"
David Blaikie37c52312014-10-04 15:49:50 +000015#include "ByteStreamer.h"
Eric Christopher45731982013-08-08 23:45:55 +000016#include "DIEHash.h"
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +000017#include "DebugLocEntry.h"
Chandler Carruthd9903882015-01-14 11:23:27 +000018#include "DwarfCompileUnit.h"
19#include "DwarfExpression.h"
David Blaikie2c86a722013-12-02 19:33:15 +000020#include "DwarfUnit.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000021#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/Statistic.h"
23#include "llvm/ADT/StringExtras.h"
24#include "llvm/ADT/Triple.h"
Zachary Turner264b5d92017-06-07 03:48:56 +000025#include "llvm/BinaryFormat/Dwarf.h"
Frederic Risse541e0b2015-01-05 21:29:41 +000026#include "llvm/CodeGen/DIE.h"
David Greene829b3e82009-08-19 21:52:55 +000027#include "llvm/CodeGen/MachineFunction.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000028#include "llvm/CodeGen/MachineModuleInfo.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000029#include "llvm/IR/Constants.h"
30#include "llvm/IR/DataLayout.h"
Chandler Carruth9a4c9e52014-03-06 00:46:21 +000031#include "llvm/IR/DebugInfo.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000032#include "llvm/IR/Instructions.h"
33#include "llvm/IR/Module.h"
Chandler Carruth4220e9c2014-03-04 11:17:44 +000034#include "llvm/IR/ValueHandle.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000035#include "llvm/MC/MCAsmInfo.h"
Frederic Rissa5ab8442015-08-07 15:14:08 +000036#include "llvm/MC/MCDwarf.h"
Chris Lattner4d2c0f92009-07-31 18:48:30 +000037#include "llvm/MC/MCSection.h"
Chris Lattner4b7dadb2009-08-19 05:49:37 +000038#include "llvm/MC/MCStreamer.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000039#include "llvm/MC/MCSymbol.h"
Devang Patel6c74a872010-04-27 19:46:33 +000040#include "llvm/Support/CommandLine.h"
Daniel Dunbarcdf01b52009-10-13 06:47:08 +000041#include "llvm/Support/Debug.h"
42#include "llvm/Support/ErrorHandling.h"
Chris Lattnerf5c834f2010-01-22 22:09:00 +000043#include "llvm/Support/FormattedStream.h"
Logan Chien5b776b72014-02-22 14:00:39 +000044#include "llvm/Support/LEB128.h"
Eric Christopher67646432013-07-26 17:02:41 +000045#include "llvm/Support/MD5.h"
Michael J. Spencer447762d2010-11-29 18:16:10 +000046#include "llvm/Support/Path.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000047#include "llvm/Support/Timer.h"
Benjamin Kramer799003b2015-03-23 19:32:43 +000048#include "llvm/Support/raw_ostream.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000049#include "llvm/Target/TargetFrameLowering.h"
50#include "llvm/Target/TargetLoweringObjectFile.h"
51#include "llvm/Target/TargetMachine.h"
52#include "llvm/Target/TargetOptions.h"
53#include "llvm/Target/TargetRegisterInfo.h"
Eric Christopherd9134482014-08-04 21:25:23 +000054#include "llvm/Target/TargetSubtargetInfo.h"
Eugene Zelenkoecefe5a2016-02-02 18:20:45 +000055
Bill Wendling2f921f82009-05-15 09:23:25 +000056using namespace llvm;
57
Chandler Carruth1b9dde02014-04-22 02:02:50 +000058#define DEBUG_TYPE "dwarfdebug"
59
Eric Christopher7f2b5512013-07-23 22:16:41 +000060static cl::opt<bool>
61DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
62 cl::desc("Disable debug info printing"));
Devang Patel6c74a872010-04-27 19:46:33 +000063
Eric Christopherdd1a0122013-09-13 00:35:05 +000064static cl::opt<bool>
65GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
66 cl::desc("Generate GNU-style pubnames and pubtypes"),
67 cl::init(false));
68
Eric Christopher02dbadb2014-02-14 01:26:55 +000069static cl::opt<bool> GenerateARangeSection("generate-arange-section",
70 cl::Hidden,
71 cl::desc("Generate dwarf aranges"),
72 cl::init(false));
73
David Blaikie488393f2017-05-12 01:13:45 +000074static cl::opt<bool> SplitDwarfCrossCuReferences(
75 "split-dwarf-cross-cu-references", cl::Hidden,
76 cl::desc("Enable cross-cu references in DWO files"), cl::init(false));
77
Eric Christopher20b76a72012-08-23 22:36:40 +000078namespace {
Eric Christopherf07ee3a2014-01-27 23:50:03 +000079enum DefaultOnOff { Default, Enable, Disable };
Eric Christopher20b76a72012-08-23 22:36:40 +000080}
Eric Christopher4996c702011-11-07 09:24:32 +000081
Paul Robinsonac7fe5e2016-12-12 20:49:11 +000082static cl::opt<DefaultOnOff> UnknownLocations(
83 "use-unknown-locations", cl::Hidden,
84 cl::desc("Make an absence of debug location information explicit."),
85 cl::values(clEnumVal(Default, "At top of block or after label"),
86 clEnumVal(Enable, "In all cases"), clEnumVal(Disable, "Never")),
87 cl::init(Default));
88
Eric Christopher7f2b5512013-07-23 22:16:41 +000089static cl::opt<DefaultOnOff>
90DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
91 cl::desc("Output prototype dwarf accelerator tables."),
92 cl::values(clEnumVal(Default, "Default for platform"),
93 clEnumVal(Enable, "Enabled"),
Mehdi Amini732afdd2016-10-08 19:41:06 +000094 clEnumVal(Disable, "Disabled")),
Eric Christopher7f2b5512013-07-23 22:16:41 +000095 cl::init(Default));
Eric Christopher20b76a72012-08-23 22:36:40 +000096
Eric Christopher7f2b5512013-07-23 22:16:41 +000097static cl::opt<DefaultOnOff>
Eric Christopher4d36ca02013-08-26 23:24:35 +000098DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
99 cl::desc("Generate DWARF pubnames and pubtypes sections"),
100 cl::values(clEnumVal(Default, "Default for platform"),
101 clEnumVal(Enable, "Enabled"),
Mehdi Amini732afdd2016-10-08 19:41:06 +0000102 clEnumVal(Disable, "Disabled")),
Eric Christopher4d36ca02013-08-26 23:24:35 +0000103 cl::init(Default));
Eric Christopher7da24882013-08-19 21:07:38 +0000104
Paul Robinson43d1e452016-04-18 22:41:41 +0000105enum LinkageNameOption {
106 DefaultLinkageNames,
107 AllLinkageNames,
108 AbstractLinkageNames
109};
110static cl::opt<LinkageNameOption>
111 DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
112 cl::desc("Which DWARF linkage-name attributes to emit."),
113 cl::values(clEnumValN(DefaultLinkageNames, "Default",
114 "Default for platform"),
115 clEnumValN(AllLinkageNames, "All", "All"),
116 clEnumValN(AbstractLinkageNames, "Abstract",
Mehdi Amini732afdd2016-10-08 19:41:06 +0000117 "Abstract subprograms")),
Paul Robinson43d1e452016-04-18 22:41:41 +0000118 cl::init(DefaultLinkageNames));
Paul Robinson78046b42015-08-11 21:36:45 +0000119
Matthias Braun9f15a792016-11-18 19:43:18 +0000120static const char *const DWARFGroupName = "dwarf";
121static const char *const DWARFGroupDescription = "DWARF Emission";
122static const char *const DbgTimerName = "writer";
123static const char *const DbgTimerDescription = "DWARF Debug Writer";
Bill Wendlingfcc14142010-04-07 09:28:04 +0000124
Adrian Prantla63b8e82017-03-16 17:42:45 +0000125void DebugLocDwarfExpression::emitOp(uint8_t Op, const char *Comment) {
Adrian Prantl92da14b2015-03-02 22:02:33 +0000126 BS.EmitInt8(
127 Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
128 : dwarf::OperationEncodingString(Op));
129}
130
Adrian Prantla63b8e82017-03-16 17:42:45 +0000131void DebugLocDwarfExpression::emitSigned(int64_t Value) {
Adrian Prantl92da14b2015-03-02 22:02:33 +0000132 BS.EmitSLEB128(Value, Twine(Value));
133}
134
Adrian Prantla63b8e82017-03-16 17:42:45 +0000135void DebugLocDwarfExpression::emitUnsigned(uint64_t Value) {
Adrian Prantl92da14b2015-03-02 22:02:33 +0000136 BS.EmitULEB128(Value, Twine(Value));
137}
138
Peter Collingbourne96c9ae62016-05-20 19:35:17 +0000139bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
140 unsigned MachineReg) {
Adrian Prantl92da14b2015-03-02 22:02:33 +0000141 // This information is not available while emitting .debug_loc entries.
142 return false;
143}
144
Bill Wendling2f921f82009-05-15 09:23:25 +0000145//===----------------------------------------------------------------------===//
146
Adrian Prantl1a1647c2014-03-18 02:34:58 +0000147bool DbgVariable::isBlockByrefVariable() const {
Duncan P. N. Exon Smithe686f152015-04-06 23:27:40 +0000148 assert(Var && "Invalid complex DbgVariable!");
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000149 return Var->getType().resolve()->isBlockByrefStruct();
Adrian Prantl1a1647c2014-03-18 02:34:58 +0000150}
151
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000152const DIType *DbgVariable::getType() const {
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000153 DIType *Ty = Var->getType().resolve();
Devang Patelf20c4f72011-04-12 22:53:02 +0000154 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
155 // addresses instead.
Duncan P. N. Exon Smith571baeb2015-04-14 01:59:58 +0000156 if (Ty->isBlockByrefStruct()) {
Devang Patelf20c4f72011-04-12 22:53:02 +0000157 /* Byref variables, in Blocks, are declared by the programmer as
158 "SomeType VarName;", but the compiler creates a
159 __Block_byref_x_VarName struct, and gives the variable VarName
160 either the struct, or a pointer to the struct, as its type. This
161 is necessary for various behind-the-scenes things the compiler
162 needs to do with by-reference variables in blocks.
Eric Christopher6a841382012-11-19 22:42:10 +0000163
Devang Patelf20c4f72011-04-12 22:53:02 +0000164 However, as far as the original *programmer* is concerned, the
165 variable should still have type 'SomeType', as originally declared.
Eric Christopher6a841382012-11-19 22:42:10 +0000166
Devang Patelf20c4f72011-04-12 22:53:02 +0000167 The following function dives into the __Block_byref_x_VarName
168 struct to find the original type of the variable. This will be
169 passed back to the code generating the type for the Debug
170 Information Entry for the variable 'VarName'. 'VarName' will then
171 have the original type 'SomeType' in its debug information.
Eric Christopher6a841382012-11-19 22:42:10 +0000172
Devang Patelf20c4f72011-04-12 22:53:02 +0000173 The original type 'SomeType' will be the type of the field named
174 'VarName' inside the __Block_byref_x_VarName struct.
Eric Christopher6a841382012-11-19 22:42:10 +0000175
Devang Patelf20c4f72011-04-12 22:53:02 +0000176 NOTE: In order for this to not completely fail on the debugger
177 side, the Debug Information Entry for the variable VarName needs to
178 have a DW_AT_location that tells the debugger how to unwind through
179 the pointers and __Block_byref_x_VarName struct to find the actual
180 value of the variable. The function addBlockByrefType does this. */
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000181 DIType *subType = Ty;
Duncan P. N. Exon Smithb1055642015-04-16 01:01:28 +0000182 uint16_t tag = Ty->getTag();
Eric Christopher6a841382012-11-19 22:42:10 +0000183
Eric Christopher9adc55f2013-09-04 19:53:21 +0000184 if (tag == dwarf::DW_TAG_pointer_type)
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000185 subType = resolve(cast<DIDerivedType>(Ty)->getBaseType());
Eric Christopher6a841382012-11-19 22:42:10 +0000186
Duncan P. N. Exon Smith6ac940d2015-07-24 18:17:17 +0000187 auto Elements = cast<DICompositeType>(subType)->getElements();
Duncan P. N. Exon Smith000fa2c2015-04-07 04:14:33 +0000188 for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
Duncan P. N. Exon Smith099ea1c2015-07-24 18:58:32 +0000189 auto *DT = cast<DIDerivedType>(Elements[i]);
Duncan P. N. Exon Smithb1055642015-04-16 01:01:28 +0000190 if (getName() == DT->getName())
Duncan P. N. Exon Smith848af382015-04-20 18:20:03 +0000191 return resolve(DT->getBaseType());
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000192 }
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000193 }
Devang Patelf20c4f72011-04-12 22:53:02 +0000194 return Ty;
195}
Bill Wendling2f921f82009-05-15 09:23:25 +0000196
Adrian Prantl67c24422017-02-17 19:42:32 +0000197ArrayRef<DbgVariable::FrameIndexExpr> DbgVariable::getFrameIndexExprs() const {
Adrian Prantl55030772017-03-22 16:50:16 +0000198 if (FrameIndexExprs.size() == 1)
199 return FrameIndexExprs;
200
201 assert(all_of(FrameIndexExprs,
202 [](const FrameIndexExpr &A) { return A.Expr->isFragment(); }) &&
203 "multiple FI expressions without DW_OP_LLVM_fragment");
Adrian Prantl67c24422017-02-17 19:42:32 +0000204 std::sort(FrameIndexExprs.begin(), FrameIndexExprs.end(),
205 [](const FrameIndexExpr &A, const FrameIndexExpr &B) -> bool {
206 return A.Expr->getFragmentInfo()->OffsetInBits <
207 B.Expr->getFragmentInfo()->OffsetInBits;
208 });
209 return FrameIndexExprs;
210}
211
George Burgess IV381fc0e2016-08-25 01:05:08 +0000212static const DwarfAccelTable::Atom TypeAtoms[] = {
David Blaikie18d33752014-04-24 01:23:49 +0000213 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
214 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
215 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
216
Chris Lattnerf0d6bd32010-04-05 05:11:15 +0000217DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
Reid Klecknerf9c275f2016-02-10 20:55:49 +0000218 : DebugHandlerBase(A), DebugLocs(A->OutStreamer->isVerboseAsm()),
219 InfoHolder(A, "info_string", DIEValueAllocator),
Frederic Riss9412d632015-03-04 02:30:17 +0000220 SkeletonHolder(A, "skel_string", DIEValueAllocator),
Eric Christopher364dbe02016-10-01 01:50:29 +0000221 IsDarwin(A->TM.getTargetTriple().isOSDarwin()),
David Blaikie2406a0622014-04-23 23:37:35 +0000222 AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
David Blaikie0ee82b92014-04-24 00:53:32 +0000223 dwarf::DW_FORM_data4)),
224 AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
David Blaikieecf04152014-04-24 01:02:42 +0000225 dwarf::DW_FORM_data4)),
226 AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
David Blaikie18d33752014-04-24 01:23:49 +0000227 dwarf::DW_FORM_data4)),
Paul Robinsonb9de1062015-07-15 22:04:54 +0000228 AccelTypes(TypeAtoms), DebuggerTuning(DebuggerKind::Default) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000229
Craig Topper353eda42014-04-24 06:44:33 +0000230 CurFn = nullptr;
Eric Christopher364dbe02016-10-01 01:50:29 +0000231 const Triple &TT = Asm->TM.getTargetTriple();
Eric Christopherad9fe892012-04-02 17:58:52 +0000232
Paul Robinson6c27a2c2015-12-16 19:58:30 +0000233 // Make sure we know our "debugger tuning." The target option takes
Paul Robinsonb9de1062015-07-15 22:04:54 +0000234 // precedence; fall back to triple-based defaults.
Paul Robinson6c27a2c2015-12-16 19:58:30 +0000235 if (Asm->TM.Options.DebuggerTuning != DebuggerKind::Default)
236 DebuggerTuning = Asm->TM.Options.DebuggerTuning;
Dimitry Andric2c364212016-01-07 22:09:12 +0000237 else if (IsDarwin)
Paul Robinsonb9de1062015-07-15 22:04:54 +0000238 DebuggerTuning = DebuggerKind::LLDB;
239 else if (TT.isPS4CPU())
240 DebuggerTuning = DebuggerKind::SCE;
241 else
242 DebuggerTuning = DebuggerKind::GDB;
243
244 // Turn on accelerator tables for LLDB by default.
Eric Christopher574b5c82013-08-19 21:41:38 +0000245 if (DwarfAccelTables == Default)
Paul Robinsonb9de1062015-07-15 22:04:54 +0000246 HasDwarfAccelTables = tuneForLLDB();
Eric Christopher574b5c82013-08-19 21:41:38 +0000247 else
Eric Christopher5297df02013-08-26 20:58:35 +0000248 HasDwarfAccelTables = DwarfAccelTables == Enable;
Eric Christopher20b76a72012-08-23 22:36:40 +0000249
David Blaikiec53e18d2016-05-24 21:19:28 +0000250 HasAppleExtensionAttributes = tuneForLLDB();
251
David Blaikie96b1ed52017-04-21 23:35:26 +0000252 // Handle split DWARF.
253 HasSplitDwarf = !Asm->TM.Options.MCOptions.SplitDwarfFile.empty();
Eric Christopher29424312012-11-12 22:22:20 +0000254
Paul Robinson43d1e452016-04-18 22:41:41 +0000255 // SCE defaults to linkage names only for abstract subprograms.
256 if (DwarfLinkageNames == DefaultLinkageNames)
257 UseAllLinkageNames = !tuneForSCE();
Paul Robinson78046b42015-08-11 21:36:45 +0000258 else
Paul Robinson43d1e452016-04-18 22:41:41 +0000259 UseAllLinkageNames = DwarfLinkageNames == AllLinkageNames;
Paul Robinson78046b42015-08-11 21:36:45 +0000260
Eric Christopher4c5bff32014-06-19 06:22:08 +0000261 unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
Greg Claytone6543972016-11-23 23:30:37 +0000262 unsigned DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
Eric Christopher793c7472014-04-28 20:42:22 +0000263 : MMI->getModule()->getDwarfVersion();
Reid Kleckner12d2c122015-08-05 22:26:20 +0000264 // Use dwarf 4 by default if nothing is requested.
265 DwarfVersion = DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION;
Manman Renac8062b2013-07-02 23:40:10 +0000266
Paul Robinsonb9de1062015-07-15 22:04:54 +0000267 // Work around a GDB bug. GDB doesn't support the standard opcode;
268 // SCE doesn't support GNU's; LLDB prefers the standard opcode, which
269 // is defined as of DWARF 3.
270 // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
271 // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
272 UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
Paul Robinson78cc0822015-03-04 20:55:11 +0000273
Adrian Prantl6323ddf2016-05-17 21:07:16 +0000274 // GDB does not fully support the DWARF 4 representation for bitfields.
275 UseDWARF2Bitfields = (DwarfVersion < 4) || tuneForGDB();
276
Lang Hames9ff69c82015-04-24 19:11:51 +0000277 Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
Bill Wendling2f921f82009-05-15 09:23:25 +0000278}
Bill Wendling2f921f82009-05-15 09:23:25 +0000279
Reid Klecknerdd2647e2014-04-30 20:34:31 +0000280// Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
281DwarfDebug::~DwarfDebug() { }
282
Eric Christopherd9843b32011-11-10 19:25:34 +0000283static bool isObjCClass(StringRef Name) {
284 return Name.startswith("+") || Name.startswith("-");
285}
286
287static bool hasObjCCategory(StringRef Name) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000288 if (!isObjCClass(Name))
289 return false;
Eric Christopherd9843b32011-11-10 19:25:34 +0000290
Benjamin Kramer260de742013-08-24 12:15:54 +0000291 return Name.find(") ") != StringRef::npos;
Eric Christopherd9843b32011-11-10 19:25:34 +0000292}
293
294static void getObjCClassCategory(StringRef In, StringRef &Class,
295 StringRef &Category) {
296 if (!hasObjCCategory(In)) {
297 Class = In.slice(In.find('[') + 1, In.find(' '));
298 Category = "";
299 return;
300 }
301
302 Class = In.slice(In.find('[') + 1, In.find('('));
303 Category = In.slice(In.find('[') + 1, In.find(' '));
Eric Christopherd9843b32011-11-10 19:25:34 +0000304}
305
306static StringRef getObjCMethodName(StringRef In) {
307 return In.slice(In.find(' ') + 1, In.find(']'));
308}
309
310// Add the various names to the Dwarf accelerator table names.
Eric Christopher9cd26af2013-09-20 23:22:52 +0000311// TODO: Determine whether or not we should add names for programs
312// that do not have a DW_AT_name or DW_AT_linkage_name field - this
313// is only slightly different than the lookup of non-standard ObjC names.
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000314void DwarfDebug::addSubprogramNames(const DISubprogram *SP, DIE &Die) {
Duncan P. N. Exon Smith537b4a82015-04-14 03:40:37 +0000315 if (!SP->isDefinition())
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000316 return;
Duncan P. N. Exon Smith537b4a82015-04-14 03:40:37 +0000317 addAccelName(SP->getName(), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000318
319 // If the linkage name is different than the name, go ahead and output
320 // that as well into the name table.
Duncan P. N. Exon Smith537b4a82015-04-14 03:40:37 +0000321 if (SP->getLinkageName() != "" && SP->getName() != SP->getLinkageName())
322 addAccelName(SP->getLinkageName(), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000323
324 // If this is an Objective-C selector name add it to the ObjC accelerator
325 // too.
Duncan P. N. Exon Smith537b4a82015-04-14 03:40:37 +0000326 if (isObjCClass(SP->getName())) {
Eric Christopherd9843b32011-11-10 19:25:34 +0000327 StringRef Class, Category;
Duncan P. N. Exon Smith537b4a82015-04-14 03:40:37 +0000328 getObjCClassCategory(SP->getName(), Class, Category);
David Blaikie0ee82b92014-04-24 00:53:32 +0000329 addAccelObjC(Class, Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000330 if (Category != "")
David Blaikie0ee82b92014-04-24 00:53:32 +0000331 addAccelObjC(Category, Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000332 // Also add the base method name to the name table.
Duncan P. N. Exon Smith537b4a82015-04-14 03:40:37 +0000333 addAccelName(getObjCMethodName(SP->getName()), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000334 }
335}
336
Manman Ren5b2f4b02013-09-11 19:40:28 +0000337/// Check whether we should create a DIE for the given Scope, return true
338/// if we don't create a DIE (the corresponding DIE is null).
Manman Ren2312ed32013-09-10 18:40:41 +0000339bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
340 if (Scope->isAbstractScope())
341 return false;
342
Manman Ren5b2f4b02013-09-11 19:40:28 +0000343 // We don't create a DIE if there is no Range.
Manman Ren2312ed32013-09-10 18:40:41 +0000344 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
345 if (Ranges.empty())
346 return true;
347
348 if (Ranges.size() > 1)
349 return false;
350
Manman Ren5b2f4b02013-09-11 19:40:28 +0000351 // We don't create a DIE if we have a single Range and the end label
352 // is null.
David Blaikiecd4b8a22014-08-31 02:14:26 +0000353 return !getLabelAfterInsn(Ranges.front().second);
Manman Ren2312ed32013-09-10 18:40:41 +0000354}
355
Benjamin Kramerb7d33112016-08-06 11:13:10 +0000356template <typename Func> static void forBothCUs(DwarfCompileUnit &CU, Func F) {
David Blaikie3a443c22014-11-04 22:12:25 +0000357 F(CU);
358 if (auto *SkelCU = CU.getSkeleton())
David Blaikiea01f2952016-08-24 18:29:49 +0000359 if (CU.getCUNode()->getSplitDebugInlining())
360 F(*SkelCU);
David Blaikie3a443c22014-11-04 22:12:25 +0000361}
362
David Blaikie488393f2017-05-12 01:13:45 +0000363bool DwarfDebug::shareAcrossDWOCUs() const {
364 return SplitDwarfCrossCuReferences;
365}
366
367void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU,
368 LexicalScope *Scope) {
David Blaikiee872a6e2014-04-29 15:58:35 +0000369 assert(Scope && Scope->getScopeNode());
370 assert(Scope->isAbstractScope());
371 assert(!Scope->getInlinedAt());
372
David Blaikieb4614682016-12-14 19:38:39 +0000373 auto *SP = cast<DISubprogram>(Scope->getScopeNode());
David Blaikiee872a6e2014-04-29 15:58:35 +0000374
David Blaikie1ea9db22014-05-21 23:14:12 +0000375 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
376 // was inlined from another compile unit.
Mehdi Amini41812052017-05-29 06:25:30 +0000377 if (useSplitDwarf() && !shareAcrossDWOCUs() && !SP->getUnit()->getSplitDebugInlining())
378 // Avoid building the original CU if it won't be used
379 SrcCU.constructAbstractSubprogramScopeDIE(Scope);
380 else {
381 auto &CU = getOrCreateDwarfCompileUnit(SP->getUnit());
382 if (auto *SkelCU = CU.getSkeleton()) {
383 (shareAcrossDWOCUs() ? CU : SrcCU)
384 .constructAbstractSubprogramScopeDIE(Scope);
385 if (CU.getCUNode()->getSplitDebugInlining())
386 SkelCU->constructAbstractSubprogramScopeDIE(Scope);
387 } else
388 CU.constructAbstractSubprogramScopeDIE(Scope);
David Blaikie488393f2017-05-12 01:13:45 +0000389 }
David Blaikiee872a6e2014-04-29 15:58:35 +0000390}
391
David Blaikieb3cee2f2017-05-25 18:50:28 +0000392bool DwarfDebug::hasDwarfPubSections(bool includeMinimalInlineScopes) const {
393 // Opting in to GNU Pubnames/types overrides the default to ensure these are
394 // generated for things like Gold's gdb_index generation.
395 if (GenerateGnuPubSections)
396 return true;
397
398 if (DwarfPubSections == Default)
399 return tuneForGDB() && !includeMinimalInlineScopes;
400
401 return DwarfPubSections == Enable;
402}
403
404void DwarfDebug::addGnuPubAttributes(DwarfCompileUnit &U, DIE &D) const {
405 if (!hasDwarfPubSections(U.includeMinimalInlineScopes()))
David Blaikie3c842622013-12-04 21:31:26 +0000406 return;
407
David Blaikief9b6a552014-04-22 22:39:41 +0000408 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
David Blaikie3c842622013-12-04 21:31:26 +0000409}
410
Eric Christopher4287a492013-12-09 23:57:44 +0000411// Create new DwarfCompileUnit for the given metadata node with tag
Eric Christopher48fef592012-12-20 21:58:40 +0000412// DW_TAG_compile_unit.
Duncan P. N. Exon Smith2fbe1352015-04-20 22:10:08 +0000413DwarfCompileUnit &
David Blaikie07963bd2017-05-26 18:52:56 +0000414DwarfDebug::getOrCreateDwarfCompileUnit(const DICompileUnit *DIUnit) {
415 if (auto *CU = CUMap.lookup(DIUnit))
416 return *CU;
Duncan P. N. Exon Smith35ef22c2015-04-15 23:19:27 +0000417 StringRef FN = DIUnit->getFilename();
418 CompilationDir = DIUnit->getDirectory();
Bill Wendling2b128d72009-05-20 23:19:06 +0000419
David Blaikief9b6a552014-04-22 22:39:41 +0000420 auto OwnedUnit = make_unique<DwarfCompileUnit>(
David Blaikiebd579052014-04-28 21:14:27 +0000421 InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
David Blaikief9b6a552014-04-22 22:39:41 +0000422 DwarfCompileUnit &NewCU = *OwnedUnit;
David Blaikie92a2f8a2014-04-28 21:04:29 +0000423 DIE &Die = NewCU.getUnitDie();
David Blaikief9b6a552014-04-22 22:39:41 +0000424 InfoHolder.addUnit(std::move(OwnedUnit));
David Blaikie0b214e42016-03-24 18:37:08 +0000425 if (useSplitDwarf()) {
David Blaikiecafd9622014-11-02 08:51:37 +0000426 NewCU.setSkeleton(constructSkeletonCU(NewCU));
David Blaikie0b214e42016-03-24 18:37:08 +0000427 NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
David Blaikie96b1ed52017-04-21 23:35:26 +0000428 Asm->TM.Options.MCOptions.SplitDwarfFile);
David Blaikie0b214e42016-03-24 18:37:08 +0000429 }
David Blaikief9b6a552014-04-22 22:39:41 +0000430
David Blaikie7ac51492014-03-20 17:05:45 +0000431 // LTO with assembly output shares a single line table amongst multiple CUs.
432 // To avoid the compilation directory being ambiguous, let the line table
433 // explicitly describe the directory of all files, never relying on the
434 // compilation directory.
Lang Hames9ff69c82015-04-24 19:11:51 +0000435 if (!Asm->OutStreamer->hasRawTextSupport() || SingleCU)
436 Asm->OutStreamer->getContext().setMCLineTableCompilationDir(
David Blaikief9b6a552014-04-22 22:39:41 +0000437 NewCU.getUniqueID(), CompilationDir);
David Blaikie2666e242013-12-06 19:38:46 +0000438
Eric Christopher9ea300f2017-03-29 23:34:27 +0000439 StringRef Producer = DIUnit->getProducer();
440 StringRef Flags = DIUnit->getFlags();
441 if (!Flags.empty()) {
442 std::string ProducerWithFlags = Producer.str() + " " + Flags.str();
443 NewCU.addString(Die, dwarf::DW_AT_producer, ProducerWithFlags);
444 } else
445 NewCU.addString(Die, dwarf::DW_AT_producer, Producer);
446
David Blaikie92a2f8a2014-04-28 21:04:29 +0000447 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
Duncan P. N. Exon Smith35ef22c2015-04-15 23:19:27 +0000448 DIUnit->getSourceLanguage());
David Blaikie92a2f8a2014-04-28 21:04:29 +0000449 NewCU.addString(Die, dwarf::DW_AT_name, FN);
Eric Christopher52ce7182013-04-09 19:23:15 +0000450
Eric Christopher52ce7182013-04-09 19:23:15 +0000451 if (!useSplitDwarf()) {
Rafael Espindola063d7252015-03-10 16:58:10 +0000452 NewCU.initStmtList();
Eric Christophera51d3fc2013-09-27 22:50:48 +0000453
454 // If we're using split dwarf the compilation dir is going to be in the
455 // skeleton CU and so we don't need to duplicate it here.
456 if (!CompilationDir.empty())
David Blaikie92a2f8a2014-04-28 21:04:29 +0000457 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
Eric Christophera51d3fc2013-09-27 22:50:48 +0000458
David Blaikie92a2f8a2014-04-28 21:04:29 +0000459 addGnuPubAttributes(NewCU, Die);
Eric Christopher52ce7182013-04-09 19:23:15 +0000460 }
Bill Wendling2b128d72009-05-20 23:19:06 +0000461
David Blaikiec53e18d2016-05-24 21:19:28 +0000462 if (useAppleExtensionAttributes()) {
463 if (DIUnit->isOptimized())
464 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
Bill Wendling2b128d72009-05-20 23:19:06 +0000465
David Blaikiec53e18d2016-05-24 21:19:28 +0000466 StringRef Flags = DIUnit->getFlags();
467 if (!Flags.empty())
468 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
Eric Christopher6a841382012-11-19 22:42:10 +0000469
David Blaikiec53e18d2016-05-24 21:19:28 +0000470 if (unsigned RVer = DIUnit->getRuntimeVersion())
471 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
472 dwarf::DW_FORM_data1, RVer);
473 }
Bill Wendling2b128d72009-05-20 23:19:06 +0000474
David Blaikiecafd9622014-11-02 08:51:37 +0000475 if (useSplitDwarf())
Greg Clayton35630c32016-12-01 18:56:29 +0000476 NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoDWOSection());
David Blaikiecafd9622014-11-02 08:51:37 +0000477 else
Greg Clayton35630c32016-12-01 18:56:29 +0000478 NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
Eric Christopherd039baa2013-12-30 03:40:32 +0000479
Adrian Prantldeef90d2015-09-14 22:10:22 +0000480 if (DIUnit->getDWOId()) {
Adrian Prantl77fefeb2015-09-22 23:21:00 +0000481 // This CU is either a clang module DWO or a skeleton CU.
Adrian Prantldeef90d2015-09-14 22:10:22 +0000482 NewCU.addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8,
483 DIUnit->getDWOId());
Adrian Prantl77fefeb2015-09-22 23:21:00 +0000484 if (!DIUnit->getSplitDebugFilename().empty())
485 // This is a prefabricated skeleton CU.
486 NewCU.addString(Die, dwarf::DW_AT_GNU_dwo_name,
487 DIUnit->getSplitDebugFilename());
Adrian Prantldeef90d2015-09-14 22:10:22 +0000488 }
489
David Majnemer0a16c222016-08-11 21:15:00 +0000490 CUMap.insert({DIUnit, &NewCU});
491 CUDieMap.insert({&Die, &NewCU});
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000492 return NewCU;
Devang Patel1a0df9a2010-05-10 22:49:55 +0000493}
494
David Blaikie8912df12014-08-31 05:41:15 +0000495void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000496 const DIImportedEntity *N) {
Duncan P. N. Exon Smith60635e32015-04-21 18:44:06 +0000497 if (DIE *D = TheCU.getOrCreateContextDIE(N->getScope()))
498 D->addChild(TheCU.constructImportedEntityDIE(N));
David Blaikief55abea2013-04-22 06:12:31 +0000499}
500
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000501/// Sort and unique GVEs by comparing their fragment offset.
502static SmallVectorImpl<DwarfCompileUnit::GlobalExpr> &
503sortGlobalExprs(SmallVectorImpl<DwarfCompileUnit::GlobalExpr> &GVEs) {
504 std::sort(GVEs.begin(), GVEs.end(),
505 [](DwarfCompileUnit::GlobalExpr A, DwarfCompileUnit::GlobalExpr B) {
Adrian Prantl49797ca2016-12-22 05:27:12 +0000506 if (A.Expr != B.Expr && A.Expr && B.Expr) {
507 auto FragmentA = A.Expr->getFragmentInfo();
508 auto FragmentB = B.Expr->getFragmentInfo();
509 if (FragmentA && FragmentB)
510 return FragmentA->OffsetInBits < FragmentB->OffsetInBits;
511 }
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000512 return false;
513 });
514 GVEs.erase(std::unique(GVEs.begin(), GVEs.end(),
515 [](DwarfCompileUnit::GlobalExpr A,
516 DwarfCompileUnit::GlobalExpr B) {
517 return A.Expr == B.Expr;
518 }),
519 GVEs.end());
520 return GVEs;
521}
522
Adrian Prantl833ad372017-07-26 18:48:32 +0000523static bool isEmptyCU(DICompileUnit *CUNode) {
524 return CUNode->getEnumTypes().empty() &&
525 CUNode->getRetainedTypes().empty() &&
526 CUNode->getGlobalVariables().empty() &&
527 CUNode->getImportedEntities().empty() &&
528 CUNode->getMacros().empty();
529}
530
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000531// Emit all Dwarf sections that should come prior to the content. Create
532// global DIEs and emit initial debug info sections. This is invoked by
533// the target AsmPrinter.
Eric Christopher58f41952012-11-19 22:42:15 +0000534void DwarfDebug::beginModule() {
Matthias Braun9f15a792016-11-18 19:43:18 +0000535 NamedRegionTimer T(DbgTimerName, DbgTimerDescription, DWARFGroupName,
536 DWARFGroupDescription, TimePassesIsEnabled);
Devang Patel6c74a872010-04-27 19:46:33 +0000537 if (DisableDebugInfoPrinting)
538 return;
539
Eric Christopher58f41952012-11-19 22:42:15 +0000540 const Module *M = MMI->getModule();
541
Peter Collingbourneb3269862016-06-01 02:58:40 +0000542 unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
543 M->debug_compile_units_end());
Adrian Prantl5992a722016-04-08 22:43:03 +0000544 // Tell MMI whether we have debug info.
545 MMI->setDebugInfoAvailability(NumDebugCUs > 0);
546 SingleCU = NumDebugCUs == 1;
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000547 DenseMap<DIGlobalVariable *, SmallVector<DwarfCompileUnit::GlobalExpr, 1>>
548 GVMap;
Peter Collingbourned4135bb2016-09-13 01:12:59 +0000549 for (const GlobalVariable &Global : M->globals()) {
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000550 SmallVector<DIGlobalVariableExpression *, 1> GVs;
Peter Collingbourned4135bb2016-09-13 01:12:59 +0000551 Global.getDebugInfo(GVs);
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000552 for (auto *GVE : GVs)
553 GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
Peter Collingbourned4135bb2016-09-13 01:12:59 +0000554 }
555
Adrian Prantl5992a722016-04-08 22:43:03 +0000556 for (DICompileUnit *CUNode : M->debug_compile_units()) {
Adrian Prantl833ad372017-07-26 18:48:32 +0000557 if (isEmptyCU(CUNode))
David Blaikie07963bd2017-05-26 18:52:56 +0000558 continue;
559
560 DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(CUNode);
Amjad Aboud72da9392016-04-30 01:44:07 +0000561 for (auto *IE : CUNode->getImportedEntities())
562 CU.addImportedEntity(IE);
Adrian Prantlbceaaa92016-12-20 02:09:43 +0000563
564 // Global Variables.
565 for (auto *GVE : CUNode->getGlobalVariables())
566 GVMap[GVE->getVariable()].push_back({nullptr, GVE->getExpression()});
567 DenseSet<DIGlobalVariable *> Processed;
568 for (auto *GVE : CUNode->getGlobalVariables()) {
569 DIGlobalVariable *GV = GVE->getVariable();
570 if (Processed.insert(GV).second)
571 CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
572 }
573
Duncan P. N. Exon Smith9928a902015-04-20 18:52:06 +0000574 for (auto *Ty : CUNode->getEnumTypes()) {
Manman Renbd1628a2014-07-28 23:04:20 +0000575 // The enum types array by design contains pointers to
576 // MDNodes rather than DIRefs. Unique them here.
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000577 CU.getOrCreateTypeDIE(cast<DIType>(Ty));
Manman Renbd1628a2014-07-28 23:04:20 +0000578 }
Duncan P. N. Exon Smith9928a902015-04-20 18:52:06 +0000579 for (auto *Ty : CUNode->getRetainedTypes()) {
Adrian Prantl0aa1aa22014-03-18 02:35:03 +0000580 // The retained types array by design contains pointers to
581 // MDNodes rather than DIRefs. Unique them here.
Amjad Aboud72da9392016-04-30 01:44:07 +0000582 if (DIType *RT = dyn_cast<DIType>(Ty))
Adrian Prantl75819ae2016-04-15 15:57:41 +0000583 // There is no point in force-emitting a forward declaration.
584 CU.getOrCreateTypeDIE(RT);
Adrian Prantl0aa1aa22014-03-18 02:35:03 +0000585 }
David Blaikief55abea2013-04-22 06:12:31 +0000586 // Emit imported_modules last so that the relevant context is already
587 // available.
Duncan P. N. Exon Smith000fa2c2015-04-07 04:14:33 +0000588 for (auto *IE : CUNode->getImportedEntities())
Amjad Aboud72da9392016-04-30 01:44:07 +0000589 constructAndAddImportedEntityDIE(CU, IE);
David Blaikiedc69ebb2013-03-11 23:39:23 +0000590 }
Bill Wendling2b128d72009-05-20 23:19:06 +0000591}
592
David Blaikieeb1a2722014-06-13 22:18:23 +0000593void DwarfDebug::finishVariableDefinitions() {
594 for (const auto &Var : ConcreteVariables) {
595 DIE *VariableDie = Var->getDIE();
David Blaikief73ae4f2014-08-12 00:00:31 +0000596 assert(VariableDie);
David Blaikieeb1a2722014-06-13 22:18:23 +0000597 // FIXME: Consider the time-space tradeoff of just storing the unit pointer
598 // in the ConcreteVariables list, rather than looking it up again here.
599 // DIE::getUnit isn't simple - it walks parent pointers, etc.
Greg Clayton35630c32016-12-01 18:56:29 +0000600 DwarfCompileUnit *Unit = CUDieMap.lookup(VariableDie->getUnitDie());
David Blaikieeb1a2722014-06-13 22:18:23 +0000601 assert(Unit);
David Blaikie488393f2017-05-12 01:13:45 +0000602 Unit->finishVariableDefinition(*Var);
David Blaikieeb1a2722014-06-13 22:18:23 +0000603 }
604}
605
David Blaikief7221ad2014-05-27 18:37:43 +0000606void DwarfDebug::finishSubprogramDefinitions() {
David Blaikie07963bd2017-05-26 18:52:56 +0000607 for (const DISubprogram *SP : ProcessedSPNodes) {
608 assert(SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug);
609 forBothCUs(
610 getOrCreateDwarfCompileUnit(SP->getUnit()),
611 [&](DwarfCompileUnit &CU) { CU.finishSubprogramDefinition(SP); });
612 }
Eric Christopher960ac372012-11-22 00:59:49 +0000613}
614
615void DwarfDebug::finalizeModuleInfo() {
Rafael Espindola063d7252015-03-10 16:58:10 +0000616 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
617
David Blaikie3c2fff32014-05-27 18:37:48 +0000618 finishSubprogramDefinitions();
619
David Blaikieeb1a2722014-06-13 22:18:23 +0000620 finishVariableDefinitions();
621
Mehdi Amini96ab48f2017-05-29 06:32:34 +0000622 // Include the DWO file name in the hash if there's more than one CU.
623 // This handles ThinLTO's situation where imported CUs may very easily be
624 // duplicate with the same CU partially imported into another ThinLTO unit.
625 StringRef DWOName;
626 if (CUMap.size() > 1)
627 DWOName = Asm->TM.Options.MCOptions.SplitDwarfFile;
628
Eric Christopherad10cb52013-12-04 23:24:38 +0000629 // Handle anything that needs to be done on a per-unit basis after
630 // all other generation.
David Blaikie1998a2e2014-11-01 01:11:19 +0000631 for (const auto &P : CUMap) {
632 auto &TheCU = *P.second;
Eric Christopher60eb7692013-08-12 20:27:48 +0000633 // Emit DW_AT_containing_type attribute to connect types with their
634 // vtable holding type.
David Blaikie1998a2e2014-11-01 01:11:19 +0000635 TheCU.constructContainingTypeDIEs();
Eric Christopher60eb7692013-08-12 20:27:48 +0000636
Eric Christopher46e23432013-12-20 04:16:18 +0000637 // Add CU specific attributes if we need to add any.
David Blaikie1998a2e2014-11-01 01:11:19 +0000638 // If we're splitting the dwarf out now that we've got the entire
639 // CU then add the dwo id to it.
640 auto *SkCU = TheCU.getSkeleton();
641 if (useSplitDwarf()) {
642 // Emit a unique identifier for this CU.
Mehdi Amini96ab48f2017-05-29 06:32:34 +0000643 uint64_t ID =
644 DIEHash(Asm).computeCUSignature(DWOName, TheCU.getUnitDie());
David Blaikie1998a2e2014-11-01 01:11:19 +0000645 TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
646 dwarf::DW_FORM_data8, ID);
647 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
648 dwarf::DW_FORM_data8, ID);
David Blaikie3ffe4dd2014-03-25 05:34:24 +0000649
David Blaikie1998a2e2014-11-01 01:11:19 +0000650 // We don't keep track of which addresses are used in which CU so this
651 // is a bit pessimistic under LTO.
Rafael Espindola063d7252015-03-10 16:58:10 +0000652 if (!AddrPool.isEmpty()) {
653 const MCSymbol *Sym = TLOF.getDwarfAddrSection()->getBeginSymbol();
David Blaikie1998a2e2014-11-01 01:11:19 +0000654 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_addr_base,
Rafael Espindola063d7252015-03-10 16:58:10 +0000655 Sym, Sym);
656 }
657 if (!SkCU->getRangeLists().empty()) {
658 const MCSymbol *Sym = TLOF.getDwarfRangesSection()->getBeginSymbol();
David Blaikie1998a2e2014-11-01 01:11:19 +0000659 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
Rafael Espindola063d7252015-03-10 16:58:10 +0000660 Sym, Sym);
661 }
David Blaikie1998a2e2014-11-01 01:11:19 +0000662 }
Eric Christopherd8667202013-12-30 17:22:27 +0000663
David Blaikie1998a2e2014-11-01 01:11:19 +0000664 // If we have code split among multiple sections or non-contiguous
665 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
666 // remain in the .o file, otherwise add a DW_AT_low_pc.
667 // FIXME: We should use ranges allow reordering of code ala
668 // .subsections_via_symbols in mach-o. This would mean turning on
669 // ranges for all subprogram DIEs for mach-o.
David Blaikiea8be0a72014-11-01 01:15:24 +0000670 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
David Blaikie5b02a192014-11-03 23:10:59 +0000671 if (unsigned NumRanges = TheCU.getRanges().size()) {
672 if (NumRanges > 1)
David Blaikie1998a2e2014-11-01 01:11:19 +0000673 // A DW_AT_low_pc attribute may also be specified in combination with
674 // DW_AT_ranges to specify the default base address for use in
675 // location lists (see Section 2.6.2) and range lists (see Section
676 // 2.17.3).
677 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
David Blaikie5b02a192014-11-03 23:10:59 +0000678 else
David Blaikie72d03ef2015-05-02 02:31:49 +0000679 U.setBaseAddress(TheCU.getRanges().front().getStart());
David Blaikie5b02a192014-11-03 23:10:59 +0000680 U.attachRangesOrLowHighPC(U.getUnitDie(), TheCU.takeRanges());
Eric Christopher60eb7692013-08-12 20:27:48 +0000681 }
Amjad Aboudd7cfb482016-01-07 14:28:20 +0000682
683 auto *CUNode = cast<DICompileUnit>(P.first);
Amjad Aboud8bbce8a2016-02-01 14:09:41 +0000684 // If compile Unit has macros, emit "DW_AT_macro_info" attribute.
685 if (CUNode->getMacros())
686 U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_macro_info,
687 U.getMacroLabelBegin(),
688 TLOF.getDwarfMacinfoSection()->getBeginSymbol());
Eric Christopher60eb7692013-08-12 20:27:48 +0000689 }
690
Adrian Prantl833ad372017-07-26 18:48:32 +0000691 // Emit all frontend-produced Skeleton CUs, i.e., Clang modules.
692 for (auto *CUNode : MMI->getModule()->debug_compile_units())
693 if (CUNode->getDWOId() && isEmptyCU(CUNode))
694 getOrCreateDwarfCompileUnit(CUNode);
695
Eric Christopher60eb7692013-08-12 20:27:48 +0000696 // Compute DIE offsets and sizes.
Eric Christopherc8a310e2012-12-10 23:34:43 +0000697 InfoHolder.computeSizeAndOffsets();
698 if (useSplitDwarf())
699 SkeletonHolder.computeSizeAndOffsets();
Eric Christopher960ac372012-11-22 00:59:49 +0000700}
701
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000702// Emit all Dwarf sections that should come after the content.
Eric Christopher960ac372012-11-22 00:59:49 +0000703void DwarfDebug::endModule() {
Craig Toppere73658d2014-04-28 04:05:08 +0000704 assert(CurFn == nullptr);
705 assert(CurMI == nullptr);
Eric Christopher960ac372012-11-22 00:59:49 +0000706
David Blaikie0dc623c2014-10-24 17:53:38 +0000707 // If we aren't actually generating debug info (check beginModule -
708 // conditionalized on !DisableDebugInfoPrinting and the presence of the
709 // llvm.dbg.cu metadata node)
Rafael Espindolaf1a13f52015-03-11 00:51:37 +0000710 if (!MMI->hasDebugInfo())
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000711 return;
Eric Christopher960ac372012-11-22 00:59:49 +0000712
Eric Christopher960ac372012-11-22 00:59:49 +0000713 // Finalize the debug info for the module.
714 finalizeModuleInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +0000715
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000716 emitDebugStr();
Eric Christopher9cd26af2013-09-20 23:22:52 +0000717
Rafael Espindola063d7252015-03-10 16:58:10 +0000718 if (useSplitDwarf())
719 emitDebugLocDWO();
720 else
721 // Emit info into a debug loc section.
722 emitDebugLoc();
723
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000724 // Corresponding abbreviations into a abbrev section.
725 emitAbbreviations();
Eric Christopher95198f502012-11-27 22:43:42 +0000726
Rafael Espindolaf1a13f52015-03-11 00:51:37 +0000727 // Emit all the DIEs into a debug info section.
728 emitDebugInfo();
729
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000730 // Emit info into a debug aranges section.
Eric Christopher02dbadb2014-02-14 01:26:55 +0000731 if (GenerateARangeSection)
732 emitDebugARanges();
Eric Christopher95198f502012-11-27 22:43:42 +0000733
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000734 // Emit info into a debug ranges section.
735 emitDebugRanges();
Eric Christopher95198f502012-11-27 22:43:42 +0000736
Amjad Aboudd7cfb482016-01-07 14:28:20 +0000737 // Emit info into a debug macinfo section.
738 emitDebugMacinfo();
739
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000740 if (useSplitDwarf()) {
741 emitDebugStrDWO();
Eric Christopher9c2ecd92012-11-30 23:59:06 +0000742 emitDebugInfoDWO();
Eric Christopher3c5a1912012-12-19 22:02:53 +0000743 emitDebugAbbrevDWO();
David Blaikie4a2f95f2014-03-18 01:17:26 +0000744 emitDebugLineDWO();
Eric Christopher962c9082013-01-15 23:56:56 +0000745 // Emit DWO addresses.
David Blaikied75fb282014-04-23 21:20:10 +0000746 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
Rafael Espindola063d7252015-03-10 16:58:10 +0000747 }
Bill Wendling2b128d72009-05-20 23:19:06 +0000748
Eric Christophera876b822012-08-23 07:32:06 +0000749 // Emit info into the dwarf accelerator table sections.
Eric Christopher20b76a72012-08-23 22:36:40 +0000750 if (useDwarfAccelTables()) {
Eric Christopher4996c702011-11-07 09:24:32 +0000751 emitAccelNames();
752 emitAccelObjC();
753 emitAccelNamespaces();
754 emitAccelTypes();
755 }
Eric Christopher6a841382012-11-19 22:42:10 +0000756
Eric Christopher4b358182013-08-30 00:40:17 +0000757 // Emit the pubnames and pubtypes sections if requested.
David Blaikieb3cee2f2017-05-25 18:50:28 +0000758 // The condition is optimistically correct - any CU not using GMLT (&
759 // implicit/default pubnames state) might still have pubnames.
760 if (hasDwarfPubSections(/* gmlt */ false)) {
David Blaikie70a33202013-09-19 17:33:35 +0000761 emitDebugPubNames(GenerateGnuPubSections);
762 emitDebugPubTypes(GenerateGnuPubSections);
Eric Christopher4b358182013-08-30 00:40:17 +0000763 }
Devang Patel04d2f2d2009-11-24 01:14:22 +0000764
Devang Pateld0701282010-08-02 17:32:15 +0000765 // clean up.
David Blaikie488393f2017-05-12 01:13:45 +0000766 // FIXME: AbstractVariables.clear();
Bill Wendling2b128d72009-05-20 23:19:06 +0000767}
768
David Blaikie488393f2017-05-12 01:13:45 +0000769void DwarfDebug::ensureAbstractVariableIsCreated(DwarfCompileUnit &CU, InlinedVariable IV,
David Blaikie6f9e8672014-06-13 23:52:55 +0000770 const MDNode *ScopeNode) {
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000771 const DILocalVariable *Cleansed = nullptr;
David Blaikie488393f2017-05-12 01:13:45 +0000772 if (CU.getExistingAbstractVariable(IV, Cleansed))
David Blaikie6f9e8672014-06-13 23:52:55 +0000773 return;
David Blaikie36408e72014-06-04 23:50:52 +0000774
David Blaikie488393f2017-05-12 01:13:45 +0000775 CU.createAbstractVariable(Cleansed, LScopes.getOrCreateAbstractScope(
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000776 cast<DILocalScope>(ScopeNode)));
David Blaikie36408e72014-06-04 23:50:52 +0000777}
778
David Blaikie488393f2017-05-12 01:13:45 +0000779void DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(DwarfCompileUnit &CU,
Duncan P. N. Exon Smith62e0f452015-04-15 22:29:27 +0000780 InlinedVariable IV, const MDNode *ScopeNode) {
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000781 const DILocalVariable *Cleansed = nullptr;
David Blaikie488393f2017-05-12 01:13:45 +0000782 if (CU.getExistingAbstractVariable(IV, Cleansed))
David Blaikie6f9e8672014-06-13 23:52:55 +0000783 return;
David Blaikie36408e72014-06-04 23:50:52 +0000784
Duncan P. N. Exon Smith33af7a82015-03-30 23:21:21 +0000785 if (LexicalScope *Scope =
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000786 LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
David Blaikie488393f2017-05-12 01:13:45 +0000787 CU.createAbstractVariable(Cleansed, Scope);
David Blaikie36408e72014-06-04 23:50:52 +0000788}
Matthias Braunef331ef2016-11-30 23:48:50 +0000789// Collect variable information from side table maintained by MF.
790void DwarfDebug::collectVariableInfoFromMFTable(
David Blaikie488393f2017-05-12 01:13:45 +0000791 DwarfCompileUnit &TheCU, DenseSet<InlinedVariable> &Processed) {
Adrian Prantlbe662712017-07-25 23:32:59 +0000792 SmallDenseMap<InlinedVariable, DbgVariable *> MFVars;
Matthias Braunef331ef2016-11-30 23:48:50 +0000793 for (const auto &VI : Asm->MF->getVariableDbgInfo()) {
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +0000794 if (!VI.Var)
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000795 continue;
Duncan P. N. Exon Smith78a95272015-04-16 22:12:59 +0000796 assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
797 "Expected inlined-at fields to agree");
798
799 InlinedVariable Var(VI.Var, VI.Loc->getInlinedAt());
Duncan P. N. Exon Smith62e0f452015-04-15 22:29:27 +0000800 Processed.insert(Var);
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +0000801 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000802
Devang Patelcdb7d442009-11-10 23:20:04 +0000803 // If variable scope is not found then skip this variable.
Craig Topper353eda42014-04-24 06:44:33 +0000804 if (!Scope)
Devang Patelcdb7d442009-11-10 23:20:04 +0000805 continue;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000806
David Blaikie488393f2017-05-12 01:13:45 +0000807 ensureAbstractVariableIsCreatedIfScoped(TheCU, Var, Scope->getScopeNode());
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000808 auto RegVar = make_unique<DbgVariable>(Var.first, Var.second);
Duncan P. N. Exon Smithe6cc5312015-06-21 16:50:43 +0000809 RegVar->initializeMMI(VI.Expr, VI.Slot);
Adrian Prantlbe662712017-07-25 23:32:59 +0000810 if (DbgVariable *DbgVar = MFVars.lookup(Var))
811 DbgVar->addMMIEntry(*RegVar);
812 else if (InfoHolder.addScopeVariable(Scope, RegVar.get())) {
813 MFVars.insert({Var, RegVar.get()});
Adrian Prantlca7e4702015-02-10 23:18:28 +0000814 ConcreteVariables.push_back(std::move(RegVar));
Adrian Prantlbe662712017-07-25 23:32:59 +0000815 }
Devang Patel475d32a2009-10-06 01:26:37 +0000816 }
Devang Patel490c8ab2010-05-20 19:57:06 +0000817}
Devang Patela3e9c9c2010-03-15 18:33:46 +0000818
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000819// Get .debug_loc entry for the instruction range starting at MI.
Adrian Prantle19e5ef2014-04-27 18:25:40 +0000820static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000821 const DIExpression *Expr = MI->getDebugExpression();
Devang Patel2442a892011-07-08 17:09:57 +0000822
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000823 assert(MI->getNumOperands() == 4);
Adrian Prantl418d1d12013-07-09 20:28:37 +0000824 if (MI->getOperand(0).isReg()) {
Devang Patel2442a892011-07-08 17:09:57 +0000825 MachineLocation MLoc;
Adrian Prantl418d1d12013-07-09 20:28:37 +0000826 // If the second operand is an immediate, this is a
827 // register-indirect address.
828 if (!MI->getOperand(1).isImm())
Adrian Prantld4c0dd42013-04-26 21:57:17 +0000829 MLoc.set(MI->getOperand(0).getReg());
830 else
831 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
Duncan P. N. Exon Smith546c8be2015-04-17 16:33:37 +0000832 return DebugLocEntry::Value(Expr, MLoc);
Devang Patel2442a892011-07-08 17:09:57 +0000833 }
834 if (MI->getOperand(0).isImm())
Duncan P. N. Exon Smith546c8be2015-04-17 16:33:37 +0000835 return DebugLocEntry::Value(Expr, MI->getOperand(0).getImm());
Devang Patel2442a892011-07-08 17:09:57 +0000836 if (MI->getOperand(0).isFPImm())
Duncan P. N. Exon Smith546c8be2015-04-17 16:33:37 +0000837 return DebugLocEntry::Value(Expr, MI->getOperand(0).getFPImm());
Devang Patel2442a892011-07-08 17:09:57 +0000838 if (MI->getOperand(0).isCImm())
Duncan P. N. Exon Smith546c8be2015-04-17 16:33:37 +0000839 return DebugLocEntry::Value(Expr, MI->getOperand(0).getCImm());
Devang Patel2442a892011-07-08 17:09:57 +0000840
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000841 llvm_unreachable("Unexpected 4-operand DBG_VALUE instruction!");
Devang Patel2442a892011-07-08 17:09:57 +0000842}
843
Adrian Prantl941fa752016-12-05 18:04:47 +0000844/// \brief If this and Next are describing different fragments of the same
Keno Fischerf8eb6a12016-01-16 01:11:33 +0000845/// variable, merge them by appending Next's values to the current
846/// list of values.
847/// Return true if the merge was successful.
848bool DebugLocEntry::MergeValues(const DebugLocEntry &Next) {
849 if (Begin == Next.Begin) {
Keno Fischer6c1e47a2016-02-03 21:13:33 +0000850 auto *FirstExpr = cast<DIExpression>(Values[0].Expression);
851 auto *FirstNextExpr = cast<DIExpression>(Next.Values[0].Expression);
Adrian Prantl941fa752016-12-05 18:04:47 +0000852 if (!FirstExpr->isFragment() || !FirstNextExpr->isFragment())
Keno Fischer6c1e47a2016-02-03 21:13:33 +0000853 return false;
854
Adrian Prantl941fa752016-12-05 18:04:47 +0000855 // We can only merge entries if none of the fragments overlap any others.
Keno Fischer6c1e47a2016-02-03 21:13:33 +0000856 // In doing so, we can take advantage of the fact that both lists are
857 // sorted.
858 for (unsigned i = 0, j = 0; i < Values.size(); ++i) {
859 for (; j < Next.Values.size(); ++j) {
Adrian Prantl941fa752016-12-05 18:04:47 +0000860 int res = DebugHandlerBase::fragmentCmp(
Reid Klecknerf9c275f2016-02-10 20:55:49 +0000861 cast<DIExpression>(Values[i].Expression),
862 cast<DIExpression>(Next.Values[j].Expression));
Keno Fischer6c1e47a2016-02-03 21:13:33 +0000863 if (res == 0) // The two expressions overlap, we can't merge.
864 return false;
865 // Values[i] is entirely before Next.Values[j],
866 // so go back to the next entry of Values.
867 else if (res == -1)
868 break;
869 // Next.Values[j] is entirely before Values[i], so go on to the
870 // next entry of Next.Values.
871 }
Keno Fischerf8eb6a12016-01-16 01:11:33 +0000872 }
Keno Fischer6c1e47a2016-02-03 21:13:33 +0000873
874 addValues(Next.Values);
875 End = Next.End;
876 return true;
Keno Fischerf8eb6a12016-01-16 01:11:33 +0000877 }
878 return false;
879}
880
Adrian Prantlb1416832014-08-01 22:11:58 +0000881/// Build the location list for all DBG_VALUEs in the function that
882/// describe the same variable. If the ranges of several independent
Adrian Prantl941fa752016-12-05 18:04:47 +0000883/// fragments of the same variable overlap partially, split them up and
Adrian Prantlb1416832014-08-01 22:11:58 +0000884/// combine the ranges. The resulting DebugLocEntries are will have
885/// strict monotonically increasing begin addresses and will never
886/// overlap.
887//
888// Input:
889//
Adrian Prantl941fa752016-12-05 18:04:47 +0000890// Ranges History [var, loc, fragment ofs size]
891// 0 | [x, (reg0, fragment 0, 32)]
892// 1 | | [x, (reg1, fragment 32, 32)] <- IsFragmentOfPrevEntry
Adrian Prantlb1416832014-08-01 22:11:58 +0000893// 2 | | ...
894// 3 | [clobber reg0]
Adrian Prantl941fa752016-12-05 18:04:47 +0000895// 4 [x, (mem, fragment 0, 64)] <- overlapping with both previous fragments of
Eric Christopherffc5ff32015-02-17 20:02:28 +0000896// x.
Adrian Prantlb1416832014-08-01 22:11:58 +0000897//
898// Output:
899//
Adrian Prantl941fa752016-12-05 18:04:47 +0000900// [0-1] [x, (reg0, fragment 0, 32)]
901// [1-3] [x, (reg0, fragment 0, 32), (reg1, fragment 32, 32)]
902// [3-4] [x, (reg1, fragment 32, 32)]
903// [4- ] [x, (mem, fragment 0, 64)]
David Blaikiee1a26a62014-08-05 23:14:16 +0000904void
905DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
906 const DbgValueHistoryMap::InstrRanges &Ranges) {
Adrian Prantlcaaf0532014-08-11 21:05:57 +0000907 SmallVector<DebugLocEntry::Value, 4> OpenRanges;
Adrian Prantlb1416832014-08-01 22:11:58 +0000908
909 for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
910 const MachineInstr *Begin = I->first;
911 const MachineInstr *End = I->second;
912 assert(Begin->isDebugValue() && "Invalid History entry");
913
914 // Check if a variable is inaccessible in this range.
Adrian Prantl5e1fa852014-08-12 21:55:58 +0000915 if (Begin->getNumOperands() > 1 &&
916 Begin->getOperand(0).isReg() && !Begin->getOperand(0).getReg()) {
Adrian Prantlb1416832014-08-01 22:11:58 +0000917 OpenRanges.clear();
918 continue;
919 }
920
Adrian Prantl941fa752016-12-05 18:04:47 +0000921 // If this fragment overlaps with any open ranges, truncate them.
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +0000922 const DIExpression *DIExpr = Begin->getDebugExpression();
David Majnemer0a16c222016-08-11 21:15:00 +0000923 auto Last = remove_if(OpenRanges, [&](DebugLocEntry::Value R) {
Adrian Prantl941fa752016-12-05 18:04:47 +0000924 return fragmentsOverlap(DIExpr, R.getExpression());
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000925 });
Adrian Prantlb1416832014-08-01 22:11:58 +0000926 OpenRanges.erase(Last, OpenRanges.end());
927
928 const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
929 assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
930
931 const MCSymbol *EndLabel;
932 if (End != nullptr)
933 EndLabel = getLabelAfterInsn(End);
934 else if (std::next(I) == Ranges.end())
Rafael Espindola07c03d32015-03-05 02:05:42 +0000935 EndLabel = Asm->getFunctionEnd();
Adrian Prantlb1416832014-08-01 22:11:58 +0000936 else
937 EndLabel = getLabelBeforeInsn(std::next(I)->first);
938 assert(EndLabel && "Forgot label after instruction ending a range!");
939
940 DEBUG(dbgs() << "DotDebugLoc: " << *Begin << "\n");
941
942 auto Value = getDebugLocValue(Begin);
David Blaikiee1a26a62014-08-05 23:14:16 +0000943 DebugLocEntry Loc(StartLabel, EndLabel, Value);
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000944 bool couldMerge = false;
945
Adrian Prantl941fa752016-12-05 18:04:47 +0000946 // If this is a fragment, it may belong to the current DebugLocEntry.
947 if (DIExpr->isFragment()) {
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000948 // Add this value to the list of open ranges.
Adrian Prantlcaaf0532014-08-11 21:05:57 +0000949 OpenRanges.push_back(Value);
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000950
Adrian Prantl941fa752016-12-05 18:04:47 +0000951 // Attempt to add the fragment to the last entry.
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000952 if (!DebugLoc.empty())
953 if (DebugLoc.back().MergeValues(Loc))
954 couldMerge = true;
955 }
956
957 if (!couldMerge) {
958 // Need to add a new DebugLocEntry. Add all values from still
Adrian Prantl941fa752016-12-05 18:04:47 +0000959 // valid non-overlapping fragments.
Adrian Prantl1c6f2ec2014-08-11 21:06:00 +0000960 if (OpenRanges.size())
961 Loc.addValues(OpenRanges);
962
Adrian Prantlb1416832014-08-01 22:11:58 +0000963 DebugLoc.push_back(std::move(Loc));
964 }
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000965
966 // Attempt to coalesce the ranges of two otherwise identical
967 // DebugLocEntries.
968 auto CurEntry = DebugLoc.rbegin();
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000969 DEBUG({
970 dbgs() << CurEntry->getValues().size() << " Values:\n";
Adrian Prantl6f8c1b62015-05-26 20:06:51 +0000971 for (auto &Value : CurEntry->getValues())
Adrian Prantldba58fb2016-02-29 22:28:22 +0000972 Value.dump();
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000973 dbgs() << "-----\n";
974 });
Adrian Prantl75707312015-05-26 20:06:48 +0000975
976 auto PrevEntry = std::next(CurEntry);
977 if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
978 DebugLoc.pop_back();
Adrian Prantlb1416832014-08-01 22:11:58 +0000979 }
980}
981
David Blaikie488393f2017-05-12 01:13:45 +0000982DbgVariable *DwarfDebug::createConcreteVariable(DwarfCompileUnit &TheCU,
983 LexicalScope &Scope,
Duncan P. N. Exon Smithe6cc5312015-06-21 16:50:43 +0000984 InlinedVariable IV) {
David Blaikie488393f2017-05-12 01:13:45 +0000985 ensureAbstractVariableIsCreatedIfScoped(TheCU, IV, Scope.getScopeNode());
Duncan P. N. Exon Smitha59d3e52016-04-23 21:08:00 +0000986 ConcreteVariables.push_back(make_unique<DbgVariable>(IV.first, IV.second));
Duncan P. N. Exon Smithe6cc5312015-06-21 16:50:43 +0000987 InfoHolder.addScopeVariable(&Scope, ConcreteVariables.back().get());
988 return ConcreteVariables.back().get();
989}
Adrian Prantlb1416832014-08-01 22:11:58 +0000990
Adrian Prantl274bcbc2017-06-16 22:40:04 +0000991/// Determine whether a *singular* DBG_VALUE is valid for the entirety of its
992/// enclosing lexical scope. The check ensures there are no other instructions
993/// in the same lexical scope preceding the DBG_VALUE and that its range is
994/// either open or otherwise rolls off the end of the scope.
995static bool validThroughout(LexicalScopes &LScopes,
996 const MachineInstr *DbgValue,
997 const MachineInstr *RangeEnd) {
998 assert(DbgValue->getDebugLoc() && "DBG_VALUE without a debug location");
999 auto MBB = DbgValue->getParent();
1000 auto DL = DbgValue->getDebugLoc();
1001 auto *LScope = LScopes.findLexicalScope(DL);
1002 // Scope doesn't exist; this is a dead DBG_VALUE.
1003 if (!LScope)
Adrian Prantlfb2add22016-02-29 19:49:46 +00001004 return false;
Adrian Prantl274bcbc2017-06-16 22:40:04 +00001005 auto &LSRange = LScope->getRanges();
1006 if (LSRange.size() == 0)
1007 return false;
1008
1009 // Determine if the DBG_VALUE is valid at the beginning of its lexical block.
1010 const MachineInstr *LScopeBegin = LSRange.front().first;
1011 // Early exit if the lexical scope begins outside of the current block.
1012 if (LScopeBegin->getParent() != MBB)
1013 return false;
1014 MachineBasicBlock::const_reverse_iterator Pred(DbgValue);
1015 for (++Pred; Pred != MBB->rend(); ++Pred) {
1016 if (Pred->getFlag(MachineInstr::FrameSetup))
1017 break;
1018 auto PredDL = Pred->getDebugLoc();
Adrian Prantl25422dc2017-06-20 21:08:52 +00001019 if (!PredDL || Pred->isMetaInstruction())
Adrian Prantl274bcbc2017-06-16 22:40:04 +00001020 continue;
1021 // Check whether the instruction preceding the DBG_VALUE is in the same
1022 // (sub)scope as the DBG_VALUE.
Adrian Prantl25422dc2017-06-20 21:08:52 +00001023 if (DL->getScope() == PredDL->getScope())
1024 return false;
1025 auto *PredScope = LScopes.findLexicalScope(PredDL);
1026 if (!PredScope || LScope->dominates(PredScope))
Adrian Prantlfb2add22016-02-29 19:49:46 +00001027 return false;
Adrian Prantl274bcbc2017-06-16 22:40:04 +00001028 }
1029
1030 // If the range of the DBG_VALUE is open-ended, report success.
1031 if (!RangeEnd)
1032 return true;
1033
1034 // Fail if there are instructions belonging to our scope in another block.
1035 const MachineInstr *LScopeEnd = LSRange.back().second;
1036 if (LScopeEnd->getParent() != MBB)
1037 return false;
1038
1039 // Single, constant DBG_VALUEs in the prologue are promoted to be live
1040 // throughout the function. This is a hack, presumably for DWARF v2 and not
1041 // necessarily correct. It would be much better to use a dbg.declare instead
1042 // if we know the constant is live throughout the scope.
1043 if (DbgValue->getOperand(0).isImm() && MBB->pred_empty())
1044 return true;
1045
1046 return false;
Adrian Prantlfb2add22016-02-29 19:49:46 +00001047}
1048
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001049// Find variables for each lexical scope.
Duncan P. N. Exon Smith2fbe1352015-04-20 22:10:08 +00001050void DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU,
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001051 const DISubprogram *SP,
Duncan P. N. Exon Smith62e0f452015-04-15 22:29:27 +00001052 DenseSet<InlinedVariable> &Processed) {
Eric Christopher270a12c2013-07-03 21:37:03 +00001053 // Grab the variable info that was squirreled away in the MMI side-table.
David Blaikie488393f2017-05-12 01:13:45 +00001054 collectVariableInfoFromMFTable(TheCU, Processed);
Devang Patel490c8ab2010-05-20 19:57:06 +00001055
Alexey Samsonov0436caa2014-04-30 23:02:40 +00001056 for (const auto &I : DbgValues) {
Duncan P. N. Exon Smith62e0f452015-04-15 22:29:27 +00001057 InlinedVariable IV = I.first;
1058 if (Processed.count(IV))
Devang Patel490c8ab2010-05-20 19:57:06 +00001059 continue;
1060
Duncan P. N. Exon Smith62e0f452015-04-15 22:29:27 +00001061 // Instruction ranges, specifying where IV is accessible.
Alexey Samsonovbb2990d2014-05-27 23:09:50 +00001062 const auto &Ranges = I.second;
1063 if (Ranges.empty())
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001064 continue;
Devang Patel9fc11702010-05-25 23:40:22 +00001065
Craig Topper353eda42014-04-24 06:44:33 +00001066 LexicalScope *Scope = nullptr;
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001067 if (const DILocation *IA = IV.second)
Duncan P. N. Exon Smith62e0f452015-04-15 22:29:27 +00001068 Scope = LScopes.findInlinedScope(IV.first->getScope(), IA);
Duncan P. N. Exon Smithb4749372015-02-17 00:02:27 +00001069 else
Duncan P. N. Exon Smith62e0f452015-04-15 22:29:27 +00001070 Scope = LScopes.findLexicalScope(IV.first->getScope());
Devang Patel490c8ab2010-05-20 19:57:06 +00001071 // If variable scope is not found then skip this variable.
Devang Patelfbd6c452010-05-21 00:10:20 +00001072 if (!Scope)
Devang Patel490c8ab2010-05-20 19:57:06 +00001073 continue;
1074
Duncan P. N. Exon Smith62e0f452015-04-15 22:29:27 +00001075 Processed.insert(IV);
David Blaikie488393f2017-05-12 01:13:45 +00001076 DbgVariable *RegVar = createConcreteVariable(TheCU, *Scope, IV);
Duncan P. N. Exon Smithe6cc5312015-06-21 16:50:43 +00001077
Alexey Samsonovbb2990d2014-05-27 23:09:50 +00001078 const MachineInstr *MInsn = Ranges.front().first;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001079 assert(MInsn->isDebugValue() && "History must begin with debug value");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001080
Adrian Prantl274bcbc2017-06-16 22:40:04 +00001081 // Check if there is a single DBG_VALUE, valid throughout the var's scope.
Adrian Prantlfb2add22016-02-29 19:49:46 +00001082 if (Ranges.size() == 1 &&
Adrian Prantl274bcbc2017-06-16 22:40:04 +00001083 validThroughout(LScopes, MInsn, Ranges.front().second)) {
Duncan P. N. Exon Smith3a73d9e2015-06-21 16:54:56 +00001084 RegVar->initializeDbgValue(MInsn);
Devang Patel9fc11702010-05-25 23:40:22 +00001085 continue;
Duncan P. N. Exon Smith3a73d9e2015-06-21 16:54:56 +00001086 }
Devang Patel9fc11702010-05-25 23:40:22 +00001087
Eric Christopher59cc0712013-01-28 17:33:26 +00001088 // Handle multiple DBG_VALUE instructions describing one variable.
Duncan P. N. Exon Smith3a73d9e2015-06-21 16:54:56 +00001089 DebugLocStream::ListBuilder List(DebugLocs, TheCU, *Asm, *RegVar, *MInsn);
Jakob Stoklund Olesen9c057ee2011-03-22 00:21:41 +00001090
Adrian Prantlb1416832014-08-01 22:11:58 +00001091 // Build the location list for this variable.
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +00001092 SmallVector<DebugLocEntry, 8> Entries;
1093 buildLocationList(Entries, Ranges);
Duncan P. N. Exon Smithfba25d62015-04-17 16:28:58 +00001094
Adrian Prantl693e8de2016-02-29 17:06:46 +00001095 // If the variable has a DIBasicType, extract it. Basic types cannot have
Duncan P. N. Exon Smithfba25d62015-04-17 16:28:58 +00001096 // unique identifiers, so don't bother resolving the type with the
1097 // identifier map.
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001098 const DIBasicType *BT = dyn_cast<DIBasicType>(
Duncan P. N. Exon Smithfba25d62015-04-17 16:28:58 +00001099 static_cast<const Metadata *>(IV.first->getType()));
1100
Adrian Prantl92da14b2015-03-02 22:02:33 +00001101 // Finalize the entry by lowering it into a DWARF bytestream.
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +00001102 for (auto &Entry : Entries)
Duncan P. N. Exon Smith3a73d9e2015-06-21 16:54:56 +00001103 Entry.finalize(*Asm, List, BT);
Devang Patela3e9c9c2010-03-15 18:33:46 +00001104 }
Devang Patele0a94bf2010-05-14 21:01:35 +00001105
1106 // Collect info for variables that were optimized out.
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001107 for (const DILocalVariable *DV : SP->getVariables()) {
Duncan P. N. Exon Smithe6cc5312015-06-21 16:50:43 +00001108 if (Processed.insert(InlinedVariable(DV, nullptr)).second)
1109 if (LexicalScope *Scope = LScopes.findLexicalScope(DV->getScope()))
David Blaikie488393f2017-05-12 01:13:45 +00001110 createConcreteVariable(TheCU, *Scope, InlinedVariable(DV, nullptr));
Devang Patele0a94bf2010-05-14 21:01:35 +00001111 }
Devang Patel9fc11702010-05-25 23:40:22 +00001112}
Devang Patele0a94bf2010-05-14 21:01:35 +00001113
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001114// Process beginning of an instruction.
Devang Patelb5694e72010-10-26 17:49:02 +00001115void DwarfDebug::beginInstruction(const MachineInstr *MI) {
Reid Klecknerf9c275f2016-02-10 20:55:49 +00001116 DebugHandlerBase::beginInstruction(MI);
1117 assert(CurMI);
1118
David Blaikie7f2b7172017-05-26 17:05:15 +00001119 const auto *SP = MI->getParent()->getParent()->getFunction()->getSubprogram();
1120 if (!SP || SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug)
1121 return;
1122
Paul Robinson4fa7b57a2016-12-09 19:15:32 +00001123 // Check if source location changes, but ignore DBG_VALUE and CFI locations.
Adrian Prantlfb31da12017-05-22 20:47:09 +00001124 if (MI->isMetaInstruction())
Paul Robinsonf428c9b2016-11-22 19:46:51 +00001125 return;
1126 const DebugLoc &DL = MI->getDebugLoc();
Paul Robinsonac7fe5e2016-12-12 20:49:11 +00001127 // When we emit a line-0 record, we don't update PrevInstLoc; so look at
1128 // the last line number actually emitted, to see if it was line 0.
1129 unsigned LastAsmLine =
1130 Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();
Paul Robinson96de8c72016-11-29 22:41:16 +00001131
Paul Robinsonac7fe5e2016-12-12 20:49:11 +00001132 if (DL == PrevInstLoc) {
1133 // If we have an ongoing unspecified location, nothing to do here.
1134 if (!DL)
1135 return;
1136 // We have an explicit location, same as the previous location.
1137 // But we might be coming back to it after a line 0 record.
1138 if (LastAsmLine == 0 && DL.getLine() != 0) {
1139 // Reinstate the source location but not marked as a statement.
1140 const MDNode *Scope = DL.getScope();
1141 recordSourceLine(DL.getLine(), DL.getCol(), Scope, /*Flags=*/0);
Paul Robinson37a13dd2016-11-30 22:49:55 +00001142 }
1143 return;
1144 }
1145
Paul Robinsonac7fe5e2016-12-12 20:49:11 +00001146 if (!DL) {
1147 // We have an unspecified location, which might want to be line 0.
1148 // If we have already emitted a line-0 record, don't repeat it.
1149 if (LastAsmLine == 0)
1150 return;
1151 // If user said Don't Do That, don't do that.
1152 if (UnknownLocations == Disable)
1153 return;
1154 // See if we have a reason to emit a line-0 record now.
1155 // Reasons to emit a line-0 record include:
1156 // - User asked for it (UnknownLocations).
1157 // - Instruction has a label, so it's referenced from somewhere else,
1158 // possibly debug information; we want it to have a source location.
1159 // - Instruction is at the top of a block; we don't want to inherit the
1160 // location from the physically previous (maybe unrelated) block.
1161 if (UnknownLocations == Enable || PrevLabel ||
1162 (PrevInstBB && PrevInstBB != MI->getParent())) {
Paul Robinson8fec3da2016-12-14 00:27:35 +00001163 // Preserve the file and column numbers, if we can, to save space in
1164 // the encoded line table.
Paul Robinsonac7fe5e2016-12-12 20:49:11 +00001165 // Do not update PrevInstLoc, it remembers the last non-0 line.
Paul Robinson8fec3da2016-12-14 00:27:35 +00001166 const MDNode *Scope = nullptr;
1167 unsigned Column = 0;
1168 if (PrevInstLoc) {
1169 Scope = PrevInstLoc.getScope();
1170 Column = PrevInstLoc.getCol();
1171 }
1172 recordSourceLine(/*Line=*/0, Column, Scope, /*Flags=*/0);
Paul Robinsonac7fe5e2016-12-12 20:49:11 +00001173 }
1174 return;
1175 }
1176
1177 // We have an explicit location, different from the previous location.
1178 // Don't repeat a line-0 record, but otherwise emit the new location.
1179 // (The new location might be an explicit line 0, which we do emit.)
Paul Robinson2dfb6882016-12-16 23:54:33 +00001180 if (PrevInstLoc && DL.getLine() == 0 && LastAsmLine == 0)
Paul Robinsonac7fe5e2016-12-12 20:49:11 +00001181 return;
Paul Robinsonf428c9b2016-11-22 19:46:51 +00001182 unsigned Flags = 0;
Paul Robinsonf428c9b2016-11-22 19:46:51 +00001183 if (DL == PrologEndLoc) {
1184 Flags |= DWARF2_FLAG_PROLOGUE_END | DWARF2_FLAG_IS_STMT;
1185 PrologEndLoc = DebugLoc();
1186 }
Paul Robinsonac7fe5e2016-12-12 20:49:11 +00001187 // If the line changed, we call that a new statement; unless we went to
1188 // line 0 and came back, in which case it is not a new statement.
1189 unsigned OldLine = PrevInstLoc ? PrevInstLoc.getLine() : LastAsmLine;
1190 if (DL.getLine() && DL.getLine() != OldLine)
Paul Robinsonf428c9b2016-11-22 19:46:51 +00001191 Flags |= DWARF2_FLAG_IS_STMT;
1192
1193 const MDNode *Scope = DL.getScope();
1194 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
Paul Robinsonac7fe5e2016-12-12 20:49:11 +00001195
1196 // If we're not at line 0, remember this location.
1197 if (DL.getLine())
1198 PrevInstLoc = DL;
Devang Patel75cc16c2009-10-01 20:31:14 +00001199}
1200
Alexey Samsonov8a86d6d2014-05-27 22:47:41 +00001201static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1202 // First known non-DBG_VALUE and non-frame setup location marks
1203 // the beginning of the function body.
1204 for (const auto &MBB : *MF)
1205 for (const auto &MI : MBB)
Adrian Prantlfb31da12017-05-22 20:47:09 +00001206 if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) &&
Michael Kuperstein2b3c16c2015-10-08 07:48:49 +00001207 MI.getDebugLoc())
Alexey Samsonov8a86d6d2014-05-27 22:47:41 +00001208 return MI.getDebugLoc();
1209 return DebugLoc();
1210}
1211
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001212// Gather pre-function debug information. Assumes being called immediately
1213// after the function entry point has been emitted.
David Blaikieb2fbb4b2017-02-16 18:48:33 +00001214void DwarfDebug::beginFunctionImpl(const MachineFunction *MF) {
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001215 CurFn = MF;
Eric Christopherfedfa442013-11-01 23:14:17 +00001216
David Blaikie2c78f182017-05-25 23:11:28 +00001217 auto *SP = MF->getFunction()->getSubprogram();
1218 assert(LScopes.empty() || SP == LScopes.getCurrentFunctionScope()->getScopeNode());
David Blaikie07963bd2017-05-26 18:52:56 +00001219 if (SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug)
Adrian Prantl5992a722016-04-08 22:43:03 +00001220 return;
David Blaikie07963bd2017-05-26 18:52:56 +00001221
1222 DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(SP->getUnit());
David Blaikie2c78f182017-05-25 23:11:28 +00001223
1224 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1225 // belongs to so that we add to the correct per-cu line table in the
1226 // non-asm case.
Lang Hames9ff69c82015-04-24 19:11:51 +00001227 if (Asm->OutStreamer->hasRawTextSupport())
Rafael Espindolab4eec1d2014-02-05 18:00:21 +00001228 // Use a single line table if we are generating assembly.
Lang Hames9ff69c82015-04-24 19:11:51 +00001229 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
Manman Ren9d4c7352013-05-21 00:57:22 +00001230 else
David Blaikie07963bd2017-05-26 18:52:56 +00001231 Asm->OutStreamer->getContext().setDwarfCompileUnitID(CU.getUniqueID());
Manman Ren4e042a62013-02-05 21:52:47 +00001232
Devang Patel34a66202011-05-11 19:22:19 +00001233 // Record beginning of function.
Alexey Samsonov8a86d6d2014-05-27 22:47:41 +00001234 PrologEndLoc = findPrologueEndLoc(MF);
David Blaikie2c78f182017-05-25 23:11:28 +00001235 if (PrologEndLoc) {
Saleem Abdulrasoolfc07c722015-01-24 20:19:45 +00001236 // We'd like to list the prologue as "not statements" but GDB behaves
1237 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
David Blaikie2c78f182017-05-25 23:11:28 +00001238 auto *SP = PrologEndLoc->getInlinedAtScope()->getSubprogram();
Duncan P. N. Exon Smithfd07a2a2015-03-30 21:32:28 +00001239 recordSourceLine(SP->getScopeLine(), 0, SP, DWARF2_FLAG_IS_STMT);
Devang Patel34a66202011-05-11 19:22:19 +00001240 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001241}
1242
David Blaikieb2fbb4b2017-02-16 18:48:33 +00001243void DwarfDebug::skippedNonDebugFunction() {
1244 // If we don't have a subprogram for this function then there will be a hole
1245 // in the range information. Keep note of this by setting the previously used
1246 // section to nullptr.
1247 PrevCU = nullptr;
1248 CurFn = nullptr;
1249}
1250
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001251// Gather and emit post-function debug information.
David Blaikieb2fbb4b2017-02-16 18:48:33 +00001252void DwarfDebug::endFunctionImpl(const MachineFunction *MF) {
1253 const DISubprogram *SP = MF->getFunction()->getSubprogram();
1254
David Blaikiee75f9632014-10-14 17:12:02 +00001255 assert(CurFn == MF &&
1256 "endFunction should be called with the same function as beginFunction");
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001257
Eric Christopher4287a492013-12-09 23:57:44 +00001258 // Set DwarfDwarfCompileUnitID in MCContext to default value.
Lang Hames9ff69c82015-04-24 19:11:51 +00001259 Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
Eric Christopher6a841382012-11-19 22:42:10 +00001260
Devang Patel3acc70e2011-08-15 22:04:40 +00001261 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
David Blaikie3e3eb332016-12-15 23:17:52 +00001262 assert(!FnScope || SP == FnScope->getScopeNode());
Adrian Prantl75819ae2016-04-15 15:57:41 +00001263 DwarfCompileUnit &TheCU = *CUMap.lookup(SP->getUnit());
David Blaikie263a0082014-10-23 00:06:27 +00001264
Duncan P. N. Exon Smith62e0f452015-04-15 22:29:27 +00001265 DenseSet<InlinedVariable> ProcessedVars;
David Blaikie263a0082014-10-23 00:06:27 +00001266 collectVariableInfo(TheCU, SP, ProcessedVars);
Devang Patel3acc70e2011-08-15 22:04:40 +00001267
David Blaikie3a7ce252014-09-19 17:03:16 +00001268 // Add the range of this function to the list of ranges for the CU.
Rafael Espindola07c03d32015-03-05 02:05:42 +00001269 TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
David Blaikie3a7ce252014-09-19 17:03:16 +00001270
1271 // Under -gmlt, skip building the subprogram if there are no inlined
Dehao Chen1ce8d6c2017-01-19 00:44:11 +00001272 // subroutines inside it. But with -fdebug-info-for-profiling, the subprogram
1273 // is still needed as we need its source location.
Dehao Chen0944a8c2017-02-01 22:45:09 +00001274 if (!TheCU.getCUNode()->getDebugInfoForProfiling() &&
Dehao Chen1ce8d6c2017-01-19 00:44:11 +00001275 TheCU.getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly &&
David Blaikiee1c79742014-09-30 21:28:32 +00001276 LScopes.getAbstractScopesList().empty() && !IsDarwin) {
David Blaikie80e5b1e2014-10-24 17:57:34 +00001277 assert(InfoHolder.getScopeVariables().empty());
David Blaikie3a7ce252014-09-19 17:03:16 +00001278 PrevLabel = nullptr;
1279 CurFn = nullptr;
1280 return;
1281 }
1282
Adrian Prantl049d21c2014-10-13 20:44:58 +00001283#ifndef NDEBUG
1284 size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
1285#endif
Devang Patel7e623022011-08-10 20:55:27 +00001286 // Construct abstract scopes.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001287 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001288 auto *SP = cast<DISubprogram>(AScope->getScopeNode());
David Blaikie4abe19e2014-05-12 18:23:35 +00001289 // Collect info for variables that were optimized out.
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001290 for (const DILocalVariable *DV : SP->getVariables()) {
Duncan P. N. Exon Smith62e0f452015-04-15 22:29:27 +00001291 if (!ProcessedVars.insert(InlinedVariable(DV, nullptr)).second)
David Blaikie4abe19e2014-05-12 18:23:35 +00001292 continue;
David Blaikie488393f2017-05-12 01:13:45 +00001293 ensureAbstractVariableIsCreated(TheCU, InlinedVariable(DV, nullptr),
Duncan P. N. Exon Smith62e0f452015-04-15 22:29:27 +00001294 DV->getScope());
Adrian Prantl049d21c2014-10-13 20:44:58 +00001295 assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
1296 && "ensureAbstractVariableIsCreated inserted abstract scopes");
Devang Patel5c0f85c2010-06-25 22:07:34 +00001297 }
David Blaikie488393f2017-05-12 01:13:45 +00001298 constructAbstractSubprogramScopeDIE(TheCU, AScope);
Bill Wendling2b128d72009-05-20 23:19:06 +00001299 }
Eric Christopher6a841382012-11-19 22:42:10 +00001300
David Blaikie38b74bf2016-12-15 23:37:38 +00001301 ProcessedSPNodes.insert(SP);
David Blaikie3e3eb332016-12-15 23:17:52 +00001302 TheCU.constructSubprogramScopeDIE(SP, FnScope);
David Blaikie3a443c22014-11-04 22:12:25 +00001303 if (auto *SkelCU = TheCU.getSkeleton())
David Blaikiea01f2952016-08-24 18:29:49 +00001304 if (!LScopes.getAbstractScopesList().empty() &&
1305 TheCU.getCUNode()->getSplitDebugInlining())
David Blaikie3e3eb332016-12-15 23:17:52 +00001306 SkelCU->constructSubprogramScopeDIE(SP, FnScope);
Devang Patel3acc70e2011-08-15 22:04:40 +00001307
Bill Wendling2b128d72009-05-20 23:19:06 +00001308 // Clear debug info
David Blaikie825bdd22014-05-21 22:41:17 +00001309 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1310 // DbgVariables except those that are also in AbstractVariables (since they
1311 // can be used cross-function)
David Blaikie80e5b1e2014-10-24 17:57:34 +00001312 InfoHolder.getScopeVariables().clear();
Craig Topper353eda42014-04-24 06:44:33 +00001313 PrevLabel = nullptr;
1314 CurFn = nullptr;
Bill Wendling2b128d72009-05-20 23:19:06 +00001315}
1316
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001317// Register a source line with debug info. Returns the unique label that was
1318// emitted and which provides correspondence to the source line list.
Devang Patel34a66202011-05-11 19:22:19 +00001319void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1320 unsigned Flags) {
Devang Patel2d9caf92009-11-25 17:36:49 +00001321 StringRef Fn;
Devang Patele01b75c2011-03-24 20:30:50 +00001322 StringRef Dir;
Dan Gohman50849c62010-05-05 23:41:32 +00001323 unsigned Src = 1;
Diego Novillo282450d2014-03-03 18:53:17 +00001324 unsigned Discriminator = 0;
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001325 if (auto *Scope = cast_or_null<DIScope>(S)) {
Duncan P. N. Exon Smithb273d062015-04-16 01:37:00 +00001326 Fn = Scope->getFilename();
1327 Dir = Scope->getDirectory();
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001328 if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
Greg Claytone6543972016-11-23 23:30:37 +00001329 if (getDwarfVersion() >= 4)
Dehao Chen6e0c8442016-10-07 15:21:31 +00001330 Discriminator = LBF->getDiscriminator();
Dan Gohman50849c62010-05-05 23:41:32 +00001331
Lang Hames9ff69c82015-04-24 19:11:51 +00001332 unsigned CUID = Asm->OutStreamer->getContext().getDwarfCompileUnitID();
David Blaikiec33b3cd2014-04-22 21:27:37 +00001333 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1334 .getOrCreateSourceID(Fn, Dir);
Dan Gohman50849c62010-05-05 23:41:32 +00001335 }
Lang Hames9ff69c82015-04-24 19:11:51 +00001336 Asm->OutStreamer->EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1337 Discriminator, Fn);
Bill Wendling2b128d72009-05-20 23:19:06 +00001338}
1339
Bill Wendling806535f2009-05-20 23:22:40 +00001340//===----------------------------------------------------------------------===//
1341// Emit Methods
1342//===----------------------------------------------------------------------===//
1343
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001344// Emit the debug info section.
1345void DwarfDebug::emitDebugInfo() {
Eric Christopherf8194852013-12-05 18:06:10 +00001346 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Rafael Espindola063d7252015-03-10 16:58:10 +00001347 Holder.emitUnits(/* UseOffsets */ false);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001348}
1349
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001350// Emit the abbreviation section.
Eric Christopher38371952012-11-20 23:30:11 +00001351void DwarfDebug::emitAbbreviations() {
Eric Christopherf8194852013-12-05 18:06:10 +00001352 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
David Blaikie0504cda2013-12-05 07:43:55 +00001353
1354 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
Eric Christopher3c5a1912012-12-19 22:02:53 +00001355}
Bill Wendling480ff322009-05-20 23:21:38 +00001356
Rafael Espindola0709a7b2015-05-21 19:20:38 +00001357void DwarfDebug::emitAccel(DwarfAccelTable &Accel, MCSection *Section,
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001358 StringRef TableName) {
David Blaikie6741bb02014-09-11 21:12:48 +00001359 Accel.FinalizeTable(Asm, TableName);
Lang Hames9ff69c82015-04-24 19:11:51 +00001360 Asm->OutStreamer->SwitchSection(Section);
Eric Christopher4996c702011-11-07 09:24:32 +00001361
1362 // Emit the full data.
Rafael Espindola063d7252015-03-10 16:58:10 +00001363 Accel.emit(Asm, Section->getBeginSymbol(), this);
David Blaikie6741bb02014-09-11 21:12:48 +00001364}
1365
1366// Emit visible names into a hashed accelerator table section.
1367void DwarfDebug::emitAccelNames() {
1368 emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001369 "Names");
Eric Christopher4996c702011-11-07 09:24:32 +00001370}
1371
Eric Christopher48fef592012-12-20 21:58:40 +00001372// Emit objective C classes and categories into a hashed accelerator table
1373// section.
Eric Christopher4996c702011-11-07 09:24:32 +00001374void DwarfDebug::emitAccelObjC() {
David Blaikie6741bb02014-09-11 21:12:48 +00001375 emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001376 "ObjC");
Eric Christopher4996c702011-11-07 09:24:32 +00001377}
1378
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001379// Emit namespace dies into a hashed accelerator table.
Eric Christopher4996c702011-11-07 09:24:32 +00001380void DwarfDebug::emitAccelNamespaces() {
David Blaikie6741bb02014-09-11 21:12:48 +00001381 emitAccel(AccelNamespace,
1382 Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001383 "namespac");
Eric Christopher4996c702011-11-07 09:24:32 +00001384}
1385
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001386// Emit type dies into a hashed accelerator table.
Eric Christopher4996c702011-11-07 09:24:32 +00001387void DwarfDebug::emitAccelTypes() {
David Blaikie6741bb02014-09-11 21:12:48 +00001388 emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001389 "types");
Eric Christopher4996c702011-11-07 09:24:32 +00001390}
1391
Eric Christopherdd1a0122013-09-13 00:35:05 +00001392// Public name handling.
1393// The format for the various pubnames:
1394//
1395// dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1396// for the DIE that is named.
1397//
1398// gnu pubnames - offset/index value/name tuples where the offset is the offset
1399// into the CU and the index value is computed according to the type of value
1400// for the DIE that is named.
1401//
1402// For type units the offset is the offset of the skeleton DIE. For split dwarf
1403// it's the offset within the debug_info/debug_types dwo section, however, the
1404// reference in the pubname header doesn't change.
1405
1406/// computeIndexValue - Compute the gdb index value for the DIE and CU.
Eric Christophera5a79422013-12-09 23:32:48 +00001407static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
Eric Christopher0fe676a2013-11-21 00:48:22 +00001408 const DIE *Die) {
David Blaikiea0e3c752017-02-03 00:44:18 +00001409 // Entities that ended up only in a Type Unit reference the CU instead (since
1410 // the pub entry has offsets within the CU there's no real offset that can be
1411 // provided anyway). As it happens all such entities (namespaces and types,
1412 // types only in C++ at that) are rendered as TYPE+EXTERNAL. If this turns out
1413 // not to be true it would be necessary to persist this information from the
1414 // point at which the entry is added to the index data structure - since by
1415 // the time the index is built from that, the original type/namespace DIE in a
1416 // type unit has already been destroyed so it can't be queried for properties
1417 // like tag, etc.
1418 if (Die->getTag() == dwarf::DW_TAG_compile_unit)
1419 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE,
1420 dwarf::GIEL_EXTERNAL);
Eric Christopherd2b497b2013-10-16 01:37:49 +00001421 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1422
1423 // We could have a specification DIE that has our most of our knowledge,
1424 // look for that now.
Duncan P. N. Exon Smithe7e1d0c2015-05-27 22:14:58 +00001425 if (DIEValue SpecVal = Die->findAttribute(dwarf::DW_AT_specification)) {
1426 DIE &SpecDIE = SpecVal.getDIEEntry().getEntry();
David Blaikie8dbcc3f2014-04-25 19:33:43 +00001427 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
Eric Christopherd2b497b2013-10-16 01:37:49 +00001428 Linkage = dwarf::GIEL_EXTERNAL;
1429 } else if (Die->findAttribute(dwarf::DW_AT_external))
1430 Linkage = dwarf::GIEL_EXTERNAL;
Eric Christopherdd1a0122013-09-13 00:35:05 +00001431
1432 switch (Die->getTag()) {
1433 case dwarf::DW_TAG_class_type:
1434 case dwarf::DW_TAG_structure_type:
1435 case dwarf::DW_TAG_union_type:
1436 case dwarf::DW_TAG_enumeration_type:
Eric Christopher261d2342013-09-23 20:55:35 +00001437 return dwarf::PubIndexEntryDescriptor(
1438 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1439 ? dwarf::GIEL_STATIC
1440 : dwarf::GIEL_EXTERNAL);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001441 case dwarf::DW_TAG_typedef:
1442 case dwarf::DW_TAG_base_type:
1443 case dwarf::DW_TAG_subrange_type:
David Blaikie8dec4072013-09-19 20:40:26 +00001444 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001445 case dwarf::DW_TAG_namespace:
David Blaikie8dec4072013-09-19 20:40:26 +00001446 return dwarf::GIEK_TYPE;
Eric Christopherdd1a0122013-09-13 00:35:05 +00001447 case dwarf::DW_TAG_subprogram:
Eric Christopherccac5c42013-09-23 22:59:14 +00001448 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001449 case dwarf::DW_TAG_variable:
Eric Christopherccac5c42013-09-23 22:59:14 +00001450 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001451 case dwarf::DW_TAG_enumerator:
David Blaikie8dec4072013-09-19 20:40:26 +00001452 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1453 dwarf::GIEL_STATIC);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001454 default:
David Blaikie8dec4072013-09-19 20:40:26 +00001455 return dwarf::GIEK_NONE;
Eric Christopherdd1a0122013-09-13 00:35:05 +00001456 }
Eric Christopherdd1a0122013-09-13 00:35:05 +00001457}
1458
Eric Christopher5f93bb92013-09-09 20:03:17 +00001459/// emitDebugPubNames - Emit visible names into a debug pubnames section.
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001460///
Eric Christopherdd1a0122013-09-13 00:35:05 +00001461void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
Rafael Espindola0709a7b2015-05-21 19:20:38 +00001462 MCSection *PSec = GnuStyle
1463 ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1464 : Asm->getObjFileLowering().getDwarfPubNamesSection();
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001465
David Blaikie192b45c2014-11-02 06:16:39 +00001466 emitDebugPubSection(GnuStyle, PSec, "Names",
1467 &DwarfCompileUnit::getGlobalNames);
David Blaikie0f55e832014-03-11 23:18:15 +00001468}
1469
1470void DwarfDebug::emitDebugPubSection(
Rafael Espindola0709a7b2015-05-21 19:20:38 +00001471 bool GnuStyle, MCSection *PSec, StringRef Name,
David Blaikie192b45c2014-11-02 06:16:39 +00001472 const StringMap<const DIE *> &(DwarfCompileUnit::*Accessor)() const) {
David Blaikiec3d9e9e2014-03-06 01:42:00 +00001473 for (const auto &NU : CUMap) {
1474 DwarfCompileUnit *TheU = NU.second;
David Blaikie55bb8ac2014-03-11 23:23:39 +00001475
1476 const auto &Globals = (TheU->*Accessor)();
1477
David Blaikieb3cee2f2017-05-25 18:50:28 +00001478 if (!hasDwarfPubSections(TheU->includeMinimalInlineScopes()))
David Blaikiece2f1cb2014-03-11 23:35:06 +00001479 continue;
1480
David Blaikiebbad0bb2014-11-01 01:03:39 +00001481 if (auto *Skeleton = TheU->getSkeleton())
David Blaikiec3d9e9e2014-03-06 01:42:00 +00001482 TheU = Skeleton;
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001483
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001484 // Start the dwarf pubnames section.
Lang Hames9ff69c82015-04-24 19:11:51 +00001485 Asm->OutStreamer->SwitchSection(PSec);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001486
Eric Christopherdd1a0122013-09-13 00:35:05 +00001487 // Emit the header.
Lang Hames9ff69c82015-04-24 19:11:51 +00001488 Asm->OutStreamer->AddComment("Length of Public " + Name + " Info");
Rafael Espindola9ab09232015-03-17 20:07:06 +00001489 MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + Name + "_begin");
1490 MCSymbol *EndLabel = Asm->createTempSymbol("pub" + Name + "_end");
David Blaikieb7a1c4d2013-12-04 17:55:41 +00001491 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001492
Lang Hames9ff69c82015-04-24 19:11:51 +00001493 Asm->OutStreamer->EmitLabel(BeginLabel);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001494
Lang Hames9ff69c82015-04-24 19:11:51 +00001495 Asm->OutStreamer->AddComment("DWARF Version");
David Majnemered89b5c2013-08-21 06:13:34 +00001496 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001497
Lang Hames9ff69c82015-04-24 19:11:51 +00001498 Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
Rafael Espindola857546e2015-06-16 23:22:02 +00001499 Asm->emitDwarfSymbolReference(TheU->getLabelBegin());
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001500
Lang Hames9ff69c82015-04-24 19:11:51 +00001501 Asm->OutStreamer->AddComment("Compilation Unit Length");
David Blaikie983bfea2014-11-01 23:07:14 +00001502 Asm->EmitInt32(TheU->getLength());
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001503
Eric Christopherdd1a0122013-09-13 00:35:05 +00001504 // Emit the pubnames for this compilation unit.
David Blaikie55bb8ac2014-03-11 23:23:39 +00001505 for (const auto &GI : Globals) {
Benjamin Kramer15596c72014-03-07 19:09:39 +00001506 const char *Name = GI.getKeyData();
1507 const DIE *Entity = GI.second;
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001508
Lang Hames9ff69c82015-04-24 19:11:51 +00001509 Asm->OutStreamer->AddComment("DIE offset");
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001510 Asm->EmitInt32(Entity->getOffset());
1511
Eric Christopherdd1a0122013-09-13 00:35:05 +00001512 if (GnuStyle) {
David Blaikie2a80e442013-12-02 22:09:48 +00001513 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
Lang Hames9ff69c82015-04-24 19:11:51 +00001514 Asm->OutStreamer->AddComment(
David Blaikieefd0bcb2013-09-20 00:33:15 +00001515 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
David Blaikie404d3042013-09-19 23:01:29 +00001516 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
David Blaikied0a869d2013-09-19 22:19:37 +00001517 Asm->EmitInt8(Desc.toBits());
Eric Christopherdd1a0122013-09-13 00:35:05 +00001518 }
1519
Lang Hames9ff69c82015-04-24 19:11:51 +00001520 Asm->OutStreamer->AddComment("External Name");
1521 Asm->OutStreamer->EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001522 }
1523
Lang Hames9ff69c82015-04-24 19:11:51 +00001524 Asm->OutStreamer->AddComment("End Mark");
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001525 Asm->EmitInt32(0);
Lang Hames9ff69c82015-04-24 19:11:51 +00001526 Asm->OutStreamer->EmitLabel(EndLabel);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001527 }
1528}
1529
Eric Christopherdd1a0122013-09-13 00:35:05 +00001530void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
Rafael Espindola0709a7b2015-05-21 19:20:38 +00001531 MCSection *PSec = GnuStyle
1532 ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1533 : Asm->getObjFileLowering().getDwarfPubTypesSection();
Eric Christopher8b3737f2013-09-13 00:34:58 +00001534
David Blaikie192b45c2014-11-02 06:16:39 +00001535 emitDebugPubSection(GnuStyle, PSec, "Types",
1536 &DwarfCompileUnit::getGlobalTypes);
Devang Patel04d2f2d2009-11-24 01:14:22 +00001537}
1538
Amjad Aboudc0778412016-01-24 08:18:55 +00001539/// Emit null-terminated strings into a debug str section.
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001540void DwarfDebug::emitDebugStr() {
Eric Christopherf8194852013-12-05 18:06:10 +00001541 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001542 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1543}
1544
Eric Christopher29e874d2014-03-07 22:40:37 +00001545void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +00001546 const DebugLocStream::Entry &Entry) {
1547 auto &&Comments = DebugLocs.getComments(Entry);
1548 auto Comment = Comments.begin();
1549 auto End = Comments.end();
1550 for (uint8_t Byte : DebugLocs.getBytes(Entry))
Adrian Prantl92da14b2015-03-02 22:02:33 +00001551 Streamer.EmitInt8(Byte, Comment != End ? *(Comment++) : "");
Adrian Prantlb1416832014-08-01 22:11:58 +00001552}
1553
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001554static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
Adrian Prantl92da14b2015-03-02 22:02:33 +00001555 ByteStreamer &Streamer,
1556 const DebugLocEntry::Value &Value,
Adrian Prantl8fafb8d2016-12-09 20:43:40 +00001557 DwarfExpression &DwarfExpr) {
Adrian Prantl956484b2017-03-20 21:35:09 +00001558 auto *DIExpr = Value.getExpression();
1559 DIExpressionCursor ExprCursor(DIExpr);
1560 DwarfExpr.addFragmentOffset(DIExpr);
Adrian Prantlb1416832014-08-01 22:11:58 +00001561 // Regular entry.
Adrian Prantle19e5ef2014-04-27 18:25:40 +00001562 if (Value.isInt()) {
Duncan P. N. Exon Smithfba25d62015-04-17 16:28:58 +00001563 if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
1564 BT->getEncoding() == dwarf::DW_ATE_signed_char))
Adrian Prantla63b8e82017-03-16 17:42:45 +00001565 DwarfExpr.addSignedConstant(Value.getInt());
Adrian Prantl66f25952015-01-13 00:04:06 +00001566 else
Adrian Prantla63b8e82017-03-16 17:42:45 +00001567 DwarfExpr.addUnsignedConstant(Value.getInt());
Adrian Prantle19e5ef2014-04-27 18:25:40 +00001568 } else if (Value.isLocation()) {
Adrian Prantl956484b2017-03-20 21:35:09 +00001569 MachineLocation Location = Value.getLoc();
Adrian Prantlc12cee32017-04-19 23:42:25 +00001570 if (Location.isIndirect())
1571 DwarfExpr.setMemoryLocationKind();
Adrian Prantl956484b2017-03-20 21:35:09 +00001572 SmallVector<uint64_t, 8> Ops;
Adrian Prantl6825fb62017-04-18 01:21:53 +00001573 if (Location.isIndirect() && Location.getOffset()) {
Florian Hahnffc498d2017-06-14 13:14:38 +00001574 Ops.push_back(dwarf::DW_OP_plus_uconst);
Adrian Prantl956484b2017-03-20 21:35:09 +00001575 Ops.push_back(Location.getOffset());
Adrian Prantl956484b2017-03-20 21:35:09 +00001576 }
1577 Ops.append(DIExpr->elements_begin(), DIExpr->elements_end());
1578 DIExpressionCursor Cursor(Ops);
Adrian Prantl8fafb8d2016-12-09 20:43:40 +00001579 const TargetRegisterInfo &TRI = *AP.MF->getSubtarget().getRegisterInfo();
Adrian Prantlc12cee32017-04-19 23:42:25 +00001580 if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
Adrian Prantl956484b2017-03-20 21:35:09 +00001581 return;
1582 return DwarfExpr.addExpression(std::move(Cursor));
Adrian Prantl3e9c8872016-04-08 00:38:37 +00001583 } else if (Value.isConstantFP()) {
1584 APInt RawBytes = Value.getConstantFP()->getValueAPF().bitcastToAPInt();
Adrian Prantla63b8e82017-03-16 17:42:45 +00001585 DwarfExpr.addUnsignedConstant(RawBytes);
Eric Christopher29e874d2014-03-07 22:40:37 +00001586 }
Adrian Prantla63b8e82017-03-16 17:42:45 +00001587 DwarfExpr.addExpression(std::move(ExprCursor));
Eric Christopher29e874d2014-03-07 22:40:37 +00001588}
1589
Duncan P. N. Exon Smith3a73d9e2015-06-21 16:54:56 +00001590void DebugLocEntry::finalize(const AsmPrinter &AP,
1591 DebugLocStream::ListBuilder &List,
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00001592 const DIBasicType *BT) {
Duncan P. N. Exon Smith3a73d9e2015-06-21 16:54:56 +00001593 DebugLocStream::EntryBuilder Entry(List, Begin, End);
1594 BufferByteStreamer Streamer = Entry.getStreamer();
Adrian Prantl8fafb8d2016-12-09 20:43:40 +00001595 DebugLocDwarfExpression DwarfExpr(AP.getDwarfVersion(), Streamer);
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +00001596 const DebugLocEntry::Value &Value = Values[0];
Adrian Prantl941fa752016-12-05 18:04:47 +00001597 if (Value.isFragment()) {
1598 // Emit all fragments that belong to the same variable and range.
David Majnemer0a16c222016-08-11 21:15:00 +00001599 assert(all_of(Values, [](DebugLocEntry::Value P) {
Adrian Prantl941fa752016-12-05 18:04:47 +00001600 return P.isFragment();
1601 }) && "all values are expected to be fragments");
Adrian Prantl92da14b2015-03-02 22:02:33 +00001602 assert(std::is_sorted(Values.begin(), Values.end()) &&
Adrian Prantl941fa752016-12-05 18:04:47 +00001603 "fragments are expected to be sorted");
Duncan P. N. Exon Smithc82570b2015-04-13 18:53:11 +00001604
Adrian Prantl8fafb8d2016-12-09 20:43:40 +00001605 for (auto Fragment : Values)
1606 emitDebugLocValue(AP, BT, Streamer, Fragment, DwarfExpr);
1607
Adrian Prantl92da14b2015-03-02 22:02:33 +00001608 } else {
Adrian Prantl941fa752016-12-05 18:04:47 +00001609 assert(Values.size() == 1 && "only fragments may have >1 value");
Adrian Prantl8fafb8d2016-12-09 20:43:40 +00001610 emitDebugLocValue(AP, BT, Streamer, Value, DwarfExpr);
Adrian Prantl92da14b2015-03-02 22:02:33 +00001611 }
Adrian Prantl8fafb8d2016-12-09 20:43:40 +00001612 DwarfExpr.finalize();
Adrian Prantl92da14b2015-03-02 22:02:33 +00001613}
1614
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +00001615void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry) {
Duncan P. N. Exon Smith653c1092015-05-06 19:11:20 +00001616 // Emit the size.
Lang Hames9ff69c82015-04-24 19:11:51 +00001617 Asm->OutStreamer->AddComment("Loc expr size");
Duncan P. N. Exon Smith653c1092015-05-06 19:11:20 +00001618 Asm->EmitInt16(DebugLocs.getBytes(Entry).size());
1619
David Blaikie0e84adc2014-04-01 16:17:41 +00001620 // Emit the entry.
1621 APByteStreamer Streamer(*Asm);
1622 emitDebugLocEntry(Streamer, Entry);
David Blaikie0e84adc2014-04-01 16:17:41 +00001623}
1624
Eric Christopher9046f942013-07-02 21:36:07 +00001625// Emit locations into the debug loc section.
Devang Patel930143b2009-11-21 02:48:08 +00001626void DwarfDebug::emitDebugLoc() {
David Blaikie07963bd2017-05-26 18:52:56 +00001627 if (DebugLocs.getLists().empty())
1628 return;
1629
Daniel Dunbarfd95b012011-03-16 22:16:39 +00001630 // Start the dwarf loc section.
Lang Hames9ff69c82015-04-24 19:11:51 +00001631 Asm->OutStreamer->SwitchSection(
David Blaikie94c1d7f2014-04-02 01:50:20 +00001632 Asm->getObjFileLowering().getDwarfLocSection());
Konstantin Zhuravlyovdc77b2e2017-04-17 17:41:25 +00001633 unsigned char Size = Asm->MAI->getCodePointerSize();
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +00001634 for (const auto &List : DebugLocs.getLists()) {
Lang Hames9ff69c82015-04-24 19:11:51 +00001635 Asm->OutStreamer->EmitLabel(List.Label);
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +00001636 const DwarfCompileUnit *CU = List.CU;
1637 for (const auto &Entry : DebugLocs.getEntries(List)) {
Eric Christopher384f3fe2014-03-20 19:16:16 +00001638 // Set up the range. This range is relative to the entry point of the
1639 // compile unit. This is a hard coded 0 for low_pc when we're emitting
1640 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
David Blaikiece343492014-11-03 21:15:30 +00001641 if (auto *Base = CU->getBaseAddress()) {
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +00001642 Asm->EmitLabelDifference(Entry.BeginSym, Base, Size);
1643 Asm->EmitLabelDifference(Entry.EndSym, Base, Size);
Eric Christopher384f3fe2014-03-20 19:16:16 +00001644 } else {
Lang Hames9ff69c82015-04-24 19:11:51 +00001645 Asm->OutStreamer->EmitSymbolValue(Entry.BeginSym, Size);
1646 Asm->OutStreamer->EmitSymbolValue(Entry.EndSym, Size);
Eric Christopher384f3fe2014-03-20 19:16:16 +00001647 }
David Blaikie94c1d7f2014-04-02 01:50:20 +00001648
David Blaikie0e84adc2014-04-01 16:17:41 +00001649 emitDebugLocEntryLocation(Entry);
Devang Patel9fc11702010-05-25 23:40:22 +00001650 }
Lang Hames9ff69c82015-04-24 19:11:51 +00001651 Asm->OutStreamer->EmitIntValue(0, Size);
1652 Asm->OutStreamer->EmitIntValue(0, Size);
David Blaikie94c1d7f2014-04-02 01:50:20 +00001653 }
1654}
1655
1656void DwarfDebug::emitDebugLocDWO() {
Lang Hames9ff69c82015-04-24 19:11:51 +00001657 Asm->OutStreamer->SwitchSection(
David Blaikie94c1d7f2014-04-02 01:50:20 +00001658 Asm->getObjFileLowering().getDwarfLocDWOSection());
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +00001659 for (const auto &List : DebugLocs.getLists()) {
Lang Hames9ff69c82015-04-24 19:11:51 +00001660 Asm->OutStreamer->EmitLabel(List.Label);
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +00001661 for (const auto &Entry : DebugLocs.getEntries(List)) {
David Blaikie94c1d7f2014-04-02 01:50:20 +00001662 // Just always use start_length for now - at least that's one address
1663 // rather than two. We could get fancier and try to, say, reuse an
1664 // address we know we've emitted elsewhere (the start of the function?
1665 // The start of the CU or CU subrange that encloses this range?)
Adrian Prantlc4fbbcf2016-10-28 17:59:50 +00001666 Asm->EmitInt8(dwarf::DW_LLE_startx_length);
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +00001667 unsigned idx = AddrPool.getIndex(Entry.BeginSym);
David Blaikie94c1d7f2014-04-02 01:50:20 +00001668 Asm->EmitULEB128(idx);
Duncan P. N. Exon Smith364a3002015-04-17 21:34:47 +00001669 Asm->EmitLabelDifference(Entry.EndSym, Entry.BeginSym, 4);
David Blaikie94c1d7f2014-04-02 01:50:20 +00001670
1671 emitDebugLocEntryLocation(Entry);
David Blaikie9c550ac2014-03-25 01:44:02 +00001672 }
Adrian Prantlc4fbbcf2016-10-28 17:59:50 +00001673 Asm->EmitInt8(dwarf::DW_LLE_end_of_list);
Devang Patel9fc11702010-05-25 23:40:22 +00001674 }
Bill Wendling480ff322009-05-20 23:21:38 +00001675}
1676
Richard Mitton21101b32013-09-19 23:21:01 +00001677struct ArangeSpan {
1678 const MCSymbol *Start, *End;
1679};
1680
1681// Emit a debug aranges section, containing a CU lookup for any
1682// address we can tie back to a CU.
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001683void DwarfDebug::emitDebugARanges() {
Rafael Espindolae8fd00d2015-02-26 22:02:02 +00001684 // Provides a unique id per text section.
Rafael Espindola0709a7b2015-05-21 19:20:38 +00001685 MapVector<MCSection *, SmallVector<SymbolCU, 8>> SectionMap;
Richard Mitton21101b32013-09-19 23:21:01 +00001686
Rafael Espindolae8fd00d2015-02-26 22:02:02 +00001687 // Filter labels by section.
1688 for (const SymbolCU &SCU : ArangeLabels) {
1689 if (SCU.Sym->isInSection()) {
1690 // Make a note of this symbol and it's section.
Rafael Espindola0709a7b2015-05-21 19:20:38 +00001691 MCSection *Section = &SCU.Sym->getSection();
Rafael Espindolae8fd00d2015-02-26 22:02:02 +00001692 if (!Section->getKind().isMetadata())
1693 SectionMap[Section].push_back(SCU);
1694 } else {
1695 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1696 // appear in the output. This sucks as we rely on sections to build
1697 // arange spans. We can do it without, but it's icky.
1698 SectionMap[nullptr].push_back(SCU);
1699 }
1700 }
Richard Mitton21101b32013-09-19 23:21:01 +00001701
Rafael Espindolae8fd00d2015-02-26 22:02:02 +00001702 DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> Spans;
1703
Rafael Espindola4f4ef152015-03-09 22:08:37 +00001704 for (auto &I : SectionMap) {
Rafael Espindola78d947b2016-05-20 00:38:28 +00001705 MCSection *Section = I.first;
Rafael Espindola4f4ef152015-03-09 22:08:37 +00001706 SmallVector<SymbolCU, 8> &List = I.second;
Rafael Espindola78d947b2016-05-20 00:38:28 +00001707 if (List.size() < 1)
Richard Mitton21101b32013-09-19 23:21:01 +00001708 continue;
1709
Rafael Espindola6ffb1d72015-02-02 19:22:51 +00001710 // If we have no section (e.g. common), just write out
1711 // individual spans for each symbol.
1712 if (!Section) {
1713 for (const SymbolCU &Cur : List) {
1714 ArangeSpan Span;
1715 Span.Start = Cur.Sym;
1716 Span.End = nullptr;
Rafael Espindola78d947b2016-05-20 00:38:28 +00001717 assert(Cur.CU);
1718 Spans[Cur.CU].push_back(Span);
Rafael Espindola6ffb1d72015-02-02 19:22:51 +00001719 }
1720 continue;
1721 }
1722
Richard Mitton21101b32013-09-19 23:21:01 +00001723 // Sort the symbols by offset within the section.
Rafael Espindola0a78f8c2016-05-19 23:17:37 +00001724 std::sort(
1725 List.begin(), List.end(), [&](const SymbolCU &A, const SymbolCU &B) {
1726 unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0;
1727 unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0;
Benjamin Kramer571e2fe2014-03-07 19:41:22 +00001728
Rafael Espindola0a78f8c2016-05-19 23:17:37 +00001729 // Symbols with no order assigned should be placed at the end.
1730 // (e.g. section end labels)
1731 if (IA == 0)
1732 return false;
1733 if (IB == 0)
1734 return true;
1735 return IA < IB;
1736 });
Richard Mitton21101b32013-09-19 23:21:01 +00001737
Rafael Espindola78d947b2016-05-20 00:38:28 +00001738 // Insert a final terminator.
1739 List.push_back(SymbolCU(nullptr, Asm->OutStreamer->endSection(Section)));
1740
Rafael Espindola6ffb1d72015-02-02 19:22:51 +00001741 // Build spans between each label.
1742 const MCSymbol *StartSym = List[0].Sym;
1743 for (size_t n = 1, e = List.size(); n < e; n++) {
1744 const SymbolCU &Prev = List[n - 1];
1745 const SymbolCU &Cur = List[n];
Richard Mitton21101b32013-09-19 23:21:01 +00001746
Rafael Espindola6ffb1d72015-02-02 19:22:51 +00001747 // Try and build the longest span we can within the same CU.
1748 if (Cur.CU != Prev.CU) {
1749 ArangeSpan Span;
1750 Span.Start = StartSym;
1751 Span.End = Cur.Sym;
Rafael Espindola78d947b2016-05-20 00:38:28 +00001752 assert(Prev.CU);
Rafael Espindola6ffb1d72015-02-02 19:22:51 +00001753 Spans[Prev.CU].push_back(Span);
1754 StartSym = Cur.Sym;
Richard Mitton21101b32013-09-19 23:21:01 +00001755 }
1756 }
1757 }
1758
Rafael Espindolae8fd00d2015-02-26 22:02:02 +00001759 // Start the dwarf aranges section.
Lang Hames9ff69c82015-04-24 19:11:51 +00001760 Asm->OutStreamer->SwitchSection(
Rafael Espindolae8fd00d2015-02-26 22:02:02 +00001761 Asm->getObjFileLowering().getDwarfARangesSection());
1762
Konstantin Zhuravlyovdc77b2e2017-04-17 17:41:25 +00001763 unsigned PtrSize = Asm->MAI->getCodePointerSize();
Richard Mitton21101b32013-09-19 23:21:01 +00001764
1765 // Build a list of CUs used.
Eric Christopher4287a492013-12-09 23:57:44 +00001766 std::vector<DwarfCompileUnit *> CUs;
Benjamin Kramer15596c72014-03-07 19:09:39 +00001767 for (const auto &it : Spans) {
1768 DwarfCompileUnit *CU = it.first;
Richard Mitton21101b32013-09-19 23:21:01 +00001769 CUs.push_back(CU);
1770 }
1771
1772 // Sort the CU list (again, to ensure consistent output order).
Peter Collingbourne7c384cc2016-02-11 19:57:46 +00001773 std::sort(CUs.begin(), CUs.end(),
1774 [](const DwarfCompileUnit *A, const DwarfCompileUnit *B) {
1775 return A->getUniqueID() < B->getUniqueID();
1776 });
Richard Mitton21101b32013-09-19 23:21:01 +00001777
1778 // Emit an arange table for each CU we used.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001779 for (DwarfCompileUnit *CU : CUs) {
Richard Mitton21101b32013-09-19 23:21:01 +00001780 std::vector<ArangeSpan> &List = Spans[CU];
1781
David Blaikie27e35f22014-11-02 01:21:43 +00001782 // Describe the skeleton CU's offset and length, not the dwo file's.
1783 if (auto *Skel = CU->getSkeleton())
1784 CU = Skel;
1785
Richard Mitton21101b32013-09-19 23:21:01 +00001786 // Emit size of content not including length itself.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001787 unsigned ContentSize =
1788 sizeof(int16_t) + // DWARF ARange version number
1789 sizeof(int32_t) + // Offset of CU in the .debug_info section
1790 sizeof(int8_t) + // Pointer Size (in bytes)
1791 sizeof(int8_t); // Segment Size (in bytes)
Richard Mitton21101b32013-09-19 23:21:01 +00001792
1793 unsigned TupleSize = PtrSize * 2;
1794
1795 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
Benjamin Kramer8a68ab32014-01-07 19:28:14 +00001796 unsigned Padding =
1797 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
Richard Mitton21101b32013-09-19 23:21:01 +00001798
1799 ContentSize += Padding;
1800 ContentSize += (List.size() + 1) * TupleSize;
1801
1802 // For each compile unit, write the list of spans it covers.
Lang Hames9ff69c82015-04-24 19:11:51 +00001803 Asm->OutStreamer->AddComment("Length of ARange Set");
Richard Mitton21101b32013-09-19 23:21:01 +00001804 Asm->EmitInt32(ContentSize);
Lang Hames9ff69c82015-04-24 19:11:51 +00001805 Asm->OutStreamer->AddComment("DWARF Arange version number");
Richard Mitton21101b32013-09-19 23:21:01 +00001806 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
Lang Hames9ff69c82015-04-24 19:11:51 +00001807 Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
Rafael Espindola857546e2015-06-16 23:22:02 +00001808 Asm->emitDwarfSymbolReference(CU->getLabelBegin());
Lang Hames9ff69c82015-04-24 19:11:51 +00001809 Asm->OutStreamer->AddComment("Address Size (in bytes)");
Richard Mitton21101b32013-09-19 23:21:01 +00001810 Asm->EmitInt8(PtrSize);
Lang Hames9ff69c82015-04-24 19:11:51 +00001811 Asm->OutStreamer->AddComment("Segment Size (in bytes)");
Richard Mitton21101b32013-09-19 23:21:01 +00001812 Asm->EmitInt8(0);
1813
Petr Hosekfaef3202016-06-01 01:59:58 +00001814 Asm->OutStreamer->emitFill(Padding, 0xff);
Richard Mitton21101b32013-09-19 23:21:01 +00001815
Benjamin Kramer15596c72014-03-07 19:09:39 +00001816 for (const ArangeSpan &Span : List) {
Richard Mitton21101b32013-09-19 23:21:01 +00001817 Asm->EmitLabelReference(Span.Start, PtrSize);
1818
1819 // Calculate the size as being from the span start to it's end.
Richard Mitton089ed892013-09-23 17:56:20 +00001820 if (Span.End) {
Richard Mitton21101b32013-09-19 23:21:01 +00001821 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
Richard Mitton089ed892013-09-23 17:56:20 +00001822 } else {
1823 // For symbols without an end marker (e.g. common), we
1824 // write a single arange entry containing just that one symbol.
1825 uint64_t Size = SymSize[Span.Start];
1826 if (Size == 0)
1827 Size = 1;
1828
Lang Hames9ff69c82015-04-24 19:11:51 +00001829 Asm->OutStreamer->EmitIntValue(Size, PtrSize);
Richard Mitton089ed892013-09-23 17:56:20 +00001830 }
Richard Mitton21101b32013-09-19 23:21:01 +00001831 }
1832
Lang Hames9ff69c82015-04-24 19:11:51 +00001833 Asm->OutStreamer->AddComment("ARange terminator");
1834 Asm->OutStreamer->EmitIntValue(0, PtrSize);
1835 Asm->OutStreamer->EmitIntValue(0, PtrSize);
Richard Mitton21101b32013-09-19 23:21:01 +00001836 }
Bill Wendling480ff322009-05-20 23:21:38 +00001837}
1838
Amjad Aboudc0778412016-01-24 08:18:55 +00001839/// Emit address ranges into a debug ranges section.
Devang Patel930143b2009-11-21 02:48:08 +00001840void DwarfDebug::emitDebugRanges() {
David Blaikie07963bd2017-05-26 18:52:56 +00001841 if (CUMap.empty())
1842 return;
1843
Bill Wendling480ff322009-05-20 23:21:38 +00001844 // Start the dwarf ranges section.
Lang Hames9ff69c82015-04-24 19:11:51 +00001845 Asm->OutStreamer->SwitchSection(
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001846 Asm->getObjFileLowering().getDwarfRangesSection());
Eric Christopher4751d702013-11-23 00:05:29 +00001847
Eric Christopher0f63d062013-12-03 00:45:45 +00001848 // Size for our labels.
Konstantin Zhuravlyovdc77b2e2017-04-17 17:41:25 +00001849 unsigned char Size = Asm->MAI->getCodePointerSize();
Eric Christopher0f63d062013-12-03 00:45:45 +00001850
1851 // Grab the specific ranges for the compile units in the module.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001852 for (const auto &I : CUMap) {
1853 DwarfCompileUnit *TheCU = I.second;
Eric Christopher0f63d062013-12-03 00:45:45 +00001854
David Blaikie3a443c22014-11-04 22:12:25 +00001855 if (auto *Skel = TheCU->getSkeleton())
1856 TheCU = Skel;
1857
Eric Christopher0f63d062013-12-03 00:45:45 +00001858 // Iterate over the misc ranges for the compile units in the module.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001859 for (const RangeSpanList &List : TheCU->getRangeLists()) {
Eric Christopherf8790642013-12-04 22:04:50 +00001860 // Emit our symbol so we can find the beginning of the range.
Lang Hames9ff69c82015-04-24 19:11:51 +00001861 Asm->OutStreamer->EmitLabel(List.getSym());
Eric Christopher0f63d062013-12-03 00:45:45 +00001862
Benjamin Kramer15596c72014-03-07 19:09:39 +00001863 for (const RangeSpan &Range : List.getRanges()) {
Eric Christopher0f63d062013-12-03 00:45:45 +00001864 const MCSymbol *Begin = Range.getStart();
1865 const MCSymbol *End = Range.getEnd();
Eric Christopher565ab112013-12-20 04:34:22 +00001866 assert(Begin && "Range without a begin symbol?");
1867 assert(End && "Range without an end symbol?");
David Blaikiece343492014-11-03 21:15:30 +00001868 if (auto *Base = TheCU->getBaseAddress()) {
Eric Christopherece0e902014-04-25 22:23:54 +00001869 Asm->EmitLabelDifference(Begin, Base, Size);
1870 Asm->EmitLabelDifference(End, Base, Size);
1871 } else {
Lang Hames9ff69c82015-04-24 19:11:51 +00001872 Asm->OutStreamer->EmitSymbolValue(Begin, Size);
1873 Asm->OutStreamer->EmitSymbolValue(End, Size);
Eric Christopherece0e902014-04-25 22:23:54 +00001874 }
Eric Christopher0f63d062013-12-03 00:45:45 +00001875 }
1876
1877 // And terminate the list with two 0 values.
Lang Hames9ff69c82015-04-24 19:11:51 +00001878 Asm->OutStreamer->EmitIntValue(0, Size);
1879 Asm->OutStreamer->EmitIntValue(0, Size);
Eric Christopher0f63d062013-12-03 00:45:45 +00001880 }
Devang Patel12563b32010-04-16 23:33:45 +00001881 }
Bill Wendling480ff322009-05-20 23:21:38 +00001882}
1883
Amjad Aboud8bbce8a2016-02-01 14:09:41 +00001884void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) {
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001885 for (auto *MN : Nodes) {
1886 if (auto *M = dyn_cast<DIMacro>(MN))
Amjad Aboud8bbce8a2016-02-01 14:09:41 +00001887 emitMacro(*M);
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001888 else if (auto *F = dyn_cast<DIMacroFile>(MN))
Amjad Aboud8bbce8a2016-02-01 14:09:41 +00001889 emitMacroFile(*F, U);
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001890 else
1891 llvm_unreachable("Unexpected DI type!");
1892 }
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001893}
1894
Amjad Aboud8bbce8a2016-02-01 14:09:41 +00001895void DwarfDebug::emitMacro(DIMacro &M) {
1896 Asm->EmitULEB128(M.getMacinfoType());
1897 Asm->EmitULEB128(M.getLine());
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001898 StringRef Name = M.getName();
1899 StringRef Value = M.getValue();
Amjad Aboud8bbce8a2016-02-01 14:09:41 +00001900 Asm->OutStreamer->EmitBytes(Name);
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001901 if (!Value.empty()) {
1902 // There should be one space between macro name and macro value.
Amjad Aboud8bbce8a2016-02-01 14:09:41 +00001903 Asm->EmitInt8(' ');
1904 Asm->OutStreamer->EmitBytes(Value);
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001905 }
Amjad Aboud8bbce8a2016-02-01 14:09:41 +00001906 Asm->EmitInt8('\0');
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001907}
1908
Amjad Aboud8bbce8a2016-02-01 14:09:41 +00001909void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001910 assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
Amjad Aboud8bbce8a2016-02-01 14:09:41 +00001911 Asm->EmitULEB128(dwarf::DW_MACINFO_start_file);
1912 Asm->EmitULEB128(F.getLine());
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001913 DIFile *File = F.getFile();
1914 unsigned FID =
1915 U.getOrCreateSourceID(File->getFilename(), File->getDirectory());
Amjad Aboud8bbce8a2016-02-01 14:09:41 +00001916 Asm->EmitULEB128(FID);
1917 handleMacroNodes(F.getElements(), U);
1918 Asm->EmitULEB128(dwarf::DW_MACINFO_end_file);
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001919}
1920
Amjad Aboudc0778412016-01-24 08:18:55 +00001921/// Emit macros into a debug macinfo section.
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001922void DwarfDebug::emitDebugMacinfo() {
David Blaikie07963bd2017-05-26 18:52:56 +00001923 if (CUMap.empty())
1924 return;
1925
Amjad Aboud8bbce8a2016-02-01 14:09:41 +00001926 // Start the dwarf macinfo section.
1927 Asm->OutStreamer->SwitchSection(
1928 Asm->getObjFileLowering().getDwarfMacinfoSection());
1929
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001930 for (const auto &P : CUMap) {
1931 auto &TheCU = *P.second;
1932 auto *SkCU = TheCU.getSkeleton();
1933 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
1934 auto *CUNode = cast<DICompileUnit>(P.first);
Amjad Aboud8bbce8a2016-02-01 14:09:41 +00001935 Asm->OutStreamer->EmitLabel(U.getMacroLabelBegin());
1936 handleMacroNodes(CUNode->getMacros(), U);
Amjad Aboudd7cfb482016-01-07 14:28:20 +00001937 }
1938 Asm->OutStreamer->AddComment("End Of Macro List Mark");
1939 Asm->EmitInt8(0);
1940}
1941
Eric Christopherd692c1d2012-12-11 19:42:09 +00001942// DWARF5 Experimental Separate Dwarf emitters.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001943
David Blaikie65a74662014-04-25 18:26:14 +00001944void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
Peter Collingbourne7c384cc2016-02-11 19:57:46 +00001945 std::unique_ptr<DwarfCompileUnit> NewU) {
David Blaikiecafd9622014-11-02 08:51:37 +00001946 NewU->addString(Die, dwarf::DW_AT_GNU_dwo_name,
David Blaikie96b1ed52017-04-21 23:35:26 +00001947 Asm->TM.Options.MCOptions.SplitDwarfFile);
David Blaikie38fe6342014-01-09 04:28:46 +00001948
David Blaikie38fe6342014-01-09 04:28:46 +00001949 if (!CompilationDir.empty())
David Blaikiecafd9622014-11-02 08:51:37 +00001950 NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
David Blaikie38fe6342014-01-09 04:28:46 +00001951
David Blaikief9b6a552014-04-22 22:39:41 +00001952 addGnuPubAttributes(*NewU, Die);
David Blaikie38fe6342014-01-09 04:28:46 +00001953
David Blaikief9b6a552014-04-22 22:39:41 +00001954 SkeletonHolder.addUnit(std::move(NewU));
David Blaikie38fe6342014-01-09 04:28:46 +00001955}
1956
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001957// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
1958// DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
David Blaikie96dea052014-03-24 21:31:35 +00001959// DW_AT_addr_base, DW_AT_ranges_base.
David Blaikief9b6a552014-04-22 22:39:41 +00001960DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001961
David Blaikief9b6a552014-04-22 22:39:41 +00001962 auto OwnedUnit = make_unique<DwarfCompileUnit>(
David Blaikiebd579052014-04-28 21:14:27 +00001963 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
David Blaikief9b6a552014-04-22 22:39:41 +00001964 DwarfCompileUnit &NewCU = *OwnedUnit;
Greg Clayton35630c32016-12-01 18:56:29 +00001965 NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
Eric Christopher4c7765f2013-01-17 03:00:04 +00001966
Rafael Espindola063d7252015-03-10 16:58:10 +00001967 NewCU.initStmtList();
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001968
David Blaikie92a2f8a2014-04-28 21:04:29 +00001969 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
Eric Christopherc8a310e2012-12-10 23:34:43 +00001970
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001971 return NewCU;
1972}
1973
Eric Christopherd692c1d2012-12-11 19:42:09 +00001974// Emit the .debug_info.dwo section for separated dwarf. This contains the
1975// compile units that would normally be in debug_info.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001976void DwarfDebug::emitDebugInfoDWO() {
Eric Christophercdf218d2012-12-10 19:51:21 +00001977 assert(useSplitDwarf() && "No split dwarf debug info?");
Rafael Espindola063d7252015-03-10 16:58:10 +00001978 // Don't emit relocations into the dwo file.
1979 InfoHolder.emitUnits(/* UseOffsets */ true);
Eric Christopher3c5a1912012-12-19 22:02:53 +00001980}
1981
1982// Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
1983// abbreviations for the .debug_info.dwo section.
1984void DwarfDebug::emitDebugAbbrevDWO() {
1985 assert(useSplitDwarf() && "No split dwarf?");
David Blaikie0504cda2013-12-05 07:43:55 +00001986 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001987}
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001988
David Blaikie4a2f95f2014-03-18 01:17:26 +00001989void DwarfDebug::emitDebugLineDWO() {
1990 assert(useSplitDwarf() && "No split dwarf?");
Lang Hames9ff69c82015-04-24 19:11:51 +00001991 Asm->OutStreamer->SwitchSection(
David Blaikie4a2f95f2014-03-18 01:17:26 +00001992 Asm->getObjFileLowering().getDwarfLineDWOSection());
Frederic Rissa5ab8442015-08-07 15:14:08 +00001993 SplitTypeUnitFileTable.Emit(*Asm->OutStreamer, MCDwarfLineTableParams());
David Blaikie4a2f95f2014-03-18 01:17:26 +00001994}
1995
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001996// Emit the .debug_str.dwo section for separated dwarf. This contains the
1997// string section and is identical in format to traditional .debug_str
1998// sections.
1999void DwarfDebug::emitDebugStrDWO() {
2000 assert(useSplitDwarf() && "No split dwarf?");
Rafael Espindola0709a7b2015-05-21 19:20:38 +00002001 MCSection *OffSec = Asm->getObjFileLowering().getDwarfStrOffDWOSection();
Eric Christopher2cbd5762013-01-07 19:32:41 +00002002 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
David Blaikie6741bb02014-09-11 21:12:48 +00002003 OffSec);
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002004}
David Blaikie409dd9c2013-11-19 23:08:21 +00002005
David Blaikie47f4b822014-03-19 00:11:28 +00002006MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2007 if (!useSplitDwarf())
2008 return nullptr;
2009 if (SingleCU)
Duncan P. N. Exon Smith35ef22c2015-04-15 23:19:27 +00002010 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode()->getDirectory());
David Blaikie47f4b822014-03-19 00:11:28 +00002011 return &SplitTypeUnitFileTable;
2012}
2013
Adrian Prantlee5feaf2015-07-15 17:01:41 +00002014uint64_t DwarfDebug::makeTypeSignature(StringRef Identifier) {
David Blaikief3de2ab2014-04-26 16:26:41 +00002015 MD5 Hash;
2016 Hash.update(Identifier);
2017 // ... take the least significant 8 bytes and return those. Our MD5
Zachary Turner82a0c972017-03-20 23:33:18 +00002018 // implementation always returns its results in little endian, so we actually
2019 // need the "high" word.
David Blaikief3de2ab2014-04-26 16:26:41 +00002020 MD5::MD5Result Result;
2021 Hash.final(Result);
Zachary Turner82a0c972017-03-20 23:33:18 +00002022 return Result.high();
David Blaikief3de2ab2014-04-26 16:26:41 +00002023}
2024
David Blaikie15632ae2014-02-12 00:31:30 +00002025void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
David Blaikie65a74662014-04-25 18:26:14 +00002026 StringRef Identifier, DIE &RefDie,
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00002027 const DICompositeType *CTy) {
David Blaikiee12b49a2014-04-26 17:27:38 +00002028 // Fast path if we're building some type units and one has already used the
2029 // address pool we know we're going to throw away all this work anyway, so
2030 // don't bother building dependent types.
2031 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2032 return;
2033
Peter Collingbourne7c384cc2016-02-11 19:57:46 +00002034 auto Ins = TypeSignatures.insert(std::make_pair(CTy, 0));
2035 if (!Ins.second) {
2036 CU.addDIETypeSignature(RefDie, Ins.first->second);
Chandler Carruthb587ab62014-01-20 08:07:07 +00002037 return;
David Blaikie409dd9c2013-11-19 23:08:21 +00002038 }
2039
David Blaikiee12b49a2014-04-26 17:27:38 +00002040 bool TopLevelType = TypeUnitsUnderConstruction.empty();
2041 AddrPool.resetUsedFlag();
2042
Peter Collingbourne7c384cc2016-02-11 19:57:46 +00002043 auto OwnedUnit = make_unique<DwarfTypeUnit>(CU, Asm, this, &InfoHolder,
2044 getDwoLineTable(CU));
David Blaikief9b6a552014-04-22 22:39:41 +00002045 DwarfTypeUnit &NewTU = *OwnedUnit;
David Blaikie92a2f8a2014-04-28 21:04:29 +00002046 DIE &UnitDie = NewTU.getUnitDie();
David Majnemer0a16c222016-08-11 21:15:00 +00002047 TypeUnitsUnderConstruction.emplace_back(std::move(OwnedUnit), CTy);
Chandler Carruthb587ab62014-01-20 08:07:07 +00002048
David Blaikie92a2f8a2014-04-28 21:04:29 +00002049 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
David Blaikie637cac42014-04-22 23:09:36 +00002050 CU.getLanguage());
Chandler Carruthb587ab62014-01-20 08:07:07 +00002051
David Blaikief3de2ab2014-04-26 16:26:41 +00002052 uint64_t Signature = makeTypeSignature(Identifier);
David Blaikief9b6a552014-04-22 22:39:41 +00002053 NewTU.setTypeSignature(Signature);
Peter Collingbourne7c384cc2016-02-11 19:57:46 +00002054 Ins.first->second = Signature;
David Blaikief3de2ab2014-04-26 16:26:41 +00002055
David Blaikie29459ae2014-07-25 17:11:58 +00002056 if (useSplitDwarf())
Greg Clayton35630c32016-12-01 18:56:29 +00002057 NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
David Blaikie29459ae2014-07-25 17:11:58 +00002058 else {
David Blaikie92a2f8a2014-04-28 21:04:29 +00002059 CU.applyStmtList(UnitDie);
Greg Clayton35630c32016-12-01 18:56:29 +00002060 NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesSection(Signature));
David Blaikie29459ae2014-07-25 17:11:58 +00002061 }
Chandler Carruthb587ab62014-01-20 08:07:07 +00002062
David Blaikief3de2ab2014-04-26 16:26:41 +00002063 NewTU.setType(NewTU.createTypeDIE(CTy));
2064
David Blaikiee12b49a2014-04-26 17:27:38 +00002065 if (TopLevelType) {
2066 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2067 TypeUnitsUnderConstruction.clear();
2068
2069 // Types referencing entries in the address table cannot be placed in type
2070 // units.
2071 if (AddrPool.hasBeenUsed()) {
2072
2073 // Remove all the types built while building this type.
2074 // This is pessimistic as some of these types might not be dependent on
2075 // the type that used an address.
2076 for (const auto &TU : TypeUnitsToAdd)
Peter Collingbourne7c384cc2016-02-11 19:57:46 +00002077 TypeSignatures.erase(TU.second);
David Blaikiee12b49a2014-04-26 17:27:38 +00002078
2079 // Construct this type in the CU directly.
2080 // This is inefficient because all the dependent types will be rebuilt
2081 // from scratch, including building them in type units, discovering that
2082 // they depend on addresses, throwing them out and rebuilding them.
Duncan P. N. Exon Smitha9308c42015-04-29 16:38:44 +00002083 CU.constructTypeDIE(RefDie, cast<DICompositeType>(CTy));
David Blaikiee12b49a2014-04-26 17:27:38 +00002084 return;
2085 }
2086
2087 // If the type wasn't dependent on fission addresses, finish adding the type
2088 // and all its dependent types.
Peter Collingbourne7c384cc2016-02-11 19:57:46 +00002089 for (auto &TU : TypeUnitsToAdd) {
2090 InfoHolder.computeSizeAndOffsetsForUnit(TU.first.get());
2091 InfoHolder.emitUnit(TU.first.get(), useSplitDwarf());
2092 }
David Blaikiee12b49a2014-04-26 17:27:38 +00002093 }
Peter Collingbourne7c384cc2016-02-11 19:57:46 +00002094 CU.addDIETypeSignature(RefDie, Signature);
David Blaikie409dd9c2013-11-19 23:08:21 +00002095}
David Blaikie4bd13b72014-03-07 18:49:45 +00002096
David Blaikie2406a0622014-04-23 23:37:35 +00002097// Accelerator table mutators - add each name along with its companion
2098// DIE to the proper table while ensuring that the name that we're going
2099// to reference is in the string table. We do this since the names we
2100// add may not only be identical to the names in the DIE.
David Blaikieb0b3fcf2014-04-25 18:52:29 +00002101void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
David Blaikie2406a0622014-04-23 23:37:35 +00002102 if (!useDwarfAccelTables())
2103 return;
Duncan P. N. Exon Smithf4599942015-05-24 16:44:32 +00002104 AccelNames.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
David Blaikie2406a0622014-04-23 23:37:35 +00002105}
David Blaikie0ee82b92014-04-24 00:53:32 +00002106
David Blaikieb0b3fcf2014-04-25 18:52:29 +00002107void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
David Blaikie0ee82b92014-04-24 00:53:32 +00002108 if (!useDwarfAccelTables())
2109 return;
Duncan P. N. Exon Smithf4599942015-05-24 16:44:32 +00002110 AccelObjC.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
David Blaikie0ee82b92014-04-24 00:53:32 +00002111}
David Blaikieecf04152014-04-24 01:02:42 +00002112
David Blaikieb0b3fcf2014-04-25 18:52:29 +00002113void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
David Blaikieecf04152014-04-24 01:02:42 +00002114 if (!useDwarfAccelTables())
2115 return;
Duncan P. N. Exon Smithf4599942015-05-24 16:44:32 +00002116 AccelNamespace.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
David Blaikieecf04152014-04-24 01:02:42 +00002117}
David Blaikie18d33752014-04-24 01:23:49 +00002118
David Blaikieb0b3fcf2014-04-25 18:52:29 +00002119void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
David Blaikie18d33752014-04-24 01:23:49 +00002120 if (!useDwarfAccelTables())
2121 return;
Duncan P. N. Exon Smithf4599942015-05-24 16:44:32 +00002122 AccelTypes.AddName(InfoHolder.getStringPool().getEntry(*Asm, Name), &Die);
David Blaikie18d33752014-04-24 01:23:49 +00002123}
Greg Claytone6543972016-11-23 23:30:37 +00002124
2125uint16_t DwarfDebug::getDwarfVersion() const {
2126 return Asm->OutStreamer->getContext().getDwarfVersion();
2127}