blob: 39caa4170beffedff2024bc1d765f03b6d875666 [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
Devang Patel80ae3492009-08-28 23:24:31 +000014#define DEBUG_TYPE "dwarfdebug"
Bill Wendling2f921f82009-05-15 09:23:25 +000015#include "DwarfDebug.h"
Chris Lattner3f3fb972010-04-05 05:24:55 +000016#include "DIE.h"
Eric Christopher4996c702011-11-07 09:24:32 +000017#include "DwarfAccelTable.h"
Devang Patel5eb43192011-04-12 17:40:32 +000018#include "DwarfCompileUnit.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000019#include "llvm/ADT/STLExtras.h"
20#include "llvm/ADT/Statistic.h"
21#include "llvm/ADT/StringExtras.h"
22#include "llvm/ADT/Triple.h"
David Greene829b3e82009-08-19 21:52:55 +000023#include "llvm/CodeGen/MachineFunction.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000024#include "llvm/CodeGen/MachineModuleInfo.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000025#include "llvm/DIBuilder.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000026#include "llvm/DebugInfo.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000027#include "llvm/IR/Constants.h"
28#include "llvm/IR/DataLayout.h"
29#include "llvm/IR/Instructions.h"
30#include "llvm/IR/Module.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000031#include "llvm/MC/MCAsmInfo.h"
Chris Lattner4d2c0f92009-07-31 18:48:30 +000032#include "llvm/MC/MCSection.h"
Chris Lattner4b7dadb2009-08-19 05:49:37 +000033#include "llvm/MC/MCStreamer.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000034#include "llvm/MC/MCSymbol.h"
Devang Patel6c74a872010-04-27 19:46:33 +000035#include "llvm/Support/CommandLine.h"
Daniel Dunbarcdf01b52009-10-13 06:47:08 +000036#include "llvm/Support/Debug.h"
37#include "llvm/Support/ErrorHandling.h"
Chris Lattnerf5c834f2010-01-22 22:09:00 +000038#include "llvm/Support/FormattedStream.h"
Michael J. Spencer447762d2010-11-29 18:16:10 +000039#include "llvm/Support/Path.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000040#include "llvm/Support/Timer.h"
41#include "llvm/Support/ValueHandle.h"
42#include "llvm/Target/TargetFrameLowering.h"
43#include "llvm/Target/TargetLoweringObjectFile.h"
44#include "llvm/Target/TargetMachine.h"
45#include "llvm/Target/TargetOptions.h"
46#include "llvm/Target/TargetRegisterInfo.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000047using namespace llvm;
48
Jim Grosbacha8683bb2010-07-21 21:21:52 +000049static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
Devang Patel30265c42010-07-07 20:12:52 +000050 cl::Hidden,
Devang Patel6c74a872010-04-27 19:46:33 +000051 cl::desc("Disable debug info printing"));
52
Dan Gohman7421ae42010-05-07 01:08:53 +000053static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
Chris Lattner0ab5e2c2011-04-15 05:18:47 +000054 cl::desc("Make an absence of debug location information explicit."),
Dan Gohman7421ae42010-05-07 01:08:53 +000055 cl::init(false));
56
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +000057static cl::opt<bool> GenerateDwarfPubNamesSection("generate-dwarf-pubnames",
Eric Christopher55909492013-04-03 05:26:07 +000058 cl::Hidden, cl::init(false),
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +000059 cl::desc("Generate DWARF pubnames section"));
60
Eric Christopher20b76a72012-08-23 22:36:40 +000061namespace {
62 enum DefaultOnOff {
63 Default, Enable, Disable
64 };
65}
Eric Christopher4996c702011-11-07 09:24:32 +000066
Eric Christopher20b76a72012-08-23 22:36:40 +000067static cl::opt<DefaultOnOff> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
68 cl::desc("Output prototype dwarf accelerator tables."),
69 cl::values(
70 clEnumVal(Default, "Default for platform"),
71 clEnumVal(Enable, "Enabled"),
72 clEnumVal(Disable, "Disabled"),
73 clEnumValEnd),
74 cl::init(Default));
75
76static cl::opt<DefaultOnOff> DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
Eric Christopher978fbff2012-08-23 07:10:46 +000077 cl::desc("Compatibility with Darwin gdb."),
Eric Christopher20b76a72012-08-23 22:36:40 +000078 cl::values(
79 clEnumVal(Default, "Default for platform"),
80 clEnumVal(Enable, "Enabled"),
81 clEnumVal(Disable, "Disabled"),
82 clEnumValEnd),
83 cl::init(Default));
Eric Christopher978fbff2012-08-23 07:10:46 +000084
Eric Christophercdf218d2012-12-10 19:51:21 +000085static cl::opt<DefaultOnOff> SplitDwarf("split-dwarf", cl::Hidden,
86 cl::desc("Output prototype dwarf split debug info."),
Eric Christopher29424312012-11-12 22:22:20 +000087 cl::values(
88 clEnumVal(Default, "Default for platform"),
89 clEnumVal(Enable, "Enabled"),
90 clEnumVal(Disable, "Disabled"),
91 clEnumValEnd),
92 cl::init(Default));
93
Bill Wendlingfcc14142010-04-07 09:28:04 +000094namespace {
95 const char *DWARFGroupName = "DWARF Emission";
96 const char *DbgTimerName = "DWARF Debug Writer";
David Blaikie684fc532013-05-06 23:33:07 +000097
98 struct CompareFirst {
99 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
100 return lhs.first < rhs.first;
101 }
102 };
Bill Wendlingfcc14142010-04-07 09:28:04 +0000103} // end anonymous namespace
104
Bill Wendling2f921f82009-05-15 09:23:25 +0000105//===----------------------------------------------------------------------===//
106
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000107// Configuration values for initial hash set sizes (log2).
108//
Bill Wendling2f921f82009-05-15 09:23:25 +0000109static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
Bill Wendling2f921f82009-05-15 09:23:25 +0000110
111namespace llvm {
112
Nick Lewycky019d2552011-07-29 03:49:23 +0000113DIType DbgVariable::getType() const {
Devang Patelf20c4f72011-04-12 22:53:02 +0000114 DIType Ty = Var.getType();
115 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
116 // addresses instead.
117 if (Var.isBlockByrefVariable()) {
118 /* Byref variables, in Blocks, are declared by the programmer as
119 "SomeType VarName;", but the compiler creates a
120 __Block_byref_x_VarName struct, and gives the variable VarName
121 either the struct, or a pointer to the struct, as its type. This
122 is necessary for various behind-the-scenes things the compiler
123 needs to do with by-reference variables in blocks.
Eric Christopher6a841382012-11-19 22:42:10 +0000124
Devang Patelf20c4f72011-04-12 22:53:02 +0000125 However, as far as the original *programmer* is concerned, the
126 variable should still have type 'SomeType', as originally declared.
Eric Christopher6a841382012-11-19 22:42:10 +0000127
Devang Patelf20c4f72011-04-12 22:53:02 +0000128 The following function dives into the __Block_byref_x_VarName
129 struct to find the original type of the variable. This will be
130 passed back to the code generating the type for the Debug
131 Information Entry for the variable 'VarName'. 'VarName' will then
132 have the original type 'SomeType' in its debug information.
Eric Christopher6a841382012-11-19 22:42:10 +0000133
Devang Patelf20c4f72011-04-12 22:53:02 +0000134 The original type 'SomeType' will be the type of the field named
135 'VarName' inside the __Block_byref_x_VarName struct.
Eric Christopher6a841382012-11-19 22:42:10 +0000136
Devang Patelf20c4f72011-04-12 22:53:02 +0000137 NOTE: In order for this to not completely fail on the debugger
138 side, the Debug Information Entry for the variable VarName needs to
139 have a DW_AT_location that tells the debugger how to unwind through
140 the pointers and __Block_byref_x_VarName struct to find the actual
141 value of the variable. The function addBlockByrefType does this. */
142 DIType subType = Ty;
143 unsigned tag = Ty.getTag();
Eric Christopher6a841382012-11-19 22:42:10 +0000144
Devang Patelf20c4f72011-04-12 22:53:02 +0000145 if (tag == dwarf::DW_TAG_pointer_type) {
146 DIDerivedType DTy = DIDerivedType(Ty);
147 subType = DTy.getTypeDerivedFrom();
148 }
Eric Christopher6a841382012-11-19 22:42:10 +0000149
Devang Patelf20c4f72011-04-12 22:53:02 +0000150 DICompositeType blockStruct = DICompositeType(subType);
151 DIArray Elements = blockStruct.getTypeArray();
Eric Christopher6a841382012-11-19 22:42:10 +0000152
Devang Patelf20c4f72011-04-12 22:53:02 +0000153 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
154 DIDescriptor Element = Elements.getElement(i);
155 DIDerivedType DT = DIDerivedType(Element);
156 if (getName() == DT.getName())
157 return (DT.getTypeDerivedFrom());
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000158 }
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000159 }
Devang Patelf20c4f72011-04-12 22:53:02 +0000160 return Ty;
161}
Bill Wendling2f921f82009-05-15 09:23:25 +0000162
Chris Lattnerf5d06362010-04-05 04:09:20 +0000163} // end llvm namespace
Bill Wendling2f921f82009-05-15 09:23:25 +0000164
Chris Lattnerf0d6bd32010-04-05 05:11:15 +0000165DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
Eric Christopherd79f5482012-12-10 19:51:13 +0000166 : Asm(A), MMI(Asm->MMI), FirstCU(0),
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000167 AbbreviationsSet(InitAbbreviationsSetSize),
Eric Christopher27614582013-01-08 22:22:06 +0000168 SourceIdMap(DIEValueAllocator),
Eric Christopherc8a310e2012-12-10 23:34:43 +0000169 PrevLabel(NULL), GlobalCUIndexCount(0),
Eric Christopher27614582013-01-08 22:22:06 +0000170 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
171 DIEValueAllocator),
Eric Christopher3c5a1912012-12-19 22:02:53 +0000172 SkeletonAbbrevSet(InitAbbreviationsSetSize),
Eric Christopher27614582013-01-08 22:22:06 +0000173 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
174 DIEValueAllocator) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000175
Rafael Espindolaa7160962011-05-06 14:56:22 +0000176 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
Chris Lattnere58b5472010-04-04 23:10:38 +0000177 DwarfStrSectionSym = TextSectionSym = 0;
Eric Christopher74804332013-02-07 21:19:50 +0000178 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
Eric Christopher55863be2013-04-07 03:43:09 +0000179 DwarfAddrSectionSym = 0;
Eric Christopher3bf29fd2012-12-27 02:14:01 +0000180 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
Devang Patel9fc11702010-05-25 23:40:22 +0000181 FunctionBeginSym = FunctionEndSym = 0;
Eric Christopherad9fe892012-04-02 17:58:52 +0000182
Eric Christopher978fbff2012-08-23 07:10:46 +0000183 // Turn on accelerator tables and older gdb compatibility
184 // for Darwin.
Eric Christopher203e12b2013-04-27 01:07:52 +0000185 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
Eric Christopher20b76a72012-08-23 22:36:40 +0000186 if (DarwinGDBCompat == Default) {
Eric Christopher7b30f2e42012-11-21 00:34:35 +0000187 if (IsDarwin)
188 IsDarwinGDBCompat = true;
Eric Christopher20b76a72012-08-23 22:36:40 +0000189 else
Eric Christopher7b30f2e42012-11-21 00:34:35 +0000190 IsDarwinGDBCompat = false;
Eric Christopher20b76a72012-08-23 22:36:40 +0000191 } else
Eric Christopher7b30f2e42012-11-21 00:34:35 +0000192 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
Eric Christopher4977f212012-08-23 22:36:36 +0000193
Eric Christopher20b76a72012-08-23 22:36:40 +0000194 if (DwarfAccelTables == Default) {
Eric Christopher7b30f2e42012-11-21 00:34:35 +0000195 if (IsDarwin)
196 HasDwarfAccelTables = true;
Eric Christopher20b76a72012-08-23 22:36:40 +0000197 else
Eric Christopher7b30f2e42012-11-21 00:34:35 +0000198 HasDwarfAccelTables = false;
Eric Christopher20b76a72012-08-23 22:36:40 +0000199 } else
Eric Christopher7b30f2e42012-11-21 00:34:35 +0000200 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
Eric Christopher20b76a72012-08-23 22:36:40 +0000201
Eric Christophercdf218d2012-12-10 19:51:21 +0000202 if (SplitDwarf == Default)
203 HasSplitDwarf = false;
Eric Christopher29424312012-11-12 22:22:20 +0000204 else
Eric Christophercdf218d2012-12-10 19:51:21 +0000205 HasSplitDwarf = SplitDwarf == Enable ? true : false;
Eric Christopher29424312012-11-12 22:22:20 +0000206
Dan Gohman6e681a52010-06-18 15:56:31 +0000207 {
208 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
Eric Christopher58f41952012-11-19 22:42:15 +0000209 beginModule();
Torok Edwinf8dba242010-04-07 10:44:46 +0000210 }
Bill Wendling2f921f82009-05-15 09:23:25 +0000211}
212DwarfDebug::~DwarfDebug() {
Bill Wendling2f921f82009-05-15 09:23:25 +0000213}
214
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000215// Switch to the specified MCSection and emit an assembler
216// temporary label to it if SymbolStem is specified.
Eric Christopher7b30f2e42012-11-21 00:34:35 +0000217static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
Eric Christophera7b61892011-11-07 09:18:38 +0000218 const char *SymbolStem = 0) {
219 Asm->OutStreamer.SwitchSection(Section);
220 if (!SymbolStem) return 0;
221
222 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
223 Asm->OutStreamer.EmitLabel(TmpSym);
224 return TmpSym;
225}
226
Eric Christophere698f532012-12-20 21:58:36 +0000227MCSymbol *DwarfUnits::getStringPoolSym() {
Eric Christopher3bf29fd2012-12-27 02:14:01 +0000228 return Asm->GetTempSymbol(StringPref);
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000229}
230
Eric Christophere698f532012-12-20 21:58:36 +0000231MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
232 std::pair<MCSymbol*, unsigned> &Entry =
Eric Christopher27614582013-01-08 22:22:06 +0000233 StringPool.GetOrCreateValue(Str).getValue();
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000234 if (Entry.first) return Entry.first;
235
236 Entry.second = NextStringPoolNumber++;
Eric Christopher3bf29fd2012-12-27 02:14:01 +0000237 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000238}
239
Eric Christopher2cbd5762013-01-07 19:32:41 +0000240unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
241 std::pair<MCSymbol*, unsigned> &Entry =
Eric Christopher27614582013-01-08 22:22:06 +0000242 StringPool.GetOrCreateValue(Str).getValue();
Eric Christopher2cbd5762013-01-07 19:32:41 +0000243 if (Entry.first) return Entry.second;
244
245 Entry.second = NextStringPoolNumber++;
246 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
247 return Entry.second;
248}
249
Eric Christopher962c9082013-01-15 23:56:56 +0000250unsigned DwarfUnits::getAddrPoolIndex(MCSymbol *Sym) {
251 std::pair<MCSymbol*, unsigned> &Entry = AddressPool[Sym];
252 if (Entry.first) return Entry.second;
253
254 Entry.second = NextAddrPoolNumber++;
255 Entry.first = Sym;
256 return Entry.second;
257}
258
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000259// Define a unique number for the abbreviation.
260//
Eric Christopherc8a310e2012-12-10 23:34:43 +0000261void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
Bill Wendling2f921f82009-05-15 09:23:25 +0000262 // Profile the node so that we can make it unique.
263 FoldingSetNodeID ID;
264 Abbrev.Profile(ID);
265
266 // Check the set for priors.
Eric Christopherc8a310e2012-12-10 23:34:43 +0000267 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
Bill Wendling2f921f82009-05-15 09:23:25 +0000268
269 // If it's newly added.
270 if (InSet == &Abbrev) {
271 // Add to abbreviation list.
Eric Christopherc8a310e2012-12-10 23:34:43 +0000272 Abbreviations->push_back(&Abbrev);
Bill Wendling2f921f82009-05-15 09:23:25 +0000273
274 // Assign the vector position + 1 as its number.
Eric Christopherc8a310e2012-12-10 23:34:43 +0000275 Abbrev.setNumber(Abbreviations->size());
Bill Wendling2f921f82009-05-15 09:23:25 +0000276 } else {
277 // Assign existing abbreviation number.
278 Abbrev.setNumber(InSet->getNumber());
279 }
280}
281
Eric Christopherd9843b32011-11-10 19:25:34 +0000282static bool isObjCClass(StringRef Name) {
283 return Name.startswith("+") || Name.startswith("-");
284}
285
286static bool hasObjCCategory(StringRef Name) {
287 if (!isObjCClass(Name)) return false;
288
289 size_t pos = Name.find(')');
290 if (pos != std::string::npos) {
291 if (Name[pos+1] != ' ') return false;
292 return true;
293 }
294 return false;
295}
296
297static void getObjCClassCategory(StringRef In, StringRef &Class,
298 StringRef &Category) {
299 if (!hasObjCCategory(In)) {
300 Class = In.slice(In.find('[') + 1, In.find(' '));
301 Category = "";
302 return;
303 }
304
305 Class = In.slice(In.find('[') + 1, In.find('('));
306 Category = In.slice(In.find('[') + 1, In.find(' '));
307 return;
308}
309
310static StringRef getObjCMethodName(StringRef In) {
311 return In.slice(In.find(' ') + 1, In.find(']'));
312}
313
314// Add the various names to the Dwarf accelerator table names.
315static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
316 DIE* Die) {
317 if (!SP.isDefinition()) return;
Eric Christopher6a841382012-11-19 22:42:10 +0000318
Eric Christopherd9843b32011-11-10 19:25:34 +0000319 TheCU->addAccelName(SP.getName(), Die);
320
321 // If the linkage name is different than the name, go ahead and output
322 // that as well into the name table.
323 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
324 TheCU->addAccelName(SP.getLinkageName(), Die);
325
326 // If this is an Objective-C selector name add it to the ObjC accelerator
327 // too.
328 if (isObjCClass(SP.getName())) {
329 StringRef Class, Category;
330 getObjCClassCategory(SP.getName(), Class, Category);
331 TheCU->addAccelObjC(Class, Die);
332 if (Category != "")
333 TheCU->addAccelObjC(Category, Die);
334 // Also add the base method name to the name table.
335 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
336 }
337}
338
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000339// Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
340// and DW_AT_high_pc attributes. If there are global variables in this
341// scope then create and insert DIEs for these variables.
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000342DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
343 const MDNode *SPNode) {
Devang Patel1a0df9a2010-05-10 22:49:55 +0000344 DIE *SPDie = SPCU->getDIE(SPNode);
Devang Patela37a95e2010-07-07 22:20:57 +0000345
Chris Lattner3a383cb2010-04-05 00:13:49 +0000346 assert(SPDie && "Unable to find subprogram DIE!");
347 DISubprogram SP(SPNode);
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000348
Bill Wendlingf720bf62012-11-07 05:19:04 +0000349 // If we're updating an abstract DIE, then we will be adding the children and
350 // object pointer later on. But what we don't want to do is process the
351 // concrete DIE twice.
Manman Ren14a029d2013-03-12 18:27:15 +0000352 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
353 if (AbsSPDIE) {
354 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
Bill Wendlingf720bf62012-11-07 05:19:04 +0000355 // Pick up abstract subprogram DIE.
Devang Patela37a95e2010-07-07 22:20:57 +0000356 SPDie = new DIE(dwarf::DW_TAG_subprogram);
Manman Ren14a029d2013-03-12 18:27:15 +0000357 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
358 // DW_FORM_ref4.
Devang Patelf20c4f72011-04-12 22:53:02 +0000359 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
Manman Ren14a029d2013-03-12 18:27:15 +0000360 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
361 AbsSPDIE);
Devang Patela37a95e2010-07-07 22:20:57 +0000362 SPCU->addDie(SPDie);
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000363 } else {
364 DISubprogram SPDecl = SP.getFunctionDeclaration();
365 if (!SPDecl.isSubprogram()) {
366 // There is not any need to generate specification DIE for a function
367 // defined at compile unit level. If a function is defined inside another
368 // function then gdb prefers the definition at top level and but does not
369 // expect specification DIE in parent function. So avoid creating
370 // specification DIE for a function defined inside a function.
371 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
372 !SP.getContext().isFile() &&
373 !isSubprogramContext(SP.getContext())) {
374 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
375
376 // Add arguments.
377 DICompositeType SPTy = SP.getType();
378 DIArray Args = SPTy.getTypeArray();
379 unsigned SPTag = SPTy.getTag();
380 if (SPTag == dwarf::DW_TAG_subroutine_type)
381 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
382 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
383 DIType ATy = DIType(Args.getElement(i));
384 SPCU->addType(Arg, ATy);
385 if (ATy.isArtificial())
386 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
387 if (ATy.isObjectPointer())
388 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
389 dwarf::DW_FORM_ref4, Arg);
390 SPDie->addChild(Arg);
391 }
392 DIE *SPDeclDie = SPDie;
393 SPDie = new DIE(dwarf::DW_TAG_subprogram);
Eric Christopher6a841382012-11-19 22:42:10 +0000394 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
395 dwarf::DW_FORM_ref4, SPDeclDie);
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000396 SPCU->addDie(SPDie);
397 }
398 }
Devang Patela37a95e2010-07-07 22:20:57 +0000399 }
400
Eric Christopher962c9082013-01-15 23:56:56 +0000401 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
402 Asm->GetTempSymbol("func_begin",
403 Asm->getFunctionNumber()));
404 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
405 Asm->GetTempSymbol("func_end",
406 Asm->getFunctionNumber()));
Chris Lattner3a383cb2010-04-05 00:13:49 +0000407 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
408 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
Devang Patelf20c4f72011-04-12 22:53:02 +0000409 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
Devang Patel6efc8e52010-02-06 01:02:37 +0000410
Eric Christopherd9843b32011-11-10 19:25:34 +0000411 // Add name to the name table, we do this here because we're guaranteed
412 // to have concrete versions of our DW_TAG_subprogram nodes.
413 addSubprogramNames(SPCU, SP, SPDie);
Eric Christopher6a841382012-11-19 22:42:10 +0000414
Chris Lattner3a383cb2010-04-05 00:13:49 +0000415 return SPDie;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000416}
417
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000418// Construct new DW_TAG_lexical_block for this scope and attach
419// DW_AT_low_pc/DW_AT_high_pc labels.
Eric Christopher6a841382012-11-19 22:42:10 +0000420DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000421 LexicalScope *Scope) {
Devang Patel6c74a872010-04-27 19:46:33 +0000422 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
423 if (Scope->isAbstractScope())
424 return ScopeDIE;
425
Devang Patel7e623022011-08-10 20:55:27 +0000426 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
Devang Patel6c74a872010-04-27 19:46:33 +0000427 if (Ranges.empty())
428 return 0;
429
Devang Patel7e623022011-08-10 20:55:27 +0000430 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
Devang Patel6c74a872010-04-27 19:46:33 +0000431 if (Ranges.size() > 1) {
432 // .debug_range section has not been laid out yet. Emit offset in
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000433 // .debug_range as a uint, size 4, for now. emitDIE will handle
Devang Patel6c74a872010-04-27 19:46:33 +0000434 // DW_AT_ranges appropriately.
Devang Patelf20c4f72011-04-12 22:53:02 +0000435 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
Eric Christopher6a841382012-11-19 22:42:10 +0000436 DebugRangeSymbols.size()
Chandler Carruth5da3f052012-11-01 09:14:31 +0000437 * Asm->getDataLayout().getPointerSize());
Devang Patel7e623022011-08-10 20:55:27 +0000438 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
Devang Patel6c74a872010-04-27 19:46:33 +0000439 RE = Ranges.end(); RI != RE; ++RI) {
Devang Patel9fc11702010-05-25 23:40:22 +0000440 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
441 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
Devang Patel6c74a872010-04-27 19:46:33 +0000442 }
443 DebugRangeSymbols.push_back(NULL);
444 DebugRangeSymbols.push_back(NULL);
445 return ScopeDIE;
446 }
447
Eric Christopher962c9082013-01-15 23:56:56 +0000448 MCSymbol *Start = getLabelBeforeInsn(RI->first);
449 MCSymbol *End = getLabelAfterInsn(RI->second);
Devang Patel6c74a872010-04-27 19:46:33 +0000450
Devang Patel9fc11702010-05-25 23:40:22 +0000451 if (End == 0) return 0;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000452
Chris Lattnere13c3722010-03-09 01:58:53 +0000453 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
454 assert(End->isDefined() && "Invalid end label for an inlined scope!");
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000455
Eric Christopher962c9082013-01-15 23:56:56 +0000456 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
457 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000458
459 return ScopeDIE;
460}
461
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000462// This scope represents inlined body of a function. Construct DIE to
463// represent this concrete inlined copy of the function.
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000464DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
465 LexicalScope *Scope) {
Devang Patel7e623022011-08-10 20:55:27 +0000466 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000467 assert(Ranges.empty() == false &&
468 "LexicalScope does not have instruction markers!");
Devang Patel6c74a872010-04-27 19:46:33 +0000469
Devang Patelf098ce22011-07-27 00:34:13 +0000470 if (!Scope->getScopeNode())
471 return NULL;
472 DIScope DS(Scope->getScopeNode());
473 DISubprogram InlinedSP = getDISubprogram(DS);
Manman Ren4213c392013-05-29 17:16:59 +0000474 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
Devang Patelf098ce22011-07-27 00:34:13 +0000475 if (!OriginDIE) {
Bill Wendling10e0e2e2012-10-30 17:51:02 +0000476 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
Devang Patelf098ce22011-07-27 00:34:13 +0000477 return NULL;
478 }
479
Devang Patel7e623022011-08-10 20:55:27 +0000480 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
Eric Christopher962c9082013-01-15 23:56:56 +0000481 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
482 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
Devang Patel6c74a872010-04-27 19:46:33 +0000483
Devang Patel4c6bd662010-07-08 22:39:20 +0000484 if (StartLabel == 0 || EndLabel == 0) {
Bill Wendling10e0e2e2012-10-30 17:51:02 +0000485 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
Devang Patel6c74a872010-04-27 19:46:33 +0000486 }
Chris Lattnere13c3722010-03-09 01:58:53 +0000487 assert(StartLabel->isDefined() &&
Chris Lattnerc3b70f62010-03-09 01:51:43 +0000488 "Invalid starting label for an inlined scope!");
Chris Lattnere13c3722010-03-09 01:58:53 +0000489 assert(EndLabel->isDefined() &&
Chris Lattnerc3b70f62010-03-09 01:51:43 +0000490 "Invalid end label for an inlined scope!");
Devang Patel6c74a872010-04-27 19:46:33 +0000491
Devang Patel73bc1722011-05-05 17:54:26 +0000492 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
Devang Patelf20c4f72011-04-12 22:53:02 +0000493 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
Manman Ren4213c392013-05-29 17:16:59 +0000494 dwarf::DW_FORM_ref4, OriginDIE);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000495
Devang Patelf098ce22011-07-27 00:34:13 +0000496 if (Ranges.size() > 1) {
497 // .debug_range section has not been laid out yet. Emit offset in
498 // .debug_range as a uint, size 4, for now. emitDIE will handle
499 // DW_AT_ranges appropriately.
500 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
Eric Christopher6a841382012-11-19 22:42:10 +0000501 DebugRangeSymbols.size()
Chandler Carruth5da3f052012-11-01 09:14:31 +0000502 * Asm->getDataLayout().getPointerSize());
Devang Patel7e623022011-08-10 20:55:27 +0000503 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
Devang Patelf098ce22011-07-27 00:34:13 +0000504 RE = Ranges.end(); RI != RE; ++RI) {
505 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
506 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
507 }
508 DebugRangeSymbols.push_back(NULL);
509 DebugRangeSymbols.push_back(NULL);
510 } else {
Eric Christopher962c9082013-01-15 23:56:56 +0000511 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
512 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
Devang Patelf098ce22011-07-27 00:34:13 +0000513 }
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000514
515 InlinedSubprogramDIEs.insert(OriginDIE);
516
517 // Track the start label for this inlined function.
Devang Patelf098ce22011-07-27 00:34:13 +0000518 //.debug_inlined section specification does not clearly state how
519 // to emit inlined scope that is split into multiple instruction ranges.
520 // For now, use first instruction range and emit low_pc/high_pc pair and
521 // corresponding .debug_inlined section entry for this pair.
Devang Patel32cc43c2010-05-07 20:54:48 +0000522 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000523 I = InlineInfo.find(InlinedSP);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000524
525 if (I == InlineInfo.end()) {
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000526 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000527 InlinedSPNodes.push_back(InlinedSP);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000528 } else
Chris Lattner085b6522010-03-09 00:31:02 +0000529 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000530
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000531 DILocation DL(Scope->getInlinedAt());
Eric Christopher0925c622012-03-26 21:38:38 +0000532 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
Manman Ren1e427202013-03-07 01:42:00 +0000533 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
534 TheCU->getUniqueID()));
Devang Patelf20c4f72011-04-12 22:53:02 +0000535 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000536
Eric Christopher8dda5d02011-12-04 06:02:38 +0000537 // Add name to the name table, we do this here because we're guaranteed
538 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
539 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
Eric Christopher6a841382012-11-19 22:42:10 +0000540
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000541 return ScopeDIE;
542}
543
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000544// Construct a DIE for this scope.
Devang Patel3acc70e2011-08-15 22:04:40 +0000545DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
Devang Patel3b548aa2010-03-08 20:52:55 +0000546 if (!Scope || !Scope->getScopeNode())
547 return NULL;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000548
Manman Ren53f3f9f2013-01-31 20:05:14 +0000549 DIScope DS(Scope->getScopeNode());
550 // Early return to avoid creating dangling variable|scope DIEs.
Manman Ren4213c392013-05-29 17:16:59 +0000551 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
552 !TheCU->getDIE(DS))
553 return NULL;
Manman Ren53f3f9f2013-01-31 20:05:14 +0000554
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000555 SmallVector<DIE *, 8> Children;
Eric Christophere3417762012-09-12 23:36:19 +0000556 DIE *ObjectPointer = NULL;
Devang Patel6c622ef2011-03-01 22:58:55 +0000557
558 // Collect arguments for current function.
Devang Patel7e623022011-08-10 20:55:27 +0000559 if (LScopes.isCurrentFunctionScope(Scope))
Devang Patel6c622ef2011-03-01 22:58:55 +0000560 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
561 if (DbgVariable *ArgDV = CurrentFnArguments[i])
Eric Christopher6a841382012-11-19 22:42:10 +0000562 if (DIE *Arg =
Eric Christophere3417762012-09-12 23:36:19 +0000563 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
Devang Patel6c622ef2011-03-01 22:58:55 +0000564 Children.push_back(Arg);
Eric Christophere3417762012-09-12 23:36:19 +0000565 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
566 }
Devang Patel6c622ef2011-03-01 22:58:55 +0000567
Eric Christopherf84354b2011-10-03 15:49:16 +0000568 // Collect lexical scope children first.
Devang Patel7e623022011-08-10 20:55:27 +0000569 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000570 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
Eric Christopher6a841382012-11-19 22:42:10 +0000571 if (DIE *Variable =
Eric Christopherc1c8a1b2012-09-21 22:18:52 +0000572 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000573 Children.push_back(Variable);
Eric Christopherc1c8a1b2012-09-21 22:18:52 +0000574 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
575 }
Devang Patel7e623022011-08-10 20:55:27 +0000576 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000577 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
Devang Patel3acc70e2011-08-15 22:04:40 +0000578 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000579 Children.push_back(Nested);
Devang Patel3b548aa2010-03-08 20:52:55 +0000580 DIE *ScopeDIE = NULL;
581 if (Scope->getInlinedAt())
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000582 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
Devang Patel3b548aa2010-03-08 20:52:55 +0000583 else if (DS.isSubprogram()) {
Devang Pateld10b2af2010-06-28 20:53:04 +0000584 ProcessedSPNodes.insert(DS);
Devang Patela37a95e2010-07-07 22:20:57 +0000585 if (Scope->isAbstractScope()) {
Manman Ren4213c392013-05-29 17:16:59 +0000586 ScopeDIE = TheCU->getDIE(DS);
Devang Patela37a95e2010-07-07 22:20:57 +0000587 // Note down abstract DIE.
588 if (ScopeDIE)
589 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
590 }
Devang Patel3b548aa2010-03-08 20:52:55 +0000591 else
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000592 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
Devang Patel3b548aa2010-03-08 20:52:55 +0000593 }
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000594 else {
595 // There is no need to emit empty lexical block DIE.
David Blaikie684fc532013-05-06 23:33:07 +0000596 std::pair<ImportedEntityMap::const_iterator,
597 ImportedEntityMap::const_iterator> Range = std::equal_range(
598 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
Timur Iskhodzhanovec4afe62013-05-07 07:47:47 +0000599 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
600 CompareFirst());
David Blaikie684fc532013-05-06 23:33:07 +0000601 if (Children.empty() && Range.first == Range.second)
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000602 return NULL;
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000603 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
David Blaikie684fc532013-05-06 23:33:07 +0000604 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second; ++i)
David Blaikie4dd2de72013-05-08 06:01:38 +0000605 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000606 }
Eric Christopher6a841382012-11-19 22:42:10 +0000607
Devang Patel23b2ae62010-03-29 22:59:58 +0000608 if (!ScopeDIE) return NULL;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000609
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000610 // Add children
611 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
612 E = Children.end(); I != E; ++I)
613 ScopeDIE->addChild(*I);
Devang Patel04d2f2d2009-11-24 01:14:22 +0000614
Eric Christophere3417762012-09-12 23:36:19 +0000615 if (DS.isSubprogram() && ObjectPointer != NULL)
616 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
617 dwarf::DW_FORM_ref4, ObjectPointer);
618
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000619 if (DS.isSubprogram())
Eric Christopherd9843b32011-11-10 19:25:34 +0000620 TheCU->addPubTypes(DISubprogram(DS));
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000621
Eric Christopherd9843b32011-11-10 19:25:34 +0000622 return ScopeDIE;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000623}
624
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000625// Look up the source id with the given directory and source file names.
626// If none currently exists, create a new id and insert it in the
627// SourceIds map. This can update DirectoryNames and SourceFileNames maps
628// as well.
Eric Christopher7b30f2e42012-11-21 00:34:35 +0000629unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
Manman Ren1e427202013-03-07 01:42:00 +0000630 StringRef DirName, unsigned CUID) {
631 // If we use .loc in assembly, we can't separate .file entries according to
632 // compile units. Thus all files will belong to the default compile unit.
633 if (Asm->TM.hasMCUseLoc() &&
634 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
635 CUID = 0;
636
Devang Patel871d0b12010-09-16 20:57:49 +0000637 // If FE did not provide a file name, then assume stdin.
638 if (FileName.empty())
Manman Ren1e427202013-03-07 01:42:00 +0000639 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
Devang Patele01b75c2011-03-24 20:30:50 +0000640
Nick Lewyckyd1ee7f82011-11-02 20:55:33 +0000641 // TODO: this might not belong here. See if we can factor this better.
642 if (DirName == CompilationDir)
643 DirName = "";
644
Manman Ren1e427202013-03-07 01:42:00 +0000645 // FileIDCUMap stores the current ID for the given compile unit.
646 unsigned SrcId = FileIDCUMap[CUID] + 1;
Devang Patel871d0b12010-09-16 20:57:49 +0000647
Manman Ren1e427202013-03-07 01:42:00 +0000648 // We look up the CUID/file/dir by concatenating them with a zero byte.
Benjamin Kramer71b19732012-03-11 14:56:26 +0000649 SmallString<128> NamePair;
Manman Ren5b22f9f2013-04-06 01:02:38 +0000650 NamePair += utostr(CUID);
Manman Ren1e427202013-03-07 01:42:00 +0000651 NamePair += '\0';
Benjamin Kramer71b19732012-03-11 14:56:26 +0000652 NamePair += DirName;
653 NamePair += '\0'; // Zero bytes are not allowed in paths.
654 NamePair += FileName;
655
656 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
657 if (Ent.getValue() != SrcId)
658 return Ent.getValue();
Bill Wendling2b128d72009-05-20 23:19:06 +0000659
Manman Ren1e427202013-03-07 01:42:00 +0000660 FileIDCUMap[CUID] = SrcId;
Rafael Espindola67c6ab82010-11-18 02:04:25 +0000661 // Print out a .file directive to specify files for .loc directives.
Manman Ren1e427202013-03-07 01:42:00 +0000662 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
Bill Wendling2b128d72009-05-20 23:19:06 +0000663
664 return SrcId;
665}
666
Eric Christopher48fef592012-12-20 21:58:40 +0000667// Create new CompileUnit for the given metadata node with tag
668// DW_TAG_compile_unit.
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000669CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
Devang Patel80ae3492009-08-28 23:24:31 +0000670 DICompileUnit DIUnit(N);
Devang Patel2d9caf92009-11-25 17:36:49 +0000671 StringRef FN = DIUnit.getFilename();
Nick Lewyckyd1ee7f82011-11-02 20:55:33 +0000672 CompilationDir = DIUnit.getDirectory();
Bill Wendling2b128d72009-05-20 23:19:06 +0000673
674 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Eli Benderskyb42d1462012-12-03 18:45:45 +0000675 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
Eric Christopherc57baee2013-05-08 00:58:51 +0000676 DIUnit.getLanguage(), Die, N, Asm,
Eric Christophere698f532012-12-20 21:58:36 +0000677 this, &InfoHolder);
Manman Ren1e427202013-03-07 01:42:00 +0000678
679 FileIDCUMap[NewCU->getUniqueID()] = 0;
680 // Call this to emit a .file directive if it wasn't emitted for the source
681 // file this CU comes from yet.
682 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
683
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000684 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
Devang Patelf20c4f72011-04-12 22:53:02 +0000685 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
686 DIUnit.getLanguage());
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000687 NewCU->addString(Die, dwarf::DW_AT_name, FN);
Eric Christopher52ce7182013-04-09 19:23:15 +0000688
Eric Christopherb1b94512012-08-01 18:19:01 +0000689 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
Eric Christopher52ce7182013-04-09 19:23:15 +0000690 // into an entity. We're using 0 (or a NULL label) for this. For
691 // split dwarf it's in the skeleton CU so omit it here.
692 if (!useSplitDwarf())
693 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
Manman Ren4e042a62013-02-05 21:52:47 +0000694
695 // Define start line table label for each Compile Unit.
696 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
697 NewCU->getUniqueID());
698 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
699 NewCU->getUniqueID());
700
Manman Ren9d4c7352013-05-21 00:57:22 +0000701 // Use a single line table if we are using .loc and generating assembly.
702 bool UseTheFirstCU =
703 (Asm->TM.hasMCUseLoc() &&
704 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
705 (NewCU->getUniqueID() == 0);
706
Devang Pateld22ed622010-03-22 23:11:36 +0000707 // DW_AT_stmt_list is a offset of line number information for this
Eric Christopher52ce7182013-04-09 19:23:15 +0000708 // compile unit in debug_line section. For split dwarf this is
709 // left in the skeleton CU and so not included.
Manman Rend2c95eb2013-02-09 00:41:44 +0000710 // The line table entries are not always emitted in assembly, so it
711 // is not okay to use line_table_start here.
Eric Christopher52ce7182013-04-09 19:23:15 +0000712 if (!useSplitDwarf()) {
713 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
714 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
Manman Ren9d4c7352013-05-21 00:57:22 +0000715 UseTheFirstCU ?
Eric Christopher52ce7182013-04-09 19:23:15 +0000716 Asm->GetTempSymbol("section_line") : LineTableStartSym);
Manman Ren9d4c7352013-05-21 00:57:22 +0000717 else if (UseTheFirstCU)
Eric Christopher52ce7182013-04-09 19:23:15 +0000718 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
719 else
720 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
721 LineTableStartSym, DwarfLineSectionSym);
722 }
Bill Wendling2b128d72009-05-20 23:19:06 +0000723
Eric Christopher52ce7182013-04-09 19:23:15 +0000724 // If we're using split dwarf the compilation dir is going to be in the
725 // skeleton CU and so we don't need to duplicate it here.
726 if (!useSplitDwarf() && !CompilationDir.empty())
Nick Lewyckyd1ee7f82011-11-02 20:55:33 +0000727 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
Bill Wendling2b128d72009-05-20 23:19:06 +0000728 if (DIUnit.isOptimized())
Eric Christopherbb69a272012-08-24 01:14:27 +0000729 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
Bill Wendling2b128d72009-05-20 23:19:06 +0000730
Devang Patel2d9caf92009-11-25 17:36:49 +0000731 StringRef Flags = DIUnit.getFlags();
732 if (!Flags.empty())
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000733 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
Eric Christopher6a841382012-11-19 22:42:10 +0000734
Nick Lewycky479a8fe2011-10-17 23:27:36 +0000735 if (unsigned RVer = DIUnit.getRunTimeVersion())
Devang Patelf20c4f72011-04-12 22:53:02 +0000736 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
Bill Wendling2b128d72009-05-20 23:19:06 +0000737 dwarf::DW_FORM_data1, RVer);
738
Devang Patel1a0df9a2010-05-10 22:49:55 +0000739 if (!FirstCU)
740 FirstCU = NewCU;
Eric Christopher7a2cdf72013-02-05 07:31:55 +0000741
Eric Christopherc8a310e2012-12-10 23:34:43 +0000742 InfoHolder.addUnit(NewCU);
743
Devang Patel1a0df9a2010-05-10 22:49:55 +0000744 CUMap.insert(std::make_pair(N, NewCU));
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000745 return NewCU;
Devang Patel1a0df9a2010-05-10 22:49:55 +0000746}
747
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000748// Construct subprogram DIE.
Eric Christopher6a841382012-11-19 22:42:10 +0000749void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
Devang Patel1f4f98d2011-08-15 23:36:40 +0000750 const MDNode *N) {
Rafael Espindola6cf4e832011-11-04 19:00:29 +0000751 CompileUnit *&CURef = SPMap[N];
752 if (CURef)
753 return;
754 CURef = TheCU;
755
Devang Patel80ae3492009-08-28 23:24:31 +0000756 DISubprogram SP(N);
Bill Wendling2b128d72009-05-20 23:19:06 +0000757 if (!SP.isDefinition())
758 // This is a method declaration which will be handled while constructing
759 // class type.
Devang Patel0751a282009-06-26 01:49:18 +0000760 return;
Bill Wendling2b128d72009-05-20 23:19:06 +0000761
Devang Patel89543712011-08-15 17:24:54 +0000762 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
Stuart Hastings4bd3dd92010-04-06 21:38:29 +0000763
764 // Add to map.
Devang Patel1a0df9a2010-05-10 22:49:55 +0000765 TheCU->insertDIE(N, SubprogramDie);
Bill Wendling2b128d72009-05-20 23:19:06 +0000766
767 // Add to context owner.
Devang Patelf20c4f72011-04-12 22:53:02 +0000768 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
Devang Patel512001a2009-12-08 23:21:45 +0000769
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +0000770 // Expose as global, if requested.
771 if (GenerateDwarfPubNamesSection)
772 TheCU->addGlobalName(SP.getName(), SubprogramDie);
Bill Wendling2b128d72009-05-20 23:19:06 +0000773}
774
David Blaikie1fd43652013-05-07 21:35:53 +0000775void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
David Blaikief55abea2013-04-22 06:12:31 +0000776 const MDNode *N) {
David Blaikie1fd43652013-05-07 21:35:53 +0000777 DIImportedEntity Module(N);
David Blaikief55abea2013-04-22 06:12:31 +0000778 if (!Module.Verify())
779 return;
David Blaikie684fc532013-05-06 23:33:07 +0000780 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
David Blaikie4dd2de72013-05-08 06:01:38 +0000781 constructImportedEntityDIE(TheCU, Module, D);
David Blaikie684fc532013-05-06 23:33:07 +0000782}
783
David Blaikie4dd2de72013-05-08 06:01:38 +0000784void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
David Blaikie684fc532013-05-06 23:33:07 +0000785 DIE *Context) {
David Blaikie1fd43652013-05-07 21:35:53 +0000786 DIImportedEntity Module(N);
David Blaikie684fc532013-05-06 23:33:07 +0000787 if (!Module.Verify())
788 return;
David Blaikie4dd2de72013-05-08 06:01:38 +0000789 return constructImportedEntityDIE(TheCU, Module, Context);
David Blaikie684fc532013-05-06 23:33:07 +0000790}
791
David Blaikie4dd2de72013-05-08 06:01:38 +0000792void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
David Blaikie1fd43652013-05-07 21:35:53 +0000793 const DIImportedEntity &Module,
David Blaikie684fc532013-05-06 23:33:07 +0000794 DIE *Context) {
795 assert(Module.Verify() &&
796 "Use one of the MDNode * overloads to handle invalid metadata");
797 assert(Context && "Should always have a context for an imported_module");
David Blaikie1fd43652013-05-07 21:35:53 +0000798 DIE *IMDie = new DIE(Module.getTag());
David Blaikief55abea2013-04-22 06:12:31 +0000799 TheCU->insertDIE(Module, IMDie);
David Blaikie1fd43652013-05-07 21:35:53 +0000800 DIE *EntityDie;
801 DIDescriptor Entity = Module.getEntity();
802 if (Entity.isNameSpace())
803 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
804 else if (Entity.isSubprogram())
805 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
David Blaikie3b6038b2013-05-08 06:01:41 +0000806 else if (Entity.isType())
807 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
David Blaikie1fd43652013-05-07 21:35:53 +0000808 else
David Blaikie3b6038b2013-05-08 06:01:41 +0000809 EntityDie = TheCU->getDIE(Entity);
David Blaikief55abea2013-04-22 06:12:31 +0000810 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
811 Module.getContext().getDirectory(),
812 TheCU->getUniqueID());
813 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
814 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
David Blaikie1fd43652013-05-07 21:35:53 +0000815 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4, EntityDie);
David Blaikiee63d5d12013-05-20 22:50:35 +0000816 StringRef Name = Module.getName();
817 if (!Name.empty())
818 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
David Blaikie684fc532013-05-06 23:33:07 +0000819 Context->addChild(IMDie);
David Blaikief55abea2013-04-22 06:12:31 +0000820}
821
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000822// Emit all Dwarf sections that should come prior to the content. Create
823// global DIEs and emit initial debug info sections. This is invoked by
824// the target AsmPrinter.
Eric Christopher58f41952012-11-19 22:42:15 +0000825void DwarfDebug::beginModule() {
Devang Patel6c74a872010-04-27 19:46:33 +0000826 if (DisableDebugInfoPrinting)
827 return;
828
Eric Christopher58f41952012-11-19 22:42:15 +0000829 const Module *M = MMI->getModule();
830
Nick Lewycky019d2552011-07-29 03:49:23 +0000831 // If module has named metadata anchors then use them, otherwise scan the
832 // module using debug info finder to collect debug info.
Devang Patele02e5852011-05-03 16:45:22 +0000833 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
David Blaikiedc69ebb2013-03-11 23:39:23 +0000834 if (!CU_Nodes)
Devang Patel07bb9ee2011-08-15 23:47:24 +0000835 return;
Devang Patele02e5852011-05-03 16:45:22 +0000836
David Blaikiedc69ebb2013-03-11 23:39:23 +0000837 // Emit initial sections so we can reference labels later.
838 emitSectionLabels();
839
840 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
841 DICompileUnit CUNode(CU_Nodes->getOperand(i));
842 CompileUnit *CU = constructCompileUnit(CUNode);
David Blaikie1fd43652013-05-07 21:35:53 +0000843 DIArray ImportedEntities = CUNode.getImportedEntities();
844 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
David Blaikie684fc532013-05-06 23:33:07 +0000845 ScopesWithImportedEntities.push_back(std::make_pair(
David Blaikie1fd43652013-05-07 21:35:53 +0000846 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
847 ImportedEntities.getElement(i)));
David Blaikie684fc532013-05-06 23:33:07 +0000848 std::sort(ScopesWithImportedEntities.begin(),
849 ScopesWithImportedEntities.end(), CompareFirst());
David Blaikiedc69ebb2013-03-11 23:39:23 +0000850 DIArray GVs = CUNode.getGlobalVariables();
851 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
852 CU->createGlobalVariableDIE(GVs.getElement(i));
853 DIArray SPs = CUNode.getSubprograms();
854 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
855 constructSubprogramDIE(CU, SPs.getElement(i));
856 DIArray EnumTypes = CUNode.getEnumTypes();
857 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
858 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
859 DIArray RetainedTypes = CUNode.getRetainedTypes();
860 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
861 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
David Blaikief55abea2013-04-22 06:12:31 +0000862 // Emit imported_modules last so that the relevant context is already
863 // available.
David Blaikie1fd43652013-05-07 21:35:53 +0000864 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
865 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
Eric Christopher6be35032013-03-29 20:23:02 +0000866 // If we're splitting the dwarf out now that we've got the entire
867 // CU then construct a skeleton CU based upon it.
868 if (useSplitDwarf()) {
Eric Christopher4eb5eb52013-04-24 12:56:18 +0000869 // This should be a unique identifier when we want to build .dwp files.
Eric Christopher44c6aa62013-04-22 07:51:08 +0000870 CU->addUInt(CU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
871 dwarf::DW_FORM_data8, 0);
Eric Christopher6be35032013-03-29 20:23:02 +0000872 // Now construct the skeleton CU associated.
873 constructSkeletonCU(CUNode);
874 }
David Blaikiedc69ebb2013-03-11 23:39:23 +0000875 }
Eric Christopher6a841382012-11-19 22:42:10 +0000876
Chris Lattner7cfa70e2010-04-05 02:19:28 +0000877 // Tell MMI that we have debug info.
878 MMI->setDebugInfoAvailability(true);
Eric Christopher6a841382012-11-19 22:42:10 +0000879
Bill Wendling2b128d72009-05-20 23:19:06 +0000880 // Prime section data.
Chris Lattner5e693ed2009-07-28 03:13:23 +0000881 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
Bill Wendling2b128d72009-05-20 23:19:06 +0000882}
883
Eric Christopher960ac372012-11-22 00:59:49 +0000884// Attach DW_AT_inline attribute with inlined subprogram DIEs.
885void DwarfDebug::computeInlinedDIEs() {
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000886 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
887 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
Eric Christopher735401c2012-11-27 00:13:51 +0000888 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000889 DIE *ISP = *AI;
Devang Patelf20c4f72011-04-12 22:53:02 +0000890 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000891 }
Rafael Espindolae7cc8bf2011-11-12 01:57:54 +0000892 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
Eric Christopher735401c2012-11-27 00:13:51 +0000893 AE = AbstractSPDies.end(); AI != AE; ++AI) {
Rafael Espindolae7cc8bf2011-11-12 01:57:54 +0000894 DIE *ISP = AI->second;
895 if (InlinedSubprogramDIEs.count(ISP))
896 continue;
897 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
898 }
Eric Christopher960ac372012-11-22 00:59:49 +0000899}
900
901// Collect info for variables that were optimized out.
902void DwarfDebug::collectDeadVariables() {
903 const Module *M = MMI->getModule();
904 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
905
906 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
907 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
908 DICompileUnit TheCU(CU_Nodes->getOperand(i));
909 DIArray Subprograms = TheCU.getSubprograms();
910 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
Eric Christopher735401c2012-11-27 00:13:51 +0000911 DISubprogram SP(Subprograms.getElement(i));
912 if (ProcessedSPNodes.count(SP) != 0) continue;
913 if (!SP.Verify()) continue;
914 if (!SP.isDefinition()) continue;
915 DIArray Variables = SP.getVariables();
916 if (Variables.getNumElements() == 0) continue;
Eric Christopher960ac372012-11-22 00:59:49 +0000917
Eric Christopher735401c2012-11-27 00:13:51 +0000918 LexicalScope *Scope =
919 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
920 DeadFnScopeMap[SP] = Scope;
Eric Christopher960ac372012-11-22 00:59:49 +0000921
Eric Christopher735401c2012-11-27 00:13:51 +0000922 // Construct subprogram DIE and add variables DIEs.
923 CompileUnit *SPCU = CUMap.lookup(TheCU);
924 assert(SPCU && "Unable to find Compile Unit!");
925 constructSubprogramDIE(SPCU, SP);
926 DIE *ScopeDIE = SPCU->getDIE(SP);
927 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
928 DIVariable DV(Variables.getElement(vi));
929 if (!DV.Verify()) continue;
930 DbgVariable *NewVar = new DbgVariable(DV, NULL);
931 if (DIE *VariableDIE =
932 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
933 ScopeDIE->addChild(VariableDIE);
934 }
Eric Christopher960ac372012-11-22 00:59:49 +0000935 }
936 }
937 }
938 DeleteContainerSeconds(DeadFnScopeMap);
939}
940
941void DwarfDebug::finalizeModuleInfo() {
942 // Collect info for variables that were optimized out.
943 collectDeadVariables();
944
945 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
946 computeInlinedDIEs();
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000947
Eric Christopherb1b94512012-08-01 18:19:01 +0000948 // Emit DW_AT_containing_type attribute to connect types with their
949 // vtable holding type.
Devang Patel89543712011-08-15 17:24:54 +0000950 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
Eric Christopher735401c2012-11-27 00:13:51 +0000951 CUE = CUMap.end(); CUI != CUE; ++CUI) {
Devang Patel89543712011-08-15 17:24:54 +0000952 CompileUnit *TheCU = CUI->second;
953 TheCU->constructContainingTypeDIEs();
Devang Pateleb57c592009-12-03 19:11:07 +0000954 }
955
Eric Christopher960ac372012-11-22 00:59:49 +0000956 // Compute DIE offsets and sizes.
Eric Christopherc8a310e2012-12-10 23:34:43 +0000957 InfoHolder.computeSizeAndOffsets();
958 if (useSplitDwarf())
959 SkeletonHolder.computeSizeAndOffsets();
Eric Christopher960ac372012-11-22 00:59:49 +0000960}
961
962void DwarfDebug::endSections() {
Bill Wendling2b128d72009-05-20 23:19:06 +0000963 // Standard sections final addresses.
Chris Lattner4b7dadb2009-08-19 05:49:37 +0000964 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
Chris Lattnera179b522010-04-04 19:25:43 +0000965 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
Chris Lattner4b7dadb2009-08-19 05:49:37 +0000966 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
Chris Lattnera179b522010-04-04 19:25:43 +0000967 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
Bill Wendling2b128d72009-05-20 23:19:06 +0000968
969 // End text sections.
Benjamin Kramer15591272012-10-31 13:45:49 +0000970 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
971 Asm->OutStreamer.SwitchSection(SectionMap[I]);
972 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
Bill Wendling2b128d72009-05-20 23:19:06 +0000973 }
Eric Christopher960ac372012-11-22 00:59:49 +0000974}
Bill Wendling2b128d72009-05-20 23:19:06 +0000975
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000976// Emit all Dwarf sections that should come after the content.
Eric Christopher960ac372012-11-22 00:59:49 +0000977void DwarfDebug::endModule() {
978
979 if (!FirstCU) return;
980
981 // End any existing sections.
982 // TODO: Does this need to happen?
983 endSections();
984
985 // Finalize the debug info for the module.
986 finalizeModuleInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +0000987
Eric Christophercdf218d2012-12-10 19:51:21 +0000988 if (!useSplitDwarf()) {
Eric Christopher95198f502012-11-27 22:43:42 +0000989 // Emit all the DIEs into a debug info section.
990 emitDebugInfo();
Eric Christopher4c9b1192012-11-27 00:41:54 +0000991
Eric Christopher95198f502012-11-27 22:43:42 +0000992 // Corresponding abbreviations into a abbrev section.
993 emitAbbreviations();
994
995 // Emit info into a debug loc section.
996 emitDebugLoc();
997
998 // Emit info into a debug aranges section.
999 emitDebugARanges();
1000
1001 // Emit info into a debug ranges section.
1002 emitDebugRanges();
1003
1004 // Emit info into a debug macinfo section.
1005 emitDebugMacInfo();
1006
1007 // Emit inline info.
1008 // TODO: When we don't need the option anymore we
1009 // can remove all of the code that this section
1010 // depends upon.
1011 if (useDarwinGDBCompat())
1012 emitDebugInlineInfo();
1013 } else {
Eric Christopherd692c1d2012-12-11 19:42:09 +00001014 // TODO: Fill this in for separated debug sections and separate
Eric Christopher95198f502012-11-27 22:43:42 +00001015 // out information into new sections.
1016
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001017 // Emit the debug info section and compile units.
Eric Christopher95198f502012-11-27 22:43:42 +00001018 emitDebugInfo();
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001019 emitDebugInfoDWO();
Eric Christopher95198f502012-11-27 22:43:42 +00001020
1021 // Corresponding abbreviations into a abbrev section.
1022 emitAbbreviations();
Eric Christopher3c5a1912012-12-19 22:02:53 +00001023 emitDebugAbbrevDWO();
Eric Christopher95198f502012-11-27 22:43:42 +00001024
1025 // Emit info into a debug loc section.
1026 emitDebugLoc();
1027
1028 // Emit info into a debug aranges section.
1029 emitDebugARanges();
1030
1031 // Emit info into a debug ranges section.
1032 emitDebugRanges();
1033
1034 // Emit info into a debug macinfo section.
1035 emitDebugMacInfo();
1036
Eric Christopher962c9082013-01-15 23:56:56 +00001037 // Emit DWO addresses.
1038 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1039
Eric Christopher95198f502012-11-27 22:43:42 +00001040 // Emit inline info.
1041 // TODO: When we don't need the option anymore we
1042 // can remove all of the code that this section
1043 // depends upon.
1044 if (useDarwinGDBCompat())
1045 emitDebugInlineInfo();
1046 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001047
Eric Christophera876b822012-08-23 07:32:06 +00001048 // Emit info into the dwarf accelerator table sections.
Eric Christopher20b76a72012-08-23 22:36:40 +00001049 if (useDwarfAccelTables()) {
Eric Christopher4996c702011-11-07 09:24:32 +00001050 emitAccelNames();
1051 emitAccelObjC();
1052 emitAccelNamespaces();
1053 emitAccelTypes();
1054 }
Eric Christopher6a841382012-11-19 22:42:10 +00001055
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001056 // Emit info into a debug pubnames section, if requested.
1057 if (GenerateDwarfPubNamesSection)
1058 emitDebugPubnames();
1059
Devang Patel04d2f2d2009-11-24 01:14:22 +00001060 // Emit info into a debug pubtypes section.
Eric Christopher77826182012-08-23 07:10:56 +00001061 // TODO: When we don't need the option anymore we can
1062 // remove all of the code that adds to the table.
Eric Christopher20b76a72012-08-23 22:36:40 +00001063 if (useDarwinGDBCompat())
Eric Christopher77826182012-08-23 07:10:56 +00001064 emitDebugPubTypes();
Devang Patel04d2f2d2009-11-24 01:14:22 +00001065
Eric Christopher95198f502012-11-27 22:43:42 +00001066 // Finally emit string information into a string table.
Eric Christopher6e20a162012-11-27 06:49:23 +00001067 emitDebugStr();
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001068 if (useSplitDwarf())
1069 emitDebugStrDWO();
Eric Christopher6e20a162012-11-27 06:49:23 +00001070
Devang Pateld0701282010-08-02 17:32:15 +00001071 // clean up.
Devang Pateleb1bb4e2011-08-16 22:09:43 +00001072 SPMap.clear();
Devang Patel1a0df9a2010-05-10 22:49:55 +00001073 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1074 E = CUMap.end(); I != E; ++I)
1075 delete I->second;
Eric Christopher8afd7b62012-12-10 19:51:18 +00001076
Eric Christopher5b33b3c2013-02-06 21:53:56 +00001077 for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(),
1078 E = SkeletonCUs.end(); I != E; ++I)
1079 delete *I;
Eric Christopher8afd7b62012-12-10 19:51:18 +00001080
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001081 // Reset these for the next Module if we have one.
1082 FirstCU = NULL;
Bill Wendling2b128d72009-05-20 23:19:06 +00001083}
1084
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001085// Find abstract variable, if any, associated with Var.
Devang Patelbb23a4a2011-08-10 21:50:54 +00001086DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
Chris Lattner915c5f92010-04-02 19:42:39 +00001087 DebugLoc ScopeLoc) {
Devang Patelbb23a4a2011-08-10 21:50:54 +00001088 LLVMContext &Ctx = DV->getContext();
1089 // More then one inlined variable corresponds to one abstract variable.
1090 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001091 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001092 if (AbsDbgVariable)
1093 return AbsDbgVariable;
1094
Devang Patel7e623022011-08-10 20:55:27 +00001095 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001096 if (!Scope)
1097 return NULL;
1098
Devang Patel99819b52011-08-15 19:01:20 +00001099 AbsDbgVariable = new DbgVariable(Var, NULL);
Devang Patel7e623022011-08-10 20:55:27 +00001100 addScopeVariable(Scope, AbsDbgVariable);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001101 AbstractVariables[Var] = AbsDbgVariable;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001102 return AbsDbgVariable;
1103}
1104
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001105// If Var is a current function argument then add it to CurrentFnArguments list.
Devang Patel6c622ef2011-03-01 22:58:55 +00001106bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
Devang Patel7e623022011-08-10 20:55:27 +00001107 DbgVariable *Var, LexicalScope *Scope) {
1108 if (!LScopes.isCurrentFunctionScope(Scope))
Devang Patel6c622ef2011-03-01 22:58:55 +00001109 return false;
1110 DIVariable DV = Var->getVariable();
1111 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1112 return false;
1113 unsigned ArgNo = DV.getArgNumber();
Eric Christopher6a841382012-11-19 22:42:10 +00001114 if (ArgNo == 0)
Devang Patel6c622ef2011-03-01 22:58:55 +00001115 return false;
1116
Devang Patel4ab660b2011-03-03 20:02:02 +00001117 size_t Size = CurrentFnArguments.size();
1118 if (Size == 0)
Devang Patel6c622ef2011-03-01 22:58:55 +00001119 CurrentFnArguments.resize(MF->getFunction()->arg_size());
Devang Patel63b3e762011-03-03 21:49:41 +00001120 // llvm::Function argument size is not good indicator of how many
Devang Patel34a7ab42011-03-03 20:08:10 +00001121 // arguments does the function have at source level.
1122 if (ArgNo > Size)
Devang Patel4ab660b2011-03-03 20:02:02 +00001123 CurrentFnArguments.resize(ArgNo * 2);
Devang Patel6c622ef2011-03-01 22:58:55 +00001124 CurrentFnArguments[ArgNo - 1] = Var;
1125 return true;
1126}
1127
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001128// Collect variable information from side table maintained by MMI.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001129void
Nick Lewycky019d2552011-07-29 03:49:23 +00001130DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
Devang Patel490c8ab2010-05-20 19:57:06 +00001131 SmallPtrSet<const MDNode *, 16> &Processed) {
Devang Patel475d32a2009-10-06 01:26:37 +00001132 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1133 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1134 VE = VMap.end(); VI != VE; ++VI) {
Devang Patel32cc43c2010-05-07 20:54:48 +00001135 const MDNode *Var = VI->first;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001136 if (!Var) continue;
Devang Patele0a94bf2010-05-14 21:01:35 +00001137 Processed.insert(Var);
Chris Lattner915c5f92010-04-02 19:42:39 +00001138 DIVariable DV(Var);
1139 const std::pair<unsigned, DebugLoc> &VP = VI->second;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001140
Devang Patel7e623022011-08-10 20:55:27 +00001141 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001142
Devang Patelcdb7d442009-11-10 23:20:04 +00001143 // If variable scope is not found then skip this variable.
Chris Lattner915c5f92010-04-02 19:42:39 +00001144 if (Scope == 0)
Devang Patelcdb7d442009-11-10 23:20:04 +00001145 continue;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001146
Devang Patele1c53f22010-05-20 16:36:41 +00001147 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
Devang Patel99819b52011-08-15 19:01:20 +00001148 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
Devang Patel3e4a9652011-08-15 21:24:36 +00001149 RegVar->setFrameIndex(VP.first);
Devang Patel6c622ef2011-03-01 22:58:55 +00001150 if (!addCurrentFnArgument(MF, RegVar, Scope))
Devang Patel7e623022011-08-10 20:55:27 +00001151 addScopeVariable(Scope, RegVar);
Devang Patel99819b52011-08-15 19:01:20 +00001152 if (AbsDbgVariable)
Devang Patel3e4a9652011-08-15 21:24:36 +00001153 AbsDbgVariable->setFrameIndex(VP.first);
Devang Patel475d32a2009-10-06 01:26:37 +00001154 }
Devang Patel490c8ab2010-05-20 19:57:06 +00001155}
Devang Patela3e9c9c2010-03-15 18:33:46 +00001156
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001157// Return true if debug value, encoded by DBG_VALUE instruction, is in a
1158// defined reg.
Devang Patel9fc11702010-05-25 23:40:22 +00001159static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
Nick Lewycky654f5ce2011-10-26 22:55:33 +00001160 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001161 return MI->getNumOperands() == 3 &&
1162 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
Adrian Prantla2888e72013-04-30 22:35:14 +00001163 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
Devang Patel9fc11702010-05-25 23:40:22 +00001164}
1165
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001166// Get .debug_loc entry for the instruction range starting at MI.
Eric Christopher6a841382012-11-19 22:42:10 +00001167static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1168 const MCSymbol *FLabel,
Devang Patel2442a892011-07-08 17:09:57 +00001169 const MCSymbol *SLabel,
1170 const MachineInstr *MI) {
1171 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1172
David Blaikie0252265b2013-06-16 20:34:15 +00001173 assert(MI->getNumOperands() == 3);
Adrian Prantla2888e72013-04-30 22:35:14 +00001174 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
Devang Patel2442a892011-07-08 17:09:57 +00001175 MachineLocation MLoc;
Adrian Prantla2888e72013-04-30 22:35:14 +00001176 // TODO: Currently an offset of 0 in a DBG_VALUE means
1177 // we need to generate a direct register value.
1178 // There is no way to specify an indirect value with offset 0.
1179 if (MI->getOperand(1).getImm() == 0)
Adrian Prantld4c0dd42013-04-26 21:57:17 +00001180 MLoc.set(MI->getOperand(0).getReg());
1181 else
1182 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
Devang Patel2442a892011-07-08 17:09:57 +00001183 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1184 }
1185 if (MI->getOperand(0).isImm())
1186 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1187 if (MI->getOperand(0).isFPImm())
1188 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1189 if (MI->getOperand(0).isCImm())
1190 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1191
Craig Topperee4dab52012-02-05 08:31:47 +00001192 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
Devang Patel2442a892011-07-08 17:09:57 +00001193}
1194
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001195// Find variables for each lexical scope.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001196void
Devang Patel5c0f85c2010-06-25 22:07:34 +00001197DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1198 SmallPtrSet<const MDNode *, 16> &Processed) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001199
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001200 // collection info from MMI table.
Devang Patel490c8ab2010-05-20 19:57:06 +00001201 collectVariableInfoFromMMITable(MF, Processed);
1202
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001203 for (SmallVectorImpl<const MDNode*>::const_iterator
1204 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1205 ++UVI) {
1206 const MDNode *Var = *UVI;
1207 if (Processed.count(Var))
Devang Patel490c8ab2010-05-20 19:57:06 +00001208 continue;
1209
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001210 // History contains relevant DBG_VALUE instructions for Var and instructions
1211 // clobbering it.
1212 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1213 if (History.empty())
1214 continue;
1215 const MachineInstr *MInsn = History.front();
Devang Patel9fc11702010-05-25 23:40:22 +00001216
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001217 DIVariable DV(Var);
Devang Patel7e623022011-08-10 20:55:27 +00001218 LexicalScope *Scope = NULL;
Devang Patel7a9dedf2010-05-27 20:25:04 +00001219 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1220 DISubprogram(DV.getContext()).describes(MF->getFunction()))
Devang Patel7e623022011-08-10 20:55:27 +00001221 Scope = LScopes.getCurrentFunctionScope();
David Blaikiedc69ebb2013-03-11 23:39:23 +00001222 else if (MDNode *IA = DV.getInlinedAt())
1223 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1224 else
1225 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
Devang Patel490c8ab2010-05-20 19:57:06 +00001226 // If variable scope is not found then skip this variable.
Devang Patelfbd6c452010-05-21 00:10:20 +00001227 if (!Scope)
Devang Patel490c8ab2010-05-20 19:57:06 +00001228 continue;
1229
1230 Processed.insert(DV);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001231 assert(MInsn->isDebugValue() && "History must begin with debug value");
Devang Patel99819b52011-08-15 19:01:20 +00001232 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1233 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
Devang Patel6c622ef2011-03-01 22:58:55 +00001234 if (!addCurrentFnArgument(MF, RegVar, Scope))
Devang Patel7e623022011-08-10 20:55:27 +00001235 addScopeVariable(Scope, RegVar);
Devang Patel99819b52011-08-15 19:01:20 +00001236 if (AbsVar)
Devang Patel3e4a9652011-08-15 21:24:36 +00001237 AbsVar->setMInsn(MInsn);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001238
Eric Christophercc10d202012-10-08 20:48:54 +00001239 // Simplify ranges that are fully coalesced.
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001240 if (History.size() <= 1 || (History.size() == 2 &&
1241 MInsn->isIdenticalTo(History.back()))) {
Devang Patel3e4a9652011-08-15 21:24:36 +00001242 RegVar->setMInsn(MInsn);
Devang Patel9fc11702010-05-25 23:40:22 +00001243 continue;
1244 }
1245
Eric Christopher59cc0712013-01-28 17:33:26 +00001246 // Handle multiple DBG_VALUE instructions describing one variable.
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001247 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001248
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001249 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1250 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1251 const MachineInstr *Begin = *HI;
1252 assert(Begin->isDebugValue() && "Invalid History entry");
Jakob Stoklund Olesen9c057ee2011-03-22 00:21:41 +00001253
Devang Patele7181b52011-06-01 23:00:17 +00001254 // Check if DBG_VALUE is truncating a range.
1255 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1256 && !Begin->getOperand(0).getReg())
1257 continue;
1258
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001259 // Compute the range for a register location.
1260 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1261 const MCSymbol *SLabel = 0;
1262
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001263 if (HI + 1 == HE)
1264 // If Begin is the last instruction in History then its value is valid
Chris Lattner0ab5e2c2011-04-15 05:18:47 +00001265 // until the end of the function.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001266 SLabel = FunctionEndSym;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001267 else {
1268 const MachineInstr *End = HI[1];
Eric Christopher6a841382012-11-19 22:42:10 +00001269 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
Devang Patel53b050a2011-07-07 21:44:42 +00001270 << "\t" << *Begin << "\t" << *End << "\n");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001271 if (End->isDebugValue())
1272 SLabel = getLabelBeforeInsn(End);
1273 else {
1274 // End is a normal instruction clobbering the range.
1275 SLabel = getLabelAfterInsn(End);
1276 assert(SLabel && "Forgot label after clobber instruction");
1277 ++HI;
1278 }
1279 }
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001280
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001281 // The value is valid until the next DBG_VALUE or clobber.
Eric Christopher365d0832011-12-16 23:42:31 +00001282 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1283 Begin));
Devang Patel9fc11702010-05-25 23:40:22 +00001284 }
1285 DotDebugLocEntries.push_back(DotDebugLocEntry());
Devang Patela3e9c9c2010-03-15 18:33:46 +00001286 }
Devang Patele0a94bf2010-05-14 21:01:35 +00001287
1288 // Collect info for variables that were optimized out.
Devang Patel59e27c52011-08-19 23:28:12 +00001289 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1290 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1291 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1292 DIVariable DV(Variables.getElement(i));
1293 if (!DV || !DV.Verify() || !Processed.insert(DV))
1294 continue;
1295 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1296 addScopeVariable(Scope, new DbgVariable(DV, NULL));
Devang Patele0a94bf2010-05-14 21:01:35 +00001297 }
Devang Patel9fc11702010-05-25 23:40:22 +00001298}
Devang Patele0a94bf2010-05-14 21:01:35 +00001299
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001300// Return Label preceding the instruction.
Eric Christopher962c9082013-01-15 23:56:56 +00001301MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001302 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1303 assert(Label && "Didn't insert label before instruction");
1304 return Label;
Devang Patel9fc11702010-05-25 23:40:22 +00001305}
1306
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001307// Return Label immediately following the instruction.
Eric Christopher962c9082013-01-15 23:56:56 +00001308MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001309 return LabelsAfterInsn.lookup(MI);
Devang Patel475d32a2009-10-06 01:26:37 +00001310}
1311
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001312// Process beginning of an instruction.
Devang Patelb5694e72010-10-26 17:49:02 +00001313void DwarfDebug::beginInstruction(const MachineInstr *MI) {
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001314 // Check if source location changes, but ignore DBG_VALUE locations.
1315 if (!MI->isDebugValue()) {
1316 DebugLoc DL = MI->getDebugLoc();
1317 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
Eric Christopheraec8a822012-04-05 20:39:05 +00001318 unsigned Flags = 0;
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001319 PrevInstLoc = DL;
Devang Patel34a66202011-05-11 19:22:19 +00001320 if (DL == PrologEndLoc) {
1321 Flags |= DWARF2_FLAG_PROLOGUE_END;
1322 PrologEndLoc = DebugLoc();
1323 }
Eric Christopheraec8a822012-04-05 20:39:05 +00001324 if (PrologEndLoc.isUnknown())
1325 Flags |= DWARF2_FLAG_IS_STMT;
1326
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001327 if (!DL.isUnknown()) {
1328 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
Devang Patel34a66202011-05-11 19:22:19 +00001329 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001330 } else
Devang Patel34a66202011-05-11 19:22:19 +00001331 recordSourceLine(0, 0, 0, 0);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001332 }
Devang Patel9fc11702010-05-25 23:40:22 +00001333 }
Devang Patel23b2ae62010-03-29 22:59:58 +00001334
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001335 // Insert labels where requested.
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001336 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1337 LabelsBeforeInsn.find(MI);
1338
1339 // No label needed.
1340 if (I == LabelsBeforeInsn.end())
1341 return;
1342
1343 // Label already assigned.
1344 if (I->second)
Devang Patel002d54d2010-05-26 19:37:24 +00001345 return;
Devang Patelbd477be2010-03-29 17:20:31 +00001346
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001347 if (!PrevLabel) {
Devang Patelacc32a52010-05-26 21:23:46 +00001348 PrevLabel = MMI->getContext().CreateTempSymbol();
1349 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel002d54d2010-05-26 19:37:24 +00001350 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001351 I->second = PrevLabel;
Devang Patel8db360d2009-10-06 01:50:42 +00001352}
1353
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001354// Process end of an instruction.
Devang Patelb5694e72010-10-26 17:49:02 +00001355void DwarfDebug::endInstruction(const MachineInstr *MI) {
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001356 // Don't create a new label after DBG_VALUE instructions.
1357 // They don't generate code.
1358 if (!MI->isDebugValue())
1359 PrevLabel = 0;
1360
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001361 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1362 LabelsAfterInsn.find(MI);
1363
1364 // No label needed.
1365 if (I == LabelsAfterInsn.end())
1366 return;
1367
1368 // Label already assigned.
1369 if (I->second)
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001370 return;
1371
1372 // We need a label after this instruction.
1373 if (!PrevLabel) {
1374 PrevLabel = MMI->getContext().CreateTempSymbol();
1375 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel3ebd8932010-04-08 16:50:29 +00001376 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001377 I->second = PrevLabel;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001378}
1379
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001380// Each LexicalScope has first instruction and last instruction to mark
1381// beginning and end of a scope respectively. Create an inverse map that list
1382// scopes starts (and ends) with an instruction. One instruction may start (or
1383// end) multiple scopes. Ignore scopes that are not reachable.
Devang Patel359b0132010-04-08 18:43:56 +00001384void DwarfDebug::identifyScopeMarkers() {
Devang Patel7e623022011-08-10 20:55:27 +00001385 SmallVector<LexicalScope *, 4> WorkList;
1386 WorkList.push_back(LScopes.getCurrentFunctionScope());
Devang Patel7771b7c2010-01-20 02:05:23 +00001387 while (!WorkList.empty()) {
Devang Patel7e623022011-08-10 20:55:27 +00001388 LexicalScope *S = WorkList.pop_back_val();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001389
Devang Patel7e623022011-08-10 20:55:27 +00001390 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001391 if (!Children.empty())
Devang Patel7e623022011-08-10 20:55:27 +00001392 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
Devang Patel7771b7c2010-01-20 02:05:23 +00001393 SE = Children.end(); SI != SE; ++SI)
1394 WorkList.push_back(*SI);
1395
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001396 if (S->isAbstractScope())
1397 continue;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001398
Devang Patel7e623022011-08-10 20:55:27 +00001399 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
Devang Patel6c74a872010-04-27 19:46:33 +00001400 if (Ranges.empty())
1401 continue;
Devang Patel7e623022011-08-10 20:55:27 +00001402 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
Devang Patel6c74a872010-04-27 19:46:33 +00001403 RE = Ranges.end(); RI != RE; ++RI) {
Devang Patel7e623022011-08-10 20:55:27 +00001404 assert(RI->first && "InsnRange does not have first instruction!");
1405 assert(RI->second && "InsnRange does not have second instruction!");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001406 requestLabelBeforeInsn(RI->first);
1407 requestLabelAfterInsn(RI->second);
Devang Patel6c74a872010-04-27 19:46:33 +00001408 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001409 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001410}
1411
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001412// Get MDNode for DebugLoc's scope.
Devang Patel589845d2011-05-09 22:14:49 +00001413static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1414 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1415 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1416 return DL.getScope(Ctx);
1417}
1418
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001419// Walk up the scope chain of given debug loc and find line number info
1420// for the function.
Devang Patel34a66202011-05-11 19:22:19 +00001421static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1422 const MDNode *Scope = getScopeNode(DL, Ctx);
1423 DISubprogram SP = getDISubprogram(Scope);
Eric Christopher34164192012-04-03 00:43:49 +00001424 if (SP.Verify()) {
1425 // Check for number of operands since the compatibility is
1426 // cheap here.
Eric Christopherb81e2b42012-04-03 17:55:42 +00001427 if (SP->getNumOperands() > 19)
Eric Christopher34164192012-04-03 00:43:49 +00001428 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1429 else
1430 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1431 }
1432
Devang Patel34a66202011-05-11 19:22:19 +00001433 return DebugLoc();
1434}
1435
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001436// Gather pre-function debug information. Assumes being called immediately
1437// after the function entry point has been emitted.
Chris Lattner76555b52010-01-26 23:18:02 +00001438void DwarfDebug::beginFunction(const MachineFunction *MF) {
Chris Lattner196dbdc2010-04-05 03:52:55 +00001439 if (!MMI->hasDebugInfo()) return;
Devang Patel7e623022011-08-10 20:55:27 +00001440 LScopes.initialize(*MF);
1441 if (LScopes.empty()) return;
1442 identifyScopeMarkers();
Devang Patel4598eb62009-10-06 18:37:31 +00001443
Manman Ren4e042a62013-02-05 21:52:47 +00001444 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1445 // belongs to.
1446 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1447 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1448 assert(TheCU && "Unable to find compile unit!");
Manman Ren9d4c7352013-05-21 00:57:22 +00001449 if (Asm->TM.hasMCUseLoc() &&
1450 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1451 // Use a single line table if we are using .loc and generating assembly.
1452 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1453 else
1454 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
Manman Ren4e042a62013-02-05 21:52:47 +00001455
Devang Patel6c74a872010-04-27 19:46:33 +00001456 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1457 Asm->getFunctionNumber());
Bill Wendling2b128d72009-05-20 23:19:06 +00001458 // Assumes in correct section after the entry point.
Devang Patel6c74a872010-04-27 19:46:33 +00001459 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
Bill Wendling2b128d72009-05-20 23:19:06 +00001460
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001461 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1462
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001463 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001464 // LiveUserVar - Map physreg numbers to the MDNode they contain.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001465 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1466
Devang Patel002d54d2010-05-26 19:37:24 +00001467 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001468 I != E; ++I) {
1469 bool AtBlockEntry = true;
Devang Patel002d54d2010-05-26 19:37:24 +00001470 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1471 II != IE; ++II) {
1472 const MachineInstr *MI = II;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001473
Devang Patel002d54d2010-05-26 19:37:24 +00001474 if (MI->isDebugValue()) {
Nick Lewycky654f5ce2011-10-26 22:55:33 +00001475 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001476
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001477 // Keep track of user variables.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001478 const MDNode *Var =
1479 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001480
1481 // Variable is in a register, we need to check for clobbers.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001482 if (isDbgValueInDefinedReg(MI))
1483 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1484
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001485 // Check the history of this variable.
1486 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1487 if (History.empty()) {
1488 UserVariables.push_back(Var);
1489 // The first mention of a function argument gets the FunctionBeginSym
1490 // label, so arguments are visible when breaking at function entry.
1491 DIVariable DV(Var);
1492 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1493 DISubprogram(getDISubprogram(DV.getContext()))
1494 .describes(MF->getFunction()))
1495 LabelsBeforeInsn[MI] = FunctionBeginSym;
1496 } else {
1497 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1498 const MachineInstr *Prev = History.back();
1499 if (Prev->isDebugValue()) {
1500 // Coalesce identical entries at the end of History.
1501 if (History.size() >= 2 &&
Devang Patelb7a328e2011-07-07 00:14:27 +00001502 Prev->isIdenticalTo(History[History.size() - 2])) {
Eric Christopher85a495e2012-10-08 20:48:49 +00001503 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
Eric Christopher6a841382012-11-19 22:42:10 +00001504 << "\t" << *Prev
Devang Patelb7a328e2011-07-07 00:14:27 +00001505 << "\t" << *History[History.size() - 2] << "\n");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001506 History.pop_back();
Devang Patelb7a328e2011-07-07 00:14:27 +00001507 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001508
1509 // Terminate old register assignments that don't reach MI;
1510 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1511 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1512 isDbgValueInDefinedReg(Prev)) {
1513 // Previous register assignment needs to terminate at the end of
1514 // its basic block.
1515 MachineBasicBlock::const_iterator LastMI =
1516 PrevMBB->getLastNonDebugInstr();
Devang Patelb7a328e2011-07-07 00:14:27 +00001517 if (LastMI == PrevMBB->end()) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001518 // Drop DBG_VALUE for empty range.
Eric Christopher85a495e2012-10-08 20:48:49 +00001519 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
Devang Patelb7a328e2011-07-07 00:14:27 +00001520 << "\t" << *Prev << "\n");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001521 History.pop_back();
David Blaikieea2605d2013-06-20 00:25:24 +00001522 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001523 // Terminate after LastMI.
1524 History.push_back(LastMI);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001525 }
1526 }
1527 }
1528 History.push_back(MI);
Devang Patel002d54d2010-05-26 19:37:24 +00001529 } else {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001530 // Not a DBG_VALUE instruction.
1531 if (!MI->isLabel())
1532 AtBlockEntry = false;
1533
Eric Christopher133195782012-10-04 20:46:14 +00001534 // First known non-DBG_VALUE and non-frame setup location marks
1535 // the beginning of the function body.
1536 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1537 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
Devang Patel34a66202011-05-11 19:22:19 +00001538 PrologEndLoc = MI->getDebugLoc();
1539
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001540 // Check if the instruction clobbers any registers with debug vars.
1541 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1542 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1543 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1544 continue;
Jakob Stoklund Olesen54038d72012-06-01 23:28:30 +00001545 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1546 AI.isValid(); ++AI) {
1547 unsigned Reg = *AI;
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001548 const MDNode *Var = LiveUserVar[Reg];
1549 if (!Var)
1550 continue;
1551 // Reg is now clobbered.
1552 LiveUserVar[Reg] = 0;
1553
1554 // Was MD last defined by a DBG_VALUE referring to Reg?
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001555 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1556 if (HistI == DbgValues.end())
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001557 continue;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001558 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1559 if (History.empty())
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001560 continue;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001561 const MachineInstr *Prev = History.back();
1562 // Sanity-check: Register assignments are terminated at the end of
1563 // their block.
1564 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1565 continue;
1566 // Is the variable still in Reg?
1567 if (!isDbgValueInDefinedReg(Prev) ||
1568 Prev->getOperand(0).getReg() != Reg)
1569 continue;
1570 // Var is clobbered. Make sure the next instruction gets a label.
1571 History.push_back(MI);
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001572 }
1573 }
Devang Patel002d54d2010-05-26 19:37:24 +00001574 }
Devang Patel002d54d2010-05-26 19:37:24 +00001575 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001576 }
1577
1578 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1579 I != E; ++I) {
1580 SmallVectorImpl<const MachineInstr*> &History = I->second;
1581 if (History.empty())
1582 continue;
1583
1584 // Make sure the final register assignments are terminated.
1585 const MachineInstr *Prev = History.back();
1586 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1587 const MachineBasicBlock *PrevMBB = Prev->getParent();
Eric Christopher6a841382012-11-19 22:42:10 +00001588 MachineBasicBlock::const_iterator LastMI =
Devang Patel784077e2011-08-10 23:58:09 +00001589 PrevMBB->getLastNonDebugInstr();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001590 if (LastMI == PrevMBB->end())
1591 // Drop DBG_VALUE for empty range.
1592 History.pop_back();
David Blaikieea2605d2013-06-20 00:25:24 +00001593 else if (PrevMBB != &PrevMBB->getParent()->back()) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001594 // Terminate after LastMI.
1595 History.push_back(LastMI);
1596 }
1597 }
1598 // Request labels for the full history.
1599 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1600 const MachineInstr *MI = History[i];
1601 if (MI->isDebugValue())
1602 requestLabelBeforeInsn(MI);
1603 else
1604 requestLabelAfterInsn(MI);
1605 }
1606 }
Devang Patel002d54d2010-05-26 19:37:24 +00001607
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001608 PrevInstLoc = DebugLoc();
Devang Patel002d54d2010-05-26 19:37:24 +00001609 PrevLabel = FunctionBeginSym;
Devang Patel34a66202011-05-11 19:22:19 +00001610
1611 // Record beginning of function.
1612 if (!PrologEndLoc.isUnknown()) {
1613 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1614 MF->getFunction()->getContext());
1615 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1616 FnStartDL.getScope(MF->getFunction()->getContext()),
David Blaikie67cb31e2012-12-04 22:02:33 +00001617 // We'd like to list the prologue as "not statements" but GDB behaves
1618 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
David Blaikie5a773bb2012-12-04 21:05:36 +00001619 DWARF2_FLAG_IS_STMT);
Devang Patel34a66202011-05-11 19:22:19 +00001620 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001621}
1622
Devang Patel7e623022011-08-10 20:55:27 +00001623void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
David Blaikie6f1a8062013-06-05 05:39:59 +00001624 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1625 DIVariable DV = Var->getVariable();
David Blaikie36d5d2f2013-06-06 21:04:51 +00001626 // Variables with positive arg numbers are parameters.
1627 if (unsigned ArgNum = DV.getArgNumber()) {
1628 // Keep all parameters in order at the start of the variable list to ensure
1629 // function types are correct (no out-of-order parameters)
1630 //
1631 // This could be improved by only doing it for optimized builds (unoptimized
1632 // builds have the right order to begin with), searching from the back (this
1633 // would catch the unoptimized case quickly), or doing a binary search
1634 // rather than linear search.
1635 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1636 while (I != Vars.end()) {
1637 unsigned CurNum = (*I)->getVariable().getArgNumber();
1638 // A local (non-parameter) variable has been found, insert immediately
1639 // before it.
1640 if (CurNum == 0)
1641 break;
1642 // A later indexed parameter has been found, insert immediately before it.
David Blaikieb272a752013-06-06 22:28:26 +00001643 if (CurNum > ArgNum)
David Blaikie36d5d2f2013-06-06 21:04:51 +00001644 break;
David Blaikieb272a752013-06-06 22:28:26 +00001645 ++I;
David Blaikie6f1a8062013-06-05 05:39:59 +00001646 }
David Blaikie36d5d2f2013-06-06 21:04:51 +00001647 Vars.insert(I, Var);
1648 return;
David Blaikie6f1a8062013-06-05 05:39:59 +00001649 }
1650
1651 Vars.push_back(Var);
Devang Patel7e623022011-08-10 20:55:27 +00001652}
1653
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001654// Gather and emit post-function debug information.
Chris Lattner76555b52010-01-26 23:18:02 +00001655void DwarfDebug::endFunction(const MachineFunction *MF) {
Devang Patel7e623022011-08-10 20:55:27 +00001656 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
Devang Patel2904aa92009-11-12 19:02:56 +00001657
Devang Patel7e623022011-08-10 20:55:27 +00001658 // Define end label for subprogram.
1659 FunctionEndSym = Asm->GetTempSymbol("func_end",
1660 Asm->getFunctionNumber());
1661 // Assumes in correct section after the entry point.
1662 Asm->OutStreamer.EmitLabel(FunctionEndSym);
Manman Ren4e042a62013-02-05 21:52:47 +00001663 // Set DwarfCompileUnitID in MCContext to default value.
1664 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
Eric Christopher6a841382012-11-19 22:42:10 +00001665
Devang Patel7e623022011-08-10 20:55:27 +00001666 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1667 collectVariableInfo(MF, ProcessedVars);
Eric Christopher6a841382012-11-19 22:42:10 +00001668
Devang Patel3acc70e2011-08-15 22:04:40 +00001669 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
Devang Pateleb1bb4e2011-08-16 22:09:43 +00001670 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
Nick Lewycky654f5ce2011-10-26 22:55:33 +00001671 assert(TheCU && "Unable to find compile unit!");
Devang Patel3acc70e2011-08-15 22:04:40 +00001672
Devang Patel7e623022011-08-10 20:55:27 +00001673 // Construct abstract scopes.
Devang Patel44403472011-08-12 18:10:19 +00001674 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1675 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1676 LexicalScope *AScope = AList[i];
1677 DISubprogram SP(AScope->getScopeNode());
Devang Patel7e623022011-08-10 20:55:27 +00001678 if (SP.Verify()) {
1679 // Collect info for variables that were optimized out.
Devang Patel59e27c52011-08-19 23:28:12 +00001680 DIArray Variables = SP.getVariables();
1681 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1682 DIVariable DV(Variables.getElement(i));
1683 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1684 continue;
Alexey Samsonov39602782012-07-06 08:45:08 +00001685 // Check that DbgVariable for DV wasn't created earlier, when
1686 // findAbstractVariable() was called for inlined instance of DV.
1687 LLVMContext &Ctx = DV->getContext();
1688 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1689 if (AbstractVariables.lookup(CleanDV))
1690 continue;
Devang Patel59e27c52011-08-19 23:28:12 +00001691 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1692 addScopeVariable(Scope, new DbgVariable(DV, NULL));
Devang Patel5c0f85c2010-06-25 22:07:34 +00001693 }
1694 }
Devang Patel44403472011-08-12 18:10:19 +00001695 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
Manman Ren4213c392013-05-29 17:16:59 +00001696 constructScopeDIE(TheCU, AScope);
Bill Wendling2b128d72009-05-20 23:19:06 +00001697 }
Eric Christopher6a841382012-11-19 22:42:10 +00001698
Devang Patel3acc70e2011-08-15 22:04:40 +00001699 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
Eric Christopher6a841382012-11-19 22:42:10 +00001700
Nick Lewycky50f02cb2011-12-02 22:16:29 +00001701 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
Eric Christopherbb69a272012-08-24 01:14:27 +00001702 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
Devang Patel3acc70e2011-08-15 22:04:40 +00001703
Bill Wendling2b128d72009-05-20 23:19:06 +00001704 // Clear debug info
Devang Patel7e623022011-08-10 20:55:27 +00001705 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1706 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1707 DeleteContainerPointers(I->second);
1708 ScopeVariables.clear();
Devang Patelad45d912011-04-22 18:09:57 +00001709 DeleteContainerPointers(CurrentFnArguments);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001710 UserVariables.clear();
1711 DbgValues.clear();
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00001712 AbstractVariables.clear();
Devang Patel6c74a872010-04-27 19:46:33 +00001713 LabelsBeforeInsn.clear();
1714 LabelsAfterInsn.clear();
Devang Patel12563b32010-04-16 23:33:45 +00001715 PrevLabel = NULL;
Bill Wendling2b128d72009-05-20 23:19:06 +00001716}
1717
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001718// Register a source line with debug info. Returns the unique label that was
1719// emitted and which provides correspondence to the source line list.
Devang Patel34a66202011-05-11 19:22:19 +00001720void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1721 unsigned Flags) {
Devang Patel2d9caf92009-11-25 17:36:49 +00001722 StringRef Fn;
Devang Patele01b75c2011-03-24 20:30:50 +00001723 StringRef Dir;
Dan Gohman50849c62010-05-05 23:41:32 +00001724 unsigned Src = 1;
1725 if (S) {
1726 DIDescriptor Scope(S);
Devang Patel2089d162009-10-05 18:03:19 +00001727
Dan Gohman50849c62010-05-05 23:41:32 +00001728 if (Scope.isCompileUnit()) {
1729 DICompileUnit CU(S);
Dan Gohman50849c62010-05-05 23:41:32 +00001730 Fn = CU.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001731 Dir = CU.getDirectory();
Devang Patelc4b69052010-10-28 17:30:52 +00001732 } else if (Scope.isFile()) {
1733 DIFile F(S);
Devang Patelc4b69052010-10-28 17:30:52 +00001734 Fn = F.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001735 Dir = F.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00001736 } else if (Scope.isSubprogram()) {
1737 DISubprogram SP(S);
Dan Gohman50849c62010-05-05 23:41:32 +00001738 Fn = SP.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001739 Dir = SP.getDirectory();
Eric Christopher6647b832011-10-11 22:59:11 +00001740 } else if (Scope.isLexicalBlockFile()) {
1741 DILexicalBlockFile DBF(S);
1742 Fn = DBF.getFilename();
1743 Dir = DBF.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00001744 } else if (Scope.isLexicalBlock()) {
1745 DILexicalBlock DB(S);
Dan Gohman50849c62010-05-05 23:41:32 +00001746 Fn = DB.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001747 Dir = DB.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00001748 } else
Craig Topperee4dab52012-02-05 08:31:47 +00001749 llvm_unreachable("Unexpected scope info");
Dan Gohman50849c62010-05-05 23:41:32 +00001750
Manman Ren1e427202013-03-07 01:42:00 +00001751 Src = getOrCreateSourceID(Fn, Dir,
1752 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
Dan Gohman50849c62010-05-05 23:41:32 +00001753 }
Nick Lewycky019d2552011-07-29 03:49:23 +00001754 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
Bill Wendling2b128d72009-05-20 23:19:06 +00001755}
1756
Bill Wendling806535f2009-05-20 23:22:40 +00001757//===----------------------------------------------------------------------===//
1758// Emit Methods
1759//===----------------------------------------------------------------------===//
1760
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001761// Compute the size and offset of a DIE.
Jim Grosbach00e9c612009-11-22 19:20:36 +00001762unsigned
Eric Christopherc8a310e2012-12-10 23:34:43 +00001763DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
Bill Wendling480ff322009-05-20 23:21:38 +00001764 // Get the children.
1765 const std::vector<DIE *> &Children = Die->getChildren();
1766
Bill Wendling480ff322009-05-20 23:21:38 +00001767 // Record the abbreviation.
Devang Patel930143b2009-11-21 02:48:08 +00001768 assignAbbrevNumber(Die->getAbbrev());
Bill Wendling480ff322009-05-20 23:21:38 +00001769
1770 // Get the abbreviation for this DIE.
1771 unsigned AbbrevNumber = Die->getAbbrevNumber();
Eric Christopherc8a310e2012-12-10 23:34:43 +00001772 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
Bill Wendling480ff322009-05-20 23:21:38 +00001773
1774 // Set DIE offset
1775 Die->setOffset(Offset);
1776
1777 // Start the size with the size of abbreviation code.
Chris Lattner7b26fce2009-08-22 20:48:53 +00001778 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
Bill Wendling480ff322009-05-20 23:21:38 +00001779
Eric Christopher4887c8f2013-03-29 23:34:06 +00001780 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1781 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
Bill Wendling480ff322009-05-20 23:21:38 +00001782
1783 // Size the DIE attribute values.
1784 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1785 // Size attribute value.
Chris Lattner5a00dea2010-04-05 00:18:22 +00001786 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
Bill Wendling480ff322009-05-20 23:21:38 +00001787
1788 // Size the DIE children if any.
1789 if (!Children.empty()) {
1790 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1791 "Children flag not set");
1792
1793 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Eric Christopher1f0cbb82012-11-20 22:14:13 +00001794 Offset = computeSizeAndOffset(Children[j], Offset);
Bill Wendling480ff322009-05-20 23:21:38 +00001795
1796 // End of children marker.
1797 Offset += sizeof(int8_t);
1798 }
1799
1800 Die->setSize(Offset - Die->getOffset());
1801 return Offset;
1802}
1803
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001804// Compute the size and offset of all the DIEs.
Eric Christopherc8a310e2012-12-10 23:34:43 +00001805void DwarfUnits::computeSizeAndOffsets() {
Manman Ren14a029d2013-03-12 18:27:15 +00001806 // Offset from the beginning of debug info section.
Eric Christopherd1c5a312013-05-30 00:43:35 +00001807 unsigned SecOffset = 0;
Eric Christopher4887c8f2013-03-29 23:34:06 +00001808 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
Eric Christopherc8a310e2012-12-10 23:34:43 +00001809 E = CUs.end(); I != E; ++I) {
Eric Christopherd1c5a312013-05-30 00:43:35 +00001810 (*I)->setDebugInfoOffset(SecOffset);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001811 unsigned Offset =
1812 sizeof(int32_t) + // Length of Compilation Unit Info
1813 sizeof(int16_t) + // DWARF version number
1814 sizeof(int32_t) + // Offset Into Abbrev. Section
1815 sizeof(int8_t); // Pointer Size (in bytes)
1816
Manman Ren14a029d2013-03-12 18:27:15 +00001817 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
Eric Christopherd1c5a312013-05-30 00:43:35 +00001818 SecOffset += EndOffset;
Devang Patel1a0df9a2010-05-10 22:49:55 +00001819 }
Bill Wendling480ff322009-05-20 23:21:38 +00001820}
1821
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001822// Emit initial Dwarf sections with a label at the start of each one.
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001823void DwarfDebug::emitSectionLabels() {
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001824 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00001825
Bill Wendling480ff322009-05-20 23:21:38 +00001826 // Dwarf sections base addresses.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001827 DwarfInfoSectionSym =
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001828 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001829 DwarfAbbrevSectionSym =
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001830 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
Eric Christopher3c5a1912012-12-19 22:02:53 +00001831 if (useSplitDwarf())
1832 DwarfAbbrevDWOSectionSym =
1833 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1834 "section_abbrev_dwo");
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001835 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001836
Chris Lattner6629ca92010-04-04 22:59:04 +00001837 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001838 emitSectionSym(Asm, MacroInfo);
Bill Wendling480ff322009-05-20 23:21:38 +00001839
Eric Christopher74804332013-02-07 21:19:50 +00001840 DwarfLineSectionSym =
1841 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001842 emitSectionSym(Asm, TLOF.getDwarfLocSection());
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00001843 if (GenerateDwarfPubNamesSection)
1844 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001845 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001846 DwarfStrSectionSym =
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001847 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
Eric Christopher55863be2013-04-07 03:43:09 +00001848 if (useSplitDwarf()) {
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001849 DwarfStrDWOSectionSym =
1850 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
Eric Christopher55863be2013-04-07 03:43:09 +00001851 DwarfAddrSectionSym =
1852 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1853 }
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001854 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
Devang Patel12563b32010-04-16 23:33:45 +00001855 "debug_range");
Bill Wendling480ff322009-05-20 23:21:38 +00001856
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001857 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
Devang Patel9fc11702010-05-25 23:40:22 +00001858 "section_debug_loc");
1859
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001860 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1861 emitSectionSym(Asm, TLOF.getDataSection());
Bill Wendling480ff322009-05-20 23:21:38 +00001862}
1863
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001864// Recursively emits a debug information entry.
Eric Christopher3c5a1912012-12-19 22:02:53 +00001865void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
Bill Wendling480ff322009-05-20 23:21:38 +00001866 // Get the abbreviation for this DIE.
1867 unsigned AbbrevNumber = Die->getAbbrevNumber();
Eric Christopher3c5a1912012-12-19 22:02:53 +00001868 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
Bill Wendling480ff322009-05-20 23:21:38 +00001869
Bill Wendling480ff322009-05-20 23:21:38 +00001870 // Emit the code (index) for the abbreviation.
Chris Lattner7bde8c02010-04-04 18:52:31 +00001871 if (Asm->isVerbose())
Chris Lattnerfa823552010-01-22 23:18:42 +00001872 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1873 Twine::utohexstr(Die->getOffset()) + ":0x" +
1874 Twine::utohexstr(Die->getSize()) + " " +
1875 dwarf::TagString(Abbrev->getTag()));
Chris Lattner9efd1182010-04-04 19:09:29 +00001876 Asm->EmitULEB128(AbbrevNumber);
Bill Wendling480ff322009-05-20 23:21:38 +00001877
Eric Christopher4887c8f2013-03-29 23:34:06 +00001878 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1879 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
Bill Wendling480ff322009-05-20 23:21:38 +00001880
1881 // Emit the DIE attribute values.
1882 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1883 unsigned Attr = AbbrevData[i].getAttribute();
1884 unsigned Form = AbbrevData[i].getForm();
1885 assert(Form && "Too many attributes for DIE (check abbreviation)");
1886
Chris Lattner7bde8c02010-04-04 18:52:31 +00001887 if (Asm->isVerbose())
Chris Lattner5adf9872010-01-24 18:54:17 +00001888 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001889
Bill Wendling480ff322009-05-20 23:21:38 +00001890 switch (Attr) {
Bill Wendling480ff322009-05-20 23:21:38 +00001891 case dwarf::DW_AT_abstract_origin: {
1892 DIEEntry *E = cast<DIEEntry>(Values[i]);
1893 DIE *Origin = E->getEntry();
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001894 unsigned Addr = Origin->getOffset();
Manman Ren14a029d2013-03-12 18:27:15 +00001895 if (Form == dwarf::DW_FORM_ref_addr) {
1896 // For DW_FORM_ref_addr, output the offset from beginning of debug info
1897 // section. Origin->getOffset() returns the offset from start of the
1898 // compile unit.
1899 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1900 Addr += Holder.getCUOffset(Origin->getCompileUnit());
1901 }
Manman Renbdcb4462013-04-04 23:13:11 +00001902 Asm->EmitInt32(Addr);
Bill Wendling480ff322009-05-20 23:21:38 +00001903 break;
1904 }
Devang Patel12563b32010-04-16 23:33:45 +00001905 case dwarf::DW_AT_ranges: {
1906 // DW_AT_range Value encodes offset in debug_range section.
1907 DIEInteger *V = cast<DIEInteger>(Values[i]);
Devang Patelda3ef852010-09-02 16:43:44 +00001908
Nick Lewycky33da3362012-06-22 01:25:12 +00001909 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
Devang Patelda3ef852010-09-02 16:43:44 +00001910 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1911 V->getValue(),
1912 4);
1913 } else {
1914 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1915 V->getValue(),
1916 DwarfDebugRangeSectionSym,
1917 4);
1918 }
Devang Patel12563b32010-04-16 23:33:45 +00001919 break;
1920 }
Devang Patel9fc11702010-05-25 23:40:22 +00001921 case dwarf::DW_AT_location: {
Nick Lewycky33da3362012-06-22 01:25:12 +00001922 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1923 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1924 Asm->EmitLabelReference(L->getValue(), 4);
1925 else
1926 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1927 } else {
Devang Patel9fc11702010-05-25 23:40:22 +00001928 Values[i]->EmitValue(Asm, Form);
Nick Lewycky33da3362012-06-22 01:25:12 +00001929 }
Devang Patel9fc11702010-05-25 23:40:22 +00001930 break;
1931 }
Devang Patela1bd5a12010-09-29 19:08:08 +00001932 case dwarf::DW_AT_accessibility: {
1933 if (Asm->isVerbose()) {
1934 DIEInteger *V = cast<DIEInteger>(Values[i]);
1935 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1936 }
1937 Values[i]->EmitValue(Asm, Form);
1938 break;
1939 }
Bill Wendling480ff322009-05-20 23:21:38 +00001940 default:
1941 // Emit an attribute using the defined form.
Chris Lattner3a383cb2010-04-05 00:13:49 +00001942 Values[i]->EmitValue(Asm, Form);
Bill Wendling480ff322009-05-20 23:21:38 +00001943 break;
1944 }
Bill Wendling480ff322009-05-20 23:21:38 +00001945 }
1946
1947 // Emit the DIE children if any.
1948 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1949 const std::vector<DIE *> &Children = Die->getChildren();
1950
1951 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Eric Christopher3c5a1912012-12-19 22:02:53 +00001952 emitDIE(Children[j], Abbrevs);
Bill Wendling480ff322009-05-20 23:21:38 +00001953
Chris Lattner7bde8c02010-04-04 18:52:31 +00001954 if (Asm->isVerbose())
Chris Lattner566cae92010-03-09 23:52:58 +00001955 Asm->OutStreamer.AddComment("End Of Children Mark");
1956 Asm->EmitInt8(0);
Bill Wendling480ff322009-05-20 23:21:38 +00001957 }
1958}
1959
Eric Christophera2de8262012-12-15 00:04:07 +00001960// Emit the various dwarf units to the unit section USection with
1961// the abbreviations going into ASection.
1962void DwarfUnits::emitUnits(DwarfDebug *DD,
1963 const MCSection *USection,
1964 const MCSection *ASection,
1965 const MCSymbol *ASectionSym) {
1966 Asm->OutStreamer.SwitchSection(USection);
Eric Christopher4887c8f2013-03-29 23:34:06 +00001967 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
Eric Christophera2de8262012-12-15 00:04:07 +00001968 E = CUs.end(); I != E; ++I) {
1969 CompileUnit *TheCU = *I;
Devang Patel1a0df9a2010-05-10 22:49:55 +00001970 DIE *Die = TheCU->getCUDie();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001971
Devang Patel1a0df9a2010-05-10 22:49:55 +00001972 // Emit the compile units header.
Eric Christophera2de8262012-12-15 00:04:07 +00001973 Asm->OutStreamer
1974 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1975 TheCU->getUniqueID()));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001976
Devang Patel1a0df9a2010-05-10 22:49:55 +00001977 // Emit size of content not including length itself
1978 unsigned ContentSize = Die->getSize() +
1979 sizeof(int16_t) + // DWARF version number
1980 sizeof(int32_t) + // Offset Into Abbrev. Section
Devang Patele141234942011-04-13 19:41:17 +00001981 sizeof(int8_t); // Pointer Size (in bytes)
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001982
Devang Patel1a0df9a2010-05-10 22:49:55 +00001983 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1984 Asm->EmitInt32(ContentSize);
1985 Asm->OutStreamer.AddComment("DWARF version number");
Manman Ren4213c392013-05-29 17:16:59 +00001986 Asm->EmitInt16(dwarf::DWARF_VERSION);
Devang Patel1a0df9a2010-05-10 22:49:55 +00001987 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
Eric Christophera2de8262012-12-15 00:04:07 +00001988 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1989 ASectionSym);
Devang Patel1a0df9a2010-05-10 22:49:55 +00001990 Asm->OutStreamer.AddComment("Address Size (in bytes)");
Chandler Carruth5da3f052012-11-01 09:14:31 +00001991 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001992
Eric Christopher3c5a1912012-12-19 22:02:53 +00001993 DD->emitDIE(Die, Abbreviations);
Eric Christophera2de8262012-12-15 00:04:07 +00001994 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
Eli Benderskyb42d1462012-12-03 18:45:45 +00001995 TheCU->getUniqueID()));
Devang Patel1a0df9a2010-05-10 22:49:55 +00001996 }
Bill Wendling480ff322009-05-20 23:21:38 +00001997}
1998
Manman Ren14a029d2013-03-12 18:27:15 +00001999/// For a given compile unit DIE, returns offset from beginning of debug info.
2000unsigned DwarfUnits::getCUOffset(DIE *Die) {
Manman Ren11fec382013-03-13 18:41:27 +00002001 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2002 "Input DIE should be compile unit in getCUOffset.");
Eric Christopher4887c8f2013-03-29 23:34:06 +00002003 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
Manman Ren14a029d2013-03-12 18:27:15 +00002004 E = CUs.end(); I != E; ++I) {
2005 CompileUnit *TheCU = *I;
2006 if (TheCU->getCUDie() == Die)
2007 return TheCU->getDebugInfoOffset();
2008 }
Manman Ren11fec382013-03-13 18:41:27 +00002009 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
Manman Ren14a029d2013-03-12 18:27:15 +00002010}
2011
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002012// Emit the debug info section.
2013void DwarfDebug::emitDebugInfo() {
Eric Christophera2de8262012-12-15 00:04:07 +00002014 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2015
2016 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2017 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2018 DwarfAbbrevSectionSym);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002019}
2020
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002021// Emit the abbreviation section.
Eric Christopher38371952012-11-20 23:30:11 +00002022void DwarfDebug::emitAbbreviations() {
Eric Christopher3c5a1912012-12-19 22:02:53 +00002023 if (!useSplitDwarf())
2024 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2025 &Abbreviations);
2026 else
2027 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2028}
Bill Wendling480ff322009-05-20 23:21:38 +00002029
Eric Christopher3c5a1912012-12-19 22:02:53 +00002030void DwarfDebug::emitAbbrevs(const MCSection *Section,
2031 std::vector<DIEAbbrev *> *Abbrevs) {
2032 // Check to see if it is worth the effort.
2033 if (!Abbrevs->empty()) {
2034 // Start the debug abbrev section.
2035 Asm->OutStreamer.SwitchSection(Section);
2036
2037 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
Eric Christopher996b2b72012-12-13 03:00:38 +00002038 Asm->OutStreamer.EmitLabel(Begin);
Bill Wendling480ff322009-05-20 23:21:38 +00002039
2040 // For each abbrevation.
Eric Christopher3c5a1912012-12-19 22:02:53 +00002041 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
Bill Wendling480ff322009-05-20 23:21:38 +00002042 // Get abbreviation data
Eric Christopher3c5a1912012-12-19 22:02:53 +00002043 const DIEAbbrev *Abbrev = Abbrevs->at(i);
Bill Wendling480ff322009-05-20 23:21:38 +00002044
2045 // Emit the abbrevations code (base 1 index.)
Chris Lattner9efd1182010-04-04 19:09:29 +00002046 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
Bill Wendling480ff322009-05-20 23:21:38 +00002047
2048 // Emit the abbreviations data.
Chris Lattner3a383cb2010-04-05 00:13:49 +00002049 Abbrev->Emit(Asm);
Bill Wendling480ff322009-05-20 23:21:38 +00002050 }
2051
2052 // Mark end of abbreviations.
Chris Lattner9efd1182010-04-04 19:09:29 +00002053 Asm->EmitULEB128(0, "EOM(3)");
Bill Wendling480ff322009-05-20 23:21:38 +00002054
Eric Christopher3c5a1912012-12-19 22:02:53 +00002055 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
Eric Christopher996b2b72012-12-13 03:00:38 +00002056 Asm->OutStreamer.EmitLabel(End);
Bill Wendling480ff322009-05-20 23:21:38 +00002057 }
2058}
2059
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002060// Emit the last address of the section and the end of the line matrix.
Devang Patel930143b2009-11-21 02:48:08 +00002061void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling480ff322009-05-20 23:21:38 +00002062 // Define last address of section.
Chris Lattner566cae92010-03-09 23:52:58 +00002063 Asm->OutStreamer.AddComment("Extended Op");
2064 Asm->EmitInt8(0);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002065
Chris Lattner566cae92010-03-09 23:52:58 +00002066 Asm->OutStreamer.AddComment("Op size");
Chandler Carruth5da3f052012-11-01 09:14:31 +00002067 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
Chris Lattner566cae92010-03-09 23:52:58 +00002068 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2069 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2070
2071 Asm->OutStreamer.AddComment("Section end label");
Chris Lattnerb245dfb2010-03-10 01:17:49 +00002072
Chris Lattnera179b522010-04-04 19:25:43 +00002073 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
Eric Christopherce0cfce2013-01-09 01:35:34 +00002074 Asm->getDataLayout().getPointerSize());
Bill Wendling480ff322009-05-20 23:21:38 +00002075
2076 // Mark end of matrix.
Chris Lattner566cae92010-03-09 23:52:58 +00002077 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2078 Asm->EmitInt8(0);
Chris Lattnerf5c834f2010-01-22 22:09:00 +00002079 Asm->EmitInt8(1);
Chris Lattnerfa823552010-01-22 23:18:42 +00002080 Asm->EmitInt8(1);
Bill Wendling480ff322009-05-20 23:21:38 +00002081}
2082
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002083// Emit visible names into a hashed accelerator table section.
Eric Christopher4996c702011-11-07 09:24:32 +00002084void DwarfDebug::emitAccelNames() {
2085 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2086 dwarf::DW_FORM_data4));
2087 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2088 E = CUMap.end(); I != E; ++I) {
2089 CompileUnit *TheCU = I->second;
Eric Christopherd9843b32011-11-10 19:25:34 +00002090 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2091 for (StringMap<std::vector<DIE*> >::const_iterator
Eric Christopher4996c702011-11-07 09:24:32 +00002092 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
Benjamin Kramer63e39eb2013-05-11 18:24:28 +00002093 StringRef Name = GI->getKey();
Eric Christopher090fcc12012-01-06 23:03:34 +00002094 const std::vector<DIE *> &Entities = GI->second;
Eric Christopherd9843b32011-11-10 19:25:34 +00002095 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2096 DE = Entities.end(); DI != DE; ++DI)
2097 AT.AddName(Name, (*DI));
Eric Christopher4996c702011-11-07 09:24:32 +00002098 }
2099 }
2100
2101 AT.FinalizeTable(Asm, "Names");
2102 Asm->OutStreamer.SwitchSection(
2103 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2104 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2105 Asm->OutStreamer.EmitLabel(SectionBegin);
2106
2107 // Emit the full data.
Eric Christophere698f532012-12-20 21:58:36 +00002108 AT.Emit(Asm, SectionBegin, &InfoHolder);
Eric Christopher4996c702011-11-07 09:24:32 +00002109}
2110
Eric Christopher48fef592012-12-20 21:58:40 +00002111// Emit objective C classes and categories into a hashed accelerator table
2112// section.
Eric Christopher4996c702011-11-07 09:24:32 +00002113void DwarfDebug::emitAccelObjC() {
2114 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2115 dwarf::DW_FORM_data4));
2116 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2117 E = CUMap.end(); I != E; ++I) {
2118 CompileUnit *TheCU = I->second;
2119 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2120 for (StringMap<std::vector<DIE*> >::const_iterator
2121 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
Benjamin Kramer63e39eb2013-05-11 18:24:28 +00002122 StringRef Name = GI->getKey();
Eric Christopher090fcc12012-01-06 23:03:34 +00002123 const std::vector<DIE *> &Entities = GI->second;
Eric Christopher4996c702011-11-07 09:24:32 +00002124 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2125 DE = Entities.end(); DI != DE; ++DI)
2126 AT.AddName(Name, (*DI));
2127 }
2128 }
2129
2130 AT.FinalizeTable(Asm, "ObjC");
2131 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2132 .getDwarfAccelObjCSection());
2133 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2134 Asm->OutStreamer.EmitLabel(SectionBegin);
2135
2136 // Emit the full data.
Eric Christophere698f532012-12-20 21:58:36 +00002137 AT.Emit(Asm, SectionBegin, &InfoHolder);
Eric Christopher4996c702011-11-07 09:24:32 +00002138}
2139
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002140// Emit namespace dies into a hashed accelerator table.
Eric Christopher4996c702011-11-07 09:24:32 +00002141void DwarfDebug::emitAccelNamespaces() {
2142 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2143 dwarf::DW_FORM_data4));
2144 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2145 E = CUMap.end(); I != E; ++I) {
2146 CompileUnit *TheCU = I->second;
Eric Christopher66b37db2011-11-10 21:47:55 +00002147 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2148 for (StringMap<std::vector<DIE*> >::const_iterator
Eric Christopher4996c702011-11-07 09:24:32 +00002149 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
Benjamin Kramer63e39eb2013-05-11 18:24:28 +00002150 StringRef Name = GI->getKey();
Eric Christopher090fcc12012-01-06 23:03:34 +00002151 const std::vector<DIE *> &Entities = GI->second;
Eric Christopher66b37db2011-11-10 21:47:55 +00002152 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2153 DE = Entities.end(); DI != DE; ++DI)
2154 AT.AddName(Name, (*DI));
Eric Christopher4996c702011-11-07 09:24:32 +00002155 }
2156 }
2157
2158 AT.FinalizeTable(Asm, "namespac");
2159 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2160 .getDwarfAccelNamespaceSection());
2161 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2162 Asm->OutStreamer.EmitLabel(SectionBegin);
2163
2164 // Emit the full data.
Eric Christophere698f532012-12-20 21:58:36 +00002165 AT.Emit(Asm, SectionBegin, &InfoHolder);
Eric Christopher4996c702011-11-07 09:24:32 +00002166}
2167
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002168// Emit type dies into a hashed accelerator table.
Eric Christopher4996c702011-11-07 09:24:32 +00002169void DwarfDebug::emitAccelTypes() {
Eric Christopher21bde872012-01-06 04:35:23 +00002170 std::vector<DwarfAccelTable::Atom> Atoms;
2171 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2172 dwarf::DW_FORM_data4));
2173 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2174 dwarf::DW_FORM_data2));
2175 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2176 dwarf::DW_FORM_data1));
2177 DwarfAccelTable AT(Atoms);
Eric Christopher4996c702011-11-07 09:24:32 +00002178 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2179 E = CUMap.end(); I != E; ++I) {
2180 CompileUnit *TheCU = I->second;
Eric Christopher21bde872012-01-06 04:35:23 +00002181 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2182 = TheCU->getAccelTypes();
2183 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
Eric Christopher4996c702011-11-07 09:24:32 +00002184 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
Benjamin Kramer63e39eb2013-05-11 18:24:28 +00002185 StringRef Name = GI->getKey();
Eric Christopher090fcc12012-01-06 23:03:34 +00002186 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
Eric Christopher21bde872012-01-06 04:35:23 +00002187 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2188 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2189 AT.AddName(Name, (*DI).first, (*DI).second);
Eric Christopher4996c702011-11-07 09:24:32 +00002190 }
2191 }
2192
2193 AT.FinalizeTable(Asm, "types");
2194 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2195 .getDwarfAccelTypesSection());
2196 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2197 Asm->OutStreamer.EmitLabel(SectionBegin);
2198
2199 // Emit the full data.
Eric Christophere698f532012-12-20 21:58:36 +00002200 AT.Emit(Asm, SectionBegin, &InfoHolder);
Eric Christopher4996c702011-11-07 09:24:32 +00002201}
2202
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002203/// emitDebugPubnames - Emit visible names into a debug pubnames section.
2204///
2205void DwarfDebug::emitDebugPubnames() {
2206 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2207
2208 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2209 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2210 CompileUnit *TheCU = I->second;
2211 unsigned ID = TheCU->getUniqueID();
2212
2213 if (TheCU->getGlobalNames().empty())
2214 continue;
2215
2216 // Start the dwarf pubnames section.
2217 Asm->OutStreamer.SwitchSection(
2218 Asm->getObjFileLowering().getDwarfPubNamesSection());
2219
2220 Asm->OutStreamer.AddComment("Length of Public Names Info");
2221 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2222 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2223
2224 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2225
2226 Asm->OutStreamer.AddComment("DWARF Version");
Manman Ren4213c392013-05-29 17:16:59 +00002227 Asm->EmitInt16(dwarf::DWARF_VERSION);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002228
2229 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2230 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2231 DwarfInfoSectionSym);
2232
2233 Asm->OutStreamer.AddComment("Compilation Unit Length");
2234 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2235 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2236 4);
2237
2238 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2239 for (StringMap<DIE*>::const_iterator
2240 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2241 const char *Name = GI->getKeyData();
2242 const DIE *Entity = GI->second;
2243
2244 Asm->OutStreamer.AddComment("DIE offset");
2245 Asm->EmitInt32(Entity->getOffset());
2246
2247 if (Asm->isVerbose())
2248 Asm->OutStreamer.AddComment("External Name");
Benjamin Kramer63e39eb2013-05-11 18:24:28 +00002249 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002250 }
2251
2252 Asm->OutStreamer.AddComment("End Mark");
2253 Asm->EmitInt32(0);
2254 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2255 }
2256}
2257
Devang Patel04d2f2d2009-11-24 01:14:22 +00002258void DwarfDebug::emitDebugPubTypes() {
Devang Patel1a0df9a2010-05-10 22:49:55 +00002259 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2260 E = CUMap.end(); I != E; ++I) {
2261 CompileUnit *TheCU = I->second;
Eric Christopher6abc9c52011-11-07 09:18:35 +00002262 // Start the dwarf pubtypes section.
Devang Patel1a0df9a2010-05-10 22:49:55 +00002263 Asm->OutStreamer.SwitchSection(
2264 Asm->getObjFileLowering().getDwarfPubTypesSection());
2265 Asm->OutStreamer.AddComment("Length of Public Types Info");
2266 Asm->EmitLabelDifference(
Eli Benderskyb42d1462012-12-03 18:45:45 +00002267 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2268 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002269
Devang Patel1a0df9a2010-05-10 22:49:55 +00002270 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
Eli Benderskyb42d1462012-12-03 18:45:45 +00002271 TheCU->getUniqueID()));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002272
Devang Patel1a0df9a2010-05-10 22:49:55 +00002273 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
Manman Ren4213c392013-05-29 17:16:59 +00002274 Asm->EmitInt16(dwarf::DWARF_VERSION);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002275
Devang Patel1a0df9a2010-05-10 22:49:55 +00002276 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
Eric Christopher16485a52012-12-15 00:04:04 +00002277 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2278 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
Eli Benderskyb42d1462012-12-03 18:45:45 +00002279 TheCU->getUniqueID()),
Devang Patel1a0df9a2010-05-10 22:49:55 +00002280 DwarfInfoSectionSym);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002281
Devang Patel1a0df9a2010-05-10 22:49:55 +00002282 Asm->OutStreamer.AddComment("Compilation Unit Length");
Eric Christopher16485a52012-12-15 00:04:04 +00002283 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
Eli Benderskyb42d1462012-12-03 18:45:45 +00002284 TheCU->getUniqueID()),
Eric Christopher16485a52012-12-15 00:04:04 +00002285 Asm->GetTempSymbol(ISec->getLabelBeginName(),
Eli Benderskyb42d1462012-12-03 18:45:45 +00002286 TheCU->getUniqueID()),
Devang Patel1a0df9a2010-05-10 22:49:55 +00002287 4);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002288
Devang Patel1a0df9a2010-05-10 22:49:55 +00002289 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2290 for (StringMap<DIE*>::const_iterator
2291 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2292 const char *Name = GI->getKeyData();
Nick Lewycky019d2552011-07-29 03:49:23 +00002293 DIE *Entity = GI->second;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002294
Devang Patel1a0df9a2010-05-10 22:49:55 +00002295 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2296 Asm->EmitInt32(Entity->getOffset());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002297
Devang Patel1a0df9a2010-05-10 22:49:55 +00002298 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
Benjamin Kramer966ed1b2011-11-09 18:16:11 +00002299 // Emit the name with a terminating null byte.
Eric Christophere3ab3d02013-01-09 01:57:54 +00002300 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
Devang Patel1a0df9a2010-05-10 22:49:55 +00002301 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002302
Devang Patel1a0df9a2010-05-10 22:49:55 +00002303 Asm->OutStreamer.AddComment("End Mark");
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002304 Asm->EmitInt32(0);
Devang Patel1a0df9a2010-05-10 22:49:55 +00002305 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
Eli Benderskyb42d1462012-12-03 18:45:45 +00002306 TheCU->getUniqueID()));
Devang Patel04d2f2d2009-11-24 01:14:22 +00002307 }
Devang Patel04d2f2d2009-11-24 01:14:22 +00002308}
2309
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002310// Emit strings into a string section.
Eric Christopher2cbd5762013-01-07 19:32:41 +00002311void DwarfUnits::emitStrings(const MCSection *StrSection,
2312 const MCSection *OffsetSection = NULL,
2313 const MCSymbol *StrSecSym = NULL) {
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002314
Eric Christopher27614582013-01-08 22:22:06 +00002315 if (StringPool.empty()) return;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002316
Chris Lattner3d72a672010-03-09 23:38:23 +00002317 // Start the dwarf str section.
Eric Christopher2cbd5762013-01-07 19:32:41 +00002318 Asm->OutStreamer.SwitchSection(StrSection);
Bill Wendling480ff322009-05-20 23:21:38 +00002319
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002320 // Get all of the string pool entries and put them in an array by their ID so
2321 // we can sort them.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002322 SmallVector<std::pair<unsigned,
Eric Christopherb800ff72013-01-07 22:40:45 +00002323 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002324
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002325 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
Eric Christopher27614582013-01-08 22:22:06 +00002326 I = StringPool.begin(), E = StringPool.end();
Eric Christopher48fef592012-12-20 21:58:40 +00002327 I != E; ++I)
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002328 Entries.push_back(std::make_pair(I->second.second, &*I));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002329
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002330 array_pod_sort(Entries.begin(), Entries.end());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002331
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002332 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
Chris Lattner3d72a672010-03-09 23:38:23 +00002333 // Emit a label for reference from debug information entries.
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002334 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002335
Benjamin Kramer966ed1b2011-11-09 18:16:11 +00002336 // Emit the string itself with a terminating null byte.
Benjamin Kramer148db362011-11-09 12:12:04 +00002337 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
Eric Christopherce0cfce2013-01-09 01:35:34 +00002338 Entries[i].second->getKeyLength()+1));
Bill Wendling480ff322009-05-20 23:21:38 +00002339 }
Eric Christopher2cbd5762013-01-07 19:32:41 +00002340
2341 // If we've got an offset section go ahead and emit that now as well.
2342 if (OffsetSection) {
2343 Asm->OutStreamer.SwitchSection(OffsetSection);
2344 unsigned offset = 0;
Eric Christopher962c9082013-01-15 23:56:56 +00002345 unsigned size = 4; // FIXME: DWARF64 is 8.
Eric Christopher2cbd5762013-01-07 19:32:41 +00002346 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
Eric Christopherbf7bc492013-01-09 03:52:05 +00002347 Asm->OutStreamer.EmitIntValue(offset, size);
Eric Christopher2cbd5762013-01-07 19:32:41 +00002348 offset += Entries[i].second->getKeyLength() + 1;
2349 }
2350 }
Bill Wendling480ff322009-05-20 23:21:38 +00002351}
2352
Eric Christopher962c9082013-01-15 23:56:56 +00002353// Emit strings into a string section.
2354void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2355
2356 if (AddressPool.empty()) return;
2357
2358 // Start the dwarf addr section.
2359 Asm->OutStreamer.SwitchSection(AddrSection);
2360
2361 // Get all of the string pool entries and put them in an array by their ID so
2362 // we can sort them.
2363 SmallVector<std::pair<unsigned,
2364 std::pair<MCSymbol*, unsigned>* >, 64> Entries;
2365
2366 for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator
2367 I = AddressPool.begin(), E = AddressPool.end();
2368 I != E; ++I)
2369 Entries.push_back(std::make_pair(I->second.second, &(I->second)));
2370
2371 array_pod_sort(Entries.begin(), Entries.end());
2372
2373 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2374 // Emit a label for reference from debug information entries.
2375 MCSymbol *Sym = Entries[i].second->first;
2376 if (Sym)
2377 Asm->EmitLabelReference(Entries[i].second->first,
2378 Asm->getDataLayout().getPointerSize());
2379 else
2380 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2381 }
2382
2383}
2384
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002385// Emit visible names into a debug str section.
2386void DwarfDebug::emitDebugStr() {
2387 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2388 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2389}
2390
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002391// Emit visible names into a debug loc section.
Devang Patel930143b2009-11-21 02:48:08 +00002392void DwarfDebug::emitDebugLoc() {
Devang Patel6b9a9fe2010-05-26 23:55:23 +00002393 if (DotDebugLocEntries.empty())
2394 return;
2395
Eric Christopher4887c8f2013-03-29 23:34:06 +00002396 for (SmallVectorImpl<DotDebugLocEntry>::iterator
Devang Patel116a9d72011-02-04 22:57:18 +00002397 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2398 I != E; ++I) {
2399 DotDebugLocEntry &Entry = *I;
2400 if (I + 1 != DotDebugLocEntries.end())
2401 Entry.Merge(I+1);
2402 }
2403
Daniel Dunbarfd95b012011-03-16 22:16:39 +00002404 // Start the dwarf loc section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002405 Asm->OutStreamer.SwitchSection(
Devang Patel9fc11702010-05-25 23:40:22 +00002406 Asm->getObjFileLowering().getDwarfLocSection());
Chandler Carruth5da3f052012-11-01 09:14:31 +00002407 unsigned char Size = Asm->getDataLayout().getPointerSize();
Devang Patel6b9a9fe2010-05-26 23:55:23 +00002408 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2409 unsigned index = 1;
Eric Christopher4887c8f2013-03-29 23:34:06 +00002410 for (SmallVectorImpl<DotDebugLocEntry>::iterator
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002411 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
Devang Patel30265c42010-07-07 20:12:52 +00002412 I != E; ++I, ++index) {
Devang Patel116a9d72011-02-04 22:57:18 +00002413 DotDebugLocEntry &Entry = *I;
2414 if (Entry.isMerged()) continue;
Devang Patel9fc11702010-05-25 23:40:22 +00002415 if (Entry.isEmpty()) {
Eric Christopherce0cfce2013-01-09 01:35:34 +00002416 Asm->OutStreamer.EmitIntValue(0, Size);
2417 Asm->OutStreamer.EmitIntValue(0, Size);
Devang Patel6b9a9fe2010-05-26 23:55:23 +00002418 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
Devang Patel9fc11702010-05-25 23:40:22 +00002419 } else {
Eric Christopherbf7bc492013-01-09 03:52:05 +00002420 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size);
2421 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size);
Devang Patel3e021532011-04-28 02:22:40 +00002422 DIVariable DV(Entry.Variable);
Rafael Espindolad23bfb82011-05-27 22:05:41 +00002423 Asm->OutStreamer.AddComment("Loc expr size");
2424 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2425 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2426 Asm->EmitLabelDifference(end, begin, 2);
2427 Asm->OutStreamer.EmitLabel(begin);
Devang Pateled9fd452011-07-08 16:49:43 +00002428 if (Entry.isInt()) {
Devang Patel324f8432011-06-01 22:03:25 +00002429 DIBasicType BTy(DV.getType());
2430 if (BTy.Verify() &&
Eric Christopher6a841382012-11-19 22:42:10 +00002431 (BTy.getEncoding() == dwarf::DW_ATE_signed
Devang Patel324f8432011-06-01 22:03:25 +00002432 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2433 Asm->OutStreamer.AddComment("DW_OP_consts");
2434 Asm->EmitInt8(dwarf::DW_OP_consts);
Devang Pateled9fd452011-07-08 16:49:43 +00002435 Asm->EmitSLEB128(Entry.getInt());
Devang Patel324f8432011-06-01 22:03:25 +00002436 } else {
2437 Asm->OutStreamer.AddComment("DW_OP_constu");
2438 Asm->EmitInt8(dwarf::DW_OP_constu);
Devang Pateled9fd452011-07-08 16:49:43 +00002439 Asm->EmitULEB128(Entry.getInt());
Devang Patel324f8432011-06-01 22:03:25 +00002440 }
Devang Pateled9fd452011-07-08 16:49:43 +00002441 } else if (Entry.isLocation()) {
Eric Christopher6a841382012-11-19 22:42:10 +00002442 if (!DV.hasComplexAddress())
Devang Pateled9fd452011-07-08 16:49:43 +00002443 // Regular entry.
David Blaikie81a4dc72013-06-19 21:55:13 +00002444 Asm->EmitDwarfRegOp(Entry.Loc, DV.isIndirect());
Devang Pateled9fd452011-07-08 16:49:43 +00002445 else {
2446 // Complex address entry.
2447 unsigned N = DV.getNumAddrElements();
2448 unsigned i = 0;
2449 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2450 if (Entry.Loc.getOffset()) {
2451 i = 2;
David Blaikie81a4dc72013-06-19 21:55:13 +00002452 Asm->EmitDwarfRegOp(Entry.Loc, DV.isIndirect());
Devang Pateled9fd452011-07-08 16:49:43 +00002453 Asm->OutStreamer.AddComment("DW_OP_deref");
2454 Asm->EmitInt8(dwarf::DW_OP_deref);
2455 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2456 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2457 Asm->EmitSLEB128(DV.getAddrElement(1));
2458 } else {
2459 // If first address element is OpPlus then emit
2460 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2461 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
David Blaikie81a4dc72013-06-19 21:55:13 +00002462 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
Devang Pateled9fd452011-07-08 16:49:43 +00002463 i = 2;
2464 }
2465 } else {
David Blaikie81a4dc72013-06-19 21:55:13 +00002466 Asm->EmitDwarfRegOp(Entry.Loc, DV.isIndirect());
Devang Pateled9fd452011-07-08 16:49:43 +00002467 }
Eric Christopher6a841382012-11-19 22:42:10 +00002468
Devang Pateled9fd452011-07-08 16:49:43 +00002469 // Emit remaining complex address elements.
2470 for (; i < N; ++i) {
2471 uint64_t Element = DV.getAddrElement(i);
2472 if (Element == DIBuilder::OpPlus) {
2473 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2474 Asm->EmitULEB128(DV.getAddrElement(++i));
Eric Christopher4d250522012-05-08 18:56:00 +00002475 } else if (Element == DIBuilder::OpDeref) {
Eric Christopher8d2a77d2012-05-08 21:24:39 +00002476 if (!Entry.Loc.isReg())
Eric Christopher4d250522012-05-08 18:56:00 +00002477 Asm->EmitInt8(dwarf::DW_OP_deref);
2478 } else
2479 llvm_unreachable("unknown Opcode found in complex address");
Devang Pateled9fd452011-07-08 16:49:43 +00002480 }
Devang Patel3e021532011-04-28 02:22:40 +00002481 }
Devang Patel3e021532011-04-28 02:22:40 +00002482 }
Devang Pateled9fd452011-07-08 16:49:43 +00002483 // else ... ignore constant fp. There is not any good way to
2484 // to represent them here in dwarf.
Rafael Espindolad23bfb82011-05-27 22:05:41 +00002485 Asm->OutStreamer.EmitLabel(end);
Devang Patel9fc11702010-05-25 23:40:22 +00002486 }
2487 }
Bill Wendling480ff322009-05-20 23:21:38 +00002488}
2489
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002490// Emit visible names into a debug aranges section.
Eric Christopher7b30f2e42012-11-21 00:34:35 +00002491void DwarfDebug::emitDebugARanges() {
Bill Wendling480ff322009-05-20 23:21:38 +00002492 // Start the dwarf aranges section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002493 Asm->OutStreamer.SwitchSection(
2494 Asm->getObjFileLowering().getDwarfARangesSection());
Bill Wendling480ff322009-05-20 23:21:38 +00002495}
2496
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002497// Emit visible names into a debug ranges section.
Devang Patel930143b2009-11-21 02:48:08 +00002498void DwarfDebug::emitDebugRanges() {
Bill Wendling480ff322009-05-20 23:21:38 +00002499 // Start the dwarf ranges section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002500 Asm->OutStreamer.SwitchSection(
Devang Patel12563b32010-04-16 23:33:45 +00002501 Asm->getObjFileLowering().getDwarfRangesSection());
Chandler Carruth5da3f052012-11-01 09:14:31 +00002502 unsigned char Size = Asm->getDataLayout().getPointerSize();
Eric Christopher4887c8f2013-03-29 23:34:06 +00002503 for (SmallVectorImpl<const MCSymbol *>::iterator
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002504 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
Devang Patel6c74a872010-04-27 19:46:33 +00002505 I != E; ++I) {
2506 if (*I)
Eric Christopherbf7bc492013-01-09 03:52:05 +00002507 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
Devang Patel12563b32010-04-16 23:33:45 +00002508 else
Eric Christopherce0cfce2013-01-09 01:35:34 +00002509 Asm->OutStreamer.EmitIntValue(0, Size);
Devang Patel12563b32010-04-16 23:33:45 +00002510 }
Bill Wendling480ff322009-05-20 23:21:38 +00002511}
2512
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002513// Emit visible names into a debug macinfo section.
Devang Patel930143b2009-11-21 02:48:08 +00002514void DwarfDebug::emitDebugMacInfo() {
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00002515 if (const MCSection *LineInfo =
Chris Lattner1472cf52009-08-02 07:24:22 +00002516 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
Bill Wendling480ff322009-05-20 23:21:38 +00002517 // Start the dwarf macinfo section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002518 Asm->OutStreamer.SwitchSection(LineInfo);
Bill Wendling480ff322009-05-20 23:21:38 +00002519 }
2520}
2521
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002522// Emit inline info using following format.
2523// Section Header:
2524// 1. length of section
2525// 2. Dwarf version number
2526// 3. address size.
2527//
2528// Entries (one "entry" for each function that was inlined):
2529//
2530// 1. offset into __debug_str section for MIPS linkage name, if exists;
2531// otherwise offset into __debug_str for regular function name.
2532// 2. offset into __debug_str section for regular function name.
2533// 3. an unsigned LEB128 number indicating the number of distinct inlining
2534// instances for the function.
2535//
2536// The rest of the entry consists of a {die_offset, low_pc} pair for each
2537// inlined instance; the die_offset points to the inlined_subroutine die in the
2538// __debug_info section, and the low_pc is the starting address for the
2539// inlining instance.
Devang Patel930143b2009-11-21 02:48:08 +00002540void DwarfDebug::emitDebugInlineInfo() {
Eric Christopher1df94bf2012-03-02 02:11:47 +00002541 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
Bill Wendling480ff322009-05-20 23:21:38 +00002542 return;
2543
Devang Patel1a0df9a2010-05-10 22:49:55 +00002544 if (!FirstCU)
Bill Wendling480ff322009-05-20 23:21:38 +00002545 return;
2546
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002547 Asm->OutStreamer.SwitchSection(
2548 Asm->getObjFileLowering().getDwarfDebugInlineSection());
Chris Lattnerf5c834f2010-01-22 22:09:00 +00002549
Chris Lattner566cae92010-03-09 23:52:58 +00002550 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
Chris Lattnerf1429f12010-04-04 19:58:12 +00002551 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2552 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
Bill Wendling480ff322009-05-20 23:21:38 +00002553
Chris Lattnera179b522010-04-04 19:25:43 +00002554 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
Bill Wendling480ff322009-05-20 23:21:38 +00002555
Chris Lattner566cae92010-03-09 23:52:58 +00002556 Asm->OutStreamer.AddComment("Dwarf Version");
Manman Ren4213c392013-05-29 17:16:59 +00002557 Asm->EmitInt16(dwarf::DWARF_VERSION);
Chris Lattner566cae92010-03-09 23:52:58 +00002558 Asm->OutStreamer.AddComment("Address Size (in bytes)");
Chandler Carruth5da3f052012-11-01 09:14:31 +00002559 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
Bill Wendling480ff322009-05-20 23:21:38 +00002560
Eric Christopher4887c8f2013-03-29 23:34:06 +00002561 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002562 E = InlinedSPNodes.end(); I != E; ++I) {
Jim Grosbach042483e2009-11-21 23:12:12 +00002563
Devang Patel32cc43c2010-05-07 20:54:48 +00002564 const MDNode *Node = *I;
2565 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
Jim Grosbach00e9c612009-11-22 19:20:36 +00002566 = InlineInfo.find(Node);
Eric Christopher4887c8f2013-03-29 23:34:06 +00002567 SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
Devang Patel80ae3492009-08-28 23:24:31 +00002568 DISubprogram SP(Node);
Devang Patel2d9caf92009-11-25 17:36:49 +00002569 StringRef LName = SP.getLinkageName();
2570 StringRef Name = SP.getName();
Bill Wendling480ff322009-05-20 23:21:38 +00002571
Chris Lattner566cae92010-03-09 23:52:58 +00002572 Asm->OutStreamer.AddComment("MIPS linkage name");
Eric Christopher77725312012-03-02 01:57:52 +00002573 if (LName.empty())
Eric Christophere698f532012-12-20 21:58:36 +00002574 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2575 DwarfStrSectionSym);
Eric Christopher77725312012-03-02 01:57:52 +00002576 else
Benjamin Kramer7c275642013-06-01 17:51:14 +00002577 Asm->EmitSectionOffset(
2578 InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)),
2579 DwarfStrSectionSym);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002580
Chris Lattner566cae92010-03-09 23:52:58 +00002581 Asm->OutStreamer.AddComment("Function name");
Eric Christophere698f532012-12-20 21:58:36 +00002582 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2583 DwarfStrSectionSym);
Chris Lattner9efd1182010-04-04 19:09:29 +00002584 Asm->EmitULEB128(Labels.size(), "Inline count");
Bill Wendling480ff322009-05-20 23:21:38 +00002585
Eric Christopher4887c8f2013-03-29 23:34:06 +00002586 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
Bill Wendling480ff322009-05-20 23:21:38 +00002587 LE = Labels.end(); LI != LE; ++LI) {
Chris Lattner7bde8c02010-04-04 18:52:31 +00002588 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
Chris Lattner085b6522010-03-09 00:31:02 +00002589 Asm->EmitInt32(LI->second->getOffset());
Bill Wendling480ff322009-05-20 23:21:38 +00002590
Chris Lattner7bde8c02010-04-04 18:52:31 +00002591 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
Chris Lattner3a383cb2010-04-05 00:13:49 +00002592 Asm->OutStreamer.EmitSymbolValue(LI->first,
Eric Christopherbf7bc492013-01-09 03:52:05 +00002593 Asm->getDataLayout().getPointerSize());
Bill Wendling480ff322009-05-20 23:21:38 +00002594 }
2595 }
2596
Chris Lattnera179b522010-04-04 19:25:43 +00002597 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
Bill Wendling480ff322009-05-20 23:21:38 +00002598}
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002599
Eric Christopherd692c1d2012-12-11 19:42:09 +00002600// DWARF5 Experimental Separate Dwarf emitters.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002601
2602// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2603// DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2604// DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2605// DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
Eric Christophercdf218d2012-12-10 19:51:21 +00002606CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002607 DICompileUnit DIUnit(N);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002608 CompilationDir = DIUnit.getDirectory();
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002609
2610 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Eli Benderskyb42d1462012-12-03 18:45:45 +00002611 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
Eric Christopherc57baee2013-05-08 00:58:51 +00002612 DIUnit.getLanguage(), Die, N, Asm,
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002613 this, &SkeletonHolder);
Eric Christopher4c7765f2013-01-17 03:00:04 +00002614
Eric Christopherdae389b2013-02-22 23:50:08 +00002615 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2616 DIUnit.getSplitDebugFilename());
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002617
Eric Christopher7a2cdf72013-02-05 07:31:55 +00002618 // This should be a unique identifier when we want to build .dwp files.
2619 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
Eric Christopher18266172013-01-17 02:59:59 +00002620
Eric Christopher44c6aa62013-04-22 07:51:08 +00002621 // Relocate to the beginning of the addr_base section, else 0 for the
2622 // beginning of the one for this compile unit.
Eric Christopher55863be2013-04-07 03:43:09 +00002623 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2624 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2625 DwarfAddrSectionSym);
2626 else
Eric Christopher44c6aa62013-04-22 07:51:08 +00002627 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2628 dwarf::DW_FORM_sec_offset, 0);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002629
2630 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
Eric Christopher962c9082013-01-15 23:56:56 +00002631 // into an entity. We're using 0, or a NULL label for this.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002632 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
Eric Christopher962c9082013-01-15 23:56:56 +00002633
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002634 // DW_AT_stmt_list is a offset of line number information for this
2635 // compile unit in debug_line section.
Eric Christopher55863be2013-04-07 03:43:09 +00002636 // FIXME: Should handle multiple compile units.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002637 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
Eric Christopher4c7765f2013-01-17 03:00:04 +00002638 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
Eric Christopher74804332013-02-07 21:19:50 +00002639 DwarfLineSectionSym);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002640 else
Eric Christopher4c7765f2013-01-17 03:00:04 +00002641 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002642
2643 if (!CompilationDir.empty())
Eric Christopher2cbd5762013-01-07 19:32:41 +00002644 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002645
Eric Christopherc8a310e2012-12-10 23:34:43 +00002646 SkeletonHolder.addUnit(NewCU);
Eric Christopher5b33b3c2013-02-06 21:53:56 +00002647 SkeletonCUs.push_back(NewCU);
Eric Christopherc8a310e2012-12-10 23:34:43 +00002648
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002649 return NewCU;
2650}
2651
Eric Christopher3c5a1912012-12-19 22:02:53 +00002652void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2653 assert(useSplitDwarf() && "No split dwarf debug info?");
2654 emitAbbrevs(Section, &SkeletonAbbrevs);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002655}
2656
Eric Christopherd692c1d2012-12-11 19:42:09 +00002657// Emit the .debug_info.dwo section for separated dwarf. This contains the
2658// compile units that would normally be in debug_info.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002659void DwarfDebug::emitDebugInfoDWO() {
Eric Christophercdf218d2012-12-10 19:51:21 +00002660 assert(useSplitDwarf() && "No split dwarf debug info?");
Eric Christophera2de8262012-12-15 00:04:07 +00002661 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
Eric Christopher3c5a1912012-12-19 22:02:53 +00002662 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2663 DwarfAbbrevDWOSectionSym);
2664}
2665
2666// Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2667// abbreviations for the .debug_info.dwo section.
2668void DwarfDebug::emitDebugAbbrevDWO() {
2669 assert(useSplitDwarf() && "No split dwarf?");
Eric Christopher48fef592012-12-20 21:58:40 +00002670 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2671 &Abbreviations);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002672}
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002673
2674// Emit the .debug_str.dwo section for separated dwarf. This contains the
2675// string section and is identical in format to traditional .debug_str
2676// sections.
2677void DwarfDebug::emitDebugStrDWO() {
2678 assert(useSplitDwarf() && "No split dwarf?");
Eric Christopherb800ff72013-01-07 22:40:45 +00002679 const MCSection *OffSec = Asm->getObjFileLowering()
2680 .getDwarfStrOffDWOSection();
Eric Christopher2cbd5762013-01-07 19:32:41 +00002681 const MCSymbol *StrSym = DwarfStrSectionSym;
2682 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2683 OffSec, StrSym);
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002684}