blob: 79e6e463440a8bf22409a8745a1be504aa2d55c0 [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
Bill Wendling2f921f82009-05-15 09:23:25 +0000108//===----------------------------------------------------------------------===//
109
Manman Renbe5576f2013-10-08 19:07:44 +0000110/// resolve - Look in the DwarfDebug map for the MDNode that
111/// corresponds to the reference.
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000112template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
Manman Renbe5576f2013-10-08 19:07:44 +0000113 return DD->resolve(Ref);
114}
115
Adrian Prantl1a1647c2014-03-18 02:34:58 +0000116bool DbgVariable::isBlockByrefVariable() const {
117 assert(Var.isVariable() && "Invalid complex DbgVariable!");
118 return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
119}
120
Nick Lewycky019d2552011-07-29 03:49:23 +0000121DIType DbgVariable::getType() const {
Adrian Prantl1a1647c2014-03-18 02:34:58 +0000122 DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
Devang Patelf20c4f72011-04-12 22:53:02 +0000123 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
124 // addresses instead.
Adrian Prantl1a1647c2014-03-18 02:34:58 +0000125 if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
Devang Patelf20c4f72011-04-12 22:53:02 +0000126 /* Byref variables, in Blocks, are declared by the programmer as
127 "SomeType VarName;", but the compiler creates a
128 __Block_byref_x_VarName struct, and gives the variable VarName
129 either the struct, or a pointer to the struct, as its type. This
130 is necessary for various behind-the-scenes things the compiler
131 needs to do with by-reference variables in blocks.
Eric Christopher6a841382012-11-19 22:42:10 +0000132
Devang Patelf20c4f72011-04-12 22:53:02 +0000133 However, as far as the original *programmer* is concerned, the
134 variable should still have type 'SomeType', as originally declared.
Eric Christopher6a841382012-11-19 22:42:10 +0000135
Devang Patelf20c4f72011-04-12 22:53:02 +0000136 The following function dives into the __Block_byref_x_VarName
137 struct to find the original type of the variable. This will be
138 passed back to the code generating the type for the Debug
139 Information Entry for the variable 'VarName'. 'VarName' will then
140 have the original type 'SomeType' in its debug information.
Eric Christopher6a841382012-11-19 22:42:10 +0000141
Devang Patelf20c4f72011-04-12 22:53:02 +0000142 The original type 'SomeType' will be the type of the field named
143 'VarName' inside the __Block_byref_x_VarName struct.
Eric Christopher6a841382012-11-19 22:42:10 +0000144
Devang Patelf20c4f72011-04-12 22:53:02 +0000145 NOTE: In order for this to not completely fail on the debugger
146 side, the Debug Information Entry for the variable VarName needs to
147 have a DW_AT_location that tells the debugger how to unwind through
148 the pointers and __Block_byref_x_VarName struct to find the actual
149 value of the variable. The function addBlockByrefType does this. */
150 DIType subType = Ty;
Eric Christopher31b05762013-08-08 01:41:00 +0000151 uint16_t tag = Ty.getTag();
Eric Christopher6a841382012-11-19 22:42:10 +0000152
Eric Christopher9adc55f2013-09-04 19:53:21 +0000153 if (tag == dwarf::DW_TAG_pointer_type)
Manman Renbe5576f2013-10-08 19:07:44 +0000154 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
Eric Christopher6a841382012-11-19 22:42:10 +0000155
Manman Renab8ffba2014-07-28 19:14:13 +0000156 DIArray Elements = DICompositeType(subType).getElements();
Devang Patelf20c4f72011-04-12 22:53:02 +0000157 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
David Blaikie5af2aca2013-11-18 23:57:26 +0000158 DIDerivedType DT(Elements.getElement(i));
Devang Patelf20c4f72011-04-12 22:53:02 +0000159 if (getName() == DT.getName())
Manman Renbe5576f2013-10-08 19:07:44 +0000160 return (resolve(DT.getTypeDerivedFrom()));
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000161 }
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000162 }
Devang Patelf20c4f72011-04-12 22:53:02 +0000163 return Ty;
164}
Bill Wendling2f921f82009-05-15 09:23:25 +0000165
David Blaikie18d33752014-04-24 01:23:49 +0000166static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
167 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
168 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
169 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
170
Chris Lattnerf0d6bd32010-04-05 05:11:15 +0000171DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
David Blaikie0dc623c2014-10-24 17:53:38 +0000172 : Asm(A), MMI(Asm->MMI), PrevLabel(nullptr), GlobalRangeCount(0),
David Blaikie2b22b1e2014-10-23 00:16:03 +0000173 InfoHolder(A, *this, "info_string", DIEValueAllocator),
Eric Christopher2037caf2014-01-28 00:49:26 +0000174 UsedNonDefaultText(false),
David Blaikie2b22b1e2014-10-23 00:16:03 +0000175 SkeletonHolder(A, *this, "skel_string", DIEValueAllocator),
David Blaikiee1c79742014-09-30 21:28:32 +0000176 IsDarwin(Triple(A->getTargetTriple()).isOSDarwin()),
David Blaikie2406a0622014-04-23 23:37:35 +0000177 AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
David Blaikie0ee82b92014-04-24 00:53:32 +0000178 dwarf::DW_FORM_data4)),
179 AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
David Blaikieecf04152014-04-24 01:02:42 +0000180 dwarf::DW_FORM_data4)),
181 AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
David Blaikie18d33752014-04-24 01:23:49 +0000182 dwarf::DW_FORM_data4)),
183 AccelTypes(TypeAtoms) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000184
Craig Topper353eda42014-04-24 06:44:33 +0000185 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = nullptr;
186 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = nullptr;
187 DwarfLineSectionSym = nullptr;
188 DwarfAddrSectionSym = nullptr;
189 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = nullptr;
190 FunctionBeginSym = FunctionEndSym = nullptr;
191 CurFn = nullptr;
192 CurMI = nullptr;
Eric Christopherad9fe892012-04-02 17:58:52 +0000193
Adrian Prantl5bf1d002013-10-15 20:26:37 +0000194 // Turn on accelerator tables for Darwin by default, pubnames by
195 // default for non-Darwin, and handle split dwarf.
Eric Christopher574b5c82013-08-19 21:41:38 +0000196 if (DwarfAccelTables == Default)
197 HasDwarfAccelTables = IsDarwin;
198 else
Eric Christopher5297df02013-08-26 20:58:35 +0000199 HasDwarfAccelTables = DwarfAccelTables == Enable;
Eric Christopher20b76a72012-08-23 22:36:40 +0000200
Eric Christophercdf218d2012-12-10 19:51:21 +0000201 if (SplitDwarf == Default)
202 HasSplitDwarf = false;
Eric Christopher29424312012-11-12 22:22:20 +0000203 else
Eric Christopher574b5c82013-08-19 21:41:38 +0000204 HasSplitDwarf = SplitDwarf == Enable;
Eric Christopher29424312012-11-12 22:22:20 +0000205
Eric Christopher4d36ca02013-08-26 23:24:35 +0000206 if (DwarfPubSections == Default)
207 HasDwarfPubSections = !IsDarwin;
Eric Christopher574b5c82013-08-19 21:41:38 +0000208 else
Eric Christopher4d36ca02013-08-26 23:24:35 +0000209 HasDwarfPubSections = DwarfPubSections == Enable;
Eric Christopher7da24882013-08-19 21:07:38 +0000210
Eric Christopher4c5bff32014-06-19 06:22:08 +0000211 unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
Eric Christopher793c7472014-04-28 20:42:22 +0000212 DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
213 : MMI->getModule()->getDwarfVersion();
Manman Renac8062b2013-07-02 23:40:10 +0000214
Oliver Stannardf7693f42014-06-19 15:39:33 +0000215 Asm->OutStreamer.getContext().setDwarfVersion(DwarfVersion);
216
Dan Gohman6e681a52010-06-18 15:56:31 +0000217 {
218 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
Eric Christopher58f41952012-11-19 22:42:15 +0000219 beginModule();
Torok Edwinf8dba242010-04-07 10:44:46 +0000220 }
Bill Wendling2f921f82009-05-15 09:23:25 +0000221}
Bill Wendling2f921f82009-05-15 09:23:25 +0000222
Reid Klecknerdd2647e2014-04-30 20:34:31 +0000223// Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
224DwarfDebug::~DwarfDebug() { }
225
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000226// Switch to the specified MCSection and emit an assembler
227// temporary label to it if SymbolStem is specified.
Eric Christopher7b30f2e42012-11-21 00:34:35 +0000228static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
Craig Topper353eda42014-04-24 06:44:33 +0000229 const char *SymbolStem = nullptr) {
Eric Christophera7b61892011-11-07 09:18:38 +0000230 Asm->OutStreamer.SwitchSection(Section);
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000231 if (!SymbolStem)
Craig Topper353eda42014-04-24 06:44:33 +0000232 return nullptr;
Eric Christophera7b61892011-11-07 09:18:38 +0000233
234 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
235 Asm->OutStreamer.EmitLabel(TmpSym);
236 return TmpSym;
237}
238
Eric Christopherd9843b32011-11-10 19:25:34 +0000239static bool isObjCClass(StringRef Name) {
240 return Name.startswith("+") || Name.startswith("-");
241}
242
243static bool hasObjCCategory(StringRef Name) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000244 if (!isObjCClass(Name))
245 return false;
Eric Christopherd9843b32011-11-10 19:25:34 +0000246
Benjamin Kramer260de742013-08-24 12:15:54 +0000247 return Name.find(") ") != StringRef::npos;
Eric Christopherd9843b32011-11-10 19:25:34 +0000248}
249
250static void getObjCClassCategory(StringRef In, StringRef &Class,
251 StringRef &Category) {
252 if (!hasObjCCategory(In)) {
253 Class = In.slice(In.find('[') + 1, In.find(' '));
254 Category = "";
255 return;
256 }
257
258 Class = In.slice(In.find('[') + 1, In.find('('));
259 Category = In.slice(In.find('[') + 1, In.find(' '));
260 return;
261}
262
263static StringRef getObjCMethodName(StringRef In) {
264 return In.slice(In.find(' ') + 1, In.find(']'));
265}
266
Richard Mittonc2508242013-10-03 22:07:08 +0000267// Helper for sorting sections into a stable output order.
268static bool SectionSort(const MCSection *A, const MCSection *B) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000269 std::string LA = (A ? A->getLabelBeginName() : "");
270 std::string LB = (B ? B->getLabelBeginName() : "");
271 return LA < LB;
Richard Mittonc2508242013-10-03 22:07:08 +0000272}
273
Eric Christopherd9843b32011-11-10 19:25:34 +0000274// Add the various names to the Dwarf accelerator table names.
Eric Christopher9cd26af2013-09-20 23:22:52 +0000275// TODO: Determine whether or not we should add names for programs
276// that do not have a DW_AT_name or DW_AT_linkage_name field - this
277// is only slightly different than the lookup of non-standard ObjC names.
David Blaikieb0b3fcf2014-04-25 18:52:29 +0000278void DwarfDebug::addSubprogramNames(DISubprogram SP, DIE &Die) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000279 if (!SP.isDefinition())
280 return;
David Blaikie2406a0622014-04-23 23:37:35 +0000281 addAccelName(SP.getName(), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000282
283 // If the linkage name is different than the name, go ahead and output
284 // that as well into the name table.
285 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
David Blaikie2406a0622014-04-23 23:37:35 +0000286 addAccelName(SP.getLinkageName(), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000287
288 // If this is an Objective-C selector name add it to the ObjC accelerator
289 // too.
290 if (isObjCClass(SP.getName())) {
291 StringRef Class, Category;
292 getObjCClassCategory(SP.getName(), Class, Category);
David Blaikie0ee82b92014-04-24 00:53:32 +0000293 addAccelObjC(Class, Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000294 if (Category != "")
David Blaikie0ee82b92014-04-24 00:53:32 +0000295 addAccelObjC(Category, Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000296 // Also add the base method name to the name table.
David Blaikie2406a0622014-04-23 23:37:35 +0000297 addAccelName(getObjCMethodName(SP.getName()), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000298 }
299}
300
Manman Ren3eb9dff2013-09-09 19:05:21 +0000301/// isSubprogramContext - Return true if Context is either a subprogram
302/// or another context nested inside a subprogram.
303bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
304 if (!Context)
305 return false;
306 DIDescriptor D(Context);
307 if (D.isSubprogram())
308 return true;
309 if (D.isType())
Manman Ren116868e2013-09-09 19:47:11 +0000310 return isSubprogramContext(resolve(DIType(Context).getContext()));
Manman Ren3eb9dff2013-09-09 19:05:21 +0000311 return false;
312}
313
Manman Ren5b2f4b02013-09-11 19:40:28 +0000314/// Check whether we should create a DIE for the given Scope, return true
315/// if we don't create a DIE (the corresponding DIE is null).
Manman Ren2312ed32013-09-10 18:40:41 +0000316bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
317 if (Scope->isAbstractScope())
318 return false;
319
Manman Ren5b2f4b02013-09-11 19:40:28 +0000320 // We don't create a DIE if there is no Range.
Manman Ren2312ed32013-09-10 18:40:41 +0000321 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
322 if (Ranges.empty())
323 return true;
324
325 if (Ranges.size() > 1)
326 return false;
327
Manman Ren5b2f4b02013-09-11 19:40:28 +0000328 // We don't create a DIE if we have a single Range and the end label
329 // is null.
David Blaikiecd4b8a22014-08-31 02:14:26 +0000330 return !getLabelAfterInsn(Ranges.front().second);
Manman Ren2312ed32013-09-10 18:40:41 +0000331}
332
David Blaikie3a443c22014-11-04 22:12:25 +0000333template <typename Func> void forBothCUs(DwarfCompileUnit &CU, Func F) {
334 F(CU);
335 if (auto *SkelCU = CU.getSkeleton())
336 F(*SkelCU);
337}
338
David Blaikie73cc7052014-10-09 20:36:27 +0000339void DwarfDebug::constructAbstractSubprogramScopeDIE(LexicalScope *Scope) {
David Blaikiee872a6e2014-04-29 15:58:35 +0000340 assert(Scope && Scope->getScopeNode());
341 assert(Scope->isAbstractScope());
342 assert(!Scope->getInlinedAt());
343
David Blaikie58410f22014-10-10 06:39:26 +0000344 const MDNode *SP = Scope->getScopeNode();
David Blaikiee872a6e2014-04-29 15:58:35 +0000345
David Blaikie9ab48842014-10-10 03:09:38 +0000346 ProcessedSPNodes.insert(SP);
347
David Blaikie1ea9db22014-05-21 23:14:12 +0000348 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
349 // was inlined from another compile unit.
David Blaikie3a443c22014-11-04 22:12:25 +0000350 auto &CU = SPMap[SP];
351 forBothCUs(*CU, [&](DwarfCompileUnit &CU) {
352 CU.constructAbstractSubprogramScopeDIE(Scope);
353 });
David Blaikiee872a6e2014-04-29 15:58:35 +0000354}
355
David Blaikie65a74662014-04-25 18:26:14 +0000356void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
David Blaikie3c842622013-12-04 21:31:26 +0000357 if (!GenerateGnuPubSections)
358 return;
359
David Blaikief9b6a552014-04-22 22:39:41 +0000360 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
David Blaikie3c842622013-12-04 21:31:26 +0000361}
362
Eric Christopher4287a492013-12-09 23:57:44 +0000363// Create new DwarfCompileUnit for the given metadata node with tag
Eric Christopher48fef592012-12-20 21:58:40 +0000364// DW_TAG_compile_unit.
David Blaikief9b6a552014-04-22 22:39:41 +0000365DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
Devang Patel2d9caf92009-11-25 17:36:49 +0000366 StringRef FN = DIUnit.getFilename();
Nick Lewyckyd1ee7f82011-11-02 20:55:33 +0000367 CompilationDir = DIUnit.getDirectory();
Bill Wendling2b128d72009-05-20 23:19:06 +0000368
David Blaikief9b6a552014-04-22 22:39:41 +0000369 auto OwnedUnit = make_unique<DwarfCompileUnit>(
David Blaikiebd579052014-04-28 21:14:27 +0000370 InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
David Blaikief9b6a552014-04-22 22:39:41 +0000371 DwarfCompileUnit &NewCU = *OwnedUnit;
David Blaikie92a2f8a2014-04-28 21:04:29 +0000372 DIE &Die = NewCU.getUnitDie();
David Blaikief9b6a552014-04-22 22:39:41 +0000373 InfoHolder.addUnit(std::move(OwnedUnit));
David Blaikiecafd9622014-11-02 08:51:37 +0000374 if (useSplitDwarf())
375 NewCU.setSkeleton(constructSkeletonCU(NewCU));
David Blaikief9b6a552014-04-22 22:39:41 +0000376
David Blaikie7ac51492014-03-20 17:05:45 +0000377 // LTO with assembly output shares a single line table amongst multiple CUs.
378 // To avoid the compilation directory being ambiguous, let the line table
379 // explicitly describe the directory of all files, never relying on the
380 // compilation directory.
David Blaikie47f4b822014-03-19 00:11:28 +0000381 if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
David Blaikiee05274d2014-03-18 00:11:48 +0000382 Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
David Blaikief9b6a552014-04-22 22:39:41 +0000383 NewCU.getUniqueID(), CompilationDir);
David Blaikie2666e242013-12-06 19:38:46 +0000384
David Blaikie92a2f8a2014-04-28 21:04:29 +0000385 NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
386 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
David Blaikie637cac42014-04-22 23:09:36 +0000387 DIUnit.getLanguage());
David Blaikie92a2f8a2014-04-28 21:04:29 +0000388 NewCU.addString(Die, dwarf::DW_AT_name, FN);
Eric Christopher52ce7182013-04-09 19:23:15 +0000389
Eric Christopher52ce7182013-04-09 19:23:15 +0000390 if (!useSplitDwarf()) {
David Blaikief9b6a552014-04-22 22:39:41 +0000391 NewCU.initStmtList(DwarfLineSectionSym);
Eric Christophera51d3fc2013-09-27 22:50:48 +0000392
393 // If we're using split dwarf the compilation dir is going to be in the
394 // skeleton CU and so we don't need to duplicate it here.
395 if (!CompilationDir.empty())
David Blaikie92a2f8a2014-04-28 21:04:29 +0000396 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
Eric Christophera51d3fc2013-09-27 22:50:48 +0000397
David Blaikie92a2f8a2014-04-28 21:04:29 +0000398 addGnuPubAttributes(NewCU, Die);
Eric Christopher52ce7182013-04-09 19:23:15 +0000399 }
Bill Wendling2b128d72009-05-20 23:19:06 +0000400
Bill Wendling2b128d72009-05-20 23:19:06 +0000401 if (DIUnit.isOptimized())
David Blaikie92a2f8a2014-04-28 21:04:29 +0000402 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
Bill Wendling2b128d72009-05-20 23:19:06 +0000403
Devang Patel2d9caf92009-11-25 17:36:49 +0000404 StringRef Flags = DIUnit.getFlags();
405 if (!Flags.empty())
David Blaikie92a2f8a2014-04-28 21:04:29 +0000406 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
Eric Christopher6a841382012-11-19 22:42:10 +0000407
Nick Lewycky479a8fe2011-10-17 23:27:36 +0000408 if (unsigned RVer = DIUnit.getRunTimeVersion())
David Blaikie92a2f8a2014-04-28 21:04:29 +0000409 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
David Blaikie637cac42014-04-22 23:09:36 +0000410 dwarf::DW_FORM_data1, RVer);
Bill Wendling2b128d72009-05-20 23:19:06 +0000411
David Blaikiecafd9622014-11-02 08:51:37 +0000412 if (useSplitDwarf())
David Blaikief9b6a552014-04-22 22:39:41 +0000413 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
David Blaikie637cac42014-04-22 23:09:36 +0000414 DwarfInfoDWOSectionSym);
David Blaikiecafd9622014-11-02 08:51:37 +0000415 else
David Blaikief9b6a552014-04-22 22:39:41 +0000416 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
David Blaikie637cac42014-04-22 23:09:36 +0000417 DwarfInfoSectionSym);
Eric Christopherd039baa2013-12-30 03:40:32 +0000418
David Blaikief9b6a552014-04-22 22:39:41 +0000419 CUMap.insert(std::make_pair(DIUnit, &NewCU));
David Blaikie92a2f8a2014-04-28 21:04:29 +0000420 CUDieMap.insert(std::make_pair(&Die, &NewCU));
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000421 return NewCU;
Devang Patel1a0df9a2010-05-10 22:49:55 +0000422}
423
David Blaikie8912df12014-08-31 05:41:15 +0000424void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
425 const MDNode *N) {
David Blaikie1fd43652013-05-07 21:35:53 +0000426 DIImportedEntity Module(N);
David Blaikie5e390e42014-02-04 01:23:52 +0000427 assert(Module.Verify());
David Blaikief9b6a552014-04-22 22:39:41 +0000428 if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
David Blaikiefebfafd2014-10-06 05:37:24 +0000429 D->addChild(TheCU.constructImportedEntityDIE(Module));
David Blaikief55abea2013-04-22 06:12:31 +0000430}
431
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000432// Emit all Dwarf sections that should come prior to the content. Create
433// global DIEs and emit initial debug info sections. This is invoked by
434// the target AsmPrinter.
Eric Christopher58f41952012-11-19 22:42:15 +0000435void DwarfDebug::beginModule() {
Devang Patel6c74a872010-04-27 19:46:33 +0000436 if (DisableDebugInfoPrinting)
437 return;
438
Eric Christopher58f41952012-11-19 22:42:15 +0000439 const Module *M = MMI->getModule();
440
David Blaikie2f040112014-07-25 16:10:16 +0000441 FunctionDIs = makeSubprogramMap(*M);
442
Devang Patele02e5852011-05-03 16:45:22 +0000443 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
David Blaikiedc69ebb2013-03-11 23:39:23 +0000444 if (!CU_Nodes)
Devang Patel07bb9ee2011-08-15 23:47:24 +0000445 return;
Manman Ren60352032013-09-05 18:48:31 +0000446 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
Devang Patele02e5852011-05-03 16:45:22 +0000447
David Blaikiedc69ebb2013-03-11 23:39:23 +0000448 // Emit initial sections so we can reference labels later.
449 emitSectionLabels();
450
David Blaikie47f4b822014-03-19 00:11:28 +0000451 SingleCU = CU_Nodes->getNumOperands() == 1;
David Blaikiee05274d2014-03-18 00:11:48 +0000452
Duncan P. N. Exon Smithde36e802014-11-11 21:30:22 +0000453 for (MDNode *N : CU_Nodes->operands()) {
454 DICompileUnit CUNode(N);
David Blaikief9b6a552014-04-22 22:39:41 +0000455 DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
David Blaikie1fd43652013-05-07 21:35:53 +0000456 DIArray ImportedEntities = CUNode.getImportedEntities();
457 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
David Blaikie684fc532013-05-06 23:33:07 +0000458 ScopesWithImportedEntities.push_back(std::make_pair(
David Blaikie1fd43652013-05-07 21:35:53 +0000459 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
460 ImportedEntities.getElement(i)));
David Blaikie684fc532013-05-06 23:33:07 +0000461 std::sort(ScopesWithImportedEntities.begin(),
Benjamin Kramerb12cf012013-08-24 12:54:27 +0000462 ScopesWithImportedEntities.end(), less_first());
David Blaikiedc69ebb2013-03-11 23:39:23 +0000463 DIArray GVs = CUNode.getGlobalVariables();
464 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
Frederic Riss9ba9eff2014-09-19 15:12:03 +0000465 CU.getOrCreateGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
David Blaikie6ba88e02014-08-29 22:10:52 +0000466 DIArray SPs = CUNode.getSubprograms();
467 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
468 SPMap.insert(std::make_pair(SPs.getElement(i), &CU));
David Blaikiedc69ebb2013-03-11 23:39:23 +0000469 DIArray EnumTypes = CUNode.getEnumTypes();
Manman Renbd1628a2014-07-28 23:04:20 +0000470 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i) {
471 DIType Ty(EnumTypes.getElement(i));
472 // The enum types array by design contains pointers to
473 // MDNodes rather than DIRefs. Unique them here.
474 DIType UniqueTy(resolve(Ty.getRef()));
475 CU.getOrCreateTypeDIE(UniqueTy);
476 }
David Blaikiedc69ebb2013-03-11 23:39:23 +0000477 DIArray RetainedTypes = CUNode.getRetainedTypes();
Adrian Prantl0aa1aa22014-03-18 02:35:03 +0000478 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
479 DIType Ty(RetainedTypes.getElement(i));
480 // The retained types array by design contains pointers to
481 // MDNodes rather than DIRefs. Unique them here.
482 DIType UniqueTy(resolve(Ty.getRef()));
David Blaikief9b6a552014-04-22 22:39:41 +0000483 CU.getOrCreateTypeDIE(UniqueTy);
Adrian Prantl0aa1aa22014-03-18 02:35:03 +0000484 }
David Blaikief55abea2013-04-22 06:12:31 +0000485 // Emit imported_modules last so that the relevant context is already
486 // available.
David Blaikie1fd43652013-05-07 21:35:53 +0000487 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
David Blaikie8912df12014-08-31 05:41:15 +0000488 constructAndAddImportedEntityDIE(CU, ImportedEntities.getElement(i));
David Blaikiedc69ebb2013-03-11 23:39:23 +0000489 }
Eric Christopher6a841382012-11-19 22:42:10 +0000490
Chris Lattner7cfa70e2010-04-05 02:19:28 +0000491 // Tell MMI that we have debug info.
492 MMI->setDebugInfoAvailability(true);
Eric Christopher6a841382012-11-19 22:42:10 +0000493
Bill Wendling2b128d72009-05-20 23:19:06 +0000494 // Prime section data.
Richard Mitton21101b32013-09-19 23:21:01 +0000495 SectionMap[Asm->getObjFileLowering().getTextSection()];
Bill Wendling2b128d72009-05-20 23:19:06 +0000496}
497
David Blaikieeb1a2722014-06-13 22:18:23 +0000498void DwarfDebug::finishVariableDefinitions() {
499 for (const auto &Var : ConcreteVariables) {
500 DIE *VariableDie = Var->getDIE();
David Blaikief73ae4f2014-08-12 00:00:31 +0000501 assert(VariableDie);
David Blaikieeb1a2722014-06-13 22:18:23 +0000502 // FIXME: Consider the time-space tradeoff of just storing the unit pointer
503 // in the ConcreteVariables list, rather than looking it up again here.
504 // DIE::getUnit isn't simple - it walks parent pointers, etc.
505 DwarfCompileUnit *Unit = lookupUnit(VariableDie->getUnit());
506 assert(Unit);
David Blaikiee847f132014-06-13 22:35:44 +0000507 DbgVariable *AbsVar = getExistingAbstractVariable(Var->getVariable());
David Blaikieeb1a2722014-06-13 22:18:23 +0000508 if (AbsVar && AbsVar->getDIE()) {
509 Unit->addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
510 *AbsVar->getDIE());
511 } else
512 Unit->applyVariableAttributes(*Var, *VariableDie);
513 }
514}
515
David Blaikief7221ad2014-05-27 18:37:43 +0000516void DwarfDebug::finishSubprogramDefinitions() {
David Blaikie7d6f29d2014-10-10 16:59:52 +0000517 for (const auto &P : SPMap)
David Blaikie3a443c22014-11-04 22:12:25 +0000518 forBothCUs(*P.second, [&](DwarfCompileUnit &CU) {
519 CU.finishSubprogramDefinition(DISubprogram(P.first));
520 });
David Blaikief7221ad2014-05-27 18:37:43 +0000521}
522
523
Eric Christopher960ac372012-11-22 00:59:49 +0000524// Collect info for variables that were optimized out.
525void DwarfDebug::collectDeadVariables() {
526 const Module *M = MMI->getModule();
Eric Christopher960ac372012-11-22 00:59:49 +0000527
528 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
Duncan P. N. Exon Smithde36e802014-11-11 21:30:22 +0000529 for (MDNode *N : CU_Nodes->operands()) {
530 DICompileUnit TheCU(N);
David Blaikie9ba72542014-05-14 21:52:46 +0000531 // Construct subprogram DIE and add variables DIEs.
532 DwarfCompileUnit *SPCU =
533 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
534 assert(SPCU && "Unable to find Compile Unit!");
Eric Christopher960ac372012-11-22 00:59:49 +0000535 DIArray Subprograms = TheCU.getSubprograms();
536 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
Eric Christopher735401c2012-11-27 00:13:51 +0000537 DISubprogram SP(Subprograms.getElement(i));
Eric Christophera6c38a32013-10-15 23:31:38 +0000538 if (ProcessedSPNodes.count(SP) != 0)
539 continue;
David Blaikie1d96cc22014-10-31 22:30:30 +0000540 SPCU->collectDeadVariables(SP);
Eric Christopher960ac372012-11-22 00:59:49 +0000541 }
542 }
543 }
Eric Christopher960ac372012-11-22 00:59:49 +0000544}
545
546void DwarfDebug::finalizeModuleInfo() {
David Blaikie3c2fff32014-05-27 18:37:48 +0000547 finishSubprogramDefinitions();
548
David Blaikieeb1a2722014-06-13 22:18:23 +0000549 finishVariableDefinitions();
550
Eric Christopher960ac372012-11-22 00:59:49 +0000551 // Collect info for variables that were optimized out.
552 collectDeadVariables();
553
Eric Christopherad10cb52013-12-04 23:24:38 +0000554 // Handle anything that needs to be done on a per-unit basis after
555 // all other generation.
David Blaikie1998a2e2014-11-01 01:11:19 +0000556 for (const auto &P : CUMap) {
557 auto &TheCU = *P.second;
Eric Christopher60eb7692013-08-12 20:27:48 +0000558 // Emit DW_AT_containing_type attribute to connect types with their
559 // vtable holding type.
David Blaikie1998a2e2014-11-01 01:11:19 +0000560 TheCU.constructContainingTypeDIEs();
Eric Christopher60eb7692013-08-12 20:27:48 +0000561
Eric Christopher46e23432013-12-20 04:16:18 +0000562 // Add CU specific attributes if we need to add any.
David Blaikie1998a2e2014-11-01 01:11:19 +0000563 // If we're splitting the dwarf out now that we've got the entire
564 // CU then add the dwo id to it.
565 auto *SkCU = TheCU.getSkeleton();
566 if (useSplitDwarf()) {
567 // Emit a unique identifier for this CU.
568 uint64_t ID = DIEHash(Asm).computeCUSignature(TheCU.getUnitDie());
569 TheCU.addUInt(TheCU.getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
570 dwarf::DW_FORM_data8, ID);
571 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
572 dwarf::DW_FORM_data8, ID);
David Blaikie3ffe4dd2014-03-25 05:34:24 +0000573
David Blaikie1998a2e2014-11-01 01:11:19 +0000574 // We don't keep track of which addresses are used in which CU so this
575 // is a bit pessimistic under LTO.
576 if (!AddrPool.isEmpty())
577 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_addr_base,
578 DwarfAddrSectionSym, DwarfAddrSectionSym);
David Blaikie542616d2014-11-03 21:52:56 +0000579 if (!SkCU->getRangeLists().empty())
David Blaikie1998a2e2014-11-01 01:11:19 +0000580 SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
581 DwarfDebugRangeSectionSym,
582 DwarfDebugRangeSectionSym);
583 }
Eric Christopherd8667202013-12-30 17:22:27 +0000584
David Blaikie1998a2e2014-11-01 01:11:19 +0000585 // If we have code split among multiple sections or non-contiguous
586 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
587 // remain in the .o file, otherwise add a DW_AT_low_pc.
588 // FIXME: We should use ranges allow reordering of code ala
589 // .subsections_via_symbols in mach-o. This would mean turning on
590 // ranges for all subprogram DIEs for mach-o.
David Blaikiea8be0a72014-11-01 01:15:24 +0000591 DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
David Blaikie5b02a192014-11-03 23:10:59 +0000592 if (unsigned NumRanges = TheCU.getRanges().size()) {
593 if (NumRanges > 1)
David Blaikie1998a2e2014-11-01 01:11:19 +0000594 // A DW_AT_low_pc attribute may also be specified in combination with
595 // DW_AT_ranges to specify the default base address for use in
596 // location lists (see Section 2.6.2) and range lists (see Section
597 // 2.17.3).
598 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
David Blaikie5b02a192014-11-03 23:10:59 +0000599 else
600 TheCU.setBaseAddress(TheCU.getRanges().front().getStart());
601 U.attachRangesOrLowHighPC(U.getUnitDie(), TheCU.takeRanges());
Eric Christopher60eb7692013-08-12 20:27:48 +0000602 }
603 }
604
605 // Compute DIE offsets and sizes.
Eric Christopherc8a310e2012-12-10 23:34:43 +0000606 InfoHolder.computeSizeAndOffsets();
607 if (useSplitDwarf())
608 SkeletonHolder.computeSizeAndOffsets();
Eric Christopher960ac372012-11-22 00:59:49 +0000609}
610
611void DwarfDebug::endSections() {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000612 // Filter labels by section.
Benjamin Kramer15596c72014-03-07 19:09:39 +0000613 for (const SymbolCU &SCU : ArangeLabels) {
Richard Mitton21101b32013-09-19 23:21:01 +0000614 if (SCU.Sym->isInSection()) {
615 // Make a note of this symbol and it's section.
616 const MCSection *Section = &SCU.Sym->getSection();
617 if (!Section->getKind().isMetadata())
618 SectionMap[Section].push_back(SCU);
619 } else {
620 // Some symbols (e.g. common/bss on mach-o) can have no section but still
621 // appear in the output. This sucks as we rely on sections to build
622 // arange spans. We can do it without, but it's icky.
Craig Topper353eda42014-04-24 06:44:33 +0000623 SectionMap[nullptr].push_back(SCU);
Richard Mitton21101b32013-09-19 23:21:01 +0000624 }
625 }
Bill Wendling2b128d72009-05-20 23:19:06 +0000626
Richard Mittonc2508242013-10-03 22:07:08 +0000627 // Build a list of sections used.
628 std::vector<const MCSection *> Sections;
Benjamin Kramer15596c72014-03-07 19:09:39 +0000629 for (const auto &it : SectionMap) {
630 const MCSection *Section = it.first;
Richard Mittonc2508242013-10-03 22:07:08 +0000631 Sections.push_back(Section);
632 }
633
634 // Sort the sections into order.
635 // This is only done to ensure consistent output order across different runs.
636 std::sort(Sections.begin(), Sections.end(), SectionSort);
637
638 // Add terminating symbols for each section.
Benjamin Kramer15596c72014-03-07 19:09:39 +0000639 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
Richard Mittonc2508242013-10-03 22:07:08 +0000640 const MCSection *Section = Sections[ID];
Craig Topper353eda42014-04-24 06:44:33 +0000641 MCSymbol *Sym = nullptr;
Richard Mitton21101b32013-09-19 23:21:01 +0000642
643 if (Section) {
Richard Mittonc2508242013-10-03 22:07:08 +0000644 // We can't call MCSection::getLabelEndName, as it's only safe to do so
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000645 // if we know the section name up-front. For user-created sections, the
Eric Christopher95531b62014-01-29 22:06:21 +0000646 // resulting label may not be valid to use as a label. (section names can
647 // use a greater set of characters on some systems)
Richard Mittonc2508242013-10-03 22:07:08 +0000648 Sym = Asm->GetTempSymbol("debug_end", ID);
Richard Mitton21101b32013-09-19 23:21:01 +0000649 Asm->OutStreamer.SwitchSection(Section);
650 Asm->OutStreamer.EmitLabel(Sym);
651 }
652
653 // Insert a final terminator.
Craig Topper353eda42014-04-24 06:44:33 +0000654 SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
Bill Wendling2b128d72009-05-20 23:19:06 +0000655 }
Eric Christopher960ac372012-11-22 00:59:49 +0000656}
Bill Wendling2b128d72009-05-20 23:19:06 +0000657
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000658// Emit all Dwarf sections that should come after the content.
Eric Christopher960ac372012-11-22 00:59:49 +0000659void DwarfDebug::endModule() {
Craig Toppere73658d2014-04-28 04:05:08 +0000660 assert(CurFn == nullptr);
661 assert(CurMI == nullptr);
Eric Christopher960ac372012-11-22 00:59:49 +0000662
David Blaikie0dc623c2014-10-24 17:53:38 +0000663 // If we aren't actually generating debug info (check beginModule -
664 // conditionalized on !DisableDebugInfoPrinting and the presence of the
665 // llvm.dbg.cu metadata node)
666 if (!DwarfInfoSectionSym)
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000667 return;
Eric Christopher960ac372012-11-22 00:59:49 +0000668
669 // End any existing sections.
670 // TODO: Does this need to happen?
671 endSections();
672
673 // Finalize the debug info for the module.
674 finalizeModuleInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +0000675
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000676 emitDebugStr();
Eric Christopher9cd26af2013-09-20 23:22:52 +0000677
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000678 // Emit all the DIEs into a debug info section.
679 emitDebugInfo();
Eric Christopher4c9b1192012-11-27 00:41:54 +0000680
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000681 // Corresponding abbreviations into a abbrev section.
682 emitAbbreviations();
Eric Christopher95198f502012-11-27 22:43:42 +0000683
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000684 // Emit info into a debug aranges section.
Eric Christopher02dbadb2014-02-14 01:26:55 +0000685 if (GenerateARangeSection)
686 emitDebugARanges();
Eric Christopher95198f502012-11-27 22:43:42 +0000687
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000688 // Emit info into a debug ranges section.
689 emitDebugRanges();
Eric Christopher95198f502012-11-27 22:43:42 +0000690
Eric Christopher9a8f5ed2013-11-19 09:04:50 +0000691 if (useSplitDwarf()) {
692 emitDebugStrDWO();
Eric Christopher9c2ecd92012-11-30 23:59:06 +0000693 emitDebugInfoDWO();
Eric Christopher3c5a1912012-12-19 22:02:53 +0000694 emitDebugAbbrevDWO();
David Blaikie4a2f95f2014-03-18 01:17:26 +0000695 emitDebugLineDWO();
David Blaikiede8e12a2014-06-19 17:59:14 +0000696 emitDebugLocDWO();
Eric Christopher962c9082013-01-15 23:56:56 +0000697 // Emit DWO addresses.
David Blaikied75fb282014-04-23 21:20:10 +0000698 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
David Blaikie94c1d7f2014-04-02 01:50:20 +0000699 } else
700 // Emit info into a debug loc section.
701 emitDebugLoc();
Bill Wendling2b128d72009-05-20 23:19:06 +0000702
Eric Christophera876b822012-08-23 07:32:06 +0000703 // Emit info into the dwarf accelerator table sections.
Eric Christopher20b76a72012-08-23 22:36:40 +0000704 if (useDwarfAccelTables()) {
Eric Christopher4996c702011-11-07 09:24:32 +0000705 emitAccelNames();
706 emitAccelObjC();
707 emitAccelNamespaces();
708 emitAccelTypes();
709 }
Eric Christopher6a841382012-11-19 22:42:10 +0000710
Eric Christopher4b358182013-08-30 00:40:17 +0000711 // Emit the pubnames and pubtypes sections if requested.
712 if (HasDwarfPubSections) {
David Blaikie70a33202013-09-19 17:33:35 +0000713 emitDebugPubNames(GenerateGnuPubSections);
714 emitDebugPubTypes(GenerateGnuPubSections);
Eric Christopher4b358182013-08-30 00:40:17 +0000715 }
Devang Patel04d2f2d2009-11-24 01:14:22 +0000716
Devang Pateld0701282010-08-02 17:32:15 +0000717 // clean up.
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000718 SPMap.clear();
David Blaikie825bdd22014-05-21 22:41:17 +0000719 AbstractVariables.clear();
Bill Wendling2b128d72009-05-20 23:19:06 +0000720}
721
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000722// Find abstract variable, if any, associated with Var.
David Blaikiebe7c6772014-06-13 22:29:31 +0000723DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV,
David Blaikie36408e72014-06-04 23:50:52 +0000724 DIVariable &Cleansed) {
Devang Patelbb23a4a2011-08-10 21:50:54 +0000725 LLVMContext &Ctx = DV->getContext();
726 // More then one inlined variable corresponds to one abstract variable.
David Blaikie36408e72014-06-04 23:50:52 +0000727 // FIXME: This duplication of variables when inlining should probably be
728 // removed. It's done to allow each DIVariable to describe its location
729 // because the DebugLoc on the dbg.value/declare isn't accurate. We should
730 // make it accurate then remove this duplication/cleansing stuff.
731 Cleansed = cleanseInlinedVariable(DV, Ctx);
732 auto I = AbstractVariables.find(Cleansed);
David Blaikie825bdd22014-05-21 22:41:17 +0000733 if (I != AbstractVariables.end())
734 return I->second.get();
David Blaikie36408e72014-06-04 23:50:52 +0000735 return nullptr;
736}
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000737
David Blaikiee847f132014-06-13 22:35:44 +0000738DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV) {
739 DIVariable Cleansed;
740 return getExistingAbstractVariable(DV, Cleansed);
741}
742
David Blaikie6f9e8672014-06-13 23:52:55 +0000743void DwarfDebug::createAbstractVariable(const DIVariable &Var,
744 LexicalScope *Scope) {
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000745 auto AbsDbgVariable = make_unique<DbgVariable>(Var, DIExpression(), this);
David Blaikief4c504e2014-10-24 00:43:47 +0000746 InfoHolder.addScopeVariable(Scope, AbsDbgVariable.get());
David Blaikie6f9e8672014-06-13 23:52:55 +0000747 AbstractVariables[Var] = std::move(AbsDbgVariable);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000748}
749
David Blaikie6f9e8672014-06-13 23:52:55 +0000750void DwarfDebug::ensureAbstractVariableIsCreated(const DIVariable &DV,
751 const MDNode *ScopeNode) {
David Blaikie36408e72014-06-04 23:50:52 +0000752 DIVariable Cleansed = DV;
David Blaikie6f9e8672014-06-13 23:52:55 +0000753 if (getExistingAbstractVariable(DV, Cleansed))
754 return;
David Blaikie36408e72014-06-04 23:50:52 +0000755
David Blaikie6f9e8672014-06-13 23:52:55 +0000756 createAbstractVariable(Cleansed, LScopes.getOrCreateAbstractScope(ScopeNode));
David Blaikie36408e72014-06-04 23:50:52 +0000757}
758
David Blaikie6f9e8672014-06-13 23:52:55 +0000759void
760DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(const DIVariable &DV,
761 const MDNode *ScopeNode) {
David Blaikie36408e72014-06-04 23:50:52 +0000762 DIVariable Cleansed = DV;
David Blaikie6f9e8672014-06-13 23:52:55 +0000763 if (getExistingAbstractVariable(DV, Cleansed))
764 return;
David Blaikie36408e72014-06-04 23:50:52 +0000765
766 if (LexicalScope *Scope = LScopes.findAbstractScope(ScopeNode))
David Blaikie6f9e8672014-06-13 23:52:55 +0000767 createAbstractVariable(Cleansed, Scope);
David Blaikie36408e72014-06-04 23:50:52 +0000768}
769
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000770// Collect variable information from side table maintained by MMI.
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000771void DwarfDebug::collectVariableInfoFromMMITable(
Craig Topper71b7b682014-08-21 05:55:13 +0000772 SmallPtrSetImpl<const MDNode *> &Processed) {
Benjamin Kramer15596c72014-03-07 19:09:39 +0000773 for (const auto &VI : MMI->getVariableDbgInfo()) {
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +0000774 if (!VI.Var)
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000775 continue;
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +0000776 Processed.insert(VI.Var);
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +0000777 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000778
Devang Patelcdb7d442009-11-10 23:20:04 +0000779 // If variable scope is not found then skip this variable.
Craig Topper353eda42014-04-24 06:44:33 +0000780 if (!Scope)
Devang Patelcdb7d442009-11-10 23:20:04 +0000781 continue;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000782
David Blaikieff468a52014-10-28 02:57:26 +0000783 DIVariable DV(VI.Var);
784 DIExpression Expr(VI.Expr);
David Blaikie6f9e8672014-06-13 23:52:55 +0000785 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
Adrian Prantlca7e4702015-02-10 23:18:28 +0000786 auto RegVar = make_unique<DbgVariable>(DV, Expr, this, VI.Slot);
787 if (InfoHolder.addScopeVariable(Scope, RegVar.get()))
788 ConcreteVariables.push_back(std::move(RegVar));
Devang Patel475d32a2009-10-06 01:26:37 +0000789 }
Devang Patel490c8ab2010-05-20 19:57:06 +0000790}
Devang Patela3e9c9c2010-03-15 18:33:46 +0000791
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000792// Get .debug_loc entry for the instruction range starting at MI.
Adrian Prantle19e5ef2014-04-27 18:25:40 +0000793static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000794 const MDNode *Expr = MI->getDebugExpression();
Adrian Prantl7f487772014-04-10 17:39:48 +0000795 const MDNode *Var = MI->getDebugVariable();
Devang Patel2442a892011-07-08 17:09:57 +0000796
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000797 assert(MI->getNumOperands() == 4);
Adrian Prantl418d1d12013-07-09 20:28:37 +0000798 if (MI->getOperand(0).isReg()) {
Devang Patel2442a892011-07-08 17:09:57 +0000799 MachineLocation MLoc;
Adrian Prantl418d1d12013-07-09 20:28:37 +0000800 // If the second operand is an immediate, this is a
801 // register-indirect address.
802 if (!MI->getOperand(1).isImm())
Adrian Prantld4c0dd42013-04-26 21:57:17 +0000803 MLoc.set(MI->getOperand(0).getReg());
804 else
805 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000806 return DebugLocEntry::Value(Var, Expr, MLoc);
Devang Patel2442a892011-07-08 17:09:57 +0000807 }
808 if (MI->getOperand(0).isImm())
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000809 return DebugLocEntry::Value(Var, Expr, MI->getOperand(0).getImm());
Devang Patel2442a892011-07-08 17:09:57 +0000810 if (MI->getOperand(0).isFPImm())
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000811 return DebugLocEntry::Value(Var, Expr, MI->getOperand(0).getFPImm());
Devang Patel2442a892011-07-08 17:09:57 +0000812 if (MI->getOperand(0).isCImm())
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000813 return DebugLocEntry::Value(Var, Expr, MI->getOperand(0).getCImm());
Devang Patel2442a892011-07-08 17:09:57 +0000814
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000815 llvm_unreachable("Unexpected 4-operand DBG_VALUE instruction!");
Devang Patel2442a892011-07-08 17:09:57 +0000816}
817
Adrian Prantlb1416832014-08-01 22:11:58 +0000818/// Determine whether two variable pieces overlap.
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000819static bool piecesOverlap(DIExpression P1, DIExpression P2) {
Adrian Prantl27bd01f2015-02-09 23:57:15 +0000820 if (!P1.isBitPiece() || !P2.isBitPiece())
Adrian Prantlb1416832014-08-01 22:11:58 +0000821 return true;
Adrian Prantl27bd01f2015-02-09 23:57:15 +0000822 unsigned l1 = P1.getBitPieceOffset();
823 unsigned l2 = P2.getBitPieceOffset();
824 unsigned r1 = l1 + P1.getBitPieceSize();
825 unsigned r2 = l2 + P2.getBitPieceSize();
Adrian Prantlb1416832014-08-01 22:11:58 +0000826 // True where [l1,r1[ and [r1,r2[ overlap.
827 return (l1 < r2) && (l2 < r1);
828}
829
830/// Build the location list for all DBG_VALUEs in the function that
831/// describe the same variable. If the ranges of several independent
832/// pieces of the same variable overlap partially, split them up and
833/// combine the ranges. The resulting DebugLocEntries are will have
834/// strict monotonically increasing begin addresses and will never
835/// overlap.
836//
837// Input:
838//
839// Ranges History [var, loc, piece ofs size]
840// 0 | [x, (reg0, piece 0, 32)]
841// 1 | | [x, (reg1, piece 32, 32)] <- IsPieceOfPrevEntry
842// 2 | | ...
843// 3 | [clobber reg0]
844// 4 [x, (mem, piece 0, 64)] <- overlapping with both previous pieces of x.
845//
846// Output:
847//
848// [0-1] [x, (reg0, piece 0, 32)]
849// [1-3] [x, (reg0, piece 0, 32), (reg1, piece 32, 32)]
850// [3-4] [x, (reg1, piece 32, 32)]
851// [4- ] [x, (mem, piece 0, 64)]
David Blaikiee1a26a62014-08-05 23:14:16 +0000852void
853DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
854 const DbgValueHistoryMap::InstrRanges &Ranges) {
Adrian Prantlcaaf0532014-08-11 21:05:57 +0000855 SmallVector<DebugLocEntry::Value, 4> OpenRanges;
Adrian Prantlb1416832014-08-01 22:11:58 +0000856
857 for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
858 const MachineInstr *Begin = I->first;
859 const MachineInstr *End = I->second;
860 assert(Begin->isDebugValue() && "Invalid History entry");
861
862 // Check if a variable is inaccessible in this range.
Adrian Prantl5e1fa852014-08-12 21:55:58 +0000863 if (Begin->getNumOperands() > 1 &&
864 Begin->getOperand(0).isReg() && !Begin->getOperand(0).getReg()) {
Adrian Prantlb1416832014-08-01 22:11:58 +0000865 OpenRanges.clear();
866 continue;
867 }
868
869 // If this piece overlaps with any open ranges, truncate them.
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000870 DIExpression DIExpr = Begin->getDebugExpression();
Adrian Prantlcaaf0532014-08-11 21:05:57 +0000871 auto Last = std::remove_if(OpenRanges.begin(), OpenRanges.end(),
Adrian Prantl76502d82014-08-11 23:22:59 +0000872 [&](DebugLocEntry::Value R) {
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000873 return piecesOverlap(DIExpr, R.getExpression());
874 });
Adrian Prantlb1416832014-08-01 22:11:58 +0000875 OpenRanges.erase(Last, OpenRanges.end());
876
877 const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
878 assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
879
880 const MCSymbol *EndLabel;
881 if (End != nullptr)
882 EndLabel = getLabelAfterInsn(End);
883 else if (std::next(I) == Ranges.end())
884 EndLabel = FunctionEndSym;
885 else
886 EndLabel = getLabelBeforeInsn(std::next(I)->first);
887 assert(EndLabel && "Forgot label after instruction ending a range!");
888
889 DEBUG(dbgs() << "DotDebugLoc: " << *Begin << "\n");
890
891 auto Value = getDebugLocValue(Begin);
David Blaikiee1a26a62014-08-05 23:14:16 +0000892 DebugLocEntry Loc(StartLabel, EndLabel, Value);
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000893 bool couldMerge = false;
894
895 // If this is a piece, it may belong to the current DebugLocEntry.
Adrian Prantl27bd01f2015-02-09 23:57:15 +0000896 if (DIExpr.isBitPiece()) {
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000897 // Add this value to the list of open ranges.
Adrian Prantlcaaf0532014-08-11 21:05:57 +0000898 OpenRanges.push_back(Value);
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000899
900 // Attempt to add the piece to the last entry.
901 if (!DebugLoc.empty())
902 if (DebugLoc.back().MergeValues(Loc))
903 couldMerge = true;
904 }
905
906 if (!couldMerge) {
907 // Need to add a new DebugLocEntry. Add all values from still
908 // valid non-overlapping pieces.
Adrian Prantl1c6f2ec2014-08-11 21:06:00 +0000909 if (OpenRanges.size())
910 Loc.addValues(OpenRanges);
911
Adrian Prantlb1416832014-08-01 22:11:58 +0000912 DebugLoc.push_back(std::move(Loc));
913 }
Adrian Prantle09ee3f2014-08-11 20:59:28 +0000914
915 // Attempt to coalesce the ranges of two otherwise identical
916 // DebugLocEntries.
917 auto CurEntry = DebugLoc.rbegin();
918 auto PrevEntry = std::next(CurEntry);
919 if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
920 DebugLoc.pop_back();
Adrian Prantlb1416832014-08-01 22:11:58 +0000921
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000922 DEBUG({
923 dbgs() << CurEntry->getValues().size() << " Values:\n";
924 for (auto Value : CurEntry->getValues()) {
925 Value.getVariable()->dump();
926 Value.getExpression()->dump();
927 }
928 dbgs() << "-----\n";
929 });
Adrian Prantlb1416832014-08-01 22:11:58 +0000930 }
931}
932
933
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000934// Find variables for each lexical scope.
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000935void
David Blaikie263a0082014-10-23 00:06:27 +0000936DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU, DISubprogram SP,
937 SmallPtrSetImpl<const MDNode *> &Processed) {
Eric Christopher270a12c2013-07-03 21:37:03 +0000938 // Grab the variable info that was squirreled away in the MMI side-table.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +0000939 collectVariableInfoFromMMITable(Processed);
Devang Patel490c8ab2010-05-20 19:57:06 +0000940
Alexey Samsonov0436caa2014-04-30 23:02:40 +0000941 for (const auto &I : DbgValues) {
942 DIVariable DV(I.first);
943 if (Processed.count(DV))
Devang Patel490c8ab2010-05-20 19:57:06 +0000944 continue;
945
Alexey Samsonovbb2990d2014-05-27 23:09:50 +0000946 // Instruction ranges, specifying where DV is accessible.
947 const auto &Ranges = I.second;
948 if (Ranges.empty())
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +0000949 continue;
Devang Patel9fc11702010-05-25 23:40:22 +0000950
Craig Topper353eda42014-04-24 06:44:33 +0000951 LexicalScope *Scope = nullptr;
Duncan P. N. Exon Smithb4749372015-02-17 00:02:27 +0000952 if (MDNode *IA = DV.getInlinedAt())
953 Scope = LScopes.findInlinedScope(DV.getContext(), IA);
954 else
David Blaikie9b8c8cd2014-05-14 01:08:28 +0000955 Scope = LScopes.findLexicalScope(DV.getContext());
Devang Patel490c8ab2010-05-20 19:57:06 +0000956 // If variable scope is not found then skip this variable.
Devang Patelfbd6c452010-05-21 00:10:20 +0000957 if (!Scope)
Devang Patel490c8ab2010-05-20 19:57:06 +0000958 continue;
959
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000960 Processed.insert(DV);
Alexey Samsonovbb2990d2014-05-27 23:09:50 +0000961 const MachineInstr *MInsn = Ranges.front().first;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +0000962 assert(MInsn->isDebugValue() && "History must begin with debug value");
David Blaikie6f9e8672014-06-13 23:52:55 +0000963 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
964 ConcreteVariables.push_back(make_unique<DbgVariable>(MInsn, this));
David Blaikieeb1a2722014-06-13 22:18:23 +0000965 DbgVariable *RegVar = ConcreteVariables.back().get();
David Blaikief4c504e2014-10-24 00:43:47 +0000966 InfoHolder.addScopeVariable(Scope, RegVar);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +0000967
Alexey Samsonovbb2990d2014-05-27 23:09:50 +0000968 // Check if the first DBG_VALUE is valid for the rest of the function.
Adrian Prantlc1197542014-05-30 21:10:13 +0000969 if (Ranges.size() == 1 && Ranges.front().second == nullptr)
Devang Patel9fc11702010-05-25 23:40:22 +0000970 continue;
Devang Patel9fc11702010-05-25 23:40:22 +0000971
Eric Christopher59cc0712013-01-28 17:33:26 +0000972 // Handle multiple DBG_VALUE instructions describing one variable.
David Blaikieafd2c6b2014-04-22 05:41:06 +0000973 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +0000974
David Blaikie0a456de2014-04-02 01:43:18 +0000975 DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
976 DebugLocList &LocList = DotDebugLocEntries.back();
David Blaikie263a0082014-10-23 00:06:27 +0000977 LocList.CU = &TheCU;
David Blaikie0a456de2014-04-02 01:43:18 +0000978 LocList.Label =
979 Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
Jakob Stoklund Olesen9c057ee2011-03-22 00:21:41 +0000980
Adrian Prantlb1416832014-08-01 22:11:58 +0000981 // Build the location list for this variable.
David Blaikiee1a26a62014-08-05 23:14:16 +0000982 buildLocationList(LocList.List, Ranges);
Devang Patela3e9c9c2010-03-15 18:33:46 +0000983 }
Devang Patele0a94bf2010-05-14 21:01:35 +0000984
985 // Collect info for variables that were optimized out.
David Blaikie263a0082014-10-23 00:06:27 +0000986 DIArray Variables = SP.getVariables();
Devang Patel59e27c52011-08-19 23:28:12 +0000987 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
988 DIVariable DV(Variables.getElement(i));
David Blaikie9ba72542014-05-14 21:52:46 +0000989 assert(DV.isVariable());
David Blaikie70573dc2014-11-19 07:49:26 +0000990 if (!Processed.insert(DV).second)
Devang Patel59e27c52011-08-19 23:28:12 +0000991 continue;
David Blaikiebb6a4e22014-06-05 00:51:35 +0000992 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext())) {
David Blaikie6f9e8672014-06-13 23:52:55 +0000993 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
Adrian Prantl87b7eb92014-10-01 18:55:02 +0000994 DIExpression NoExpr;
995 ConcreteVariables.push_back(make_unique<DbgVariable>(DV, NoExpr, this));
David Blaikief4c504e2014-10-24 00:43:47 +0000996 InfoHolder.addScopeVariable(Scope, ConcreteVariables.back().get());
David Blaikiebb6a4e22014-06-05 00:51:35 +0000997 }
Devang Patele0a94bf2010-05-14 21:01:35 +0000998 }
Devang Patel9fc11702010-05-25 23:40:22 +0000999}
Devang Patele0a94bf2010-05-14 21:01:35 +00001000
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001001// Return Label preceding the instruction.
Eric Christopher962c9082013-01-15 23:56:56 +00001002MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001003 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1004 assert(Label && "Didn't insert label before instruction");
1005 return Label;
Devang Patel9fc11702010-05-25 23:40:22 +00001006}
1007
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001008// Return Label immediately following the instruction.
Eric Christopher962c9082013-01-15 23:56:56 +00001009MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001010 return LabelsAfterInsn.lookup(MI);
Devang Patel475d32a2009-10-06 01:26:37 +00001011}
1012
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001013// Process beginning of an instruction.
Devang Patelb5694e72010-10-26 17:49:02 +00001014void DwarfDebug::beginInstruction(const MachineInstr *MI) {
Craig Toppere73658d2014-04-28 04:05:08 +00001015 assert(CurMI == nullptr);
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001016 CurMI = MI;
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001017 // Check if source location changes, but ignore DBG_VALUE locations.
1018 if (!MI->isDebugValue()) {
1019 DebugLoc DL = MI->getDebugLoc();
1020 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
Eric Christopheraec8a822012-04-05 20:39:05 +00001021 unsigned Flags = 0;
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001022 PrevInstLoc = DL;
Devang Patel34a66202011-05-11 19:22:19 +00001023 if (DL == PrologEndLoc) {
1024 Flags |= DWARF2_FLAG_PROLOGUE_END;
1025 PrologEndLoc = DebugLoc();
David Blaikieaeaa5bf2014-12-30 22:47:13 +00001026 Flags |= DWARF2_FLAG_IS_STMT;
Devang Patel34a66202011-05-11 19:22:19 +00001027 }
David Blaikieaeaa5bf2014-12-30 22:47:13 +00001028 if (DL.getLine() !=
1029 Asm->OutStreamer.getContext().getCurrentDwarfLoc().getLine())
Eric Christopheraec8a822012-04-05 20:39:05 +00001030 Flags |= DWARF2_FLAG_IS_STMT;
1031
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001032 if (!DL.isUnknown()) {
1033 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
Devang Patel34a66202011-05-11 19:22:19 +00001034 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001035 } else
Craig Topper353eda42014-04-24 06:44:33 +00001036 recordSourceLine(0, 0, nullptr, 0);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001037 }
Devang Patel9fc11702010-05-25 23:40:22 +00001038 }
Devang Patel23b2ae62010-03-29 22:59:58 +00001039
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001040 // Insert labels where requested.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001041 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1042 LabelsBeforeInsn.find(MI);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001043
1044 // No label needed.
1045 if (I == LabelsBeforeInsn.end())
1046 return;
1047
1048 // Label already assigned.
1049 if (I->second)
Devang Patel002d54d2010-05-26 19:37:24 +00001050 return;
Devang Patelbd477be2010-03-29 17:20:31 +00001051
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001052 if (!PrevLabel) {
Devang Patelacc32a52010-05-26 21:23:46 +00001053 PrevLabel = MMI->getContext().CreateTempSymbol();
1054 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel002d54d2010-05-26 19:37:24 +00001055 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001056 I->second = PrevLabel;
Devang Patel8db360d2009-10-06 01:50:42 +00001057}
1058
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001059// Process end of an instruction.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001060void DwarfDebug::endInstruction() {
Craig Toppere73658d2014-04-28 04:05:08 +00001061 assert(CurMI != nullptr);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001062 // Don't create a new label after DBG_VALUE instructions.
1063 // They don't generate code.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001064 if (!CurMI->isDebugValue())
Craig Topper353eda42014-04-24 06:44:33 +00001065 PrevLabel = nullptr;
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001066
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001067 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001068 LabelsAfterInsn.find(CurMI);
Craig Topper353eda42014-04-24 06:44:33 +00001069 CurMI = nullptr;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001070
1071 // No label needed.
1072 if (I == LabelsAfterInsn.end())
1073 return;
1074
1075 // Label already assigned.
1076 if (I->second)
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001077 return;
1078
1079 // We need a label after this instruction.
1080 if (!PrevLabel) {
1081 PrevLabel = MMI->getContext().CreateTempSymbol();
1082 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel3ebd8932010-04-08 16:50:29 +00001083 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001084 I->second = PrevLabel;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001085}
1086
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001087// Each LexicalScope has first instruction and last instruction to mark
1088// beginning and end of a scope respectively. Create an inverse map that list
1089// scopes starts (and ends) with an instruction. One instruction may start (or
1090// end) multiple scopes. Ignore scopes that are not reachable.
Devang Patel359b0132010-04-08 18:43:56 +00001091void DwarfDebug::identifyScopeMarkers() {
Devang Patel7e623022011-08-10 20:55:27 +00001092 SmallVector<LexicalScope *, 4> WorkList;
1093 WorkList.push_back(LScopes.getCurrentFunctionScope());
Devang Patel7771b7c2010-01-20 02:05:23 +00001094 while (!WorkList.empty()) {
Devang Patel7e623022011-08-10 20:55:27 +00001095 LexicalScope *S = WorkList.pop_back_val();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001096
Craig Topper977e9cd2013-07-03 04:24:43 +00001097 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001098 if (!Children.empty())
Benjamin Kramer15596c72014-03-07 19:09:39 +00001099 WorkList.append(Children.begin(), Children.end());
Devang Patel7771b7c2010-01-20 02:05:23 +00001100
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001101 if (S->isAbstractScope())
1102 continue;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001103
Benjamin Kramer15596c72014-03-07 19:09:39 +00001104 for (const InsnRange &R : S->getRanges()) {
1105 assert(R.first && "InsnRange does not have first instruction!");
1106 assert(R.second && "InsnRange does not have second instruction!");
1107 requestLabelBeforeInsn(R.first);
1108 requestLabelAfterInsn(R.second);
Devang Patel6c74a872010-04-27 19:46:33 +00001109 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001110 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001111}
1112
Alexey Samsonov8a86d6d2014-05-27 22:47:41 +00001113static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1114 // First known non-DBG_VALUE and non-frame setup location marks
1115 // the beginning of the function body.
1116 for (const auto &MBB : *MF)
1117 for (const auto &MI : MBB)
1118 if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
Saleem Abdulrasoolfc07c722015-01-24 20:19:45 +00001119 !MI.getDebugLoc().isUnknown()) {
Adrian Prantlb9fa9452014-12-16 00:20:49 +00001120 // Did the target forget to set the FrameSetup flag for CFI insns?
1121 assert(!MI.isCFIInstruction() &&
1122 "First non-frame-setup instruction is a CFI instruction.");
Alexey Samsonov8a86d6d2014-05-27 22:47:41 +00001123 return MI.getDebugLoc();
Adrian Prantlb9fa9452014-12-16 00:20:49 +00001124 }
Alexey Samsonov8a86d6d2014-05-27 22:47:41 +00001125 return DebugLoc();
1126}
1127
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001128// Gather pre-function debug information. Assumes being called immediately
1129// after the function entry point has been emitted.
Chris Lattner76555b52010-01-26 23:18:02 +00001130void DwarfDebug::beginFunction(const MachineFunction *MF) {
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001131 CurFn = MF;
Eric Christopherfedfa442013-11-01 23:14:17 +00001132
1133 // If there's no debug info for the function we're not going to do anything.
1134 if (!MMI->hasDebugInfo())
1135 return;
1136
David Blaikie2f040112014-07-25 16:10:16 +00001137 auto DI = FunctionDIs.find(MF->getFunction());
1138 if (DI == FunctionDIs.end())
1139 return;
1140
Eric Christopherfedfa442013-11-01 23:14:17 +00001141 // Grab the lexical scopes for the function, if we don't have any of those
1142 // then we're not going to be able to do anything.
Devang Patel7e623022011-08-10 20:55:27 +00001143 LScopes.initialize(*MF);
Eric Christopher384f3fe2014-03-20 19:16:16 +00001144 if (LScopes.empty())
Eric Christopherfedfa442013-11-01 23:14:17 +00001145 return;
1146
Alexey Samsonov0436caa2014-04-30 23:02:40 +00001147 assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
Eric Christopherfedfa442013-11-01 23:14:17 +00001148
1149 // Make sure that each lexical scope will have a begin/end label.
Devang Patel7e623022011-08-10 20:55:27 +00001150 identifyScopeMarkers();
Devang Patel4598eb62009-10-06 18:37:31 +00001151
Eric Christopher4287a492013-12-09 23:57:44 +00001152 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
Eric Christopherfedfa442013-11-01 23:14:17 +00001153 // belongs to so that we add to the correct per-cu line table in the
1154 // non-asm case.
Manman Ren4e042a62013-02-05 21:52:47 +00001155 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
David Blaikie2f040112014-07-25 16:10:16 +00001156 // FnScope->getScopeNode() and DI->second should represent the same function,
1157 // though they may not be the same MDNode due to inline functions merged in
1158 // LTO where the debug info metadata still differs (either due to distinct
1159 // written differences - two versions of a linkonce_odr function
1160 // written/copied into two separate files, or some sub-optimal metadata that
1161 // isn't structurally identical (see: file path/name info from clang, which
1162 // includes the directory of the cpp file being built, even when the file name
1163 // is absolute (such as an <> lookup header)))
Eric Christopher4287a492013-12-09 23:57:44 +00001164 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
Manman Ren4e042a62013-02-05 21:52:47 +00001165 assert(TheCU && "Unable to find compile unit!");
Rafael Espindolab4eec1d2014-02-05 18:00:21 +00001166 if (Asm->OutStreamer.hasRawTextSupport())
1167 // Use a single line table if we are generating assembly.
Manman Ren9d4c7352013-05-21 00:57:22 +00001168 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1169 else
1170 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
Manman Ren4e042a62013-02-05 21:52:47 +00001171
Eric Christopherfedfa442013-11-01 23:14:17 +00001172 // Emit a label for the function so that we have a beginning address.
1173 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
Bill Wendling2b128d72009-05-20 23:19:06 +00001174 // Assumes in correct section after the entry point.
Devang Patel6c74a872010-04-27 19:46:33 +00001175 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
Bill Wendling2b128d72009-05-20 23:19:06 +00001176
Alexey Samsonov414b6fb2014-04-30 21:34:11 +00001177 // Calculate history for local variables.
Eric Christopherd9134482014-08-04 21:25:23 +00001178 calculateDbgValueHistory(MF, Asm->TM.getSubtargetImpl()->getRegisterInfo(),
1179 DbgValues);
Alexey Samsonov414b6fb2014-04-30 21:34:11 +00001180
1181 // Request labels for the full history.
Alexey Samsonovbb2990d2014-05-27 23:09:50 +00001182 for (const auto &I : DbgValues) {
1183 const auto &Ranges = I.second;
1184 if (Ranges.empty())
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001185 continue;
1186
Alexey Samsonov414b6fb2014-04-30 21:34:11 +00001187 // The first mention of a function argument gets the FunctionBeginSym
1188 // label, so arguments are visible when breaking at function entry.
Adrian Prantl87b7eb92014-10-01 18:55:02 +00001189 DIVariable DIVar(Ranges.front().first->getDebugVariable());
1190 if (DIVar.isVariable() && DIVar.getTag() == dwarf::DW_TAG_arg_variable &&
1191 getDISubprogram(DIVar.getContext()).describes(MF->getFunction())) {
1192 LabelsBeforeInsn[Ranges.front().first] = FunctionBeginSym;
Adrian Prantl27bd01f2015-02-09 23:57:15 +00001193 if (Ranges.front().first->getDebugExpression().isBitPiece()) {
Adrian Prantlb1416832014-08-01 22:11:58 +00001194 // Mark all non-overlapping initial pieces.
1195 for (auto I = Ranges.begin(); I != Ranges.end(); ++I) {
Adrian Prantl87b7eb92014-10-01 18:55:02 +00001196 DIExpression Piece = I->first->getDebugExpression();
Adrian Prantlb1416832014-08-01 22:11:58 +00001197 if (std::all_of(Ranges.begin(), I,
Adrian Prantl87b7eb92014-10-01 18:55:02 +00001198 [&](DbgValueHistoryMap::InstrRange Pred) {
1199 return !piecesOverlap(Piece, Pred.first->getDebugExpression());
Adrian Prantlb1416832014-08-01 22:11:58 +00001200 }))
1201 LabelsBeforeInsn[I->first] = FunctionBeginSym;
1202 else
1203 break;
1204 }
1205 }
1206 }
Alexey Samsonov414b6fb2014-04-30 21:34:11 +00001207
Alexey Samsonovbb2990d2014-05-27 23:09:50 +00001208 for (const auto &Range : Ranges) {
1209 requestLabelBeforeInsn(Range.first);
1210 if (Range.second)
1211 requestLabelAfterInsn(Range.second);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001212 }
1213 }
Devang Patel002d54d2010-05-26 19:37:24 +00001214
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001215 PrevInstLoc = DebugLoc();
Devang Patel002d54d2010-05-26 19:37:24 +00001216 PrevLabel = FunctionBeginSym;
Devang Patel34a66202011-05-11 19:22:19 +00001217
1218 // Record beginning of function.
Alexey Samsonov8a86d6d2014-05-27 22:47:41 +00001219 PrologEndLoc = findPrologueEndLoc(MF);
Devang Patel34a66202011-05-11 19:22:19 +00001220 if (!PrologEndLoc.isUnknown()) {
Eric Christopherfedfa442013-11-01 23:14:17 +00001221 DebugLoc FnStartDL =
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +00001222 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
Saleem Abdulrasoolfc07c722015-01-24 20:19:45 +00001223
1224 // We'd like to list the prologue as "not statements" but GDB behaves
1225 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1226 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1227 FnStartDL.getScope(MF->getFunction()->getContext()),
1228 DWARF2_FLAG_IS_STMT);
Devang Patel34a66202011-05-11 19:22:19 +00001229 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001230}
1231
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001232// Gather and emit post-function debug information.
NAKAMURA Takumib9271612013-12-03 13:15:54 +00001233void DwarfDebug::endFunction(const MachineFunction *MF) {
David Blaikiee75f9632014-10-14 17:12:02 +00001234 assert(CurFn == MF &&
1235 "endFunction should be called with the same function as beginFunction");
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001236
David Blaikie2f040112014-07-25 16:10:16 +00001237 if (!MMI->hasDebugInfo() || LScopes.empty() ||
1238 !FunctionDIs.count(MF->getFunction())) {
Eric Christopher384f3fe2014-03-20 19:16:16 +00001239 // If we don't have a lexical scope for this function then there will
1240 // be a hole in the range information. Keep note of this by setting the
1241 // previously used section to nullptr.
Eric Christopher384f3fe2014-03-20 19:16:16 +00001242 PrevCU = nullptr;
Craig Topper353eda42014-04-24 06:44:33 +00001243 CurFn = nullptr;
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001244 return;
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001245 }
Devang Patel2904aa92009-11-12 19:02:56 +00001246
Devang Patel7e623022011-08-10 20:55:27 +00001247 // Define end label for subprogram.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001248 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
Devang Patel7e623022011-08-10 20:55:27 +00001249 // Assumes in correct section after the entry point.
1250 Asm->OutStreamer.EmitLabel(FunctionEndSym);
Eric Christopher1a972152014-01-29 23:05:43 +00001251
Eric Christopher4287a492013-12-09 23:57:44 +00001252 // Set DwarfDwarfCompileUnitID in MCContext to default value.
Manman Ren4e042a62013-02-05 21:52:47 +00001253 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
Eric Christopher6a841382012-11-19 22:42:10 +00001254
Devang Patel3acc70e2011-08-15 22:04:40 +00001255 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
David Blaikie263a0082014-10-23 00:06:27 +00001256 DISubprogram SP(FnScope->getScopeNode());
1257 DwarfCompileUnit &TheCU = *SPMap.lookup(SP);
1258
1259 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1260 collectVariableInfo(TheCU, SP, ProcessedVars);
Devang Patel3acc70e2011-08-15 22:04:40 +00001261
David Blaikie3a7ce252014-09-19 17:03:16 +00001262 // Add the range of this function to the list of ranges for the CU.
1263 TheCU.addRange(RangeSpan(FunctionBeginSym, FunctionEndSym));
1264
1265 // Under -gmlt, skip building the subprogram if there are no inlined
1266 // subroutines inside it.
1267 if (TheCU.getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly &&
David Blaikiee1c79742014-09-30 21:28:32 +00001268 LScopes.getAbstractScopesList().empty() && !IsDarwin) {
David Blaikie80e5b1e2014-10-24 17:57:34 +00001269 assert(InfoHolder.getScopeVariables().empty());
David Blaikie3a7ce252014-09-19 17:03:16 +00001270 assert(DbgValues.empty());
David Blaikie8b2fdb82014-10-09 18:24:28 +00001271 // FIXME: This wouldn't be true in LTO with a -g (with inlining) CU followed
1272 // by a -gmlt CU. Add a test and remove this assertion.
David Blaikie3a7ce252014-09-19 17:03:16 +00001273 assert(AbstractVariables.empty());
1274 LabelsBeforeInsn.clear();
1275 LabelsAfterInsn.clear();
1276 PrevLabel = nullptr;
1277 CurFn = nullptr;
1278 return;
1279 }
1280
Adrian Prantl049d21c2014-10-13 20:44:58 +00001281#ifndef NDEBUG
1282 size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
1283#endif
Devang Patel7e623022011-08-10 20:55:27 +00001284 // Construct abstract scopes.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001285 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
Devang Patel44403472011-08-12 18:10:19 +00001286 DISubprogram SP(AScope->getScopeNode());
David Blaikiedb5371b2014-07-18 22:26:59 +00001287 assert(SP.isSubprogram());
David Blaikie4abe19e2014-05-12 18:23:35 +00001288 // Collect info for variables that were optimized out.
1289 DIArray Variables = SP.getVariables();
1290 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1291 DIVariable DV(Variables.getElement(i));
1292 assert(DV && DV.isVariable());
David Blaikie70573dc2014-11-19 07:49:26 +00001293 if (!ProcessedVars.insert(DV).second)
David Blaikie4abe19e2014-05-12 18:23:35 +00001294 continue;
David Blaikie6f9e8672014-06-13 23:52:55 +00001295 ensureAbstractVariableIsCreated(DV, DV.getContext());
Adrian Prantl049d21c2014-10-13 20:44:58 +00001296 assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
1297 && "ensureAbstractVariableIsCreated inserted abstract scopes");
Devang Patel5c0f85c2010-06-25 22:07:34 +00001298 }
David Blaikie73cc7052014-10-09 20:36:27 +00001299 constructAbstractSubprogramScopeDIE(AScope);
Bill Wendling2b128d72009-05-20 23:19:06 +00001300 }
Eric Christopher6a841382012-11-19 22:42:10 +00001301
David Blaikie1d072342014-10-09 20:21:36 +00001302 TheCU.constructSubprogramScopeDIE(FnScope);
David Blaikie3a443c22014-11-04 22:12:25 +00001303 if (auto *SkelCU = TheCU.getSkeleton())
1304 if (!LScopes.getAbstractScopesList().empty())
1305 SkelCU->constructSubprogramScopeDIE(FnScope);
Devang Patel3acc70e2011-08-15 22:04:40 +00001306
Bill Wendling2b128d72009-05-20 23:19:06 +00001307 // Clear debug info
David Blaikie825bdd22014-05-21 22:41:17 +00001308 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1309 // DbgVariables except those that are also in AbstractVariables (since they
1310 // can be used cross-function)
David Blaikie80e5b1e2014-10-24 17:57:34 +00001311 InfoHolder.getScopeVariables().clear();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001312 DbgValues.clear();
Devang Patel6c74a872010-04-27 19:46:33 +00001313 LabelsBeforeInsn.clear();
1314 LabelsAfterInsn.clear();
Craig Topper353eda42014-04-24 06:44:33 +00001315 PrevLabel = nullptr;
1316 CurFn = nullptr;
Bill Wendling2b128d72009-05-20 23:19:06 +00001317}
1318
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001319// Register a source line with debug info. Returns the unique label that was
1320// emitted and which provides correspondence to the source line list.
Devang Patel34a66202011-05-11 19:22:19 +00001321void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1322 unsigned Flags) {
Devang Patel2d9caf92009-11-25 17:36:49 +00001323 StringRef Fn;
Devang Patele01b75c2011-03-24 20:30:50 +00001324 StringRef Dir;
Dan Gohman50849c62010-05-05 23:41:32 +00001325 unsigned Src = 1;
Diego Novillo282450d2014-03-03 18:53:17 +00001326 unsigned Discriminator = 0;
David Blaikie4c6d9872014-05-15 20:18:50 +00001327 if (DIScope Scope = DIScope(S)) {
1328 assert(Scope.isScope());
1329 Fn = Scope.getFilename();
1330 Dir = Scope.getDirectory();
David Blaikie2f3f76f2014-08-21 22:45:21 +00001331 if (Scope.isLexicalBlockFile())
1332 Discriminator = DILexicalBlockFile(S).getDiscriminator();
Dan Gohman50849c62010-05-05 23:41:32 +00001333
David Blaikie0e8d4012014-03-17 23:53:25 +00001334 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
David Blaikiec33b3cd2014-04-22 21:27:37 +00001335 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1336 .getOrCreateSourceID(Fn, Dir);
Dan Gohman50849c62010-05-05 23:41:32 +00001337 }
Diego Novillo282450d2014-03-03 18:53:17 +00001338 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1339 Discriminator, Fn);
Bill Wendling2b128d72009-05-20 23:19:06 +00001340}
1341
Bill Wendling806535f2009-05-20 23:22:40 +00001342//===----------------------------------------------------------------------===//
1343// Emit Methods
1344//===----------------------------------------------------------------------===//
1345
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001346// Emit initial Dwarf sections with a label at the start of each one.
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001347void DwarfDebug::emitSectionLabels() {
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001348 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00001349
Bill Wendling480ff322009-05-20 23:21:38 +00001350 // Dwarf sections base addresses.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001351 DwarfInfoSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001352 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
David Blaikie29459ae2014-07-25 17:11:58 +00001353 if (useSplitDwarf()) {
Eric Christopherd8667202013-12-30 17:22:27 +00001354 DwarfInfoDWOSectionSym =
1355 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
David Blaikie29459ae2014-07-25 17:11:58 +00001356 DwarfTypesDWOSectionSym =
1357 emitSectionSym(Asm, TLOF.getDwarfTypesDWOSection(), "section_types_dwo");
1358 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001359 DwarfAbbrevSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001360 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
Eric Christopher3c5a1912012-12-19 22:02:53 +00001361 if (useSplitDwarf())
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001362 DwarfAbbrevDWOSectionSym = emitSectionSym(
1363 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
David Blaikie20474102014-02-25 22:46:44 +00001364 if (GenerateARangeSection)
1365 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001366
Eric Christopher74804332013-02-07 21:19:50 +00001367 DwarfLineSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001368 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
Eric Christopher261d2342013-09-23 20:55:35 +00001369 if (GenerateGnuPubSections) {
Eric Christopher39eebfa2013-09-30 23:14:16 +00001370 DwarfGnuPubNamesSectionSym =
1371 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1372 DwarfGnuPubTypesSectionSym =
1373 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
Eric Christopher261d2342013-09-23 20:55:35 +00001374 } else if (HasDwarfPubSections) {
1375 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1376 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
Michael Gottesmanc89466f2013-09-04 04:39:38 +00001377 }
Eric Christopherdd1a0122013-09-13 00:35:05 +00001378
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001379 DwarfStrSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001380 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
Eric Christopher55863be2013-04-07 03:43:09 +00001381 if (useSplitDwarf()) {
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001382 DwarfStrDWOSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001383 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
Eric Christopher55863be2013-04-07 03:43:09 +00001384 DwarfAddrSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001385 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
David Blaikiee12ab122014-04-01 16:09:49 +00001386 DwarfDebugLocSectionSym =
David Blaikie9c550ac2014-03-25 01:44:02 +00001387 emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1388 } else
1389 DwarfDebugLocSectionSym =
1390 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001391 DwarfDebugRangeSectionSym =
1392 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
Bill Wendling480ff322009-05-20 23:21:38 +00001393}
1394
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001395// Recursively emits a debug information entry.
David Blaikieb8184182014-04-14 22:45:02 +00001396void DwarfDebug::emitDIE(DIE &Die) {
Bill Wendling480ff322009-05-20 23:21:38 +00001397 // Get the abbreviation for this DIE.
David Blaikieb8184182014-04-14 22:45:02 +00001398 const DIEAbbrev &Abbrev = Die.getAbbrev();
Bill Wendling480ff322009-05-20 23:21:38 +00001399
Bill Wendling480ff322009-05-20 23:21:38 +00001400 // Emit the code (index) for the abbreviation.
Chris Lattner7bde8c02010-04-04 18:52:31 +00001401 if (Asm->isVerbose())
David Blaikieff3ab2c2013-12-05 01:01:41 +00001402 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
David Blaikieb8184182014-04-14 22:45:02 +00001403 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1404 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
David Blaikieff3ab2c2013-12-05 01:01:41 +00001405 dwarf::TagString(Abbrev.getTag()));
1406 Asm->EmitULEB128(Abbrev.getNumber());
Bill Wendling480ff322009-05-20 23:21:38 +00001407
David Blaikieb8184182014-04-14 22:45:02 +00001408 const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
David Blaikieff3ab2c2013-12-05 01:01:41 +00001409 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
Bill Wendling480ff322009-05-20 23:21:38 +00001410
1411 // Emit the DIE attribute values.
1412 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
David Blaikief2443192013-10-21 17:28:37 +00001413 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1414 dwarf::Form Form = AbbrevData[i].getForm();
Bill Wendling480ff322009-05-20 23:21:38 +00001415 assert(Form && "Too many attributes for DIE (check abbreviation)");
1416
Eric Christopher13a1bb32014-03-06 00:00:49 +00001417 if (Asm->isVerbose()) {
Chris Lattner5adf9872010-01-24 18:54:17 +00001418 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
Eric Christopher13a1bb32014-03-06 00:00:49 +00001419 if (Attr == dwarf::DW_AT_accessibility)
1420 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1421 cast<DIEInteger>(Values[i])->getValue()));
1422 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001423
Eric Christopherdd508382014-03-06 00:00:56 +00001424 // Emit an attribute using the defined form.
1425 Values[i]->EmitValue(Asm, Form);
Bill Wendling480ff322009-05-20 23:21:38 +00001426 }
1427
1428 // Emit the DIE children if any.
Eric Christophere8f10722014-03-05 01:44:58 +00001429 if (Abbrev.hasChildren()) {
David Blaikieb8184182014-04-14 22:45:02 +00001430 for (auto &Child : Die.getChildren())
1431 emitDIE(*Child);
Bill Wendling480ff322009-05-20 23:21:38 +00001432
David Blaikie155f8812013-12-04 21:51:05 +00001433 Asm->OutStreamer.AddComment("End Of Children Mark");
Chris Lattner566cae92010-03-09 23:52:58 +00001434 Asm->EmitInt8(0);
Bill Wendling480ff322009-05-20 23:21:38 +00001435 }
1436}
1437
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001438// Emit the debug info section.
1439void DwarfDebug::emitDebugInfo() {
Eric Christopherf8194852013-12-05 18:06:10 +00001440 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Eric Christophera2de8262012-12-15 00:04:07 +00001441
David Blaikie2b22b1e2014-10-23 00:16:03 +00001442 Holder.emitUnits(DwarfAbbrevSectionSym);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001443}
1444
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001445// Emit the abbreviation section.
Eric Christopher38371952012-11-20 23:30:11 +00001446void DwarfDebug::emitAbbreviations() {
Eric Christopherf8194852013-12-05 18:06:10 +00001447 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
David Blaikie0504cda2013-12-05 07:43:55 +00001448
1449 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
Eric Christopher3c5a1912012-12-19 22:02:53 +00001450}
Bill Wendling480ff322009-05-20 23:21:38 +00001451
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001452// Emit the last address of the section and the end of the line matrix.
Devang Patel930143b2009-11-21 02:48:08 +00001453void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling480ff322009-05-20 23:21:38 +00001454 // Define last address of section.
Chris Lattner566cae92010-03-09 23:52:58 +00001455 Asm->OutStreamer.AddComment("Extended Op");
1456 Asm->EmitInt8(0);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001457
Chris Lattner566cae92010-03-09 23:52:58 +00001458 Asm->OutStreamer.AddComment("Op size");
Chandler Carruth5da3f052012-11-01 09:14:31 +00001459 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
Chris Lattner566cae92010-03-09 23:52:58 +00001460 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1461 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1462
1463 Asm->OutStreamer.AddComment("Section end label");
Chris Lattnerb245dfb2010-03-10 01:17:49 +00001464
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001465 Asm->OutStreamer.EmitSymbolValue(
1466 Asm->GetTempSymbol("section_end", SectionEnd),
1467 Asm->getDataLayout().getPointerSize());
Bill Wendling480ff322009-05-20 23:21:38 +00001468
1469 // Mark end of matrix.
Chris Lattner566cae92010-03-09 23:52:58 +00001470 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1471 Asm->EmitInt8(0);
Chris Lattnerf5c834f2010-01-22 22:09:00 +00001472 Asm->EmitInt8(1);
Chris Lattnerfa823552010-01-22 23:18:42 +00001473 Asm->EmitInt8(1);
Bill Wendling480ff322009-05-20 23:21:38 +00001474}
1475
David Blaikie6741bb02014-09-11 21:12:48 +00001476void DwarfDebug::emitAccel(DwarfAccelTable &Accel, const MCSection *Section,
1477 StringRef TableName, StringRef SymName) {
1478 Accel.FinalizeTable(Asm, TableName);
1479 Asm->OutStreamer.SwitchSection(Section);
1480 auto *SectionBegin = Asm->GetTempSymbol(SymName);
Eric Christopher4996c702011-11-07 09:24:32 +00001481 Asm->OutStreamer.EmitLabel(SectionBegin);
1482
1483 // Emit the full data.
Frederic Riss3a6b3542014-11-12 23:48:14 +00001484 Accel.Emit(Asm, SectionBegin, this, DwarfStrSectionSym);
David Blaikie6741bb02014-09-11 21:12:48 +00001485}
1486
1487// Emit visible names into a hashed accelerator table section.
1488void DwarfDebug::emitAccelNames() {
1489 emitAccel(AccelNames, Asm->getObjFileLowering().getDwarfAccelNamesSection(),
1490 "Names", "names_begin");
Eric Christopher4996c702011-11-07 09:24:32 +00001491}
1492
Eric Christopher48fef592012-12-20 21:58:40 +00001493// Emit objective C classes and categories into a hashed accelerator table
1494// section.
Eric Christopher4996c702011-11-07 09:24:32 +00001495void DwarfDebug::emitAccelObjC() {
David Blaikie6741bb02014-09-11 21:12:48 +00001496 emitAccel(AccelObjC, Asm->getObjFileLowering().getDwarfAccelObjCSection(),
1497 "ObjC", "objc_begin");
Eric Christopher4996c702011-11-07 09:24:32 +00001498}
1499
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001500// Emit namespace dies into a hashed accelerator table.
Eric Christopher4996c702011-11-07 09:24:32 +00001501void DwarfDebug::emitAccelNamespaces() {
David Blaikie6741bb02014-09-11 21:12:48 +00001502 emitAccel(AccelNamespace,
1503 Asm->getObjFileLowering().getDwarfAccelNamespaceSection(),
1504 "namespac", "namespac_begin");
Eric Christopher4996c702011-11-07 09:24:32 +00001505}
1506
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001507// Emit type dies into a hashed accelerator table.
Eric Christopher4996c702011-11-07 09:24:32 +00001508void DwarfDebug::emitAccelTypes() {
David Blaikie6741bb02014-09-11 21:12:48 +00001509 emitAccel(AccelTypes, Asm->getObjFileLowering().getDwarfAccelTypesSection(),
1510 "types", "types_begin");
Eric Christopher4996c702011-11-07 09:24:32 +00001511}
1512
Eric Christopherdd1a0122013-09-13 00:35:05 +00001513// Public name handling.
1514// The format for the various pubnames:
1515//
1516// dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1517// for the DIE that is named.
1518//
1519// gnu pubnames - offset/index value/name tuples where the offset is the offset
1520// into the CU and the index value is computed according to the type of value
1521// for the DIE that is named.
1522//
1523// For type units the offset is the offset of the skeleton DIE. For split dwarf
1524// it's the offset within the debug_info/debug_types dwo section, however, the
1525// reference in the pubname header doesn't change.
1526
1527/// computeIndexValue - Compute the gdb index value for the DIE and CU.
Eric Christophera5a79422013-12-09 23:32:48 +00001528static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
Eric Christopher0fe676a2013-11-21 00:48:22 +00001529 const DIE *Die) {
Eric Christopherd2b497b2013-10-16 01:37:49 +00001530 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1531
1532 // We could have a specification DIE that has our most of our knowledge,
1533 // look for that now.
1534 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1535 if (SpecVal) {
David Blaikie8dbcc3f2014-04-25 19:33:43 +00001536 DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1537 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
Eric Christopherd2b497b2013-10-16 01:37:49 +00001538 Linkage = dwarf::GIEL_EXTERNAL;
1539 } else if (Die->findAttribute(dwarf::DW_AT_external))
1540 Linkage = dwarf::GIEL_EXTERNAL;
Eric Christopherdd1a0122013-09-13 00:35:05 +00001541
1542 switch (Die->getTag()) {
1543 case dwarf::DW_TAG_class_type:
1544 case dwarf::DW_TAG_structure_type:
1545 case dwarf::DW_TAG_union_type:
1546 case dwarf::DW_TAG_enumeration_type:
Eric Christopher261d2342013-09-23 20:55:35 +00001547 return dwarf::PubIndexEntryDescriptor(
1548 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1549 ? dwarf::GIEL_STATIC
1550 : dwarf::GIEL_EXTERNAL);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001551 case dwarf::DW_TAG_typedef:
1552 case dwarf::DW_TAG_base_type:
1553 case dwarf::DW_TAG_subrange_type:
David Blaikie8dec4072013-09-19 20:40:26 +00001554 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001555 case dwarf::DW_TAG_namespace:
David Blaikie8dec4072013-09-19 20:40:26 +00001556 return dwarf::GIEK_TYPE;
Eric Christopherdd1a0122013-09-13 00:35:05 +00001557 case dwarf::DW_TAG_subprogram:
Eric Christopherccac5c42013-09-23 22:59:14 +00001558 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001559 case dwarf::DW_TAG_variable:
Eric Christopherccac5c42013-09-23 22:59:14 +00001560 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001561 case dwarf::DW_TAG_enumerator:
David Blaikie8dec4072013-09-19 20:40:26 +00001562 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1563 dwarf::GIEL_STATIC);
Eric Christopherdd1a0122013-09-13 00:35:05 +00001564 default:
David Blaikie8dec4072013-09-19 20:40:26 +00001565 return dwarf::GIEK_NONE;
Eric Christopherdd1a0122013-09-13 00:35:05 +00001566 }
Eric Christopherdd1a0122013-09-13 00:35:05 +00001567}
1568
Eric Christopher5f93bb92013-09-09 20:03:17 +00001569/// emitDebugPubNames - Emit visible names into a debug pubnames section.
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001570///
Eric Christopherdd1a0122013-09-13 00:35:05 +00001571void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
Eric Christopherdd1a0122013-09-13 00:35:05 +00001572 const MCSection *PSec =
1573 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1574 : Asm->getObjFileLowering().getDwarfPubNamesSection();
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001575
David Blaikie192b45c2014-11-02 06:16:39 +00001576 emitDebugPubSection(GnuStyle, PSec, "Names",
1577 &DwarfCompileUnit::getGlobalNames);
David Blaikie0f55e832014-03-11 23:18:15 +00001578}
1579
1580void DwarfDebug::emitDebugPubSection(
1581 bool GnuStyle, const MCSection *PSec, StringRef Name,
David Blaikie192b45c2014-11-02 06:16:39 +00001582 const StringMap<const DIE *> &(DwarfCompileUnit::*Accessor)() const) {
David Blaikiec3d9e9e2014-03-06 01:42:00 +00001583 for (const auto &NU : CUMap) {
1584 DwarfCompileUnit *TheU = NU.second;
David Blaikie55bb8ac2014-03-11 23:23:39 +00001585
1586 const auto &Globals = (TheU->*Accessor)();
1587
David Blaikiece2f1cb2014-03-11 23:35:06 +00001588 if (Globals.empty())
1589 continue;
1590
David Blaikiebbad0bb2014-11-01 01:03:39 +00001591 if (auto *Skeleton = TheU->getSkeleton())
David Blaikiec3d9e9e2014-03-06 01:42:00 +00001592 TheU = Skeleton;
David Blaikie2a80e442013-12-02 22:09:48 +00001593 unsigned ID = TheU->getUniqueID();
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001594
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001595 // Start the dwarf pubnames section.
Eric Christopher13b99d22013-09-10 21:49:37 +00001596 Asm->OutStreamer.SwitchSection(PSec);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001597
Eric Christopherdd1a0122013-09-13 00:35:05 +00001598 // Emit the header.
David Blaikie0f55e832014-03-11 23:18:15 +00001599 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
1600 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
1601 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
David Blaikieb7a1c4d2013-12-04 17:55:41 +00001602 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001603
David Blaikieb7a1c4d2013-12-04 17:55:41 +00001604 Asm->OutStreamer.EmitLabel(BeginLabel);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001605
1606 Asm->OutStreamer.AddComment("DWARF Version");
David Majnemered89b5c2013-08-21 06:13:34 +00001607 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001608
1609 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
David Blaikie7d734602013-12-06 22:33:05 +00001610 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001611
1612 Asm->OutStreamer.AddComment("Compilation Unit Length");
David Blaikie983bfea2014-11-01 23:07:14 +00001613 Asm->EmitInt32(TheU->getLength());
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001614
Eric Christopherdd1a0122013-09-13 00:35:05 +00001615 // Emit the pubnames for this compilation unit.
David Blaikie55bb8ac2014-03-11 23:23:39 +00001616 for (const auto &GI : Globals) {
Benjamin Kramer15596c72014-03-07 19:09:39 +00001617 const char *Name = GI.getKeyData();
1618 const DIE *Entity = GI.second;
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001619
1620 Asm->OutStreamer.AddComment("DIE offset");
1621 Asm->EmitInt32(Entity->getOffset());
1622
Eric Christopherdd1a0122013-09-13 00:35:05 +00001623 if (GnuStyle) {
David Blaikie2a80e442013-12-02 22:09:48 +00001624 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
David Blaikied0a869d2013-09-19 22:19:37 +00001625 Asm->OutStreamer.AddComment(
David Blaikieefd0bcb2013-09-20 00:33:15 +00001626 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
David Blaikie404d3042013-09-19 23:01:29 +00001627 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
David Blaikied0a869d2013-09-19 22:19:37 +00001628 Asm->EmitInt8(Desc.toBits());
Eric Christopherdd1a0122013-09-13 00:35:05 +00001629 }
1630
David Blaikie155f8812013-12-04 21:51:05 +00001631 Asm->OutStreamer.AddComment("External Name");
Benjamin Kramer15596c72014-03-07 19:09:39 +00001632 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001633 }
1634
1635 Asm->OutStreamer.AddComment("End Mark");
1636 Asm->EmitInt32(0);
David Blaikieb7a1c4d2013-12-04 17:55:41 +00001637 Asm->OutStreamer.EmitLabel(EndLabel);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001638 }
1639}
1640
Eric Christopherdd1a0122013-09-13 00:35:05 +00001641void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
Eric Christopher261d2342013-09-23 20:55:35 +00001642 const MCSection *PSec =
1643 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1644 : Asm->getObjFileLowering().getDwarfPubTypesSection();
Eric Christopher8b3737f2013-09-13 00:34:58 +00001645
David Blaikie192b45c2014-11-02 06:16:39 +00001646 emitDebugPubSection(GnuStyle, PSec, "Types",
1647 &DwarfCompileUnit::getGlobalTypes);
Devang Patel04d2f2d2009-11-24 01:14:22 +00001648}
1649
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001650// Emit visible names into a debug str section.
1651void DwarfDebug::emitDebugStr() {
Eric Christopherf8194852013-12-05 18:06:10 +00001652 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001653 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1654}
1655
Adrian Prantlb1416832014-08-01 22:11:58 +00001656/// Emits an optimal (=sorted) sequence of DW_OP_pieces.
1657void DwarfDebug::emitLocPieces(ByteStreamer &Streamer,
1658 const DITypeIdentifierMap &Map,
1659 ArrayRef<DebugLocEntry::Value> Values) {
Adrian Prantl293dd932014-08-11 21:05:55 +00001660 assert(std::all_of(Values.begin(), Values.end(), [](DebugLocEntry::Value P) {
Adrian Prantl27bd01f2015-02-09 23:57:15 +00001661 return P.isBitPiece();
Adrian Prantlb1416832014-08-01 22:11:58 +00001662 }) && "all values are expected to be pieces");
Adrian Prantl293dd932014-08-11 21:05:55 +00001663 assert(std::is_sorted(Values.begin(), Values.end()) &&
1664 "pieces are expected to be sorted");
Adrian Prantlb1416832014-08-01 22:11:58 +00001665
1666 unsigned Offset = 0;
Adrian Prantl293dd932014-08-11 21:05:55 +00001667 for (auto Piece : Values) {
Adrian Prantl87b7eb92014-10-01 18:55:02 +00001668 DIExpression Expr = Piece.getExpression();
Adrian Prantl27bd01f2015-02-09 23:57:15 +00001669 unsigned PieceOffset = Expr.getBitPieceOffset();
1670 unsigned PieceSize = Expr.getBitPieceSize();
Adrian Prantl293dd932014-08-11 21:05:55 +00001671 assert(Offset <= PieceOffset && "overlapping or duplicate pieces");
Adrian Prantlb1416832014-08-01 22:11:58 +00001672 if (Offset < PieceOffset) {
1673 // The DWARF spec seriously mandates pieces with no locations for gaps.
Adrian Prantl27bd01f2015-02-09 23:57:15 +00001674 Asm->EmitDwarfOpPiece(Streamer, PieceOffset-Offset);
Adrian Prantlb1416832014-08-01 22:11:58 +00001675 Offset += PieceOffset-Offset;
1676 }
Adrian Prantlb1416832014-08-01 22:11:58 +00001677 Offset += PieceSize;
1678
Adrian Prantlb458dc22014-10-01 18:10:54 +00001679#ifndef NDEBUG
Adrian Prantl87b7eb92014-10-01 18:55:02 +00001680 DIVariable Var = Piece.getVariable();
Adrian Prantlb1416832014-08-01 22:11:58 +00001681 unsigned VarSize = Var.getSizeInBits(Map);
Adrian Prantl27bd01f2015-02-09 23:57:15 +00001682 assert(PieceSize+PieceOffset <= VarSize
Adrian Prantlb1416832014-08-01 22:11:58 +00001683 && "piece is larger than or outside of variable");
Adrian Prantl27bd01f2015-02-09 23:57:15 +00001684 assert(PieceSize != VarSize
Adrian Prantlb1416832014-08-01 22:11:58 +00001685 && "piece covers entire variable");
1686#endif
Adrian Prantl27bd01f2015-02-09 23:57:15 +00001687 emitDebugLocValue(Streamer, Piece, PieceOffset);
Adrian Prantlb1416832014-08-01 22:11:58 +00001688 }
1689}
1690
1691
Eric Christopher29e874d2014-03-07 22:40:37 +00001692void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
Eric Christopher05135fb2014-03-18 02:18:24 +00001693 const DebugLocEntry &Entry) {
Adrian Prantle19e5ef2014-04-27 18:25:40 +00001694 const DebugLocEntry::Value Value = Entry.getValues()[0];
Adrian Prantl27bd01f2015-02-09 23:57:15 +00001695 if (Value.isBitPiece())
Adrian Prantlb1416832014-08-01 22:11:58 +00001696 // Emit all pieces that belong to the same variable and range.
1697 return emitLocPieces(Streamer, TypeIdentifierMap, Entry.getValues());
1698
1699 assert(Entry.getValues().size() == 1 && "only pieces may have >1 value");
1700 emitDebugLocValue(Streamer, Value);
1701}
1702
1703void DwarfDebug::emitDebugLocValue(ByteStreamer &Streamer,
Adrian Prantl092d9482015-01-13 23:39:11 +00001704 const DebugLocEntry::Value &Value,
1705 unsigned PieceOffsetInBits) {
Adrian Prantl76502d82014-08-11 23:22:59 +00001706 DIVariable DV = Value.getVariable();
Adrian Prantl092d9482015-01-13 23:39:11 +00001707 DebugLocDwarfExpression DwarfExpr(*Asm, Streamer);
1708
Adrian Prantlb1416832014-08-01 22:11:58 +00001709 // Regular entry.
Adrian Prantle19e5ef2014-04-27 18:25:40 +00001710 if (Value.isInt()) {
Adrian Prantl1a1647c2014-03-18 02:34:58 +00001711 DIBasicType BTy(resolve(DV.getType()));
Eric Christopher29e874d2014-03-07 22:40:37 +00001712 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
Adrian Prantl66f25952015-01-13 00:04:06 +00001713 BTy.getEncoding() == dwarf::DW_ATE_signed_char))
Adrian Prantl092d9482015-01-13 23:39:11 +00001714 DwarfExpr.AddSignedConstant(Value.getInt());
Adrian Prantl66f25952015-01-13 00:04:06 +00001715 else
Adrian Prantl092d9482015-01-13 23:39:11 +00001716 DwarfExpr.AddUnsignedConstant(Value.getInt());
Adrian Prantle19e5ef2014-04-27 18:25:40 +00001717 } else if (Value.isLocation()) {
1718 MachineLocation Loc = Value.getLoc();
Adrian Prantl87b7eb92014-10-01 18:55:02 +00001719 DIExpression Expr = Value.getExpression();
Adrian Prantl092d9482015-01-13 23:39:11 +00001720 if (!Expr || (Expr.getNumElements() == 0))
Eric Christopher29e874d2014-03-07 22:40:37 +00001721 // Regular entry.
Adrian Prantl5883af32015-01-19 17:57:29 +00001722 Asm->EmitDwarfRegOp(Streamer, Loc);
Eric Christopher29e874d2014-03-07 22:40:37 +00001723 else {
1724 // Complex address entry.
Adrian Prantl092d9482015-01-13 23:39:11 +00001725 if (Loc.getOffset()) {
1726 DwarfExpr.AddMachineRegIndirect(Loc.getReg(), Loc.getOffset());
1727 DwarfExpr.AddExpression(Expr, PieceOffsetInBits);
1728 } else
1729 DwarfExpr.AddMachineRegExpression(Expr, Loc.getReg(),
1730 PieceOffsetInBits);
Eric Christopher29e874d2014-03-07 22:40:37 +00001731 }
1732 }
1733 // else ... ignore constant fp. There is not any good way to
1734 // to represent them here in dwarf.
1735 // FIXME: ^
1736}
1737
David Blaikie0e84adc2014-04-01 16:17:41 +00001738void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
1739 Asm->OutStreamer.AddComment("Loc expr size");
1740 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1741 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1742 Asm->EmitLabelDifference(end, begin, 2);
1743 Asm->OutStreamer.EmitLabel(begin);
1744 // Emit the entry.
1745 APByteStreamer Streamer(*Asm);
1746 emitDebugLocEntry(Streamer, Entry);
1747 // Close the range.
1748 Asm->OutStreamer.EmitLabel(end);
1749}
1750
Eric Christopher9046f942013-07-02 21:36:07 +00001751// Emit locations into the debug loc section.
Devang Patel930143b2009-11-21 02:48:08 +00001752void DwarfDebug::emitDebugLoc() {
Daniel Dunbarfd95b012011-03-16 22:16:39 +00001753 // Start the dwarf loc section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001754 Asm->OutStreamer.SwitchSection(
David Blaikie94c1d7f2014-04-02 01:50:20 +00001755 Asm->getObjFileLowering().getDwarfLocSection());
Chandler Carruth5da3f052012-11-01 09:14:31 +00001756 unsigned char Size = Asm->getDataLayout().getPointerSize();
David Blaikie84d8e182014-03-24 22:38:38 +00001757 for (const auto &DebugLoc : DotDebugLocEntries) {
David Blaikie0a456de2014-04-02 01:43:18 +00001758 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
David Blaikiee1a26a62014-08-05 23:14:16 +00001759 const DwarfCompileUnit *CU = DebugLoc.CU;
David Blaikie0a456de2014-04-02 01:43:18 +00001760 for (const auto &Entry : DebugLoc.List) {
Eric Christopher384f3fe2014-03-20 19:16:16 +00001761 // Set up the range. This range is relative to the entry point of the
1762 // compile unit. This is a hard coded 0 for low_pc when we're emitting
1763 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
David Blaikiece343492014-11-03 21:15:30 +00001764 if (auto *Base = CU->getBaseAddress()) {
Eric Christopher384f3fe2014-03-20 19:16:16 +00001765 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
1766 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
1767 } else {
1768 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
1769 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
1770 }
David Blaikie94c1d7f2014-04-02 01:50:20 +00001771
David Blaikie0e84adc2014-04-01 16:17:41 +00001772 emitDebugLocEntryLocation(Entry);
Devang Patel9fc11702010-05-25 23:40:22 +00001773 }
David Blaikie94c1d7f2014-04-02 01:50:20 +00001774 Asm->OutStreamer.EmitIntValue(0, Size);
1775 Asm->OutStreamer.EmitIntValue(0, Size);
1776 }
1777}
1778
1779void DwarfDebug::emitDebugLocDWO() {
1780 Asm->OutStreamer.SwitchSection(
1781 Asm->getObjFileLowering().getDwarfLocDWOSection());
1782 for (const auto &DebugLoc : DotDebugLocEntries) {
1783 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
1784 for (const auto &Entry : DebugLoc.List) {
1785 // Just always use start_length for now - at least that's one address
1786 // rather than two. We could get fancier and try to, say, reuse an
1787 // address we know we've emitted elsewhere (the start of the function?
1788 // The start of the CU or CU subrange that encloses this range?)
1789 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
David Blaikied75fb282014-04-23 21:20:10 +00001790 unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
David Blaikie94c1d7f2014-04-02 01:50:20 +00001791 Asm->EmitULEB128(idx);
1792 Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
1793
1794 emitDebugLocEntryLocation(Entry);
David Blaikie9c550ac2014-03-25 01:44:02 +00001795 }
David Blaikie94c1d7f2014-04-02 01:50:20 +00001796 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
Devang Patel9fc11702010-05-25 23:40:22 +00001797 }
Bill Wendling480ff322009-05-20 23:21:38 +00001798}
1799
Richard Mitton21101b32013-09-19 23:21:01 +00001800struct ArangeSpan {
1801 const MCSymbol *Start, *End;
1802};
1803
1804// Emit a debug aranges section, containing a CU lookup for any
1805// address we can tie back to a CU.
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001806void DwarfDebug::emitDebugARanges() {
Bill Wendling480ff322009-05-20 23:21:38 +00001807 // Start the dwarf aranges section.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001808 Asm->OutStreamer.SwitchSection(
1809 Asm->getObjFileLowering().getDwarfARangesSection());
Richard Mitton21101b32013-09-19 23:21:01 +00001810
Eric Christopher793c7472014-04-28 20:42:22 +00001811 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> SpansType;
Richard Mitton21101b32013-09-19 23:21:01 +00001812
1813 SpansType Spans;
1814
1815 // Build a list of sections used.
1816 std::vector<const MCSection *> Sections;
Benjamin Kramer15596c72014-03-07 19:09:39 +00001817 for (const auto &it : SectionMap) {
1818 const MCSection *Section = it.first;
Richard Mitton21101b32013-09-19 23:21:01 +00001819 Sections.push_back(Section);
1820 }
1821
1822 // Sort the sections into order.
1823 // This is only done to ensure consistent output order across different runs.
1824 std::sort(Sections.begin(), Sections.end(), SectionSort);
1825
1826 // Build a set of address spans, sorted by CU.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001827 for (const MCSection *Section : Sections) {
David Blaikieafd2c6b2014-04-22 05:41:06 +00001828 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
Richard Mitton21101b32013-09-19 23:21:01 +00001829 if (List.size() < 2)
1830 continue;
1831
Rafael Espindola6ffb1d72015-02-02 19:22:51 +00001832 // If we have no section (e.g. common), just write out
1833 // individual spans for each symbol.
1834 if (!Section) {
1835 for (const SymbolCU &Cur : List) {
1836 ArangeSpan Span;
1837 Span.Start = Cur.Sym;
1838 Span.End = nullptr;
1839 if (Cur.CU)
1840 Spans[Cur.CU].push_back(Span);
1841 }
1842 continue;
1843 }
1844
Richard Mitton21101b32013-09-19 23:21:01 +00001845 // Sort the symbols by offset within the section.
Benjamin Kramer571e2fe2014-03-07 19:41:22 +00001846 std::sort(List.begin(), List.end(),
1847 [&](const SymbolCU &A, const SymbolCU &B) {
1848 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
1849 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
1850
1851 // Symbols with no order assigned should be placed at the end.
1852 // (e.g. section end labels)
1853 if (IA == 0)
1854 return false;
1855 if (IB == 0)
1856 return true;
1857 return IA < IB;
1858 });
Richard Mitton21101b32013-09-19 23:21:01 +00001859
Rafael Espindola6ffb1d72015-02-02 19:22:51 +00001860 // Build spans between each label.
1861 const MCSymbol *StartSym = List[0].Sym;
1862 for (size_t n = 1, e = List.size(); n < e; n++) {
1863 const SymbolCU &Prev = List[n - 1];
1864 const SymbolCU &Cur = List[n];
Richard Mitton21101b32013-09-19 23:21:01 +00001865
Rafael Espindola6ffb1d72015-02-02 19:22:51 +00001866 // Try and build the longest span we can within the same CU.
1867 if (Cur.CU != Prev.CU) {
1868 ArangeSpan Span;
1869 Span.Start = StartSym;
1870 Span.End = Cur.Sym;
1871 Spans[Prev.CU].push_back(Span);
1872 StartSym = Cur.Sym;
Richard Mitton21101b32013-09-19 23:21:01 +00001873 }
1874 }
1875 }
1876
Richard Mitton21101b32013-09-19 23:21:01 +00001877 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
1878
1879 // Build a list of CUs used.
Eric Christopher4287a492013-12-09 23:57:44 +00001880 std::vector<DwarfCompileUnit *> CUs;
Benjamin Kramer15596c72014-03-07 19:09:39 +00001881 for (const auto &it : Spans) {
1882 DwarfCompileUnit *CU = it.first;
Richard Mitton21101b32013-09-19 23:21:01 +00001883 CUs.push_back(CU);
1884 }
1885
1886 // Sort the CU list (again, to ensure consistent output order).
Benjamin Kramer571e2fe2014-03-07 19:41:22 +00001887 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
1888 return A->getUniqueID() < B->getUniqueID();
1889 });
Richard Mitton21101b32013-09-19 23:21:01 +00001890
1891 // Emit an arange table for each CU we used.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001892 for (DwarfCompileUnit *CU : CUs) {
Richard Mitton21101b32013-09-19 23:21:01 +00001893 std::vector<ArangeSpan> &List = Spans[CU];
1894
David Blaikie27e35f22014-11-02 01:21:43 +00001895 // Describe the skeleton CU's offset and length, not the dwo file's.
1896 if (auto *Skel = CU->getSkeleton())
1897 CU = Skel;
1898
Richard Mitton21101b32013-09-19 23:21:01 +00001899 // Emit size of content not including length itself.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001900 unsigned ContentSize =
1901 sizeof(int16_t) + // DWARF ARange version number
1902 sizeof(int32_t) + // Offset of CU in the .debug_info section
1903 sizeof(int8_t) + // Pointer Size (in bytes)
1904 sizeof(int8_t); // Segment Size (in bytes)
Richard Mitton21101b32013-09-19 23:21:01 +00001905
1906 unsigned TupleSize = PtrSize * 2;
1907
1908 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
Benjamin Kramer8a68ab32014-01-07 19:28:14 +00001909 unsigned Padding =
1910 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
Richard Mitton21101b32013-09-19 23:21:01 +00001911
1912 ContentSize += Padding;
1913 ContentSize += (List.size() + 1) * TupleSize;
1914
1915 // For each compile unit, write the list of spans it covers.
1916 Asm->OutStreamer.AddComment("Length of ARange Set");
1917 Asm->EmitInt32(ContentSize);
1918 Asm->OutStreamer.AddComment("DWARF Arange version number");
1919 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
1920 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
David Blaikie27e35f22014-11-02 01:21:43 +00001921 Asm->EmitSectionOffset(CU->getLabelBegin(), CU->getSectionSym());
Richard Mitton21101b32013-09-19 23:21:01 +00001922 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1923 Asm->EmitInt8(PtrSize);
1924 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
1925 Asm->EmitInt8(0);
1926
Benjamin Kramer8a68ab32014-01-07 19:28:14 +00001927 Asm->OutStreamer.EmitFill(Padding, 0xff);
Richard Mitton21101b32013-09-19 23:21:01 +00001928
Benjamin Kramer15596c72014-03-07 19:09:39 +00001929 for (const ArangeSpan &Span : List) {
Richard Mitton21101b32013-09-19 23:21:01 +00001930 Asm->EmitLabelReference(Span.Start, PtrSize);
1931
1932 // Calculate the size as being from the span start to it's end.
Richard Mitton089ed892013-09-23 17:56:20 +00001933 if (Span.End) {
Richard Mitton21101b32013-09-19 23:21:01 +00001934 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
Richard Mitton089ed892013-09-23 17:56:20 +00001935 } else {
1936 // For symbols without an end marker (e.g. common), we
1937 // write a single arange entry containing just that one symbol.
1938 uint64_t Size = SymSize[Span.Start];
1939 if (Size == 0)
1940 Size = 1;
1941
1942 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
1943 }
Richard Mitton21101b32013-09-19 23:21:01 +00001944 }
1945
1946 Asm->OutStreamer.AddComment("ARange terminator");
1947 Asm->OutStreamer.EmitIntValue(0, PtrSize);
1948 Asm->OutStreamer.EmitIntValue(0, PtrSize);
1949 }
Bill Wendling480ff322009-05-20 23:21:38 +00001950}
1951
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001952// Emit visible names into a debug ranges section.
Devang Patel930143b2009-11-21 02:48:08 +00001953void DwarfDebug::emitDebugRanges() {
Bill Wendling480ff322009-05-20 23:21:38 +00001954 // Start the dwarf ranges section.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001955 Asm->OutStreamer.SwitchSection(
1956 Asm->getObjFileLowering().getDwarfRangesSection());
Eric Christopher4751d702013-11-23 00:05:29 +00001957
Eric Christopher0f63d062013-12-03 00:45:45 +00001958 // Size for our labels.
1959 unsigned char Size = Asm->getDataLayout().getPointerSize();
1960
1961 // Grab the specific ranges for the compile units in the module.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001962 for (const auto &I : CUMap) {
1963 DwarfCompileUnit *TheCU = I.second;
Eric Christopher0f63d062013-12-03 00:45:45 +00001964
David Blaikie3a443c22014-11-04 22:12:25 +00001965 if (auto *Skel = TheCU->getSkeleton())
1966 TheCU = Skel;
1967
Eric Christopher0f63d062013-12-03 00:45:45 +00001968 // Iterate over the misc ranges for the compile units in the module.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001969 for (const RangeSpanList &List : TheCU->getRangeLists()) {
Eric Christopherf8790642013-12-04 22:04:50 +00001970 // Emit our symbol so we can find the beginning of the range.
1971 Asm->OutStreamer.EmitLabel(List.getSym());
Eric Christopher0f63d062013-12-03 00:45:45 +00001972
Benjamin Kramer15596c72014-03-07 19:09:39 +00001973 for (const RangeSpan &Range : List.getRanges()) {
Eric Christopher0f63d062013-12-03 00:45:45 +00001974 const MCSymbol *Begin = Range.getStart();
1975 const MCSymbol *End = Range.getEnd();
Eric Christopher565ab112013-12-20 04:34:22 +00001976 assert(Begin && "Range without a begin symbol?");
1977 assert(End && "Range without an end symbol?");
David Blaikiece343492014-11-03 21:15:30 +00001978 if (auto *Base = TheCU->getBaseAddress()) {
Eric Christopherece0e902014-04-25 22:23:54 +00001979 Asm->EmitLabelDifference(Begin, Base, Size);
1980 Asm->EmitLabelDifference(End, Base, Size);
1981 } else {
1982 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
1983 Asm->OutStreamer.EmitSymbolValue(End, Size);
1984 }
Eric Christopher0f63d062013-12-03 00:45:45 +00001985 }
1986
1987 // And terminate the list with two 0 values.
Eric Christopherce0cfce2013-01-09 01:35:34 +00001988 Asm->OutStreamer.EmitIntValue(0, Size);
Eric Christopher0f63d062013-12-03 00:45:45 +00001989 Asm->OutStreamer.EmitIntValue(0, Size);
1990 }
Devang Patel12563b32010-04-16 23:33:45 +00001991 }
Bill Wendling480ff322009-05-20 23:21:38 +00001992}
1993
Eric Christopherd692c1d2012-12-11 19:42:09 +00001994// DWARF5 Experimental Separate Dwarf emitters.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001995
David Blaikie65a74662014-04-25 18:26:14 +00001996void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
David Blaikief9b6a552014-04-22 22:39:41 +00001997 std::unique_ptr<DwarfUnit> NewU) {
David Blaikiecafd9622014-11-02 08:51:37 +00001998 NewU->addString(Die, dwarf::DW_AT_GNU_dwo_name,
David Blaikie4aa49b22014-11-02 08:52:37 +00001999 U.getCUNode().getSplitDebugFilename());
David Blaikie38fe6342014-01-09 04:28:46 +00002000
David Blaikie38fe6342014-01-09 04:28:46 +00002001 if (!CompilationDir.empty())
David Blaikiecafd9622014-11-02 08:51:37 +00002002 NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
David Blaikie38fe6342014-01-09 04:28:46 +00002003
David Blaikief9b6a552014-04-22 22:39:41 +00002004 addGnuPubAttributes(*NewU, Die);
David Blaikie38fe6342014-01-09 04:28:46 +00002005
David Blaikief9b6a552014-04-22 22:39:41 +00002006 SkeletonHolder.addUnit(std::move(NewU));
David Blaikie38fe6342014-01-09 04:28:46 +00002007}
2008
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002009// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2010// 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 +00002011// DW_AT_addr_base, DW_AT_ranges_base.
David Blaikief9b6a552014-04-22 22:39:41 +00002012DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002013
David Blaikief9b6a552014-04-22 22:39:41 +00002014 auto OwnedUnit = make_unique<DwarfCompileUnit>(
David Blaikiebd579052014-04-28 21:14:27 +00002015 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
David Blaikief9b6a552014-04-22 22:39:41 +00002016 DwarfCompileUnit &NewCU = *OwnedUnit;
2017 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
David Blaikie637cac42014-04-22 23:09:36 +00002018 DwarfInfoSectionSym);
Eric Christopher4c7765f2013-01-17 03:00:04 +00002019
David Blaikief9b6a552014-04-22 22:39:41 +00002020 NewCU.initStmtList(DwarfLineSectionSym);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002021
David Blaikie92a2f8a2014-04-28 21:04:29 +00002022 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
Eric Christopherc8a310e2012-12-10 23:34:43 +00002023
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002024 return NewCU;
2025}
2026
Eric Christopherd692c1d2012-12-11 19:42:09 +00002027// Emit the .debug_info.dwo section for separated dwarf. This contains the
2028// compile units that would normally be in debug_info.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002029void DwarfDebug::emitDebugInfoDWO() {
Eric Christophercdf218d2012-12-10 19:51:21 +00002030 assert(useSplitDwarf() && "No split dwarf debug info?");
David Blaikie326e1fa2014-04-02 02:04:51 +00002031 // Don't pass an abbrev symbol, using a constant zero instead so as not to
2032 // emit relocations into the dwo file.
David Blaikie2b22b1e2014-10-23 00:16:03 +00002033 InfoHolder.emitUnits(/* AbbrevSymbol */ nullptr);
Eric Christopher3c5a1912012-12-19 22:02:53 +00002034}
2035
2036// Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2037// abbreviations for the .debug_info.dwo section.
2038void DwarfDebug::emitDebugAbbrevDWO() {
2039 assert(useSplitDwarf() && "No split dwarf?");
David Blaikie0504cda2013-12-05 07:43:55 +00002040 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002041}
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002042
David Blaikie4a2f95f2014-03-18 01:17:26 +00002043void DwarfDebug::emitDebugLineDWO() {
2044 assert(useSplitDwarf() && "No split dwarf?");
2045 Asm->OutStreamer.SwitchSection(
2046 Asm->getObjFileLowering().getDwarfLineDWOSection());
David Blaikie8287aff2014-03-18 02:13:23 +00002047 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
David Blaikie4a2f95f2014-03-18 01:17:26 +00002048}
2049
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002050// Emit the .debug_str.dwo section for separated dwarf. This contains the
2051// string section and is identical in format to traditional .debug_str
2052// sections.
2053void DwarfDebug::emitDebugStrDWO() {
2054 assert(useSplitDwarf() && "No split dwarf?");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002055 const MCSection *OffSec =
2056 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
Eric Christopher2cbd5762013-01-07 19:32:41 +00002057 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
David Blaikie6741bb02014-09-11 21:12:48 +00002058 OffSec);
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002059}
David Blaikie409dd9c2013-11-19 23:08:21 +00002060
David Blaikie47f4b822014-03-19 00:11:28 +00002061MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2062 if (!useSplitDwarf())
2063 return nullptr;
2064 if (SingleCU)
2065 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2066 return &SplitTypeUnitFileTable;
2067}
2068
David Blaikief3de2ab2014-04-26 16:26:41 +00002069static uint64_t makeTypeSignature(StringRef Identifier) {
2070 MD5 Hash;
2071 Hash.update(Identifier);
2072 // ... take the least significant 8 bytes and return those. Our MD5
2073 // implementation always returns its results in little endian, swap bytes
2074 // appropriately.
2075 MD5::MD5Result Result;
2076 Hash.final(Result);
2077 return *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2078}
2079
David Blaikie15632ae2014-02-12 00:31:30 +00002080void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
David Blaikie65a74662014-04-25 18:26:14 +00002081 StringRef Identifier, DIE &RefDie,
David Blaikief645f962014-01-09 03:23:41 +00002082 DICompositeType CTy) {
David Blaikiee12b49a2014-04-26 17:27:38 +00002083 // Fast path if we're building some type units and one has already used the
2084 // address pool we know we're going to throw away all this work anyway, so
2085 // don't bother building dependent types.
2086 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2087 return;
2088
David Blaikie47f615e2013-12-17 23:32:35 +00002089 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
Chandler Carruthb587ab62014-01-20 08:07:07 +00002090 if (TU) {
David Blaikie15632ae2014-02-12 00:31:30 +00002091 CU.addDIETypeSignature(RefDie, *TU);
Chandler Carruthb587ab62014-01-20 08:07:07 +00002092 return;
David Blaikie409dd9c2013-11-19 23:08:21 +00002093 }
2094
David Blaikiee12b49a2014-04-26 17:27:38 +00002095 bool TopLevelType = TypeUnitsUnderConstruction.empty();
2096 AddrPool.resetUsedFlag();
2097
David Blaikie29459ae2014-07-25 17:11:58 +00002098 auto OwnedUnit = make_unique<DwarfTypeUnit>(
2099 InfoHolder.getUnits().size() + TypeUnitsUnderConstruction.size(), CU, Asm,
2100 this, &InfoHolder, getDwoLineTable(CU));
David Blaikief9b6a552014-04-22 22:39:41 +00002101 DwarfTypeUnit &NewTU = *OwnedUnit;
David Blaikie92a2f8a2014-04-28 21:04:29 +00002102 DIE &UnitDie = NewTU.getUnitDie();
David Blaikief9b6a552014-04-22 22:39:41 +00002103 TU = &NewTU;
Eric Christopher793c7472014-04-28 20:42:22 +00002104 TypeUnitsUnderConstruction.push_back(
2105 std::make_pair(std::move(OwnedUnit), CTy));
Chandler Carruthb587ab62014-01-20 08:07:07 +00002106
David Blaikie92a2f8a2014-04-28 21:04:29 +00002107 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
David Blaikie637cac42014-04-22 23:09:36 +00002108 CU.getLanguage());
Chandler Carruthb587ab62014-01-20 08:07:07 +00002109
David Blaikief3de2ab2014-04-26 16:26:41 +00002110 uint64_t Signature = makeTypeSignature(Identifier);
David Blaikief9b6a552014-04-22 22:39:41 +00002111 NewTU.setTypeSignature(Signature);
David Blaikief3de2ab2014-04-26 16:26:41 +00002112
David Blaikie29459ae2014-07-25 17:11:58 +00002113 if (useSplitDwarf())
David Blaikiea34568b2014-11-01 20:06:28 +00002114 NewTU.initSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
David Blaikie29459ae2014-07-25 17:11:58 +00002115 else {
David Blaikie92a2f8a2014-04-28 21:04:29 +00002116 CU.applyStmtList(UnitDie);
David Blaikie29459ae2014-07-25 17:11:58 +00002117 NewTU.initSection(
2118 Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2119 }
Chandler Carruthb587ab62014-01-20 08:07:07 +00002120
David Blaikief3de2ab2014-04-26 16:26:41 +00002121 NewTU.setType(NewTU.createTypeDIE(CTy));
2122
David Blaikiee12b49a2014-04-26 17:27:38 +00002123 if (TopLevelType) {
2124 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2125 TypeUnitsUnderConstruction.clear();
2126
2127 // Types referencing entries in the address table cannot be placed in type
2128 // units.
2129 if (AddrPool.hasBeenUsed()) {
2130
2131 // Remove all the types built while building this type.
2132 // This is pessimistic as some of these types might not be dependent on
2133 // the type that used an address.
2134 for (const auto &TU : TypeUnitsToAdd)
2135 DwarfTypeUnits.erase(TU.second);
2136
2137 // Construct this type in the CU directly.
2138 // This is inefficient because all the dependent types will be rebuilt
2139 // from scratch, including building them in type units, discovering that
2140 // they depend on addresses, throwing them out and rebuilding them.
2141 CU.constructTypeDIE(RefDie, CTy);
2142 return;
2143 }
2144
2145 // If the type wasn't dependent on fission addresses, finish adding the type
2146 // and all its dependent types.
David Blaikiec13bc972014-08-27 05:04:14 +00002147 for (auto &TU : TypeUnitsToAdd)
David Blaikiee12b49a2014-04-26 17:27:38 +00002148 InfoHolder.addUnit(std::move(TU.first));
David Blaikiee12b49a2014-04-26 17:27:38 +00002149 }
David Blaikief9b6a552014-04-22 22:39:41 +00002150 CU.addDIETypeSignature(RefDie, NewTU);
David Blaikie409dd9c2013-11-19 23:08:21 +00002151}
David Blaikie4bd13b72014-03-07 18:49:45 +00002152
David Blaikie2406a0622014-04-23 23:37:35 +00002153// Accelerator table mutators - add each name along with its companion
2154// DIE to the proper table while ensuring that the name that we're going
2155// to reference is in the string table. We do this since the names we
2156// add may not only be identical to the names in the DIE.
David Blaikieb0b3fcf2014-04-25 18:52:29 +00002157void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
David Blaikie2406a0622014-04-23 23:37:35 +00002158 if (!useDwarfAccelTables())
2159 return;
David Blaikie772ab8a2014-04-25 22:21:35 +00002160 AccelNames.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2161 &Die);
David Blaikie2406a0622014-04-23 23:37:35 +00002162}
David Blaikie0ee82b92014-04-24 00:53:32 +00002163
David Blaikieb0b3fcf2014-04-25 18:52:29 +00002164void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
David Blaikie0ee82b92014-04-24 00:53:32 +00002165 if (!useDwarfAccelTables())
2166 return;
David Blaikie772ab8a2014-04-25 22:21:35 +00002167 AccelObjC.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2168 &Die);
David Blaikie0ee82b92014-04-24 00:53:32 +00002169}
David Blaikieecf04152014-04-24 01:02:42 +00002170
David Blaikieb0b3fcf2014-04-25 18:52:29 +00002171void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
David Blaikieecf04152014-04-24 01:02:42 +00002172 if (!useDwarfAccelTables())
2173 return;
David Blaikie772ab8a2014-04-25 22:21:35 +00002174 AccelNamespace.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2175 &Die);
David Blaikieecf04152014-04-24 01:02:42 +00002176}
David Blaikie18d33752014-04-24 01:23:49 +00002177
David Blaikieb0b3fcf2014-04-25 18:52:29 +00002178void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
David Blaikie18d33752014-04-24 01:23:49 +00002179 if (!useDwarfAccelTables())
2180 return;
David Blaikie772ab8a2014-04-25 22:21:35 +00002181 AccelTypes.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2182 &Die);
David Blaikie18d33752014-04-24 01:23:49 +00002183}