blob: 85f807808b3ed2ff21f69284feaef47411a5947e [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"
Chandler Carruthd9903882015-01-14 11:23:27 +000017#include "DwarfCompileUnit.h"
18#include "DwarfExpression.h"
David Blaikie2c86a722013-12-02 19:33:15 +000019#include "DwarfUnit.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000020#include "llvm/ADT/STLExtras.h"
21#include "llvm/ADT/Statistic.h"
22#include "llvm/ADT/StringExtras.h"
23#include "llvm/ADT/Triple.h"
Frederic Risse541e0b2015-01-05 21:29:41 +000024#include "llvm/CodeGen/DIE.h"
David Greene829b3e82009-08-19 21:52:55 +000025#include "llvm/CodeGen/MachineFunction.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000026#include "llvm/CodeGen/MachineModuleInfo.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000027#include "llvm/IR/Constants.h"
Chandler Carruth12664a02014-03-06 00:22:06 +000028#include "llvm/IR/DIBuilder.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000029#include "llvm/IR/DataLayout.h"
Chandler Carruth9a4c9e52014-03-06 00:46:21 +000030#include "llvm/IR/DebugInfo.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000031#include "llvm/IR/Instructions.h"
32#include "llvm/IR/Module.h"
Chandler Carruth4220e9c2014-03-04 11:17:44 +000033#include "llvm/IR/ValueHandle.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000034#include "llvm/MC/MCAsmInfo.h"
Chris Lattner4d2c0f92009-07-31 18:48:30 +000035#include "llvm/MC/MCSection.h"
Chris Lattner4b7dadb2009-08-19 05:49:37 +000036#include "llvm/MC/MCStreamer.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000037#include "llvm/MC/MCSymbol.h"
Devang Patel6c74a872010-04-27 19:46:33 +000038#include "llvm/Support/CommandLine.h"
Daniel Dunbarcdf01b52009-10-13 06:47:08 +000039#include "llvm/Support/Debug.h"
David Majnemered89b5c2013-08-21 06:13:34 +000040#include "llvm/Support/Dwarf.h"
Saleem Abdulrasool271ac582014-07-14 16:28:09 +000041#include "llvm/Support/Endian.h"
Daniel Dunbarcdf01b52009-10-13 06:47:08 +000042#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"
Chandler Carruthed0881b2012-12-03 16:50:05 +000048#include "llvm/Target/TargetFrameLowering.h"
49#include "llvm/Target/TargetLoweringObjectFile.h"
50#include "llvm/Target/TargetMachine.h"
51#include "llvm/Target/TargetOptions.h"
52#include "llvm/Target/TargetRegisterInfo.h"
Eric Christopherd9134482014-08-04 21:25:23 +000053#include "llvm/Target/TargetSubtargetInfo.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000054using namespace llvm;
55
Chandler Carruth1b9dde02014-04-22 02:02:50 +000056#define DEBUG_TYPE "dwarfdebug"
57
Eric Christopher7f2b5512013-07-23 22:16:41 +000058static cl::opt<bool>
59DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
60 cl::desc("Disable debug info printing"));
Devang Patel6c74a872010-04-27 19:46:33 +000061
Eric Christopher7f2b5512013-07-23 22:16:41 +000062static cl::opt<bool> UnknownLocations(
63 "use-unknown-locations", cl::Hidden,
64 cl::desc("Make an absence of debug location information explicit."),
65 cl::init(false));
Dan Gohman7421ae42010-05-07 01:08:53 +000066
Eric Christopherdd1a0122013-09-13 00:35:05 +000067static cl::opt<bool>
68GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
69 cl::desc("Generate GNU-style pubnames and pubtypes"),
70 cl::init(false));
71
Eric Christopher02dbadb2014-02-14 01:26:55 +000072static cl::opt<bool> GenerateARangeSection("generate-arange-section",
73 cl::Hidden,
74 cl::desc("Generate dwarf aranges"),
75 cl::init(false));
76
Eric Christopher20b76a72012-08-23 22:36:40 +000077namespace {
Eric Christopherf07ee3a2014-01-27 23:50:03 +000078enum DefaultOnOff { Default, Enable, Disable };
Eric Christopher20b76a72012-08-23 22:36:40 +000079}
Eric Christopher4996c702011-11-07 09:24:32 +000080
Eric Christopher7f2b5512013-07-23 22:16:41 +000081static cl::opt<DefaultOnOff>
82DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
83 cl::desc("Output prototype dwarf accelerator tables."),
84 cl::values(clEnumVal(Default, "Default for platform"),
85 clEnumVal(Enable, "Enabled"),
86 clEnumVal(Disable, "Disabled"), clEnumValEnd),
87 cl::init(Default));
Eric Christopher20b76a72012-08-23 22:36:40 +000088
Eric Christopher7f2b5512013-07-23 22:16:41 +000089static cl::opt<DefaultOnOff>
Eric Christopher7f2b5512013-07-23 22:16:41 +000090SplitDwarf("split-dwarf", cl::Hidden,
Eric Christopher5d008fe2013-12-04 23:24:28 +000091 cl::desc("Output DWARF5 split debug info."),
Eric Christopher7f2b5512013-07-23 22:16:41 +000092 cl::values(clEnumVal(Default, "Default for platform"),
93 clEnumVal(Enable, "Enabled"),
94 clEnumVal(Disable, "Disabled"), clEnumValEnd),
95 cl::init(Default));
Eric Christopher29424312012-11-12 22:22:20 +000096
Eric Christopher7da24882013-08-19 21:07:38 +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"),
102 clEnumVal(Disable, "Disabled"), clEnumValEnd),
103 cl::init(Default));
Eric Christopher7da24882013-08-19 21:07:38 +0000104
Benjamin Kramerb12cf012013-08-24 12:54:27 +0000105static const char *const DWARFGroupName = "DWARF Emission";
106static const char *const DbgTimerName = "DWARF Debug Writer";
Bill Wendlingfcc14142010-04-07 09:28:04 +0000107
Adrian Prantl92da14b2015-03-02 22:02:33 +0000108void DebugLocDwarfExpression::EmitOp(uint8_t Op, const char *Comment) {
109 BS.EmitInt8(
110 Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
111 : dwarf::OperationEncodingString(Op));
112}
113
Adrian Prantl51233682015-03-10 19:23:37 +0000114void DebugLocDwarfExpression::EmitSigned(int64_t Value) {
Adrian Prantl92da14b2015-03-02 22:02:33 +0000115 BS.EmitSLEB128(Value, Twine(Value));
116}
117
Adrian Prantl51233682015-03-10 19:23:37 +0000118void DebugLocDwarfExpression::EmitUnsigned(uint64_t Value) {
Adrian Prantl92da14b2015-03-02 22:02:33 +0000119 BS.EmitULEB128(Value, Twine(Value));
120}
121
122bool DebugLocDwarfExpression::isFrameRegister(unsigned MachineReg) {
123 // This information is not available while emitting .debug_loc entries.
124 return false;
125}
126
Bill Wendling2f921f82009-05-15 09:23:25 +0000127//===----------------------------------------------------------------------===//
128
Manman Renbe5576f2013-10-08 19:07:44 +0000129/// resolve - Look in the DwarfDebug map for the MDNode that
130/// corresponds to the reference.
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000131template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
Manman Renbe5576f2013-10-08 19:07:44 +0000132 return DD->resolve(Ref);
133}
134
Adrian Prantl1a1647c2014-03-18 02:34:58 +0000135bool DbgVariable::isBlockByrefVariable() const {
136 assert(Var.isVariable() && "Invalid complex DbgVariable!");
137 return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
138}
139
Nick Lewycky019d2552011-07-29 03:49:23 +0000140DIType DbgVariable::getType() const {
Adrian Prantl1a1647c2014-03-18 02:34:58 +0000141 DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
Devang Patelf20c4f72011-04-12 22:53:02 +0000142 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
143 // addresses instead.
Adrian Prantl1a1647c2014-03-18 02:34:58 +0000144 if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
Devang Patelf20c4f72011-04-12 22:53:02 +0000145 /* Byref variables, in Blocks, are declared by the programmer as
146 "SomeType VarName;", but the compiler creates a
147 __Block_byref_x_VarName struct, and gives the variable VarName
148 either the struct, or a pointer to the struct, as its type. This
149 is necessary for various behind-the-scenes things the compiler
150 needs to do with by-reference variables in blocks.
Eric Christopher6a841382012-11-19 22:42:10 +0000151
Devang Patelf20c4f72011-04-12 22:53:02 +0000152 However, as far as the original *programmer* is concerned, the
153 variable should still have type 'SomeType', as originally declared.
Eric Christopher6a841382012-11-19 22:42:10 +0000154
Devang Patelf20c4f72011-04-12 22:53:02 +0000155 The following function dives into the __Block_byref_x_VarName
156 struct to find the original type of the variable. This will be
157 passed back to the code generating the type for the Debug
158 Information Entry for the variable 'VarName'. 'VarName' will then
159 have the original type 'SomeType' in its debug information.
Eric Christopher6a841382012-11-19 22:42:10 +0000160
Devang Patelf20c4f72011-04-12 22:53:02 +0000161 The original type 'SomeType' will be the type of the field named
162 'VarName' inside the __Block_byref_x_VarName struct.
Eric Christopher6a841382012-11-19 22:42:10 +0000163
Devang Patelf20c4f72011-04-12 22:53:02 +0000164 NOTE: In order for this to not completely fail on the debugger
165 side, the Debug Information Entry for the variable VarName needs to
166 have a DW_AT_location that tells the debugger how to unwind through
167 the pointers and __Block_byref_x_VarName struct to find the actual
168 value of the variable. The function addBlockByrefType does this. */
169 DIType subType = Ty;
Eric Christopher31b05762013-08-08 01:41:00 +0000170 uint16_t tag = Ty.getTag();
Eric Christopher6a841382012-11-19 22:42:10 +0000171
Eric Christopher9adc55f2013-09-04 19:53:21 +0000172 if (tag == dwarf::DW_TAG_pointer_type)
Manman Renbe5576f2013-10-08 19:07:44 +0000173 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
Eric Christopher6a841382012-11-19 22:42:10 +0000174
Manman Renab8ffba2014-07-28 19:14:13 +0000175 DIArray Elements = DICompositeType(subType).getElements();
Devang Patelf20c4f72011-04-12 22:53:02 +0000176 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
David Blaikie5af2aca2013-11-18 23:57:26 +0000177 DIDerivedType DT(Elements.getElement(i));
Devang Patelf20c4f72011-04-12 22:53:02 +0000178 if (getName() == DT.getName())
Manman Renbe5576f2013-10-08 19:07:44 +0000179 return (resolve(DT.getTypeDerivedFrom()));
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000180 }
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000181 }
Devang Patelf20c4f72011-04-12 22:53:02 +0000182 return Ty;
183}
Bill Wendling2f921f82009-05-15 09:23:25 +0000184
David Blaikie18d33752014-04-24 01:23:49 +0000185static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
186 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
187 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
188 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
189
Chris Lattnerf0d6bd32010-04-05 05:11:15 +0000190DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
David Blaikie0dc623c2014-10-24 17:53:38 +0000191 : Asm(A), MMI(Asm->MMI), PrevLabel(nullptr), GlobalRangeCount(0),
Frederic Riss9412d632015-03-04 02:30:17 +0000192 InfoHolder(A, "info_string", DIEValueAllocator),
Eric Christopher2037caf2014-01-28 00:49:26 +0000193 UsedNonDefaultText(false),
Frederic Riss9412d632015-03-04 02:30:17 +0000194 SkeletonHolder(A, "skel_string", DIEValueAllocator),
David Blaikiee1c79742014-09-30 21:28:32 +0000195 IsDarwin(Triple(A->getTargetTriple()).isOSDarwin()),
Paul Robinson78cc0822015-03-04 20:55:11 +0000196 IsPS4(Triple(A->getTargetTriple()).isPS4()),
David Blaikie2406a0622014-04-23 23:37:35 +0000197 AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
David Blaikie0ee82b92014-04-24 00:53:32 +0000198 dwarf::DW_FORM_data4)),
199 AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
David Blaikieecf04152014-04-24 01:02:42 +0000200 dwarf::DW_FORM_data4)),
201 AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
David Blaikie18d33752014-04-24 01:23:49 +0000202 dwarf::DW_FORM_data4)),
203 AccelTypes(TypeAtoms) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000204
Craig Topper353eda42014-04-24 06:44:33 +0000205 CurFn = nullptr;
206 CurMI = nullptr;
Eric Christopherad9fe892012-04-02 17:58:52 +0000207
Adrian Prantl5bf1d002013-10-15 20:26:37 +0000208 // Turn on accelerator tables for Darwin by default, pubnames by
Paul Robinson49e38962015-03-05 00:08:27 +0000209 // default for non-Darwin/PS4, and handle split dwarf.
Eric Christopher574b5c82013-08-19 21:41:38 +0000210 if (DwarfAccelTables == Default)
211 HasDwarfAccelTables = IsDarwin;
212 else
Eric Christopher5297df02013-08-26 20:58:35 +0000213 HasDwarfAccelTables = DwarfAccelTables == Enable;
Eric Christopher20b76a72012-08-23 22:36:40 +0000214
Eric Christophercdf218d2012-12-10 19:51:21 +0000215 if (SplitDwarf == Default)
216 HasSplitDwarf = false;
Eric Christopher29424312012-11-12 22:22:20 +0000217 else
Eric Christopher574b5c82013-08-19 21:41:38 +0000218 HasSplitDwarf = SplitDwarf == Enable;
Eric Christopher29424312012-11-12 22:22:20 +0000219
Eric Christopher4d36ca02013-08-26 23:24:35 +0000220 if (DwarfPubSections == Default)
Paul Robinson49e38962015-03-05 00:08:27 +0000221 HasDwarfPubSections = !IsDarwin && !IsPS4;
Eric Christopher574b5c82013-08-19 21:41:38 +0000222 else
Eric Christopher4d36ca02013-08-26 23:24:35 +0000223 HasDwarfPubSections = DwarfPubSections == Enable;
Eric Christopher7da24882013-08-19 21:07:38 +0000224
Eric Christopher4c5bff32014-06-19 06:22:08 +0000225 unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
Eric Christopher793c7472014-04-28 20:42:22 +0000226 DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
227 : MMI->getModule()->getDwarfVersion();
Manman Renac8062b2013-07-02 23:40:10 +0000228
Paul Robinson78cc0822015-03-04 20:55:11 +0000229 // Darwin and PS4 use the standard TLS opcode (defined in DWARF 3).
230 // Everybody else uses GNU's.
231 UseGNUTLSOpcode = !(IsDarwin || IsPS4) || DwarfVersion < 3;
232
Oliver Stannardf7693f42014-06-19 15:39:33 +0000233 Asm->OutStreamer.getContext().setDwarfVersion(DwarfVersion);
234
Dan Gohman6e681a52010-06-18 15:56:31 +0000235 {
236 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
Eric Christopher58f41952012-11-19 22:42:15 +0000237 beginModule();
Torok Edwinf8dba242010-04-07 10:44:46 +0000238 }
Bill Wendling2f921f82009-05-15 09:23:25 +0000239}
Bill Wendling2f921f82009-05-15 09:23:25 +0000240
Reid Klecknerdd2647e2014-04-30 20:34:31 +0000241// Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
242DwarfDebug::~DwarfDebug() { }
243
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000244// Switch to the specified MCSection and emit an assembler
245// temporary label to it if SymbolStem is specified.
Rafael Espindola6b9998b2015-03-10 22:00:25 +0000246static void emitSectionSym(AsmPrinter *Asm, const MCSection *Section) {
Eric Christophera7b61892011-11-07 09:18:38 +0000247 Asm->OutStreamer.SwitchSection(Section);
Rafael Espindola6b9998b2015-03-10 22:00:25 +0000248 MCSymbol *TmpSym = Section->getBeginSymbol();
Eric Christophera7b61892011-11-07 09:18:38 +0000249 Asm->OutStreamer.EmitLabel(TmpSym);
Eric Christophera7b61892011-11-07 09:18:38 +0000250}
251
Eric Christopherd9843b32011-11-10 19:25:34 +0000252static bool isObjCClass(StringRef Name) {
253 return Name.startswith("+") || Name.startswith("-");
254}
255
256static bool hasObjCCategory(StringRef Name) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000257 if (!isObjCClass(Name))
258 return false;
Eric Christopherd9843b32011-11-10 19:25:34 +0000259
Benjamin Kramer260de742013-08-24 12:15:54 +0000260 return Name.find(") ") != StringRef::npos;
Eric Christopherd9843b32011-11-10 19:25:34 +0000261}
262
263static void getObjCClassCategory(StringRef In, StringRef &Class,
264 StringRef &Category) {
265 if (!hasObjCCategory(In)) {
266 Class = In.slice(In.find('[') + 1, In.find(' '));
267 Category = "";
268 return;
269 }
270
271 Class = In.slice(In.find('[') + 1, In.find('('));
272 Category = In.slice(In.find('[') + 1, In.find(' '));
273 return;
274}
275
276static StringRef getObjCMethodName(StringRef In) {
277 return In.slice(In.find(' ') + 1, In.find(']'));
278}
279
280// Add the various names to the Dwarf accelerator table names.
Eric Christopher9cd26af2013-09-20 23:22:52 +0000281// TODO: Determine whether or not we should add names for programs
282// that do not have a DW_AT_name or DW_AT_linkage_name field - this
283// is only slightly different than the lookup of non-standard ObjC names.
David Blaikieb0b3fcf2014-04-25 18:52:29 +0000284void DwarfDebug::addSubprogramNames(DISubprogram SP, DIE &Die) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000285 if (!SP.isDefinition())
286 return;
David Blaikie2406a0622014-04-23 23:37:35 +0000287 addAccelName(SP.getName(), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000288
289 // If the linkage name is different than the name, go ahead and output
290 // that as well into the name table.
291 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
David Blaikie2406a0622014-04-23 23:37:35 +0000292 addAccelName(SP.getLinkageName(), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000293
294 // If this is an Objective-C selector name add it to the ObjC accelerator
295 // too.
296 if (isObjCClass(SP.getName())) {
297 StringRef Class, Category;
298 getObjCClassCategory(SP.getName(), Class, Category);
David Blaikie0ee82b92014-04-24 00:53:32 +0000299 addAccelObjC(Class, Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000300 if (Category != "")
David Blaikie0ee82b92014-04-24 00:53:32 +0000301 addAccelObjC(Category, Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000302 // Also add the base method name to the name table.
David Blaikie2406a0622014-04-23 23:37:35 +0000303 addAccelName(getObjCMethodName(SP.getName()), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000304 }
305}
306
Manman Ren3eb9dff2013-09-09 19:05:21 +0000307/// isSubprogramContext - Return true if Context is either a subprogram
308/// or another context nested inside a subprogram.
309bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
310 if (!Context)
311 return false;
312 DIDescriptor D(Context);
313 if (D.isSubprogram())
314 return true;
315 if (D.isType())
Manman Ren116868e2013-09-09 19:47:11 +0000316 return isSubprogramContext(resolve(DIType(Context).getContext()));
Manman Ren3eb9dff2013-09-09 19:05:21 +0000317 return false;
318}
319
Manman Ren5b2f4b02013-09-11 19:40:28 +0000320/// Check whether we should create a DIE for the given Scope, return true
321/// if we don't create a DIE (the corresponding DIE is null).
Manman Ren2312ed32013-09-10 18:40:41 +0000322bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
323 if (Scope->isAbstractScope())
324 return false;
325
Manman Ren5b2f4b02013-09-11 19:40:28 +0000326 // We don't create a DIE if there is no Range.
Manman Ren2312ed32013-09-10 18:40:41 +0000327 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
328 if (Ranges.empty())
329 return true;
330
331 if (Ranges.size() > 1)
332 return false;
333
Manman Ren5b2f4b02013-09-11 19:40:28 +0000334 // We don't create a DIE if we have a single Range and the end label
335 // is null.
David Blaikiecd4b8a22014-08-31 02:14:26 +0000336 return !getLabelAfterInsn(Ranges.front().second);
Manman Ren2312ed32013-09-10 18:40:41 +0000337}
338
David Blaikie3a443c22014-11-04 22:12:25 +0000339template <typename Func> void forBothCUs(DwarfCompileUnit &CU, Func F) {
340 F(CU);
341 if (auto *SkelCU = CU.getSkeleton())
342 F(*SkelCU);
343}
344
David Blaikie73cc7052014-10-09 20:36:27 +0000345void DwarfDebug::constructAbstractSubprogramScopeDIE(LexicalScope *Scope) {
David Blaikiee872a6e2014-04-29 15:58:35 +0000346 assert(Scope && Scope->getScopeNode());
347 assert(Scope->isAbstractScope());
348 assert(!Scope->getInlinedAt());
349
David Blaikie58410f22014-10-10 06:39:26 +0000350 const MDNode *SP = Scope->getScopeNode();
David Blaikiee872a6e2014-04-29 15:58:35 +0000351
David Blaikie9ab48842014-10-10 03:09:38 +0000352 ProcessedSPNodes.insert(SP);
353
David Blaikie1ea9db22014-05-21 23:14:12 +0000354 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
355 // was inlined from another compile unit.
David Blaikie3a443c22014-11-04 22:12:25 +0000356 auto &CU = SPMap[SP];
357 forBothCUs(*CU, [&](DwarfCompileUnit &CU) {
358 CU.constructAbstractSubprogramScopeDIE(Scope);
359 });
David Blaikiee872a6e2014-04-29 15:58:35 +0000360}
361
David Blaikie65a74662014-04-25 18:26:14 +0000362void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
David Blaikie3c842622013-12-04 21:31:26 +0000363 if (!GenerateGnuPubSections)
364 return;
365
David Blaikief9b6a552014-04-22 22:39:41 +0000366 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
David Blaikie3c842622013-12-04 21:31:26 +0000367}
368
Eric Christopher4287a492013-12-09 23:57:44 +0000369// Create new DwarfCompileUnit for the given metadata node with tag
Eric Christopher48fef592012-12-20 21:58:40 +0000370// DW_TAG_compile_unit.
David Blaikief9b6a552014-04-22 22:39:41 +0000371DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
Devang Patel2d9caf92009-11-25 17:36:49 +0000372 StringRef FN = DIUnit.getFilename();
Nick Lewyckyd1ee7f82011-11-02 20:55:33 +0000373 CompilationDir = DIUnit.getDirectory();
Bill Wendling2b128d72009-05-20 23:19:06 +0000374
David Blaikief9b6a552014-04-22 22:39:41 +0000375 auto OwnedUnit = make_unique<DwarfCompileUnit>(
David Blaikiebd579052014-04-28 21:14:27 +0000376 InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
David Blaikief9b6a552014-04-22 22:39:41 +0000377 DwarfCompileUnit &NewCU = *OwnedUnit;
David Blaikie92a2f8a2014-04-28 21:04:29 +0000378 DIE &Die = NewCU.getUnitDie();
David Blaikief9b6a552014-04-22 22:39:41 +0000379 InfoHolder.addUnit(std::move(OwnedUnit));
David Blaikiecafd9622014-11-02 08:51:37 +0000380 if (useSplitDwarf())
381 NewCU.setSkeleton(constructSkeletonCU(NewCU));
David Blaikief9b6a552014-04-22 22:39:41 +0000382
David Blaikie7ac51492014-03-20 17:05:45 +0000383 // LTO with assembly output shares a single line table amongst multiple CUs.
384 // To avoid the compilation directory being ambiguous, let the line table
385 // explicitly describe the directory of all files, never relying on the
386 // compilation directory.
David Blaikie47f4b822014-03-19 00:11:28 +0000387 if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
David Blaikiee05274d2014-03-18 00:11:48 +0000388 Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
David Blaikief9b6a552014-04-22 22:39:41 +0000389 NewCU.getUniqueID(), CompilationDir);
David Blaikie2666e242013-12-06 19:38:46 +0000390
David Blaikie92a2f8a2014-04-28 21:04:29 +0000391 NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
392 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
David Blaikie637cac42014-04-22 23:09:36 +0000393 DIUnit.getLanguage());
David Blaikie92a2f8a2014-04-28 21:04:29 +0000394 NewCU.addString(Die, dwarf::DW_AT_name, FN);
Eric Christopher52ce7182013-04-09 19:23:15 +0000395
Eric Christopher52ce7182013-04-09 19:23:15 +0000396 if (!useSplitDwarf()) {
Rafael Espindola063d7252015-03-10 16:58:10 +0000397 NewCU.initStmtList();
Eric Christophera51d3fc2013-09-27 22:50:48 +0000398
399 // If we're using split dwarf the compilation dir is going to be in the
400 // skeleton CU and so we don't need to duplicate it here.
401 if (!CompilationDir.empty())
David Blaikie92a2f8a2014-04-28 21:04:29 +0000402 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
Eric Christophera51d3fc2013-09-27 22:50:48 +0000403
David Blaikie92a2f8a2014-04-28 21:04:29 +0000404 addGnuPubAttributes(NewCU, Die);
Eric Christopher52ce7182013-04-09 19:23:15 +0000405 }
Bill Wendling2b128d72009-05-20 23:19:06 +0000406
Bill Wendling2b128d72009-05-20 23:19:06 +0000407 if (DIUnit.isOptimized())
David Blaikie92a2f8a2014-04-28 21:04:29 +0000408 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
Bill Wendling2b128d72009-05-20 23:19:06 +0000409
Devang Patel2d9caf92009-11-25 17:36:49 +0000410 StringRef Flags = DIUnit.getFlags();
411 if (!Flags.empty())
David Blaikie92a2f8a2014-04-28 21:04:29 +0000412 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
Eric Christopher6a841382012-11-19 22:42:10 +0000413
Nick Lewycky479a8fe2011-10-17 23:27:36 +0000414 if (unsigned RVer = DIUnit.getRunTimeVersion())
David Blaikie92a2f8a2014-04-28 21:04:29 +0000415 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
David Blaikie637cac42014-04-22 23:09:36 +0000416 dwarf::DW_FORM_data1, RVer);
Bill Wendling2b128d72009-05-20 23:19:06 +0000417
David Blaikiecafd9622014-11-02 08:51:37 +0000418 if (useSplitDwarf())
Rafael Espindola063d7252015-03-10 16:58:10 +0000419 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection());
David Blaikiecafd9622014-11-02 08:51:37 +0000420 else
Rafael Espindola063d7252015-03-10 16:58:10 +0000421 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
Eric Christopherd039baa2013-12-30 03:40:32 +0000422
David Blaikief9b6a552014-04-22 22:39:41 +0000423 CUMap.insert(std::make_pair(DIUnit, &NewCU));
David Blaikie92a2f8a2014-04-28 21:04:29 +0000424 CUDieMap.insert(std::make_pair(&Die, &NewCU));
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000425 return NewCU;
Devang Patel1a0df9a2010-05-10 22:49:55 +0000426}
427
David Blaikie8912df12014-08-31 05:41:15 +0000428void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
429 const MDNode *N) {
David Blaikie1fd43652013-05-07 21:35:53 +0000430 DIImportedEntity Module(N);
David Blaikie5e390e42014-02-04 01:23:52 +0000431 assert(Module.Verify());
David Blaikief9b6a552014-04-22 22:39:41 +0000432 if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
David Blaikiefebfafd2014-10-06 05:37:24 +0000433 D->addChild(TheCU.constructImportedEntityDIE(Module));
David Blaikief55abea2013-04-22 06:12:31 +0000434}
435
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000436// Emit all Dwarf sections that should come prior to the content. Create
437// global DIEs and emit initial debug info sections. This is invoked by
438// the target AsmPrinter.
Eric Christopher58f41952012-11-19 22:42:15 +0000439void DwarfDebug::beginModule() {
Devang Patel6c74a872010-04-27 19:46:33 +0000440 if (DisableDebugInfoPrinting)
441 return;
442
Eric Christopher58f41952012-11-19 22:42:15 +0000443 const Module *M = MMI->getModule();
444
David Blaikie2f040112014-07-25 16:10:16 +0000445 FunctionDIs = makeSubprogramMap(*M);
446
Devang Patele02e5852011-05-03 16:45:22 +0000447 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
David Blaikiedc69ebb2013-03-11 23:39:23 +0000448 if (!CU_Nodes)
Devang Patel07bb9ee2011-08-15 23:47:24 +0000449 return;
Manman Ren60352032013-09-05 18:48:31 +0000450 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
Devang Patele02e5852011-05-03 16:45:22 +0000451
David Blaikiedc69ebb2013-03-11 23:39:23 +0000452 // Emit initial sections so we can reference labels later.
453 emitSectionLabels();
454
David Blaikie47f4b822014-03-19 00:11:28 +0000455 SingleCU = CU_Nodes->getNumOperands() == 1;
David Blaikiee05274d2014-03-18 00:11:48 +0000456
Duncan P. N. Exon Smithde36e802014-11-11 21:30:22 +0000457 for (MDNode *N : CU_Nodes->operands()) {
458 DICompileUnit CUNode(N);
David Blaikief9b6a552014-04-22 22:39:41 +0000459 DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
David Blaikie1fd43652013-05-07 21:35:53 +0000460 DIArray ImportedEntities = CUNode.getImportedEntities();
461 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
David Blaikie684fc532013-05-06 23:33:07 +0000462 ScopesWithImportedEntities.push_back(std::make_pair(
David Blaikie1fd43652013-05-07 21:35:53 +0000463 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
464 ImportedEntities.getElement(i)));
Dario Domizioli5f7008a2015-03-03 18:40:53 +0000465 // Stable sort to preserve the order of appearance of imported entities.
466 // This is to avoid out-of-order processing of interdependent declarations
467 // within the same scope, e.g. { namespace A = base; namespace B = A; }
468 std::stable_sort(ScopesWithImportedEntities.begin(),
469 ScopesWithImportedEntities.end(), less_first());
David Blaikiedc69ebb2013-03-11 23:39:23 +0000470 DIArray GVs = CUNode.getGlobalVariables();
471 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
Frederic Riss9ba9eff2014-09-19 15:12:03 +0000472 CU.getOrCreateGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
David Blaikie6ba88e02014-08-29 22:10:52 +0000473 DIArray SPs = CUNode.getSubprograms();
474 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
475 SPMap.insert(std::make_pair(SPs.getElement(i), &CU));
David Blaikiedc69ebb2013-03-11 23:39:23 +0000476 DIArray EnumTypes = CUNode.getEnumTypes();
Manman Renbd1628a2014-07-28 23:04:20 +0000477 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i) {
478 DIType Ty(EnumTypes.getElement(i));
479 // The enum types array by design contains pointers to
480 // MDNodes rather than DIRefs. Unique them here.
481 DIType UniqueTy(resolve(Ty.getRef()));
482 CU.getOrCreateTypeDIE(UniqueTy);
483 }
David Blaikiedc69ebb2013-03-11 23:39:23 +0000484 DIArray RetainedTypes = CUNode.getRetainedTypes();
Adrian Prantl0aa1aa22014-03-18 02:35:03 +0000485 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
486 DIType Ty(RetainedTypes.getElement(i));
487 // The retained types array by design contains pointers to
488 // MDNodes rather than DIRefs. Unique them here.
489 DIType UniqueTy(resolve(Ty.getRef()));
David Blaikief9b6a552014-04-22 22:39:41 +0000490 CU.getOrCreateTypeDIE(UniqueTy);
Adrian Prantl0aa1aa22014-03-18 02:35:03 +0000491 }
David Blaikief55abea2013-04-22 06:12:31 +0000492 // Emit imported_modules last so that the relevant context is already
493 // available.
David Blaikie1fd43652013-05-07 21:35:53 +0000494 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
David Blaikie8912df12014-08-31 05:41:15 +0000495 constructAndAddImportedEntityDIE(CU, ImportedEntities.getElement(i));
David Blaikiedc69ebb2013-03-11 23:39:23 +0000496 }
Eric Christopher6a841382012-11-19 22:42:10 +0000497
Chris Lattner7cfa70e2010-04-05 02:19:28 +0000498 // Tell MMI that we have debug info.
499 MMI->setDebugInfoAvailability(true);
Bill Wendling2b128d72009-05-20 23:19:06 +0000500}
501
David Blaikieeb1a2722014-06-13 22:18:23 +0000502void DwarfDebug::finishVariableDefinitions() {
503 for (const auto &Var : ConcreteVariables) {
504 DIE *VariableDie = Var->getDIE();
David Blaikief73ae4f2014-08-12 00:00:31 +0000505 assert(VariableDie);
David Blaikieeb1a2722014-06-13 22:18:23 +0000506 // FIXME: Consider the time-space tradeoff of just storing the unit pointer
507 // in the ConcreteVariables list, rather than looking it up again here.
508 // DIE::getUnit isn't simple - it walks parent pointers, etc.
509 DwarfCompileUnit *Unit = lookupUnit(VariableDie->getUnit());
510 assert(Unit);
David Blaikiee847f132014-06-13 22:35:44 +0000511 DbgVariable *AbsVar = getExistingAbstractVariable(Var->getVariable());
David Blaikieeb1a2722014-06-13 22:18:23 +0000512 if (AbsVar && AbsVar->getDIE()) {
513 Unit->addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
514 *AbsVar->getDIE());
515 } else
516 Unit->applyVariableAttributes(*Var, *VariableDie);
517 }
518}
519
David Blaikief7221ad2014-05-27 18:37:43 +0000520void DwarfDebug::finishSubprogramDefinitions() {
David Blaikie7d6f29d2014-10-10 16:59:52 +0000521 for (const auto &P : SPMap)
David Blaikie3a443c22014-11-04 22:12:25 +0000522 forBothCUs(*P.second, [&](DwarfCompileUnit &CU) {
523 CU.finishSubprogramDefinition(DISubprogram(P.first));
524 });
David Blaikief7221ad2014-05-27 18:37:43 +0000525}
526
527
Eric Christopher960ac372012-11-22 00:59:49 +0000528// Collect info for variables that were optimized out.
529void DwarfDebug::collectDeadVariables() {
530 const Module *M = MMI->getModule();
Eric Christopher960ac372012-11-22 00:59:49 +0000531
532 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
Duncan P. N. Exon Smithde36e802014-11-11 21:30:22 +0000533 for (MDNode *N : CU_Nodes->operands()) {
534 DICompileUnit TheCU(N);
David Blaikie9ba72542014-05-14 21:52:46 +0000535 // Construct subprogram DIE and add variables DIEs.
536 DwarfCompileUnit *SPCU =
537 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
538 assert(SPCU && "Unable to find Compile Unit!");
Eric Christopher960ac372012-11-22 00:59:49 +0000539 DIArray Subprograms = TheCU.getSubprograms();
540 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
Eric Christopher735401c2012-11-27 00:13:51 +0000541 DISubprogram SP(Subprograms.getElement(i));
Eric Christophera6c38a32013-10-15 23:31:38 +0000542 if (ProcessedSPNodes.count(SP) != 0)
543 continue;
David Blaikie1d96cc22014-10-31 22:30:30 +0000544 SPCU->collectDeadVariables(SP);
Eric Christopher960ac372012-11-22 00:59:49 +0000545 }
546 }
547 }
Eric Christopher960ac372012-11-22 00:59:49 +0000548}
549
550void DwarfDebug::finalizeModuleInfo() {
Rafael Espindola063d7252015-03-10 16:58:10 +0000551 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
552
David Blaikie3c2fff32014-05-27 18:37:48 +0000553 finishSubprogramDefinitions();
554
David Blaikieeb1a2722014-06-13 22:18:23 +0000555 finishVariableDefinitions();
556
Eric Christopher960ac372012-11-22 00:59:49 +0000557 // Collect info for variables that were optimized out.
558 collectDeadVariables();
559
Eric Christopherad10cb52013-12-04 23:24:38 +0000560 // Handle anything that needs to be done on a per-unit basis after
561 // all other generation.
David Blaikie1998a2e2014-11-01 01:11:19 +0000562 for (const auto &P : CUMap) {
563 auto &TheCU = *P.second;
Eric Christopher60eb7692013-08-12 20:27:48 +0000564 // Emit DW_AT_containing_type attribute to connect types with their
565 // vtable holding type.
David Blaikie1998a2e2014-11-01 01:11:19 +0000566 TheCU.constructContainingTypeDIEs();
Eric Christopher60eb7692013-08-12 20:27:48 +0000567
Eric Christopher46e23432013-12-20 04:16:18 +0000568 // Add CU specific attributes if we need to add any.
David Blaikie1998a2e2014-11-01 01:11:19 +0000569 // If we're splitting the dwarf out now that we've got the entire
570 // CU then add the dwo id to it.
571 auto *SkCU = TheCU.getSkeleton();
572 if (useSplitDwarf()) {
573 // Emit a unique identifier for this CU.
574 uint64_t ID = DIEHash(Asm).computeCUSignature(TheCU.getUnitDie());
575 TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
576 dwarf::DW_FORM_data8, ID);
577 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
578 dwarf::DW_FORM_data8, ID);
David Blaikie3ffe4dd2014-03-25 05:34:24 +0000579
David Blaikie1998a2e2014-11-01 01:11:19 +0000580 // We don't keep track of which addresses are used in which CU so this
581 // is a bit pessimistic under LTO.
Rafael Espindola063d7252015-03-10 16:58:10 +0000582 if (!AddrPool.isEmpty()) {
583 const MCSymbol *Sym = TLOF.getDwarfAddrSection()->getBeginSymbol();
David Blaikie1998a2e2014-11-01 01:11:19 +0000584 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_addr_base,
Rafael Espindola063d7252015-03-10 16:58:10 +0000585 Sym, Sym);
586 }
587 if (!SkCU->getRangeLists().empty()) {
588 const MCSymbol *Sym = TLOF.getDwarfRangesSection()->getBeginSymbol();
David Blaikie1998a2e2014-11-01 01:11:19 +0000589 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
Rafael Espindola063d7252015-03-10 16:58:10 +0000590 Sym, Sym);
591 }
David Blaikie1998a2e2014-11-01 01:11:19 +0000592 }
Eric Christopherd8667202013-12-30 17:22:27 +0000593
David Blaikie1998a2e2014-11-01 01:11:19 +0000594 // If we have code split among multiple sections or non-contiguous
595 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
596 // remain in the .o file, otherwise add a DW_AT_low_pc.
597 // FIXME: We should use ranges allow reordering of code ala
598 // .subsections_via_symbols in mach-o. This would mean turning on
599 // ranges for all subprogram DIEs for mach-o.
David Blaikiea8be0a72014-11-01 01:15:24 +0000600 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
David Blaikie5b02a192014-11-03 23:10:59 +0000601 if (unsigned NumRanges = TheCU.getRanges().size()) {
602 if (NumRanges > 1)
David Blaikie1998a2e2014-11-01 01:11:19 +0000603 // A DW_AT_low_pc attribute may also be specified in combination with
604 // DW_AT_ranges to specify the default base address for use in
605 // location lists (see Section 2.6.2) and range lists (see Section
606 // 2.17.3).
607 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
David Blaikie5b02a192014-11-03 23:10:59 +0000608 else
609 TheCU.setBaseAddress(TheCU.getRanges().front().getStart());
610 U.attachRangesOrLowHighPC(U.getUnitDie(), TheCU.takeRanges());
Eric Christopher60eb7692013-08-12 20:27:48 +0000611 }
612 }
613
614 // Compute DIE offsets and sizes.
Eric Christopherc8a310e2012-12-10 23:34:43 +0000615 InfoHolder.computeSizeAndOffsets();
616 if (useSplitDwarf())
617 SkeletonHolder.computeSizeAndOffsets();
Eric Christopher960ac372012-11-22 00:59:49 +0000618}
619
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000620// Emit all Dwarf sections that should come after the content.
Eric Christopher960ac372012-11-22 00:59:49 +0000621void DwarfDebug::endModule() {
Rafael Espindola063d7252015-03-10 16:58:10 +0000622 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Craig Toppere73658d2014-04-28 04:05:08 +0000623 assert(CurFn == nullptr);
624 assert(CurMI == nullptr);
Eric Christopher960ac372012-11-22 00:59:49 +0000625
David Blaikie0dc623c2014-10-24 17:53:38 +0000626 // If we aren't actually generating debug info (check beginModule -
627 // conditionalized on !DisableDebugInfoPrinting and the presence of the
628 // llvm.dbg.cu metadata node)
Rafael Espindola6b9998b2015-03-10 22:00:25 +0000629 if (!TLOF.getDwarfInfoSection()->getBeginSymbol()->isInSection())
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000630 return;
Eric Christopher960ac372012-11-22 00:59:49 +0000631
Eric Christopher960ac372012-11-22 00:59:49 +0000632 // Finalize the debug info for the module.
633 finalizeModuleInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +0000634
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000635 emitDebugStr();
Eric Christopher9cd26af2013-09-20 23:22:52 +0000636
Rafael Espindola063d7252015-03-10 16:58:10 +0000637 if (useSplitDwarf())
638 emitDebugLocDWO();
639 else
640 // Emit info into a debug loc section.
641 emitDebugLoc();
642
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000643 // Emit all the DIEs into a debug info section.
644 emitDebugInfo();
Eric Christopher4c9b1192012-11-27 00:41:54 +0000645
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000646 // Corresponding abbreviations into a abbrev section.
647 emitAbbreviations();
Eric Christopher95198f502012-11-27 22:43:42 +0000648
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000649 // Emit info into a debug aranges section.
Eric Christopher02dbadb2014-02-14 01:26:55 +0000650 if (GenerateARangeSection)
651 emitDebugARanges();
Eric Christopher95198f502012-11-27 22:43:42 +0000652
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000653 // Emit info into a debug ranges section.
654 emitDebugRanges();
Eric Christopher95198f502012-11-27 22:43:42 +0000655
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000656 if (useSplitDwarf()) {
657 emitDebugStrDWO();
Eric Christopher9c2ecd92012-11-30 23:59:06 +0000658 emitDebugInfoDWO();
Eric Christopher3c5a1912012-12-19 22:02:53 +0000659 emitDebugAbbrevDWO();
David Blaikie4a2f95f2014-03-18 01:17:26 +0000660 emitDebugLineDWO();
Eric Christopher962c9082013-01-15 23:56:56 +0000661 // Emit DWO addresses.
David Blaikied75fb282014-04-23 21:20:10 +0000662 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
Rafael Espindola063d7252015-03-10 16:58:10 +0000663 }
Bill Wendling2b128d72009-05-20 23:19:06 +0000664
Eric Christophera876b822012-08-23 07:32:06 +0000665 // Emit info into the dwarf accelerator table sections.
Eric Christopher20b76a72012-08-23 22:36:40 +0000666 if (useDwarfAccelTables()) {
Eric Christopher4996c702011-11-07 09:24:32 +0000667 emitAccelNames();
668 emitAccelObjC();
669 emitAccelNamespaces();
670 emitAccelTypes();
671 }
Eric Christopher6a841382012-11-19 22:42:10 +0000672
Eric Christopher4b358182013-08-30 00:40:17 +0000673 // Emit the pubnames and pubtypes sections if requested.
674 if (HasDwarfPubSections) {
David Blaikie70a33202013-09-19 17:33:35 +0000675 emitDebugPubNames(GenerateGnuPubSections);
676 emitDebugPubTypes(GenerateGnuPubSections);
Eric Christopher4b358182013-08-30 00:40:17 +0000677 }
Devang Patel04d2f2d2009-11-24 01:14:22 +0000678
Devang Pateld0701282010-08-02 17:32:15 +0000679 // clean up.
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000680 SPMap.clear();
David Blaikie825bdd22014-05-21 22:41:17 +0000681 AbstractVariables.clear();
Bill Wendling2b128d72009-05-20 23:19:06 +0000682}
683
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000684// Find abstract variable, if any, associated with Var.
David Blaikiebe7c6772014-06-13 22:29:31 +0000685DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV,
David Blaikie36408e72014-06-04 23:50:52 +0000686 DIVariable &Cleansed) {
Devang Patelbb23a4a2011-08-10 21:50:54 +0000687 LLVMContext &Ctx = DV->getContext();
688 // More then one inlined variable corresponds to one abstract variable.
David Blaikie36408e72014-06-04 23:50:52 +0000689 // FIXME: This duplication of variables when inlining should probably be
690 // removed. It's done to allow each DIVariable to describe its location
691 // because the DebugLoc on the dbg.value/declare isn't accurate. We should
692 // make it accurate then remove this duplication/cleansing stuff.
693 Cleansed = cleanseInlinedVariable(DV, Ctx);
694 auto I = AbstractVariables.find(Cleansed);
David Blaikie825bdd22014-05-21 22:41:17 +0000695 if (I != AbstractVariables.end())
696 return I->second.get();
David Blaikie36408e72014-06-04 23:50:52 +0000697 return nullptr;
698}
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000699
David Blaikiee847f132014-06-13 22:35:44 +0000700DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV) {
701 DIVariable Cleansed;
702 return getExistingAbstractVariable(DV, Cleansed);
703}
704
David Blaikie6f9e8672014-06-13 23:52:55 +0000705void DwarfDebug::createAbstractVariable(const DIVariable &Var,
706 LexicalScope *Scope) {
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000707 auto AbsDbgVariable = make_unique<DbgVariable>(Var, DIExpression(), this);
David Blaikief4c504e2014-10-24 00:43:47 +0000708 InfoHolder.addScopeVariable(Scope, AbsDbgVariable.get());
David Blaikie6f9e8672014-06-13 23:52:55 +0000709 AbstractVariables[Var] = std::move(AbsDbgVariable);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000710}
711
David Blaikie6f9e8672014-06-13 23:52:55 +0000712void DwarfDebug::ensureAbstractVariableIsCreated(const DIVariable &DV,
713 const MDNode *ScopeNode) {
David Blaikie36408e72014-06-04 23:50:52 +0000714 DIVariable Cleansed = DV;
David Blaikie6f9e8672014-06-13 23:52:55 +0000715 if (getExistingAbstractVariable(DV, Cleansed))
716 return;
David Blaikie36408e72014-06-04 23:50:52 +0000717
David Blaikie6f9e8672014-06-13 23:52:55 +0000718 createAbstractVariable(Cleansed, LScopes.getOrCreateAbstractScope(ScopeNode));
David Blaikie36408e72014-06-04 23:50:52 +0000719}
720
David Blaikie6f9e8672014-06-13 23:52:55 +0000721void
722DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(const DIVariable &DV,
723 const MDNode *ScopeNode) {
David Blaikie36408e72014-06-04 23:50:52 +0000724 DIVariable Cleansed = DV;
David Blaikie6f9e8672014-06-13 23:52:55 +0000725 if (getExistingAbstractVariable(DV, Cleansed))
726 return;
David Blaikie36408e72014-06-04 23:50:52 +0000727
728 if (LexicalScope *Scope = LScopes.findAbstractScope(ScopeNode))
David Blaikie6f9e8672014-06-13 23:52:55 +0000729 createAbstractVariable(Cleansed, Scope);
David Blaikie36408e72014-06-04 23:50:52 +0000730}
731
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000732// Collect variable information from side table maintained by MMI.
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000733void DwarfDebug::collectVariableInfoFromMMITable(
Craig Topper71b7b682014-08-21 05:55:13 +0000734 SmallPtrSetImpl<const MDNode *> &Processed) {
Benjamin Kramer15596c72014-03-07 19:09:39 +0000735 for (const auto &VI : MMI->getVariableDbgInfo()) {
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +0000736 if (!VI.Var)
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000737 continue;
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +0000738 Processed.insert(VI.Var);
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +0000739 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000740
Devang Patelcdb7d442009-11-10 23:20:04 +0000741 // If variable scope is not found then skip this variable.
Craig Topper353eda42014-04-24 06:44:33 +0000742 if (!Scope)
Devang Patelcdb7d442009-11-10 23:20:04 +0000743 continue;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000744
David Blaikieff468a52014-10-28 02:57:26 +0000745 DIVariable DV(VI.Var);
746 DIExpression Expr(VI.Expr);
David Blaikie6f9e8672014-06-13 23:52:55 +0000747 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
Adrian Prantlca7e4702015-02-10 23:18:28 +0000748 auto RegVar = make_unique<DbgVariable>(DV, Expr, this, VI.Slot);
749 if (InfoHolder.addScopeVariable(Scope, RegVar.get()))
750 ConcreteVariables.push_back(std::move(RegVar));
Devang Patel475d32a2009-10-06 01:26:37 +0000751 }
Devang Patel490c8ab2010-05-20 19:57:06 +0000752}
Devang Patela3e9c9c2010-03-15 18:33:46 +0000753
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000754// Get .debug_loc entry for the instruction range starting at MI.
Adrian Prantle19e5ef2014-04-27 18:25:40 +0000755static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000756 const MDNode *Expr = MI->getDebugExpression();
Adrian Prantl7f487772014-04-10 17:39:48 +0000757 const MDNode *Var = MI->getDebugVariable();
Devang Patel2442a892011-07-08 17:09:57 +0000758
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000759 assert(MI->getNumOperands() == 4);
Adrian Prantl418d1d12013-07-09 20:28:37 +0000760 if (MI->getOperand(0).isReg()) {
Devang Patel2442a892011-07-08 17:09:57 +0000761 MachineLocation MLoc;
Adrian Prantl418d1d12013-07-09 20:28:37 +0000762 // If the second operand is an immediate, this is a
763 // register-indirect address.
764 if (!MI->getOperand(1).isImm())
Adrian Prantld4c0dd42013-04-26 21:57:17 +0000765 MLoc.set(MI->getOperand(0).getReg());
766 else
767 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000768 return DebugLocEntry::Value(Var, Expr, MLoc);
Devang Patel2442a892011-07-08 17:09:57 +0000769 }
770 if (MI->getOperand(0).isImm())
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000771 return DebugLocEntry::Value(Var, Expr, MI->getOperand(0).getImm());
Devang Patel2442a892011-07-08 17:09:57 +0000772 if (MI->getOperand(0).isFPImm())
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000773 return DebugLocEntry::Value(Var, Expr, MI->getOperand(0).getFPImm());
Devang Patel2442a892011-07-08 17:09:57 +0000774 if (MI->getOperand(0).isCImm())
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000775 return DebugLocEntry::Value(Var, Expr, MI->getOperand(0).getCImm());
Devang Patel2442a892011-07-08 17:09:57 +0000776
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000777 llvm_unreachable("Unexpected 4-operand DBG_VALUE instruction!");
Devang Patel2442a892011-07-08 17:09:57 +0000778}
779
Adrian Prantlb1416832014-08-01 22:11:58 +0000780/// Determine whether two variable pieces overlap.
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000781static bool piecesOverlap(DIExpression P1, DIExpression P2) {
Adrian Prantl27bd01f2015-02-09 23:57:15 +0000782 if (!P1.isBitPiece() || !P2.isBitPiece())
Adrian Prantlb1416832014-08-01 22:11:58 +0000783 return true;
Adrian Prantl27bd01f2015-02-09 23:57:15 +0000784 unsigned l1 = P1.getBitPieceOffset();
785 unsigned l2 = P2.getBitPieceOffset();
786 unsigned r1 = l1 + P1.getBitPieceSize();
787 unsigned r2 = l2 + P2.getBitPieceSize();
Adrian Prantlb1416832014-08-01 22:11:58 +0000788 // True where [l1,r1[ and [r1,r2[ overlap.
789 return (l1 < r2) && (l2 < r1);
790}
791
792/// Build the location list for all DBG_VALUEs in the function that
793/// describe the same variable. If the ranges of several independent
794/// pieces of the same variable overlap partially, split them up and
795/// combine the ranges. The resulting DebugLocEntries are will have
796/// strict monotonically increasing begin addresses and will never
797/// overlap.
798//
799// Input:
800//
801// Ranges History [var, loc, piece ofs size]
802// 0 | [x, (reg0, piece 0, 32)]
803// 1 | | [x, (reg1, piece 32, 32)] <- IsPieceOfPrevEntry
804// 2 | | ...
805// 3 | [clobber reg0]
Eric Christopherffc5ff32015-02-17 20:02:28 +0000806// 4 [x, (mem, piece 0, 64)] <- overlapping with both previous pieces of
807// x.
Adrian Prantlb1416832014-08-01 22:11:58 +0000808//
809// Output:
810//
811// [0-1] [x, (reg0, piece 0, 32)]
812// [1-3] [x, (reg0, piece 0, 32), (reg1, piece 32, 32)]
813// [3-4] [x, (reg1, piece 32, 32)]
814// [4- ] [x, (mem, piece 0, 64)]
David Blaikiee1a26a62014-08-05 23:14:16 +0000815void
816DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
817 const DbgValueHistoryMap::InstrRanges &Ranges) {
Adrian Prantlcaaf0532014-08-11 21:05:57 +0000818 SmallVector<DebugLocEntry::Value, 4> OpenRanges;
Adrian Prantlb1416832014-08-01 22:11:58 +0000819
820 for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
821 const MachineInstr *Begin = I->first;
822 const MachineInstr *End = I->second;
823 assert(Begin->isDebugValue() && "Invalid History entry");
824
825 // Check if a variable is inaccessible in this range.
Adrian Prantl5e1fa852014-08-12 21:55:58 +0000826 if (Begin->getNumOperands() > 1 &&
827 Begin->getOperand(0).isReg() && !Begin->getOperand(0).getReg()) {
Adrian Prantlb1416832014-08-01 22:11:58 +0000828 OpenRanges.clear();
829 continue;
830 }
831
832 // If this piece overlaps with any open ranges, truncate them.
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000833 DIExpression DIExpr = Begin->getDebugExpression();
Adrian Prantlcaaf0532014-08-11 21:05:57 +0000834 auto Last = std::remove_if(OpenRanges.begin(), OpenRanges.end(),
Adrian Prantl76502d82014-08-11 23:22:59 +0000835 [&](DebugLocEntry::Value R) {
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000836 return piecesOverlap(DIExpr, R.getExpression());
837 });
Adrian Prantlb1416832014-08-01 22:11:58 +0000838 OpenRanges.erase(Last, OpenRanges.end());
839
840 const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
841 assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
842
843 const MCSymbol *EndLabel;
844 if (End != nullptr)
845 EndLabel = getLabelAfterInsn(End);
846 else if (std::next(I) == Ranges.end())
Rafael Espindola07c03d32015-03-05 02:05:42 +0000847 EndLabel = Asm->getFunctionEnd();
Adrian Prantlb1416832014-08-01 22:11:58 +0000848 else
849 EndLabel = getLabelBeforeInsn(std::next(I)->first);
850 assert(EndLabel && "Forgot label after instruction ending a range!");
851
852 DEBUG(dbgs() << "DotDebugLoc: " << *Begin << "\n");
853
854 auto Value = getDebugLocValue(Begin);
David Blaikiee1a26a62014-08-05 23:14:16 +0000855 DebugLocEntry Loc(StartLabel, EndLabel, Value);
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000856 bool couldMerge = false;
857
858 // If this is a piece, it may belong to the current DebugLocEntry.
Adrian Prantl27bd01f2015-02-09 23:57:15 +0000859 if (DIExpr.isBitPiece()) {
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000860 // Add this value to the list of open ranges.
Adrian Prantlcaaf0532014-08-11 21:05:57 +0000861 OpenRanges.push_back(Value);
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000862
863 // Attempt to add the piece to the last entry.
864 if (!DebugLoc.empty())
865 if (DebugLoc.back().MergeValues(Loc))
866 couldMerge = true;
867 }
868
869 if (!couldMerge) {
870 // Need to add a new DebugLocEntry. Add all values from still
871 // valid non-overlapping pieces.
Adrian Prantl1c6f2ec2014-08-11 21:06:00 +0000872 if (OpenRanges.size())
873 Loc.addValues(OpenRanges);
874
Adrian Prantlb1416832014-08-01 22:11:58 +0000875 DebugLoc.push_back(std::move(Loc));
876 }
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000877
878 // Attempt to coalesce the ranges of two otherwise identical
879 // DebugLocEntries.
880 auto CurEntry = DebugLoc.rbegin();
881 auto PrevEntry = std::next(CurEntry);
882 if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
883 DebugLoc.pop_back();
Adrian Prantlb1416832014-08-01 22:11:58 +0000884
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000885 DEBUG({
886 dbgs() << CurEntry->getValues().size() << " Values:\n";
887 for (auto Value : CurEntry->getValues()) {
888 Value.getVariable()->dump();
889 Value.getExpression()->dump();
890 }
891 dbgs() << "-----\n";
892 });
Adrian Prantlb1416832014-08-01 22:11:58 +0000893 }
894}
895
896
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000897// Find variables for each lexical scope.
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000898void
David Blaikie263a0082014-10-23 00:06:27 +0000899DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU, DISubprogram SP,
900 SmallPtrSetImpl<const MDNode *> &Processed) {
Eric Christopher270a12c2013-07-03 21:37:03 +0000901 // Grab the variable info that was squirreled away in the MMI side-table.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +0000902 collectVariableInfoFromMMITable(Processed);
Devang Patel490c8ab2010-05-20 19:57:06 +0000903
Alexey Samsonov0436caa2014-04-30 23:02:40 +0000904 for (const auto &I : DbgValues) {
905 DIVariable DV(I.first);
906 if (Processed.count(DV))
Devang Patel490c8ab2010-05-20 19:57:06 +0000907 continue;
908
Alexey Samsonovbb2990d2014-05-27 23:09:50 +0000909 // Instruction ranges, specifying where DV is accessible.
910 const auto &Ranges = I.second;
911 if (Ranges.empty())
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +0000912 continue;
Devang Patel9fc11702010-05-25 23:40:22 +0000913
Craig Topper353eda42014-04-24 06:44:33 +0000914 LexicalScope *Scope = nullptr;
Duncan P. N. Exon Smithb4749372015-02-17 00:02:27 +0000915 if (MDNode *IA = DV.getInlinedAt())
916 Scope = LScopes.findInlinedScope(DV.getContext(), IA);
917 else
David Blaikie9b8c8cd2014-05-14 01:08:28 +0000918 Scope = LScopes.findLexicalScope(DV.getContext());
Devang Patel490c8ab2010-05-20 19:57:06 +0000919 // If variable scope is not found then skip this variable.
Devang Patelfbd6c452010-05-21 00:10:20 +0000920 if (!Scope)
Devang Patel490c8ab2010-05-20 19:57:06 +0000921 continue;
922
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000923 Processed.insert(DV);
Alexey Samsonovbb2990d2014-05-27 23:09:50 +0000924 const MachineInstr *MInsn = Ranges.front().first;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +0000925 assert(MInsn->isDebugValue() && "History must begin with debug value");
David Blaikie6f9e8672014-06-13 23:52:55 +0000926 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
927 ConcreteVariables.push_back(make_unique<DbgVariable>(MInsn, this));
David Blaikieeb1a2722014-06-13 22:18:23 +0000928 DbgVariable *RegVar = ConcreteVariables.back().get();
David Blaikief4c504e2014-10-24 00:43:47 +0000929 InfoHolder.addScopeVariable(Scope, RegVar);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +0000930
Alexey Samsonovbb2990d2014-05-27 23:09:50 +0000931 // Check if the first DBG_VALUE is valid for the rest of the function.
Adrian Prantlc1197542014-05-30 21:10:13 +0000932 if (Ranges.size() == 1 && Ranges.front().second == nullptr)
Devang Patel9fc11702010-05-25 23:40:22 +0000933 continue;
Devang Patel9fc11702010-05-25 23:40:22 +0000934
Eric Christopher59cc0712013-01-28 17:33:26 +0000935 // Handle multiple DBG_VALUE instructions describing one variable.
David Blaikieafd2c6b2014-04-22 05:41:06 +0000936 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +0000937
David Blaikie0a456de2014-04-02 01:43:18 +0000938 DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
939 DebugLocList &LocList = DotDebugLocEntries.back();
David Blaikie263a0082014-10-23 00:06:27 +0000940 LocList.CU = &TheCU;
David Blaikie0a456de2014-04-02 01:43:18 +0000941 LocList.Label =
942 Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
Jakob Stoklund Olesen9c057ee2011-03-22 00:21:41 +0000943
Adrian Prantlb1416832014-08-01 22:11:58 +0000944 // Build the location list for this variable.
David Blaikiee1a26a62014-08-05 23:14:16 +0000945 buildLocationList(LocList.List, Ranges);
Adrian Prantl92da14b2015-03-02 22:02:33 +0000946 // Finalize the entry by lowering it into a DWARF bytestream.
947 for (auto &Entry : LocList.List)
948 Entry.finalize(*Asm, TypeIdentifierMap);
Devang Patela3e9c9c2010-03-15 18:33:46 +0000949 }
Devang Patele0a94bf2010-05-14 21:01:35 +0000950
951 // Collect info for variables that were optimized out.
David Blaikie263a0082014-10-23 00:06:27 +0000952 DIArray Variables = SP.getVariables();
Devang Patel59e27c52011-08-19 23:28:12 +0000953 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
954 DIVariable DV(Variables.getElement(i));
David Blaikie9ba72542014-05-14 21:52:46 +0000955 assert(DV.isVariable());
David Blaikie70573dc2014-11-19 07:49:26 +0000956 if (!Processed.insert(DV).second)
Devang Patel59e27c52011-08-19 23:28:12 +0000957 continue;
David Blaikiebb6a4e22014-06-05 00:51:35 +0000958 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext())) {
David Blaikie6f9e8672014-06-13 23:52:55 +0000959 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000960 DIExpression NoExpr;
961 ConcreteVariables.push_back(make_unique<DbgVariable>(DV, NoExpr, this));
David Blaikief4c504e2014-10-24 00:43:47 +0000962 InfoHolder.addScopeVariable(Scope, ConcreteVariables.back().get());
David Blaikiebb6a4e22014-06-05 00:51:35 +0000963 }
Devang Patele0a94bf2010-05-14 21:01:35 +0000964 }
Devang Patel9fc11702010-05-25 23:40:22 +0000965}
Devang Patele0a94bf2010-05-14 21:01:35 +0000966
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000967// Return Label preceding the instruction.
Eric Christopher962c9082013-01-15 23:56:56 +0000968MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +0000969 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
970 assert(Label && "Didn't insert label before instruction");
971 return Label;
Devang Patel9fc11702010-05-25 23:40:22 +0000972}
973
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000974// Return Label immediately following the instruction.
Eric Christopher962c9082013-01-15 23:56:56 +0000975MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +0000976 return LabelsAfterInsn.lookup(MI);
Devang Patel475d32a2009-10-06 01:26:37 +0000977}
978
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000979// Process beginning of an instruction.
Devang Patelb5694e72010-10-26 17:49:02 +0000980void DwarfDebug::beginInstruction(const MachineInstr *MI) {
Craig Toppere73658d2014-04-28 04:05:08 +0000981 assert(CurMI == nullptr);
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +0000982 CurMI = MI;
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +0000983 // Check if source location changes, but ignore DBG_VALUE locations.
984 if (!MI->isDebugValue()) {
985 DebugLoc DL = MI->getDebugLoc();
986 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
Eric Christopheraec8a822012-04-05 20:39:05 +0000987 unsigned Flags = 0;
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +0000988 PrevInstLoc = DL;
Devang Patel34a66202011-05-11 19:22:19 +0000989 if (DL == PrologEndLoc) {
990 Flags |= DWARF2_FLAG_PROLOGUE_END;
991 PrologEndLoc = DebugLoc();
David Blaikieaeaa5bf2014-12-30 22:47:13 +0000992 Flags |= DWARF2_FLAG_IS_STMT;
Devang Patel34a66202011-05-11 19:22:19 +0000993 }
David Blaikieaeaa5bf2014-12-30 22:47:13 +0000994 if (DL.getLine() !=
995 Asm->OutStreamer.getContext().getCurrentDwarfLoc().getLine())
Eric Christopheraec8a822012-04-05 20:39:05 +0000996 Flags |= DWARF2_FLAG_IS_STMT;
997
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +0000998 if (!DL.isUnknown()) {
999 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
Devang Patel34a66202011-05-11 19:22:19 +00001000 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001001 } else
Craig Topper353eda42014-04-24 06:44:33 +00001002 recordSourceLine(0, 0, nullptr, 0);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001003 }
Devang Patel9fc11702010-05-25 23:40:22 +00001004 }
Devang Patel23b2ae62010-03-29 22:59:58 +00001005
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001006 // Insert labels where requested.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001007 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1008 LabelsBeforeInsn.find(MI);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001009
1010 // No label needed.
1011 if (I == LabelsBeforeInsn.end())
1012 return;
1013
1014 // Label already assigned.
1015 if (I->second)
Devang Patel002d54d2010-05-26 19:37:24 +00001016 return;
Devang Patelbd477be2010-03-29 17:20:31 +00001017
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001018 if (!PrevLabel) {
Devang Patelacc32a52010-05-26 21:23:46 +00001019 PrevLabel = MMI->getContext().CreateTempSymbol();
1020 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel002d54d2010-05-26 19:37:24 +00001021 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001022 I->second = PrevLabel;
Devang Patel8db360d2009-10-06 01:50:42 +00001023}
1024
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001025// Process end of an instruction.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001026void DwarfDebug::endInstruction() {
Craig Toppere73658d2014-04-28 04:05:08 +00001027 assert(CurMI != nullptr);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001028 // Don't create a new label after DBG_VALUE instructions.
1029 // They don't generate code.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001030 if (!CurMI->isDebugValue())
Craig Topper353eda42014-04-24 06:44:33 +00001031 PrevLabel = nullptr;
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001032
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001033 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001034 LabelsAfterInsn.find(CurMI);
Craig Topper353eda42014-04-24 06:44:33 +00001035 CurMI = nullptr;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001036
1037 // No label needed.
1038 if (I == LabelsAfterInsn.end())
1039 return;
1040
1041 // Label already assigned.
1042 if (I->second)
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001043 return;
1044
1045 // We need a label after this instruction.
1046 if (!PrevLabel) {
1047 PrevLabel = MMI->getContext().CreateTempSymbol();
1048 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel3ebd8932010-04-08 16:50:29 +00001049 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001050 I->second = PrevLabel;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001051}
1052
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001053// Each LexicalScope has first instruction and last instruction to mark
1054// beginning and end of a scope respectively. Create an inverse map that list
1055// scopes starts (and ends) with an instruction. One instruction may start (or
1056// end) multiple scopes. Ignore scopes that are not reachable.
Devang Patel359b0132010-04-08 18:43:56 +00001057void DwarfDebug::identifyScopeMarkers() {
Devang Patel7e623022011-08-10 20:55:27 +00001058 SmallVector<LexicalScope *, 4> WorkList;
1059 WorkList.push_back(LScopes.getCurrentFunctionScope());
Devang Patel7771b7c2010-01-20 02:05:23 +00001060 while (!WorkList.empty()) {
Devang Patel7e623022011-08-10 20:55:27 +00001061 LexicalScope *S = WorkList.pop_back_val();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001062
Craig Topper977e9cd2013-07-03 04:24:43 +00001063 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001064 if (!Children.empty())
Benjamin Kramer15596c72014-03-07 19:09:39 +00001065 WorkList.append(Children.begin(), Children.end());
Devang Patel7771b7c2010-01-20 02:05:23 +00001066
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001067 if (S->isAbstractScope())
1068 continue;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001069
Benjamin Kramer15596c72014-03-07 19:09:39 +00001070 for (const InsnRange &R : S->getRanges()) {
1071 assert(R.first && "InsnRange does not have first instruction!");
1072 assert(R.second && "InsnRange does not have second instruction!");
1073 requestLabelBeforeInsn(R.first);
1074 requestLabelAfterInsn(R.second);
Devang Patel6c74a872010-04-27 19:46:33 +00001075 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001076 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001077}
1078
Alexey Samsonov8a86d6d2014-05-27 22:47:41 +00001079static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1080 // First known non-DBG_VALUE and non-frame setup location marks
1081 // the beginning of the function body.
1082 for (const auto &MBB : *MF)
1083 for (const auto &MI : MBB)
1084 if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
Saleem Abdulrasoolfc07c722015-01-24 20:19:45 +00001085 !MI.getDebugLoc().isUnknown()) {
Adrian Prantlb9fa9452014-12-16 00:20:49 +00001086 // Did the target forget to set the FrameSetup flag for CFI insns?
1087 assert(!MI.isCFIInstruction() &&
1088 "First non-frame-setup instruction is a CFI instruction.");
Alexey Samsonov8a86d6d2014-05-27 22:47:41 +00001089 return MI.getDebugLoc();
Adrian Prantlb9fa9452014-12-16 00:20:49 +00001090 }
Alexey Samsonov8a86d6d2014-05-27 22:47:41 +00001091 return DebugLoc();
1092}
1093
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001094// Gather pre-function debug information. Assumes being called immediately
1095// after the function entry point has been emitted.
Chris Lattner76555b52010-01-26 23:18:02 +00001096void DwarfDebug::beginFunction(const MachineFunction *MF) {
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001097 CurFn = MF;
Eric Christopherfedfa442013-11-01 23:14:17 +00001098
1099 // If there's no debug info for the function we're not going to do anything.
1100 if (!MMI->hasDebugInfo())
1101 return;
1102
David Blaikie2f040112014-07-25 16:10:16 +00001103 auto DI = FunctionDIs.find(MF->getFunction());
1104 if (DI == FunctionDIs.end())
1105 return;
1106
Eric Christopherfedfa442013-11-01 23:14:17 +00001107 // Grab the lexical scopes for the function, if we don't have any of those
1108 // then we're not going to be able to do anything.
Devang Patel7e623022011-08-10 20:55:27 +00001109 LScopes.initialize(*MF);
Eric Christopher384f3fe2014-03-20 19:16:16 +00001110 if (LScopes.empty())
Eric Christopherfedfa442013-11-01 23:14:17 +00001111 return;
1112
Alexey Samsonov0436caa2014-04-30 23:02:40 +00001113 assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
Eric Christopherfedfa442013-11-01 23:14:17 +00001114
1115 // Make sure that each lexical scope will have a begin/end label.
Devang Patel7e623022011-08-10 20:55:27 +00001116 identifyScopeMarkers();
Devang Patel4598eb62009-10-06 18:37:31 +00001117
Eric Christopher4287a492013-12-09 23:57:44 +00001118 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
Eric Christopherfedfa442013-11-01 23:14:17 +00001119 // belongs to so that we add to the correct per-cu line table in the
1120 // non-asm case.
Manman Ren4e042a62013-02-05 21:52:47 +00001121 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
David Blaikie2f040112014-07-25 16:10:16 +00001122 // FnScope->getScopeNode() and DI->second should represent the same function,
1123 // though they may not be the same MDNode due to inline functions merged in
1124 // LTO where the debug info metadata still differs (either due to distinct
1125 // written differences - two versions of a linkonce_odr function
1126 // written/copied into two separate files, or some sub-optimal metadata that
1127 // isn't structurally identical (see: file path/name info from clang, which
1128 // includes the directory of the cpp file being built, even when the file name
1129 // is absolute (such as an <> lookup header)))
Eric Christopher4287a492013-12-09 23:57:44 +00001130 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
Manman Ren4e042a62013-02-05 21:52:47 +00001131 assert(TheCU && "Unable to find compile unit!");
Rafael Espindolab4eec1d2014-02-05 18:00:21 +00001132 if (Asm->OutStreamer.hasRawTextSupport())
1133 // Use a single line table if we are generating assembly.
Manman Ren9d4c7352013-05-21 00:57:22 +00001134 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1135 else
1136 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
Manman Ren4e042a62013-02-05 21:52:47 +00001137
Alexey Samsonov414b6fb2014-04-30 21:34:11 +00001138 // Calculate history for local variables.
Eric Christopherd4e723f2015-02-20 22:36:11 +00001139 calculateDbgValueHistory(MF, Asm->MF->getSubtarget().getRegisterInfo(),
Eric Christopherd9134482014-08-04 21:25:23 +00001140 DbgValues);
Alexey Samsonov414b6fb2014-04-30 21:34:11 +00001141
1142 // Request labels for the full history.
Alexey Samsonovbb2990d2014-05-27 23:09:50 +00001143 for (const auto &I : DbgValues) {
1144 const auto &Ranges = I.second;
1145 if (Ranges.empty())
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001146 continue;
1147
Rafael Espindola07c03d32015-03-05 02:05:42 +00001148 // The first mention of a function argument gets the CurrentFnBegin
Alexey Samsonov414b6fb2014-04-30 21:34:11 +00001149 // label, so arguments are visible when breaking at function entry.
Adrian Prantl87b7eb92014-10-01 18:55:02 +00001150 DIVariable DIVar(Ranges.front().first->getDebugVariable());
1151 if (DIVar.isVariable() && DIVar.getTag() == dwarf::DW_TAG_arg_variable &&
1152 getDISubprogram(DIVar.getContext()).describes(MF->getFunction())) {
Rafael Espindola07c03d32015-03-05 02:05:42 +00001153 LabelsBeforeInsn[Ranges.front().first] = Asm->getFunctionBegin();
Adrian Prantl27bd01f2015-02-09 23:57:15 +00001154 if (Ranges.front().first->getDebugExpression().isBitPiece()) {
Adrian Prantlb1416832014-08-01 22:11:58 +00001155 // Mark all non-overlapping initial pieces.
1156 for (auto I = Ranges.begin(); I != Ranges.end(); ++I) {
Adrian Prantl87b7eb92014-10-01 18:55:02 +00001157 DIExpression Piece = I->first->getDebugExpression();
Adrian Prantlb1416832014-08-01 22:11:58 +00001158 if (std::all_of(Ranges.begin(), I,
Adrian Prantl87b7eb92014-10-01 18:55:02 +00001159 [&](DbgValueHistoryMap::InstrRange Pred) {
1160 return !piecesOverlap(Piece, Pred.first->getDebugExpression());
Adrian Prantlb1416832014-08-01 22:11:58 +00001161 }))
Rafael Espindola07c03d32015-03-05 02:05:42 +00001162 LabelsBeforeInsn[I->first] = Asm->getFunctionBegin();
Adrian Prantlb1416832014-08-01 22:11:58 +00001163 else
1164 break;
1165 }
1166 }
1167 }
Alexey Samsonov414b6fb2014-04-30 21:34:11 +00001168
Alexey Samsonovbb2990d2014-05-27 23:09:50 +00001169 for (const auto &Range : Ranges) {
1170 requestLabelBeforeInsn(Range.first);
1171 if (Range.second)
1172 requestLabelAfterInsn(Range.second);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001173 }
1174 }
Devang Patel002d54d2010-05-26 19:37:24 +00001175
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001176 PrevInstLoc = DebugLoc();
Rafael Espindola07c03d32015-03-05 02:05:42 +00001177 PrevLabel = Asm->getFunctionBegin();
Devang Patel34a66202011-05-11 19:22:19 +00001178
1179 // Record beginning of function.
Alexey Samsonov8a86d6d2014-05-27 22:47:41 +00001180 PrologEndLoc = findPrologueEndLoc(MF);
Devang Patel34a66202011-05-11 19:22:19 +00001181 if (!PrologEndLoc.isUnknown()) {
Eric Christopherfedfa442013-11-01 23:14:17 +00001182 DebugLoc FnStartDL =
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +00001183 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
Saleem Abdulrasoolfc07c722015-01-24 20:19:45 +00001184
1185 // We'd like to list the prologue as "not statements" but GDB behaves
1186 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1187 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1188 FnStartDL.getScope(MF->getFunction()->getContext()),
1189 DWARF2_FLAG_IS_STMT);
Devang Patel34a66202011-05-11 19:22:19 +00001190 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001191}
1192
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001193// Gather and emit post-function debug information.
NAKAMURA Takumib9271612013-12-03 13:15:54 +00001194void DwarfDebug::endFunction(const MachineFunction *MF) {
David Blaikiee75f9632014-10-14 17:12:02 +00001195 assert(CurFn == MF &&
1196 "endFunction should be called with the same function as beginFunction");
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001197
David Blaikie2f040112014-07-25 16:10:16 +00001198 if (!MMI->hasDebugInfo() || LScopes.empty() ||
1199 !FunctionDIs.count(MF->getFunction())) {
Eric Christopher384f3fe2014-03-20 19:16:16 +00001200 // If we don't have a lexical scope for this function then there will
1201 // be a hole in the range information. Keep note of this by setting the
1202 // previously used section to nullptr.
Eric Christopher384f3fe2014-03-20 19:16:16 +00001203 PrevCU = nullptr;
Craig Topper353eda42014-04-24 06:44:33 +00001204 CurFn = nullptr;
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001205 return;
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001206 }
Devang Patel2904aa92009-11-12 19:02:56 +00001207
Eric Christopher4287a492013-12-09 23:57:44 +00001208 // Set DwarfDwarfCompileUnitID in MCContext to default value.
Manman Ren4e042a62013-02-05 21:52:47 +00001209 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
Eric Christopher6a841382012-11-19 22:42:10 +00001210
Devang Patel3acc70e2011-08-15 22:04:40 +00001211 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
David Blaikie263a0082014-10-23 00:06:27 +00001212 DISubprogram SP(FnScope->getScopeNode());
1213 DwarfCompileUnit &TheCU = *SPMap.lookup(SP);
1214
1215 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1216 collectVariableInfo(TheCU, SP, ProcessedVars);
Devang Patel3acc70e2011-08-15 22:04:40 +00001217
David Blaikie3a7ce252014-09-19 17:03:16 +00001218 // Add the range of this function to the list of ranges for the CU.
Rafael Espindola07c03d32015-03-05 02:05:42 +00001219 TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
David Blaikie3a7ce252014-09-19 17:03:16 +00001220
1221 // Under -gmlt, skip building the subprogram if there are no inlined
1222 // subroutines inside it.
1223 if (TheCU.getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly &&
David Blaikiee1c79742014-09-30 21:28:32 +00001224 LScopes.getAbstractScopesList().empty() && !IsDarwin) {
David Blaikie80e5b1e2014-10-24 17:57:34 +00001225 assert(InfoHolder.getScopeVariables().empty());
David Blaikie3a7ce252014-09-19 17:03:16 +00001226 assert(DbgValues.empty());
David Blaikie8b2fdb82014-10-09 18:24:28 +00001227 // FIXME: This wouldn't be true in LTO with a -g (with inlining) CU followed
1228 // by a -gmlt CU. Add a test and remove this assertion.
David Blaikie3a7ce252014-09-19 17:03:16 +00001229 assert(AbstractVariables.empty());
1230 LabelsBeforeInsn.clear();
1231 LabelsAfterInsn.clear();
1232 PrevLabel = nullptr;
1233 CurFn = nullptr;
1234 return;
1235 }
1236
Adrian Prantl049d21c2014-10-13 20:44:58 +00001237#ifndef NDEBUG
1238 size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
1239#endif
Devang Patel7e623022011-08-10 20:55:27 +00001240 // Construct abstract scopes.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001241 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
Devang Patel44403472011-08-12 18:10:19 +00001242 DISubprogram SP(AScope->getScopeNode());
David Blaikiedb5371b2014-07-18 22:26:59 +00001243 assert(SP.isSubprogram());
David Blaikie4abe19e2014-05-12 18:23:35 +00001244 // Collect info for variables that were optimized out.
1245 DIArray Variables = SP.getVariables();
1246 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1247 DIVariable DV(Variables.getElement(i));
1248 assert(DV && DV.isVariable());
David Blaikie70573dc2014-11-19 07:49:26 +00001249 if (!ProcessedVars.insert(DV).second)
David Blaikie4abe19e2014-05-12 18:23:35 +00001250 continue;
David Blaikie6f9e8672014-06-13 23:52:55 +00001251 ensureAbstractVariableIsCreated(DV, DV.getContext());
Adrian Prantl049d21c2014-10-13 20:44:58 +00001252 assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
1253 && "ensureAbstractVariableIsCreated inserted abstract scopes");
Devang Patel5c0f85c2010-06-25 22:07:34 +00001254 }
David Blaikie73cc7052014-10-09 20:36:27 +00001255 constructAbstractSubprogramScopeDIE(AScope);
Bill Wendling2b128d72009-05-20 23:19:06 +00001256 }
Eric Christopher6a841382012-11-19 22:42:10 +00001257
David Blaikie1d072342014-10-09 20:21:36 +00001258 TheCU.constructSubprogramScopeDIE(FnScope);
David Blaikie3a443c22014-11-04 22:12:25 +00001259 if (auto *SkelCU = TheCU.getSkeleton())
1260 if (!LScopes.getAbstractScopesList().empty())
1261 SkelCU->constructSubprogramScopeDIE(FnScope);
Devang Patel3acc70e2011-08-15 22:04:40 +00001262
Bill Wendling2b128d72009-05-20 23:19:06 +00001263 // Clear debug info
David Blaikie825bdd22014-05-21 22:41:17 +00001264 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1265 // DbgVariables except those that are also in AbstractVariables (since they
1266 // can be used cross-function)
David Blaikie80e5b1e2014-10-24 17:57:34 +00001267 InfoHolder.getScopeVariables().clear();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001268 DbgValues.clear();
Devang Patel6c74a872010-04-27 19:46:33 +00001269 LabelsBeforeInsn.clear();
1270 LabelsAfterInsn.clear();
Craig Topper353eda42014-04-24 06:44:33 +00001271 PrevLabel = nullptr;
1272 CurFn = nullptr;
Bill Wendling2b128d72009-05-20 23:19:06 +00001273}
1274
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001275// Register a source line with debug info. Returns the unique label that was
1276// emitted and which provides correspondence to the source line list.
Devang Patel34a66202011-05-11 19:22:19 +00001277void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1278 unsigned Flags) {
Devang Patel2d9caf92009-11-25 17:36:49 +00001279 StringRef Fn;
Devang Patele01b75c2011-03-24 20:30:50 +00001280 StringRef Dir;
Dan Gohman50849c62010-05-05 23:41:32 +00001281 unsigned Src = 1;
Diego Novillo282450d2014-03-03 18:53:17 +00001282 unsigned Discriminator = 0;
David Blaikie4c6d9872014-05-15 20:18:50 +00001283 if (DIScope Scope = DIScope(S)) {
1284 assert(Scope.isScope());
1285 Fn = Scope.getFilename();
1286 Dir = Scope.getDirectory();
David Blaikie2f3f76f2014-08-21 22:45:21 +00001287 if (Scope.isLexicalBlockFile())
1288 Discriminator = DILexicalBlockFile(S).getDiscriminator();
Dan Gohman50849c62010-05-05 23:41:32 +00001289
David Blaikie0e8d4012014-03-17 23:53:25 +00001290 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
David Blaikiec33b3cd2014-04-22 21:27:37 +00001291 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1292 .getOrCreateSourceID(Fn, Dir);
Dan Gohman50849c62010-05-05 23:41:32 +00001293 }
Diego Novillo282450d2014-03-03 18:53:17 +00001294 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1295 Discriminator, Fn);
Bill Wendling2b128d72009-05-20 23:19:06 +00001296}
1297
Bill Wendling806535f2009-05-20 23:22:40 +00001298//===----------------------------------------------------------------------===//
1299// Emit Methods
1300//===----------------------------------------------------------------------===//
1301
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001302// Emit initial Dwarf sections with a label at the start of each one.
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001303void DwarfDebug::emitSectionLabels() {
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001304 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00001305
Bill Wendling480ff322009-05-20 23:21:38 +00001306 // Dwarf sections base addresses.
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001307 emitSectionSym(Asm, TLOF.getDwarfInfoSection());
David Blaikie29459ae2014-07-25 17:11:58 +00001308 if (useSplitDwarf()) {
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001309 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection());
1310 emitSectionSym(Asm, TLOF.getDwarfTypesDWOSection());
David Blaikie29459ae2014-07-25 17:11:58 +00001311 }
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001312 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection());
Eric Christopher3c5a1912012-12-19 22:02:53 +00001313 if (useSplitDwarf())
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001314 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001315
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001316 emitSectionSym(Asm, TLOF.getDwarfLineSection());
1317 emitSectionSym(Asm, TLOF.getDwarfStrSection());
Eric Christopher55863be2013-04-07 03:43:09 +00001318 if (useSplitDwarf()) {
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001319 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection());
1320 emitSectionSym(Asm, TLOF.getDwarfAddrSection());
1321 emitSectionSym(Asm, TLOF.getDwarfLocDWOSection());
David Blaikie9c550ac2014-03-25 01:44:02 +00001322 } else
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001323 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1324 emitSectionSym(Asm, TLOF.getDwarfRangesSection());
Bill Wendling480ff322009-05-20 23:21:38 +00001325}
1326
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001327// Emit the debug info section.
1328void DwarfDebug::emitDebugInfo() {
Eric Christopherf8194852013-12-05 18:06:10 +00001329 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Rafael Espindola063d7252015-03-10 16:58:10 +00001330 Holder.emitUnits(/* UseOffsets */ false);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001331}
1332
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001333// Emit the abbreviation section.
Eric Christopher38371952012-11-20 23:30:11 +00001334void DwarfDebug::emitAbbreviations() {
Eric Christopherf8194852013-12-05 18:06:10 +00001335 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
David Blaikie0504cda2013-12-05 07:43:55 +00001336
1337 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
Eric Christopher3c5a1912012-12-19 22:02:53 +00001338}
Bill Wendling480ff322009-05-20 23:21:38 +00001339
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001340// Emit the last address of the section and the end of the line matrix.
Devang Patel930143b2009-11-21 02:48:08 +00001341void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling480ff322009-05-20 23:21:38 +00001342 // Define last address of section.
Chris Lattner566cae92010-03-09 23:52:58 +00001343 Asm->OutStreamer.AddComment("Extended Op");
1344 Asm->EmitInt8(0);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001345
Chris Lattner566cae92010-03-09 23:52:58 +00001346 Asm->OutStreamer.AddComment("Op size");
Chandler Carruth5da3f052012-11-01 09:14:31 +00001347 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
Chris Lattner566cae92010-03-09 23:52:58 +00001348 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1349 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1350
1351 Asm->OutStreamer.AddComment("Section end label");
Chris Lattnerb245dfb2010-03-10 01:17:49 +00001352
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001353 Asm->OutStreamer.EmitSymbolValue(
1354 Asm->GetTempSymbol("section_end", SectionEnd),
1355 Asm->getDataLayout().getPointerSize());
Bill Wendling480ff322009-05-20 23:21:38 +00001356
1357 // Mark end of matrix.
Chris Lattner566cae92010-03-09 23:52:58 +00001358 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1359 Asm->EmitInt8(0);
Chris Lattnerf5c834f2010-01-22 22:09:00 +00001360 Asm->EmitInt8(1);
Chris Lattnerfa823552010-01-22 23:18:42 +00001361 Asm->EmitInt8(1);
Bill Wendling480ff322009-05-20 23:21:38 +00001362}
1363
David Blaikie6741bb02014-09-11 21:12:48 +00001364void DwarfDebug::emitAccel(DwarfAccelTable &Accel, const MCSection *Section,
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001365 StringRef TableName) {
David Blaikie6741bb02014-09-11 21:12:48 +00001366 Accel.FinalizeTable(Asm, TableName);
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001367 emitSectionSym(Asm, Section);
Eric Christopher4996c702011-11-07 09:24:32 +00001368
1369 // Emit the full data.
Rafael Espindola063d7252015-03-10 16:58:10 +00001370 Accel.emit(Asm, Section->getBeginSymbol(), this);
David Blaikie6741bb02014-09-11 21:12:48 +00001371}
1372
1373// Emit visible names into a hashed accelerator table section.
1374void DwarfDebug::emitAccelNames() {
1375 emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001376 "Names");
Eric Christopher4996c702011-11-07 09:24:32 +00001377}
1378
Eric Christopher48fef592012-12-20 21:58:40 +00001379// Emit objective C classes and categories into a hashed accelerator table
1380// section.
Eric Christopher4996c702011-11-07 09:24:32 +00001381void DwarfDebug::emitAccelObjC() {
David Blaikie6741bb02014-09-11 21:12:48 +00001382 emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001383 "ObjC");
Eric Christopher4996c702011-11-07 09:24:32 +00001384}
1385
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001386// Emit namespace dies into a hashed accelerator table.
Eric Christopher4996c702011-11-07 09:24:32 +00001387void DwarfDebug::emitAccelNamespaces() {
David Blaikie6741bb02014-09-11 21:12:48 +00001388 emitAccel(AccelNamespace,
1389 Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001390 "namespac");
Eric Christopher4996c702011-11-07 09:24:32 +00001391}
1392
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001393// Emit type dies into a hashed accelerator table.
Eric Christopher4996c702011-11-07 09:24:32 +00001394void DwarfDebug::emitAccelTypes() {
David Blaikie6741bb02014-09-11 21:12:48 +00001395 emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
Rafael Espindola6b9998b2015-03-10 22:00:25 +00001396 "types");
Eric Christopher4996c702011-11-07 09:24:32 +00001397}
1398
Eric Christopherdd1a0122013-09-13 00:35:05 +00001399// Public name handling.
1400// The format for the various pubnames:
1401//
1402// dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1403// for the DIE that is named.
1404//
1405// gnu pubnames - offset/index value/name tuples where the offset is the offset
1406// into the CU and the index value is computed according to the type of value
1407// for the DIE that is named.
1408//
1409// For type units the offset is the offset of the skeleton DIE. For split dwarf
1410// it's the offset within the debug_info/debug_types dwo section, however, the
1411// reference in the pubname header doesn't change.
1412
1413/// computeIndexValue - Compute the gdb index value for the DIE and CU.
Eric Christophera5a79422013-12-09 23:32:48 +00001414static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
Eric Christopher0fe676a2013-11-21 00:48:22 +00001415 const DIE *Die) {
Eric Christopherd2b497b2013-10-16 01:37:49 +00001416 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1417
1418 // We could have a specification DIE that has our most of our knowledge,
1419 // look for that now.
1420 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1421 if (SpecVal) {
David Blaikie8dbcc3f2014-04-25 19:33:43 +00001422 DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1423 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
Eric Christopherd2b497b2013-10-16 01:37:49 +00001424 Linkage = dwarf::GIEL_EXTERNAL;
1425 } else if (Die->findAttribute(dwarf::DW_AT_external))
1426 Linkage = dwarf::GIEL_EXTERNAL;
Eric Christopherdd1a0122013-09-13 00:35:05 +00001427
1428 switch (Die->getTag()) {
1429 case dwarf::DW_TAG_class_type:
1430 case dwarf::DW_TAG_structure_type:
1431 case dwarf::DW_TAG_union_type:
1432 case dwarf::DW_TAG_enumeration_type:
Eric Christopher261d2342013-09-23 20:55:35 +00001433 return dwarf::PubIndexEntryDescriptor(
1434 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1435 ? dwarf::GIEL_STATIC
1436 : dwarf::GIEL_EXTERNAL);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001437 case dwarf::DW_TAG_typedef:
1438 case dwarf::DW_TAG_base_type:
1439 case dwarf::DW_TAG_subrange_type:
David Blaikie8dec4072013-09-19 20:40:26 +00001440 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001441 case dwarf::DW_TAG_namespace:
David Blaikie8dec4072013-09-19 20:40:26 +00001442 return dwarf::GIEK_TYPE;
Eric Christopherdd1a0122013-09-13 00:35:05 +00001443 case dwarf::DW_TAG_subprogram:
Eric Christopherccac5c42013-09-23 22:59:14 +00001444 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001445 case dwarf::DW_TAG_variable:
Eric Christopherccac5c42013-09-23 22:59:14 +00001446 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001447 case dwarf::DW_TAG_enumerator:
David Blaikie8dec4072013-09-19 20:40:26 +00001448 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1449 dwarf::GIEL_STATIC);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001450 default:
David Blaikie8dec4072013-09-19 20:40:26 +00001451 return dwarf::GIEK_NONE;
Eric Christopherdd1a0122013-09-13 00:35:05 +00001452 }
Eric Christopherdd1a0122013-09-13 00:35:05 +00001453}
1454
Eric Christopher5f93bb92013-09-09 20:03:17 +00001455/// emitDebugPubNames - Emit visible names into a debug pubnames section.
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001456///
Eric Christopherdd1a0122013-09-13 00:35:05 +00001457void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
Eric Christopherdd1a0122013-09-13 00:35:05 +00001458 const MCSection *PSec =
1459 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1460 : Asm->getObjFileLowering().getDwarfPubNamesSection();
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001461
David Blaikie192b45c2014-11-02 06:16:39 +00001462 emitDebugPubSection(GnuStyle, PSec, "Names",
1463 &DwarfCompileUnit::getGlobalNames);
David Blaikie0f55e832014-03-11 23:18:15 +00001464}
1465
1466void DwarfDebug::emitDebugPubSection(
1467 bool GnuStyle, const MCSection *PSec, StringRef Name,
David Blaikie192b45c2014-11-02 06:16:39 +00001468 const StringMap<const DIE *> &(DwarfCompileUnit::*Accessor)() const) {
David Blaikiec3d9e9e2014-03-06 01:42:00 +00001469 for (const auto &NU : CUMap) {
1470 DwarfCompileUnit *TheU = NU.second;
David Blaikie55bb8ac2014-03-11 23:23:39 +00001471
1472 const auto &Globals = (TheU->*Accessor)();
1473
David Blaikiece2f1cb2014-03-11 23:35:06 +00001474 if (Globals.empty())
1475 continue;
1476
David Blaikiebbad0bb2014-11-01 01:03:39 +00001477 if (auto *Skeleton = TheU->getSkeleton())
David Blaikiec3d9e9e2014-03-06 01:42:00 +00001478 TheU = Skeleton;
David Blaikie2a80e442013-12-02 22:09:48 +00001479 unsigned ID = TheU->getUniqueID();
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001480
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001481 // Start the dwarf pubnames section.
Eric Christopher13b99d22013-09-10 21:49:37 +00001482 Asm->OutStreamer.SwitchSection(PSec);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001483
Eric Christopherdd1a0122013-09-13 00:35:05 +00001484 // Emit the header.
David Blaikie0f55e832014-03-11 23:18:15 +00001485 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
1486 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
1487 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
David Blaikieb7a1c4d2013-12-04 17:55:41 +00001488 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001489
David Blaikieb7a1c4d2013-12-04 17:55:41 +00001490 Asm->OutStreamer.EmitLabel(BeginLabel);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001491
1492 Asm->OutStreamer.AddComment("DWARF Version");
David Majnemered89b5c2013-08-21 06:13:34 +00001493 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001494
1495 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
Rafael Espindola063d7252015-03-10 16:58:10 +00001496 Asm->emitSectionOffset(TheU->getLabelBegin());
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001497
1498 Asm->OutStreamer.AddComment("Compilation Unit Length");
David Blaikie983bfea2014-11-01 23:07:14 +00001499 Asm->EmitInt32(TheU->getLength());
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001500
Eric Christopherdd1a0122013-09-13 00:35:05 +00001501 // Emit the pubnames for this compilation unit.
David Blaikie55bb8ac2014-03-11 23:23:39 +00001502 for (const auto &GI : Globals) {
Benjamin Kramer15596c72014-03-07 19:09:39 +00001503 const char *Name = GI.getKeyData();
1504 const DIE *Entity = GI.second;
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001505
1506 Asm->OutStreamer.AddComment("DIE offset");
1507 Asm->EmitInt32(Entity->getOffset());
1508
Eric Christopherdd1a0122013-09-13 00:35:05 +00001509 if (GnuStyle) {
David Blaikie2a80e442013-12-02 22:09:48 +00001510 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
David Blaikied0a869d2013-09-19 22:19:37 +00001511 Asm->OutStreamer.AddComment(
David Blaikieefd0bcb2013-09-20 00:33:15 +00001512 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
David Blaikie404d3042013-09-19 23:01:29 +00001513 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
David Blaikied0a869d2013-09-19 22:19:37 +00001514 Asm->EmitInt8(Desc.toBits());
Eric Christopherdd1a0122013-09-13 00:35:05 +00001515 }
1516
David Blaikie155f8812013-12-04 21:51:05 +00001517 Asm->OutStreamer.AddComment("External Name");
Benjamin Kramer15596c72014-03-07 19:09:39 +00001518 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001519 }
1520
1521 Asm->OutStreamer.AddComment("End Mark");
1522 Asm->EmitInt32(0);
David Blaikieb7a1c4d2013-12-04 17:55:41 +00001523 Asm->OutStreamer.EmitLabel(EndLabel);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001524 }
1525}
1526
Eric Christopherdd1a0122013-09-13 00:35:05 +00001527void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
Eric Christopher261d2342013-09-23 20:55:35 +00001528 const MCSection *PSec =
1529 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1530 : Asm->getObjFileLowering().getDwarfPubTypesSection();
Eric Christopher8b3737f2013-09-13 00:34:58 +00001531
David Blaikie192b45c2014-11-02 06:16:39 +00001532 emitDebugPubSection(GnuStyle, PSec, "Types",
1533 &DwarfCompileUnit::getGlobalTypes);
Devang Patel04d2f2d2009-11-24 01:14:22 +00001534}
1535
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001536// Emit visible names into a debug str section.
1537void DwarfDebug::emitDebugStr() {
Eric Christopherf8194852013-12-05 18:06:10 +00001538 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001539 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1540}
1541
Adrian Prantlb1416832014-08-01 22:11:58 +00001542
Eric Christopher29e874d2014-03-07 22:40:37 +00001543void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
Eric Christopher05135fb2014-03-18 02:18:24 +00001544 const DebugLocEntry &Entry) {
Adrian Prantl92da14b2015-03-02 22:02:33 +00001545 auto Comment = Entry.getComments().begin();
1546 auto End = Entry.getComments().end();
1547 for (uint8_t Byte : Entry.getDWARFBytes())
1548 Streamer.EmitInt8(Byte, Comment != End ? *(Comment++) : "");
Adrian Prantlb1416832014-08-01 22:11:58 +00001549}
1550
Adrian Prantl92da14b2015-03-02 22:02:33 +00001551static void emitDebugLocValue(const AsmPrinter &AP,
1552 const DITypeIdentifierMap &TypeIdentifierMap,
1553 ByteStreamer &Streamer,
1554 const DebugLocEntry::Value &Value,
1555 unsigned PieceOffsetInBits) {
Adrian Prantl76502d82014-08-11 23:22:59 +00001556 DIVariable DV = Value.getVariable();
Adrian Prantl92da14b2015-03-02 22:02:33 +00001557 DebugLocDwarfExpression DwarfExpr(
1558 *AP.TM.getSubtargetImpl()->getRegisterInfo(),
1559 AP.getDwarfDebug()->getDwarfVersion(), Streamer);
Adrian Prantlb1416832014-08-01 22:11:58 +00001560 // Regular entry.
Adrian Prantle19e5ef2014-04-27 18:25:40 +00001561 if (Value.isInt()) {
Adrian Prantl92da14b2015-03-02 22:02:33 +00001562 DIBasicType BTy(DV.getType().resolve(TypeIdentifierMap));
Eric Christopher29e874d2014-03-07 22:40:37 +00001563 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
Adrian Prantl66f25952015-01-13 00:04:06 +00001564 BTy.getEncoding() == dwarf::DW_ATE_signed_char))
Adrian Prantl092d9482015-01-13 23:39:11 +00001565 DwarfExpr.AddSignedConstant(Value.getInt());
Adrian Prantl66f25952015-01-13 00:04:06 +00001566 else
Adrian Prantl092d9482015-01-13 23:39:11 +00001567 DwarfExpr.AddUnsignedConstant(Value.getInt());
Adrian Prantle19e5ef2014-04-27 18:25:40 +00001568 } else if (Value.isLocation()) {
1569 MachineLocation Loc = Value.getLoc();
Adrian Prantl87b7eb92014-10-01 18:55:02 +00001570 DIExpression Expr = Value.getExpression();
Adrian Prantl092d9482015-01-13 23:39:11 +00001571 if (!Expr || (Expr.getNumElements() == 0))
Eric Christopher29e874d2014-03-07 22:40:37 +00001572 // Regular entry.
Adrian Prantl92da14b2015-03-02 22:02:33 +00001573 AP.EmitDwarfRegOp(Streamer, Loc);
Eric Christopher29e874d2014-03-07 22:40:37 +00001574 else {
1575 // Complex address entry.
Adrian Prantl092d9482015-01-13 23:39:11 +00001576 if (Loc.getOffset()) {
1577 DwarfExpr.AddMachineRegIndirect(Loc.getReg(), Loc.getOffset());
Duncan P. N. Exon Smith57bab0b2015-02-17 22:30:56 +00001578 DwarfExpr.AddExpression(Expr.begin(), Expr.end(), PieceOffsetInBits);
Adrian Prantl092d9482015-01-13 23:39:11 +00001579 } else
1580 DwarfExpr.AddMachineRegExpression(Expr, Loc.getReg(),
1581 PieceOffsetInBits);
Eric Christopher29e874d2014-03-07 22:40:37 +00001582 }
1583 }
1584 // else ... ignore constant fp. There is not any good way to
1585 // to represent them here in dwarf.
1586 // FIXME: ^
1587}
1588
Adrian Prantl92da14b2015-03-02 22:02:33 +00001589
1590void DebugLocEntry::finalize(const AsmPrinter &AP,
1591 const DITypeIdentifierMap &TypeIdentifierMap) {
1592 BufferByteStreamer Streamer(DWARFBytes, Comments);
1593 const DebugLocEntry::Value Value = Values[0];
1594 if (Value.isBitPiece()) {
1595 // Emit all pieces that belong to the same variable and range.
1596 assert(std::all_of(Values.begin(), Values.end(), [](DebugLocEntry::Value P) {
1597 return P.isBitPiece();
1598 }) && "all values are expected to be pieces");
1599 assert(std::is_sorted(Values.begin(), Values.end()) &&
1600 "pieces are expected to be sorted");
1601
1602 unsigned Offset = 0;
1603 for (auto Piece : Values) {
1604 DIExpression Expr = Piece.getExpression();
1605 unsigned PieceOffset = Expr.getBitPieceOffset();
1606 unsigned PieceSize = Expr.getBitPieceSize();
1607 assert(Offset <= PieceOffset && "overlapping or duplicate pieces");
1608 if (Offset < PieceOffset) {
1609 // The DWARF spec seriously mandates pieces with no locations for gaps.
1610 DebugLocDwarfExpression Expr(
1611 *AP.TM.getSubtargetImpl()->getRegisterInfo(),
1612 AP.getDwarfDebug()->getDwarfVersion(), Streamer);
1613 Expr.AddOpPiece(PieceOffset-Offset, 0);
1614 Offset += PieceOffset-Offset;
1615 }
1616 Offset += PieceSize;
1617
1618#ifndef NDEBUG
1619 DIVariable Var = Piece.getVariable();
1620 unsigned VarSize = Var.getSizeInBits(TypeIdentifierMap);
1621 assert(PieceSize+PieceOffset <= VarSize
1622 && "piece is larger than or outside of variable");
1623 assert(PieceSize != VarSize
1624 && "piece covers entire variable");
1625#endif
1626 emitDebugLocValue(AP, TypeIdentifierMap, Streamer, Piece, PieceOffset);
1627 }
1628 } else {
1629 assert(Values.size() == 1 && "only pieces may have >1 value");
1630 emitDebugLocValue(AP, TypeIdentifierMap, Streamer, Value, 0);
1631 }
1632}
1633
1634
David Blaikie0e84adc2014-04-01 16:17:41 +00001635void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
1636 Asm->OutStreamer.AddComment("Loc expr size");
1637 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1638 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1639 Asm->EmitLabelDifference(end, begin, 2);
1640 Asm->OutStreamer.EmitLabel(begin);
1641 // Emit the entry.
1642 APByteStreamer Streamer(*Asm);
1643 emitDebugLocEntry(Streamer, Entry);
1644 // Close the range.
1645 Asm->OutStreamer.EmitLabel(end);
1646}
1647
Eric Christopher9046f942013-07-02 21:36:07 +00001648// Emit locations into the debug loc section.
Devang Patel930143b2009-11-21 02:48:08 +00001649void DwarfDebug::emitDebugLoc() {
Daniel Dunbarfd95b012011-03-16 22:16:39 +00001650 // Start the dwarf loc section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001651 Asm->OutStreamer.SwitchSection(
David Blaikie94c1d7f2014-04-02 01:50:20 +00001652 Asm->getObjFileLowering().getDwarfLocSection());
Chandler Carruth5da3f052012-11-01 09:14:31 +00001653 unsigned char Size = Asm->getDataLayout().getPointerSize();
David Blaikie84d8e182014-03-24 22:38:38 +00001654 for (const auto &DebugLoc : DotDebugLocEntries) {
David Blaikie0a456de2014-04-02 01:43:18 +00001655 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
David Blaikiee1a26a62014-08-05 23:14:16 +00001656 const DwarfCompileUnit *CU = DebugLoc.CU;
David Blaikie0a456de2014-04-02 01:43:18 +00001657 for (const auto &Entry : DebugLoc.List) {
Eric Christopher384f3fe2014-03-20 19:16:16 +00001658 // Set up the range. This range is relative to the entry point of the
1659 // compile unit. This is a hard coded 0 for low_pc when we're emitting
1660 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
David Blaikiece343492014-11-03 21:15:30 +00001661 if (auto *Base = CU->getBaseAddress()) {
Eric Christopher384f3fe2014-03-20 19:16:16 +00001662 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
1663 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
1664 } else {
1665 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
1666 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
1667 }
David Blaikie94c1d7f2014-04-02 01:50:20 +00001668
David Blaikie0e84adc2014-04-01 16:17:41 +00001669 emitDebugLocEntryLocation(Entry);
Devang Patel9fc11702010-05-25 23:40:22 +00001670 }
David Blaikie94c1d7f2014-04-02 01:50:20 +00001671 Asm->OutStreamer.EmitIntValue(0, Size);
1672 Asm->OutStreamer.EmitIntValue(0, Size);
1673 }
1674}
1675
1676void DwarfDebug::emitDebugLocDWO() {
1677 Asm->OutStreamer.SwitchSection(
1678 Asm->getObjFileLowering().getDwarfLocDWOSection());
1679 for (const auto &DebugLoc : DotDebugLocEntries) {
1680 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
1681 for (const auto &Entry : DebugLoc.List) {
1682 // Just always use start_length for now - at least that's one address
1683 // rather than two. We could get fancier and try to, say, reuse an
1684 // address we know we've emitted elsewhere (the start of the function?
1685 // The start of the CU or CU subrange that encloses this range?)
1686 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
David Blaikied75fb282014-04-23 21:20:10 +00001687 unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
David Blaikie94c1d7f2014-04-02 01:50:20 +00001688 Asm->EmitULEB128(idx);
1689 Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
1690
1691 emitDebugLocEntryLocation(Entry);
David Blaikie9c550ac2014-03-25 01:44:02 +00001692 }
David Blaikie94c1d7f2014-04-02 01:50:20 +00001693 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
Devang Patel9fc11702010-05-25 23:40:22 +00001694 }
Bill Wendling480ff322009-05-20 23:21:38 +00001695}
1696
Richard Mitton21101b32013-09-19 23:21:01 +00001697struct ArangeSpan {
1698 const MCSymbol *Start, *End;
1699};
1700
1701// Emit a debug aranges section, containing a CU lookup for any
1702// address we can tie back to a CU.
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001703void DwarfDebug::emitDebugARanges() {
Rafael Espindolae8fd00d2015-02-26 22:02:02 +00001704 // Provides a unique id per text section.
Rafael Espindola4f4ef152015-03-09 22:08:37 +00001705 MapVector<const MCSection *, SmallVector<SymbolCU, 8>> SectionMap;
Richard Mitton21101b32013-09-19 23:21:01 +00001706
Rafael Espindolae8fd00d2015-02-26 22:02:02 +00001707 // Filter labels by section.
1708 for (const SymbolCU &SCU : ArangeLabels) {
1709 if (SCU.Sym->isInSection()) {
1710 // Make a note of this symbol and it's section.
1711 const MCSection *Section = &SCU.Sym->getSection();
1712 if (!Section->getKind().isMetadata())
1713 SectionMap[Section].push_back(SCU);
1714 } else {
1715 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1716 // appear in the output. This sucks as we rely on sections to build
1717 // arange spans. We can do it without, but it's icky.
1718 SectionMap[nullptr].push_back(SCU);
1719 }
1720 }
Richard Mitton21101b32013-09-19 23:21:01 +00001721
Rafael Espindolae8fd00d2015-02-26 22:02:02 +00001722 // Add terminating symbols for each section.
Rafael Espindola4f4ef152015-03-09 22:08:37 +00001723 unsigned ID = 0;
1724 for (const auto &I : SectionMap) {
1725 const MCSection *Section = I.first;
Rafael Espindolae8fd00d2015-02-26 22:02:02 +00001726 MCSymbol *Sym = nullptr;
1727
1728 if (Section) {
1729 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1730 // if we know the section name up-front. For user-created sections, the
1731 // resulting label may not be valid to use as a label. (section names can
1732 // use a greater set of characters on some systems)
1733 Sym = Asm->GetTempSymbol("debug_end", ID);
1734 Asm->OutStreamer.SwitchSection(Section);
1735 Asm->OutStreamer.EmitLabel(Sym);
1736 }
1737
1738 // Insert a final terminator.
1739 SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
Rafael Espindola4f4ef152015-03-09 22:08:37 +00001740 ++ID;
Rafael Espindolae8fd00d2015-02-26 22:02:02 +00001741 }
1742
1743 DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> Spans;
1744
Rafael Espindola4f4ef152015-03-09 22:08:37 +00001745 for (auto &I : SectionMap) {
1746 const MCSection *Section = I.first;
1747 SmallVector<SymbolCU, 8> &List = I.second;
Richard Mitton21101b32013-09-19 23:21:01 +00001748 if (List.size() < 2)
1749 continue;
1750
Rafael Espindola6ffb1d72015-02-02 19:22:51 +00001751 // If we have no section (e.g. common), just write out
1752 // individual spans for each symbol.
1753 if (!Section) {
1754 for (const SymbolCU &Cur : List) {
1755 ArangeSpan Span;
1756 Span.Start = Cur.Sym;
1757 Span.End = nullptr;
1758 if (Cur.CU)
1759 Spans[Cur.CU].push_back(Span);
1760 }
1761 continue;
1762 }
1763
Richard Mitton21101b32013-09-19 23:21:01 +00001764 // Sort the symbols by offset within the section.
Benjamin Kramer571e2fe2014-03-07 19:41:22 +00001765 std::sort(List.begin(), List.end(),
1766 [&](const SymbolCU &A, const SymbolCU &B) {
1767 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
1768 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
1769
1770 // Symbols with no order assigned should be placed at the end.
1771 // (e.g. section end labels)
1772 if (IA == 0)
1773 return false;
1774 if (IB == 0)
1775 return true;
1776 return IA < IB;
1777 });
Richard Mitton21101b32013-09-19 23:21:01 +00001778
Rafael Espindola6ffb1d72015-02-02 19:22:51 +00001779 // Build spans between each label.
1780 const MCSymbol *StartSym = List[0].Sym;
1781 for (size_t n = 1, e = List.size(); n < e; n++) {
1782 const SymbolCU &Prev = List[n - 1];
1783 const SymbolCU &Cur = List[n];
Richard Mitton21101b32013-09-19 23:21:01 +00001784
Rafael Espindola6ffb1d72015-02-02 19:22:51 +00001785 // Try and build the longest span we can within the same CU.
1786 if (Cur.CU != Prev.CU) {
1787 ArangeSpan Span;
1788 Span.Start = StartSym;
1789 Span.End = Cur.Sym;
1790 Spans[Prev.CU].push_back(Span);
1791 StartSym = Cur.Sym;
Richard Mitton21101b32013-09-19 23:21:01 +00001792 }
1793 }
1794 }
1795
Rafael Espindolae8fd00d2015-02-26 22:02:02 +00001796 // Start the dwarf aranges section.
1797 Asm->OutStreamer.SwitchSection(
1798 Asm->getObjFileLowering().getDwarfARangesSection());
1799
Richard Mitton21101b32013-09-19 23:21:01 +00001800 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
1801
1802 // Build a list of CUs used.
Eric Christopher4287a492013-12-09 23:57:44 +00001803 std::vector<DwarfCompileUnit *> CUs;
Benjamin Kramer15596c72014-03-07 19:09:39 +00001804 for (const auto &it : Spans) {
1805 DwarfCompileUnit *CU = it.first;
Richard Mitton21101b32013-09-19 23:21:01 +00001806 CUs.push_back(CU);
1807 }
1808
1809 // Sort the CU list (again, to ensure consistent output order).
Benjamin Kramer571e2fe2014-03-07 19:41:22 +00001810 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
1811 return A->getUniqueID() < B->getUniqueID();
1812 });
Richard Mitton21101b32013-09-19 23:21:01 +00001813
1814 // Emit an arange table for each CU we used.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001815 for (DwarfCompileUnit *CU : CUs) {
Richard Mitton21101b32013-09-19 23:21:01 +00001816 std::vector<ArangeSpan> &List = Spans[CU];
1817
David Blaikie27e35f22014-11-02 01:21:43 +00001818 // Describe the skeleton CU's offset and length, not the dwo file's.
1819 if (auto *Skel = CU->getSkeleton())
1820 CU = Skel;
1821
Richard Mitton21101b32013-09-19 23:21:01 +00001822 // Emit size of content not including length itself.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001823 unsigned ContentSize =
1824 sizeof(int16_t) + // DWARF ARange version number
1825 sizeof(int32_t) + // Offset of CU in the .debug_info section
1826 sizeof(int8_t) + // Pointer Size (in bytes)
1827 sizeof(int8_t); // Segment Size (in bytes)
Richard Mitton21101b32013-09-19 23:21:01 +00001828
1829 unsigned TupleSize = PtrSize * 2;
1830
1831 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
Benjamin Kramer8a68ab32014-01-07 19:28:14 +00001832 unsigned Padding =
1833 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
Richard Mitton21101b32013-09-19 23:21:01 +00001834
1835 ContentSize += Padding;
1836 ContentSize += (List.size() + 1) * TupleSize;
1837
1838 // For each compile unit, write the list of spans it covers.
1839 Asm->OutStreamer.AddComment("Length of ARange Set");
1840 Asm->EmitInt32(ContentSize);
1841 Asm->OutStreamer.AddComment("DWARF Arange version number");
1842 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
1843 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
Rafael Espindola063d7252015-03-10 16:58:10 +00001844 Asm->emitSectionOffset(CU->getLabelBegin());
Richard Mitton21101b32013-09-19 23:21:01 +00001845 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1846 Asm->EmitInt8(PtrSize);
1847 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
1848 Asm->EmitInt8(0);
1849
Benjamin Kramer8a68ab32014-01-07 19:28:14 +00001850 Asm->OutStreamer.EmitFill(Padding, 0xff);
Richard Mitton21101b32013-09-19 23:21:01 +00001851
Benjamin Kramer15596c72014-03-07 19:09:39 +00001852 for (const ArangeSpan &Span : List) {
Richard Mitton21101b32013-09-19 23:21:01 +00001853 Asm->EmitLabelReference(Span.Start, PtrSize);
1854
1855 // Calculate the size as being from the span start to it's end.
Richard Mitton089ed892013-09-23 17:56:20 +00001856 if (Span.End) {
Richard Mitton21101b32013-09-19 23:21:01 +00001857 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
Richard Mitton089ed892013-09-23 17:56:20 +00001858 } else {
1859 // For symbols without an end marker (e.g. common), we
1860 // write a single arange entry containing just that one symbol.
1861 uint64_t Size = SymSize[Span.Start];
1862 if (Size == 0)
1863 Size = 1;
1864
1865 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
1866 }
Richard Mitton21101b32013-09-19 23:21:01 +00001867 }
1868
1869 Asm->OutStreamer.AddComment("ARange terminator");
1870 Asm->OutStreamer.EmitIntValue(0, PtrSize);
1871 Asm->OutStreamer.EmitIntValue(0, PtrSize);
1872 }
Bill Wendling480ff322009-05-20 23:21:38 +00001873}
1874
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001875// Emit visible names into a debug ranges section.
Devang Patel930143b2009-11-21 02:48:08 +00001876void DwarfDebug::emitDebugRanges() {
Bill Wendling480ff322009-05-20 23:21:38 +00001877 // Start the dwarf ranges section.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001878 Asm->OutStreamer.SwitchSection(
1879 Asm->getObjFileLowering().getDwarfRangesSection());
Eric Christopher4751d702013-11-23 00:05:29 +00001880
Eric Christopher0f63d062013-12-03 00:45:45 +00001881 // Size for our labels.
1882 unsigned char Size = Asm->getDataLayout().getPointerSize();
1883
1884 // Grab the specific ranges for the compile units in the module.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001885 for (const auto &I : CUMap) {
1886 DwarfCompileUnit *TheCU = I.second;
Eric Christopher0f63d062013-12-03 00:45:45 +00001887
David Blaikie3a443c22014-11-04 22:12:25 +00001888 if (auto *Skel = TheCU->getSkeleton())
1889 TheCU = Skel;
1890
Eric Christopher0f63d062013-12-03 00:45:45 +00001891 // Iterate over the misc ranges for the compile units in the module.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001892 for (const RangeSpanList &List : TheCU->getRangeLists()) {
Eric Christopherf8790642013-12-04 22:04:50 +00001893 // Emit our symbol so we can find the beginning of the range.
1894 Asm->OutStreamer.EmitLabel(List.getSym());
Eric Christopher0f63d062013-12-03 00:45:45 +00001895
Benjamin Kramer15596c72014-03-07 19:09:39 +00001896 for (const RangeSpan &Range : List.getRanges()) {
Eric Christopher0f63d062013-12-03 00:45:45 +00001897 const MCSymbol *Begin = Range.getStart();
1898 const MCSymbol *End = Range.getEnd();
Eric Christopher565ab112013-12-20 04:34:22 +00001899 assert(Begin && "Range without a begin symbol?");
1900 assert(End && "Range without an end symbol?");
David Blaikiece343492014-11-03 21:15:30 +00001901 if (auto *Base = TheCU->getBaseAddress()) {
Eric Christopherece0e902014-04-25 22:23:54 +00001902 Asm->EmitLabelDifference(Begin, Base, Size);
1903 Asm->EmitLabelDifference(End, Base, Size);
1904 } else {
1905 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
1906 Asm->OutStreamer.EmitSymbolValue(End, Size);
1907 }
Eric Christopher0f63d062013-12-03 00:45:45 +00001908 }
1909
1910 // And terminate the list with two 0 values.
Eric Christopherce0cfce2013-01-09 01:35:34 +00001911 Asm->OutStreamer.EmitIntValue(0, Size);
Eric Christopher0f63d062013-12-03 00:45:45 +00001912 Asm->OutStreamer.EmitIntValue(0, Size);
1913 }
Devang Patel12563b32010-04-16 23:33:45 +00001914 }
Bill Wendling480ff322009-05-20 23:21:38 +00001915}
1916
Eric Christopherd692c1d2012-12-11 19:42:09 +00001917// DWARF5 Experimental Separate Dwarf emitters.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001918
David Blaikie65a74662014-04-25 18:26:14 +00001919void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
David Blaikief9b6a552014-04-22 22:39:41 +00001920 std::unique_ptr<DwarfUnit> NewU) {
David Blaikiecafd9622014-11-02 08:51:37 +00001921 NewU->addString(Die, dwarf::DW_AT_GNU_dwo_name,
David Blaikie4aa49b22014-11-02 08:52:37 +00001922 U.getCUNode().getSplitDebugFilename());
David Blaikie38fe6342014-01-09 04:28:46 +00001923
David Blaikie38fe6342014-01-09 04:28:46 +00001924 if (!CompilationDir.empty())
David Blaikiecafd9622014-11-02 08:51:37 +00001925 NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
David Blaikie38fe6342014-01-09 04:28:46 +00001926
David Blaikief9b6a552014-04-22 22:39:41 +00001927 addGnuPubAttributes(*NewU, Die);
David Blaikie38fe6342014-01-09 04:28:46 +00001928
David Blaikief9b6a552014-04-22 22:39:41 +00001929 SkeletonHolder.addUnit(std::move(NewU));
David Blaikie38fe6342014-01-09 04:28:46 +00001930}
1931
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001932// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
1933// 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 +00001934// DW_AT_addr_base, DW_AT_ranges_base.
David Blaikief9b6a552014-04-22 22:39:41 +00001935DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001936
David Blaikief9b6a552014-04-22 22:39:41 +00001937 auto OwnedUnit = make_unique<DwarfCompileUnit>(
David Blaikiebd579052014-04-28 21:14:27 +00001938 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
David Blaikief9b6a552014-04-22 22:39:41 +00001939 DwarfCompileUnit &NewCU = *OwnedUnit;
Rafael Espindola063d7252015-03-10 16:58:10 +00001940 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection());
Eric Christopher4c7765f2013-01-17 03:00:04 +00001941
Rafael Espindola063d7252015-03-10 16:58:10 +00001942 NewCU.initStmtList();
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001943
David Blaikie92a2f8a2014-04-28 21:04:29 +00001944 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
Eric Christopherc8a310e2012-12-10 23:34:43 +00001945
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001946 return NewCU;
1947}
1948
Eric Christopherd692c1d2012-12-11 19:42:09 +00001949// Emit the .debug_info.dwo section for separated dwarf. This contains the
1950// compile units that would normally be in debug_info.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001951void DwarfDebug::emitDebugInfoDWO() {
Eric Christophercdf218d2012-12-10 19:51:21 +00001952 assert(useSplitDwarf() && "No split dwarf debug info?");
Rafael Espindola063d7252015-03-10 16:58:10 +00001953 // Don't emit relocations into the dwo file.
1954 InfoHolder.emitUnits(/* UseOffsets */ true);
Eric Christopher3c5a1912012-12-19 22:02:53 +00001955}
1956
1957// Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
1958// abbreviations for the .debug_info.dwo section.
1959void DwarfDebug::emitDebugAbbrevDWO() {
1960 assert(useSplitDwarf() && "No split dwarf?");
David Blaikie0504cda2013-12-05 07:43:55 +00001961 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001962}
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001963
David Blaikie4a2f95f2014-03-18 01:17:26 +00001964void DwarfDebug::emitDebugLineDWO() {
1965 assert(useSplitDwarf() && "No split dwarf?");
1966 Asm->OutStreamer.SwitchSection(
1967 Asm->getObjFileLowering().getDwarfLineDWOSection());
David Blaikie8287aff2014-03-18 02:13:23 +00001968 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
David Blaikie4a2f95f2014-03-18 01:17:26 +00001969}
1970
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001971// Emit the .debug_str.dwo section for separated dwarf. This contains the
1972// string section and is identical in format to traditional .debug_str
1973// sections.
1974void DwarfDebug::emitDebugStrDWO() {
1975 assert(useSplitDwarf() && "No split dwarf?");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001976 const MCSection *OffSec =
1977 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
Eric Christopher2cbd5762013-01-07 19:32:41 +00001978 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
David Blaikie6741bb02014-09-11 21:12:48 +00001979 OffSec);
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001980}
David Blaikie409dd9c2013-11-19 23:08:21 +00001981
David Blaikie47f4b822014-03-19 00:11:28 +00001982MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
1983 if (!useSplitDwarf())
1984 return nullptr;
1985 if (SingleCU)
1986 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
1987 return &SplitTypeUnitFileTable;
1988}
1989
David Blaikief3de2ab2014-04-26 16:26:41 +00001990static uint64_t makeTypeSignature(StringRef Identifier) {
1991 MD5 Hash;
1992 Hash.update(Identifier);
1993 // ... take the least significant 8 bytes and return those. Our MD5
1994 // implementation always returns its results in little endian, swap bytes
1995 // appropriately.
1996 MD5::MD5Result Result;
1997 Hash.final(Result);
Rui Ueyama3206b792015-03-02 21:19:12 +00001998 return support::endian::read64le(Result + 8);
David Blaikief3de2ab2014-04-26 16:26:41 +00001999}
2000
David Blaikie15632ae2014-02-12 00:31:30 +00002001void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
David Blaikie65a74662014-04-25 18:26:14 +00002002 StringRef Identifier, DIE &RefDie,
David Blaikief645f962014-01-09 03:23:41 +00002003 DICompositeType CTy) {
David Blaikiee12b49a2014-04-26 17:27:38 +00002004 // Fast path if we're building some type units and one has already used the
2005 // address pool we know we're going to throw away all this work anyway, so
2006 // don't bother building dependent types.
2007 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2008 return;
2009
David Blaikie47f615e2013-12-17 23:32:35 +00002010 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
Chandler Carruthb587ab62014-01-20 08:07:07 +00002011 if (TU) {
David Blaikie15632ae2014-02-12 00:31:30 +00002012 CU.addDIETypeSignature(RefDie, *TU);
Chandler Carruthb587ab62014-01-20 08:07:07 +00002013 return;
David Blaikie409dd9c2013-11-19 23:08:21 +00002014 }
2015
David Blaikiee12b49a2014-04-26 17:27:38 +00002016 bool TopLevelType = TypeUnitsUnderConstruction.empty();
2017 AddrPool.resetUsedFlag();
2018
David Blaikie29459ae2014-07-25 17:11:58 +00002019 auto OwnedUnit = make_unique<DwarfTypeUnit>(
2020 InfoHolder.getUnits().size() + TypeUnitsUnderConstruction.size(), CU, Asm,
2021 this, &InfoHolder, getDwoLineTable(CU));
David Blaikief9b6a552014-04-22 22:39:41 +00002022 DwarfTypeUnit &NewTU = *OwnedUnit;
David Blaikie92a2f8a2014-04-28 21:04:29 +00002023 DIE &UnitDie = NewTU.getUnitDie();
David Blaikief9b6a552014-04-22 22:39:41 +00002024 TU = &NewTU;
Eric Christopher793c7472014-04-28 20:42:22 +00002025 TypeUnitsUnderConstruction.push_back(
2026 std::make_pair(std::move(OwnedUnit), CTy));
Chandler Carruthb587ab62014-01-20 08:07:07 +00002027
David Blaikie92a2f8a2014-04-28 21:04:29 +00002028 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
David Blaikie637cac42014-04-22 23:09:36 +00002029 CU.getLanguage());
Chandler Carruthb587ab62014-01-20 08:07:07 +00002030
David Blaikief3de2ab2014-04-26 16:26:41 +00002031 uint64_t Signature = makeTypeSignature(Identifier);
David Blaikief9b6a552014-04-22 22:39:41 +00002032 NewTU.setTypeSignature(Signature);
David Blaikief3de2ab2014-04-26 16:26:41 +00002033
David Blaikie29459ae2014-07-25 17:11:58 +00002034 if (useSplitDwarf())
David Blaikiea34568b2014-11-01 20:06:28 +00002035 NewTU.initSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
David Blaikie29459ae2014-07-25 17:11:58 +00002036 else {
David Blaikie92a2f8a2014-04-28 21:04:29 +00002037 CU.applyStmtList(UnitDie);
David Blaikie29459ae2014-07-25 17:11:58 +00002038 NewTU.initSection(
2039 Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2040 }
Chandler Carruthb587ab62014-01-20 08:07:07 +00002041
David Blaikief3de2ab2014-04-26 16:26:41 +00002042 NewTU.setType(NewTU.createTypeDIE(CTy));
2043
David Blaikiee12b49a2014-04-26 17:27:38 +00002044 if (TopLevelType) {
2045 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2046 TypeUnitsUnderConstruction.clear();
2047
2048 // Types referencing entries in the address table cannot be placed in type
2049 // units.
2050 if (AddrPool.hasBeenUsed()) {
2051
2052 // Remove all the types built while building this type.
2053 // This is pessimistic as some of these types might not be dependent on
2054 // the type that used an address.
2055 for (const auto &TU : TypeUnitsToAdd)
2056 DwarfTypeUnits.erase(TU.second);
2057
2058 // Construct this type in the CU directly.
2059 // This is inefficient because all the dependent types will be rebuilt
2060 // from scratch, including building them in type units, discovering that
2061 // they depend on addresses, throwing them out and rebuilding them.
2062 CU.constructTypeDIE(RefDie, CTy);
2063 return;
2064 }
2065
2066 // If the type wasn't dependent on fission addresses, finish adding the type
2067 // and all its dependent types.
David Blaikiec13bc972014-08-27 05:04:14 +00002068 for (auto &TU : TypeUnitsToAdd)
David Blaikiee12b49a2014-04-26 17:27:38 +00002069 InfoHolder.addUnit(std::move(TU.first));
David Blaikiee12b49a2014-04-26 17:27:38 +00002070 }
David Blaikief9b6a552014-04-22 22:39:41 +00002071 CU.addDIETypeSignature(RefDie, NewTU);
David Blaikie409dd9c2013-11-19 23:08:21 +00002072}
David Blaikie4bd13b72014-03-07 18:49:45 +00002073
David Blaikie2406a0622014-04-23 23:37:35 +00002074// Accelerator table mutators - add each name along with its companion
2075// DIE to the proper table while ensuring that the name that we're going
2076// to reference is in the string table. We do this since the names we
2077// add may not only be identical to the names in the DIE.
David Blaikieb0b3fcf2014-04-25 18:52:29 +00002078void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
David Blaikie2406a0622014-04-23 23:37:35 +00002079 if (!useDwarfAccelTables())
2080 return;
David Blaikie772ab8a2014-04-25 22:21:35 +00002081 AccelNames.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2082 &Die);
David Blaikie2406a0622014-04-23 23:37:35 +00002083}
David Blaikie0ee82b92014-04-24 00:53:32 +00002084
David Blaikieb0b3fcf2014-04-25 18:52:29 +00002085void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
David Blaikie0ee82b92014-04-24 00:53:32 +00002086 if (!useDwarfAccelTables())
2087 return;
David Blaikie772ab8a2014-04-25 22:21:35 +00002088 AccelObjC.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2089 &Die);
David Blaikie0ee82b92014-04-24 00:53:32 +00002090}
David Blaikieecf04152014-04-24 01:02:42 +00002091
David Blaikieb0b3fcf2014-04-25 18:52:29 +00002092void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
David Blaikieecf04152014-04-24 01:02:42 +00002093 if (!useDwarfAccelTables())
2094 return;
David Blaikie772ab8a2014-04-25 22:21:35 +00002095 AccelNamespace.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2096 &Die);
David Blaikieecf04152014-04-24 01:02:42 +00002097}
David Blaikie18d33752014-04-24 01:23:49 +00002098
David Blaikieb0b3fcf2014-04-25 18:52:29 +00002099void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
David Blaikie18d33752014-04-24 01:23:49 +00002100 if (!useDwarfAccelTables())
2101 return;
David Blaikie772ab8a2014-04-25 22:21:35 +00002102 AccelTypes.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2103 &Die);
David Blaikie18d33752014-04-24 01:23:49 +00002104}