blob: f4182d0b79b20975a55422556c6fc626bda8b89e [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"
Eric Christopher29e874d2014-03-07 22:40:37 +000015#include "ByteStreamer.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000016#include "DwarfDebug.h"
Chris Lattner3f3fb972010-04-05 05:24:55 +000017#include "DIE.h"
Eric Christopher45731982013-08-08 23:45:55 +000018#include "DIEHash.h"
Eric Christopher4996c702011-11-07 09:24:32 +000019#include "DwarfAccelTable.h"
David Blaikie2c86a722013-12-02 19:33:15 +000020#include "DwarfUnit.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000021#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/Statistic.h"
23#include "llvm/ADT/StringExtras.h"
24#include "llvm/ADT/Triple.h"
David Greene829b3e82009-08-19 21:52:55 +000025#include "llvm/CodeGen/MachineFunction.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000026#include "llvm/CodeGen/MachineModuleInfo.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000027#include "llvm/IR/Constants.h"
Chandler Carruth12664a02014-03-06 00:22:06 +000028#include "llvm/IR/DIBuilder.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000029#include "llvm/IR/DataLayout.h"
Chandler Carruth9a4c9e52014-03-06 00:46:21 +000030#include "llvm/IR/DebugInfo.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000031#include "llvm/IR/Instructions.h"
32#include "llvm/IR/Module.h"
Chandler Carruth4220e9c2014-03-04 11:17:44 +000033#include "llvm/IR/ValueHandle.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000034#include "llvm/MC/MCAsmInfo.h"
Chris Lattner4d2c0f92009-07-31 18:48:30 +000035#include "llvm/MC/MCSection.h"
Chris Lattner4b7dadb2009-08-19 05:49:37 +000036#include "llvm/MC/MCStreamer.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000037#include "llvm/MC/MCSymbol.h"
Devang Patel6c74a872010-04-27 19:46:33 +000038#include "llvm/Support/CommandLine.h"
Daniel Dunbarcdf01b52009-10-13 06:47:08 +000039#include "llvm/Support/Debug.h"
David Majnemered89b5c2013-08-21 06:13:34 +000040#include "llvm/Support/Dwarf.h"
Daniel Dunbarcdf01b52009-10-13 06:47:08 +000041#include "llvm/Support/ErrorHandling.h"
Chris Lattnerf5c834f2010-01-22 22:09:00 +000042#include "llvm/Support/FormattedStream.h"
Logan Chien5b776b72014-02-22 14:00:39 +000043#include "llvm/Support/LEB128.h"
Eric Christopher67646432013-07-26 17:02:41 +000044#include "llvm/Support/MD5.h"
Michael J. Spencer447762d2010-11-29 18:16:10 +000045#include "llvm/Support/Path.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000046#include "llvm/Support/Timer.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000047#include "llvm/Target/TargetFrameLowering.h"
48#include "llvm/Target/TargetLoweringObjectFile.h"
49#include "llvm/Target/TargetMachine.h"
50#include "llvm/Target/TargetOptions.h"
51#include "llvm/Target/TargetRegisterInfo.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000052using namespace llvm;
53
Eric Christopher7f2b5512013-07-23 22:16:41 +000054static cl::opt<bool>
55DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
56 cl::desc("Disable debug info printing"));
Devang Patel6c74a872010-04-27 19:46:33 +000057
Eric Christopher7f2b5512013-07-23 22:16:41 +000058static cl::opt<bool> UnknownLocations(
59 "use-unknown-locations", cl::Hidden,
60 cl::desc("Make an absence of debug location information explicit."),
61 cl::init(false));
Dan Gohman7421ae42010-05-07 01:08:53 +000062
Eric Christopherdd1a0122013-09-13 00:35:05 +000063static cl::opt<bool>
64GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
65 cl::desc("Generate GNU-style pubnames and pubtypes"),
66 cl::init(false));
67
Eric Christopher02dbadb2014-02-14 01:26:55 +000068static cl::opt<bool> GenerateARangeSection("generate-arange-section",
69 cl::Hidden,
70 cl::desc("Generate dwarf aranges"),
71 cl::init(false));
72
Eric Christopher20b76a72012-08-23 22:36:40 +000073namespace {
Eric Christopherf07ee3a2014-01-27 23:50:03 +000074enum DefaultOnOff { Default, Enable, Disable };
Eric Christopher20b76a72012-08-23 22:36:40 +000075}
Eric Christopher4996c702011-11-07 09:24:32 +000076
Eric Christopher7f2b5512013-07-23 22:16:41 +000077static cl::opt<DefaultOnOff>
78DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
79 cl::desc("Output prototype dwarf accelerator tables."),
80 cl::values(clEnumVal(Default, "Default for platform"),
81 clEnumVal(Enable, "Enabled"),
82 clEnumVal(Disable, "Disabled"), clEnumValEnd),
83 cl::init(Default));
Eric Christopher20b76a72012-08-23 22:36:40 +000084
Eric Christopher7f2b5512013-07-23 22:16:41 +000085static cl::opt<DefaultOnOff>
Eric Christopher7f2b5512013-07-23 22:16:41 +000086SplitDwarf("split-dwarf", cl::Hidden,
Eric Christopher5d008fe2013-12-04 23:24:28 +000087 cl::desc("Output DWARF5 split debug info."),
Eric Christopher7f2b5512013-07-23 22:16:41 +000088 cl::values(clEnumVal(Default, "Default for platform"),
89 clEnumVal(Enable, "Enabled"),
90 clEnumVal(Disable, "Disabled"), clEnumValEnd),
91 cl::init(Default));
Eric Christopher29424312012-11-12 22:22:20 +000092
Eric Christopher7da24882013-08-19 21:07:38 +000093static cl::opt<DefaultOnOff>
Eric Christopher4d36ca02013-08-26 23:24:35 +000094DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
95 cl::desc("Generate DWARF pubnames and pubtypes sections"),
96 cl::values(clEnumVal(Default, "Default for platform"),
97 clEnumVal(Enable, "Enabled"),
98 clEnumVal(Disable, "Disabled"), clEnumValEnd),
99 cl::init(Default));
Eric Christopher7da24882013-08-19 21:07:38 +0000100
Eric Christopher33ff6972013-11-21 23:46:41 +0000101static cl::opt<unsigned>
102DwarfVersionNumber("dwarf-version", cl::Hidden,
Eric Christophera5a79422013-12-09 23:32:48 +0000103 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
Eric Christopher33ff6972013-11-21 23:46:41 +0000104
Benjamin Kramerb12cf012013-08-24 12:54:27 +0000105static const char *const DWARFGroupName = "DWARF Emission";
106static const char *const DbgTimerName = "DWARF Debug Writer";
Bill Wendlingfcc14142010-04-07 09:28:04 +0000107
Bill Wendling2f921f82009-05-15 09:23:25 +0000108//===----------------------------------------------------------------------===//
109
Bill Wendling2f921f82009-05-15 09:23:25 +0000110namespace llvm {
111
Manman Renbe5576f2013-10-08 19:07:44 +0000112/// resolve - Look in the DwarfDebug map for the MDNode that
113/// corresponds to the reference.
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000114template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
Manman Renbe5576f2013-10-08 19:07:44 +0000115 return DD->resolve(Ref);
116}
117
Adrian Prantl1a1647c2014-03-18 02:34:58 +0000118bool DbgVariable::isBlockByrefVariable() const {
119 assert(Var.isVariable() && "Invalid complex DbgVariable!");
120 return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
121}
122
123
Nick Lewycky019d2552011-07-29 03:49:23 +0000124DIType DbgVariable::getType() const {
Adrian Prantl1a1647c2014-03-18 02:34:58 +0000125 DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
Devang Patelf20c4f72011-04-12 22:53:02 +0000126 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
127 // addresses instead.
Adrian Prantl1a1647c2014-03-18 02:34:58 +0000128 if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
Devang Patelf20c4f72011-04-12 22:53:02 +0000129 /* Byref variables, in Blocks, are declared by the programmer as
130 "SomeType VarName;", but the compiler creates a
131 __Block_byref_x_VarName struct, and gives the variable VarName
132 either the struct, or a pointer to the struct, as its type. This
133 is necessary for various behind-the-scenes things the compiler
134 needs to do with by-reference variables in blocks.
Eric Christopher6a841382012-11-19 22:42:10 +0000135
Devang Patelf20c4f72011-04-12 22:53:02 +0000136 However, as far as the original *programmer* is concerned, the
137 variable should still have type 'SomeType', as originally declared.
Eric Christopher6a841382012-11-19 22:42:10 +0000138
Devang Patelf20c4f72011-04-12 22:53:02 +0000139 The following function dives into the __Block_byref_x_VarName
140 struct to find the original type of the variable. This will be
141 passed back to the code generating the type for the Debug
142 Information Entry for the variable 'VarName'. 'VarName' will then
143 have the original type 'SomeType' in its debug information.
Eric Christopher6a841382012-11-19 22:42:10 +0000144
Devang Patelf20c4f72011-04-12 22:53:02 +0000145 The original type 'SomeType' will be the type of the field named
146 'VarName' inside the __Block_byref_x_VarName struct.
Eric Christopher6a841382012-11-19 22:42:10 +0000147
Devang Patelf20c4f72011-04-12 22:53:02 +0000148 NOTE: In order for this to not completely fail on the debugger
149 side, the Debug Information Entry for the variable VarName needs to
150 have a DW_AT_location that tells the debugger how to unwind through
151 the pointers and __Block_byref_x_VarName struct to find the actual
152 value of the variable. The function addBlockByrefType does this. */
153 DIType subType = Ty;
Eric Christopher31b05762013-08-08 01:41:00 +0000154 uint16_t tag = Ty.getTag();
Eric Christopher6a841382012-11-19 22:42:10 +0000155
Eric Christopher9adc55f2013-09-04 19:53:21 +0000156 if (tag == dwarf::DW_TAG_pointer_type)
Manman Renbe5576f2013-10-08 19:07:44 +0000157 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
Eric Christopher6a841382012-11-19 22:42:10 +0000158
Eric Christopher9adc55f2013-09-04 19:53:21 +0000159 DIArray Elements = DICompositeType(subType).getTypeArray();
Devang Patelf20c4f72011-04-12 22:53:02 +0000160 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
David Blaikie5af2aca2013-11-18 23:57:26 +0000161 DIDerivedType DT(Elements.getElement(i));
Devang Patelf20c4f72011-04-12 22:53:02 +0000162 if (getName() == DT.getName())
Manman Renbe5576f2013-10-08 19:07:44 +0000163 return (resolve(DT.getTypeDerivedFrom()));
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000164 }
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000165 }
Devang Patelf20c4f72011-04-12 22:53:02 +0000166 return Ty;
167}
Bill Wendling2f921f82009-05-15 09:23:25 +0000168
Chris Lattnerf5d06362010-04-05 04:09:20 +0000169} // end llvm namespace
Bill Wendling2f921f82009-05-15 09:23:25 +0000170
Eric Christopher942f22c2014-01-11 00:28:12 +0000171/// Return Dwarf Version by checking module flags.
172static unsigned getDwarfVersionFromModule(const Module *M) {
Manman Ren8bfde892013-07-16 23:21:16 +0000173 Value *Val = M->getModuleFlag("Dwarf Version");
174 if (!Val)
Eric Christophere31e0722013-09-04 22:21:24 +0000175 return dwarf::DWARF_VERSION;
Manman Ren8bfde892013-07-16 23:21:16 +0000176 return cast<ConstantInt>(Val)->getZExtValue();
Manman Renac8062b2013-07-02 23:40:10 +0000177}
178
Chris Lattnerf0d6bd32010-04-05 05:11:15 +0000179DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
David Blaikiec2df16b2014-03-17 18:13:58 +0000180 : Asm(A), MMI(Asm->MMI), FirstCU(0), PrevLabel(NULL), GlobalRangeCount(0),
Eric Christopher384f3fe2014-03-20 19:16:16 +0000181 InfoHolder(A, "info_string", DIEValueAllocator),
Eric Christopher2037caf2014-01-28 00:49:26 +0000182 UsedNonDefaultText(false),
David Blaikie0504cda2013-12-05 07:43:55 +0000183 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000184
Eric Christopher50effa02014-01-03 02:16:44 +0000185 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
Eric Christopher74804332013-02-07 21:19:50 +0000186 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
David Blaikie9c550ac2014-03-25 01:44:02 +0000187 DwarfAddrSectionSym = DwarfDebugLocDWOSectionSym = 0;
Eric Christopher3bf29fd2012-12-27 02:14:01 +0000188 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
Devang Patel9fc11702010-05-25 23:40:22 +0000189 FunctionBeginSym = FunctionEndSym = 0;
Eric Christophera5a79422013-12-09 23:32:48 +0000190 CurFn = 0;
191 CurMI = 0;
Eric Christopherad9fe892012-04-02 17:58:52 +0000192
Adrian Prantl5bf1d002013-10-15 20:26:37 +0000193 // Turn on accelerator tables for Darwin by default, pubnames by
194 // default for non-Darwin, and handle split dwarf.
Eric Christopher203e12b2013-04-27 01:07:52 +0000195 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
Eric Christopher4977f212012-08-23 22:36:36 +0000196
Eric Christopher574b5c82013-08-19 21:41:38 +0000197 if (DwarfAccelTables == Default)
198 HasDwarfAccelTables = IsDarwin;
199 else
Eric Christopher5297df02013-08-26 20:58:35 +0000200 HasDwarfAccelTables = DwarfAccelTables == Enable;
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 Christopher574b5c82013-08-19 21:41:38 +0000205 HasSplitDwarf = SplitDwarf == Enable;
Eric Christopher29424312012-11-12 22:22:20 +0000206
Eric Christopher4d36ca02013-08-26 23:24:35 +0000207 if (DwarfPubSections == Default)
208 HasDwarfPubSections = !IsDarwin;
Eric Christopher574b5c82013-08-19 21:41:38 +0000209 else
Eric Christopher4d36ca02013-08-26 23:24:35 +0000210 HasDwarfPubSections = DwarfPubSections == Enable;
Eric Christopher7da24882013-08-19 21:07:38 +0000211
Eric Christopher942f22c2014-01-11 00:28:12 +0000212 DwarfVersion = DwarfVersionNumber
213 ? DwarfVersionNumber
214 : getDwarfVersionFromModule(MMI->getModule());
Manman Renac8062b2013-07-02 23:40:10 +0000215
Dan Gohman6e681a52010-06-18 15:56:31 +0000216 {
217 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
Eric Christopher58f41952012-11-19 22:42:15 +0000218 beginModule();
Torok Edwinf8dba242010-04-07 10:44:46 +0000219 }
Bill Wendling2f921f82009-05-15 09:23:25 +0000220}
Bill Wendling2f921f82009-05-15 09:23:25 +0000221
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000222// Switch to the specified MCSection and emit an assembler
223// temporary label to it if SymbolStem is specified.
Eric Christopher7b30f2e42012-11-21 00:34:35 +0000224static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
Eric Christophera7b61892011-11-07 09:18:38 +0000225 const char *SymbolStem = 0) {
226 Asm->OutStreamer.SwitchSection(Section);
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000227 if (!SymbolStem)
228 return 0;
Eric Christophera7b61892011-11-07 09:18:38 +0000229
230 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
231 Asm->OutStreamer.EmitLabel(TmpSym);
232 return TmpSym;
233}
234
Eric Christopherf8194852013-12-05 18:06:10 +0000235DwarfFile::~DwarfFile() {
Benjamin Kramer15596c72014-03-07 19:09:39 +0000236 for (DwarfUnit *DU : CUs)
237 delete DU;
David Blaikie72f1a3e2013-11-23 01:17:34 +0000238}
239
Eric Christopherf8194852013-12-05 18:06:10 +0000240MCSymbol *DwarfFile::getStringPoolSym() {
Eric Christopher3bf29fd2012-12-27 02:14:01 +0000241 return Asm->GetTempSymbol(StringPref);
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000242}
243
Eric Christopherf8194852013-12-05 18:06:10 +0000244MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000245 std::pair<MCSymbol *, unsigned> &Entry =
246 StringPool.GetOrCreateValue(Str).getValue();
247 if (Entry.first)
248 return Entry.first;
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000249
250 Entry.second = NextStringPoolNumber++;
Eric Christopher3bf29fd2012-12-27 02:14:01 +0000251 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000252}
253
Eric Christopherf8194852013-12-05 18:06:10 +0000254unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000255 std::pair<MCSymbol *, unsigned> &Entry =
256 StringPool.GetOrCreateValue(Str).getValue();
257 if (Entry.first)
258 return Entry.second;
Eric Christopher2cbd5762013-01-07 19:32:41 +0000259
260 Entry.second = NextStringPoolNumber++;
261 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
262 return Entry.second;
263}
264
David Blaikief1a6dea2014-02-15 19:34:03 +0000265unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym, bool TLS) {
266 std::pair<AddrPool::iterator, bool> P = AddressPool.insert(
267 std::make_pair(Sym, AddressPoolEntry(NextAddrPoolNumber, TLS)));
David Blaikiea67de2b2013-06-28 18:55:13 +0000268 if (P.second)
269 ++NextAddrPoolNumber;
David Blaikief1a6dea2014-02-15 19:34:03 +0000270 return P.first->second.Number;
Eric Christopher962c9082013-01-15 23:56:56 +0000271}
272
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000273// Define a unique number for the abbreviation.
274//
Eric Christopherf8194852013-12-05 18:06:10 +0000275void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
Bill Wendling2f921f82009-05-15 09:23:25 +0000276 // Check the set for priors.
David Blaikie0504cda2013-12-05 07:43:55 +0000277 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
Bill Wendling2f921f82009-05-15 09:23:25 +0000278
279 // If it's newly added.
280 if (InSet == &Abbrev) {
281 // Add to abbreviation list.
David Blaikie2d4e1122013-10-30 17:14:24 +0000282 Abbreviations.push_back(&Abbrev);
Bill Wendling2f921f82009-05-15 09:23:25 +0000283
284 // Assign the vector position + 1 as its number.
David Blaikie2d4e1122013-10-30 17:14:24 +0000285 Abbrev.setNumber(Abbreviations.size());
Bill Wendling2f921f82009-05-15 09:23:25 +0000286 } else {
287 // Assign existing abbreviation number.
288 Abbrev.setNumber(InSet->getNumber());
289 }
290}
291
Eric Christopherd9843b32011-11-10 19:25:34 +0000292static bool isObjCClass(StringRef Name) {
293 return Name.startswith("+") || Name.startswith("-");
294}
295
296static bool hasObjCCategory(StringRef Name) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000297 if (!isObjCClass(Name))
298 return false;
Eric Christopherd9843b32011-11-10 19:25:34 +0000299
Benjamin Kramer260de742013-08-24 12:15:54 +0000300 return Name.find(") ") != StringRef::npos;
Eric Christopherd9843b32011-11-10 19:25:34 +0000301}
302
303static void getObjCClassCategory(StringRef In, StringRef &Class,
304 StringRef &Category) {
305 if (!hasObjCCategory(In)) {
306 Class = In.slice(In.find('[') + 1, In.find(' '));
307 Category = "";
308 return;
309 }
310
311 Class = In.slice(In.find('[') + 1, In.find('('));
312 Category = In.slice(In.find('[') + 1, In.find(' '));
313 return;
314}
315
316static StringRef getObjCMethodName(StringRef In) {
317 return In.slice(In.find(' ') + 1, In.find(']'));
318}
319
Richard Mittonc2508242013-10-03 22:07:08 +0000320// Helper for sorting sections into a stable output order.
321static bool SectionSort(const MCSection *A, const MCSection *B) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000322 std::string LA = (A ? A->getLabelBeginName() : "");
323 std::string LB = (B ? B->getLabelBeginName() : "");
324 return LA < LB;
Richard Mittonc2508242013-10-03 22:07:08 +0000325}
326
Eric Christopherd9843b32011-11-10 19:25:34 +0000327// Add the various names to the Dwarf accelerator table names.
Eric Christopher9cd26af2013-09-20 23:22:52 +0000328// TODO: Determine whether or not we should add names for programs
329// that do not have a DW_AT_name or DW_AT_linkage_name field - this
330// is only slightly different than the lookup of non-standard ObjC names.
Eric Christophera5a79422013-12-09 23:32:48 +0000331static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000332 if (!SP.isDefinition())
333 return;
David Blaikie2a80e442013-12-02 22:09:48 +0000334 TheU->addAccelName(SP.getName(), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000335
336 // If the linkage name is different than the name, go ahead and output
337 // that as well into the name table.
338 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
David Blaikie2a80e442013-12-02 22:09:48 +0000339 TheU->addAccelName(SP.getLinkageName(), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000340
341 // If this is an Objective-C selector name add it to the ObjC accelerator
342 // too.
343 if (isObjCClass(SP.getName())) {
344 StringRef Class, Category;
345 getObjCClassCategory(SP.getName(), Class, Category);
David Blaikie2a80e442013-12-02 22:09:48 +0000346 TheU->addAccelObjC(Class, Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000347 if (Category != "")
David Blaikie2a80e442013-12-02 22:09:48 +0000348 TheU->addAccelObjC(Category, Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000349 // Also add the base method name to the name table.
David Blaikie2a80e442013-12-02 22:09:48 +0000350 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000351 }
352}
353
Manman Ren3eb9dff2013-09-09 19:05:21 +0000354/// isSubprogramContext - Return true if Context is either a subprogram
355/// or another context nested inside a subprogram.
356bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
357 if (!Context)
358 return false;
359 DIDescriptor D(Context);
360 if (D.isSubprogram())
361 return true;
362 if (D.isType())
Manman Ren116868e2013-09-09 19:47:11 +0000363 return isSubprogramContext(resolve(DIType(Context).getContext()));
Manman Ren3eb9dff2013-09-09 19:05:21 +0000364 return false;
365}
366
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000367// Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
368// and DW_AT_high_pc attributes. If there are global variables in this
369// scope then create and insert DIEs for these variables.
Eric Christopher4287a492013-12-09 23:57:44 +0000370DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
371 DISubprogram SP) {
David Blaikie25bc7192013-11-15 23:13:08 +0000372 DIE *SPDie = SPCU->getDIE(SP);
Devang Patela37a95e2010-07-07 22:20:57 +0000373
Chris Lattner3a383cb2010-04-05 00:13:49 +0000374 assert(SPDie && "Unable to find subprogram DIE!");
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000375
Bill Wendlingf720bf62012-11-07 05:19:04 +0000376 // If we're updating an abstract DIE, then we will be adding the children and
377 // object pointer later on. But what we don't want to do is process the
378 // concrete DIE twice.
David Blaikie25bc7192013-11-15 23:13:08 +0000379 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
Bill Wendlingf720bf62012-11-07 05:19:04 +0000380 // Pick up abstract subprogram DIE.
David Blaikie2a80e442013-12-02 22:09:48 +0000381 SPDie =
382 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
Manman Ren4c4b69c2013-10-11 23:58:05 +0000383 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000384 } else {
385 DISubprogram SPDecl = SP.getFunctionDeclaration();
386 if (!SPDecl.isSubprogram()) {
387 // There is not any need to generate specification DIE for a function
388 // defined at compile unit level. If a function is defined inside another
389 // function then gdb prefers the definition at top level and but does not
390 // expect specification DIE in parent function. So avoid creating
391 // specification DIE for a function defined inside a function.
Manman Renc50fa112013-10-10 18:40:01 +0000392 DIScope SPContext = resolve(SP.getContext());
393 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000394 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000395 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
396
397 // Add arguments.
398 DICompositeType SPTy = SP.getType();
399 DIArray Args = SPTy.getTypeArray();
Eric Christopher31b05762013-08-08 01:41:00 +0000400 uint16_t SPTag = SPTy.getTag();
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000401 if (SPTag == dwarf::DW_TAG_subroutine_type)
Adrian Prantl69140d22014-02-25 22:27:14 +0000402 SPCU->constructSubprogramArguments(*SPDie, Args);
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000403 DIE *SPDeclDie = SPDie;
David Blaikie2a80e442013-12-02 22:09:48 +0000404 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
405 *SPCU->getUnitDie());
Manman Ren4c4b69c2013-10-11 23:58:05 +0000406 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000407 }
408 }
Devang Patela37a95e2010-07-07 22:20:57 +0000409 }
410
David Blaikie4bd13b72014-03-07 18:49:45 +0000411 attachLowHighPC(SPCU, SPDie, FunctionBeginSym, FunctionEndSym);
Eric Christopher0f63d062013-12-03 00:45:45 +0000412
Chris Lattner3a383cb2010-04-05 00:13:49 +0000413 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
414 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
Devang Patelf20c4f72011-04-12 22:53:02 +0000415 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
Devang Patel6efc8e52010-02-06 01:02:37 +0000416
Eric Christopherd9843b32011-11-10 19:25:34 +0000417 // Add name to the name table, we do this here because we're guaranteed
418 // to have concrete versions of our DW_TAG_subprogram nodes.
419 addSubprogramNames(SPCU, SP, SPDie);
Eric Christopher6a841382012-11-19 22:42:10 +0000420
Chris Lattner3a383cb2010-04-05 00:13:49 +0000421 return SPDie;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000422}
423
Manman Ren5b2f4b02013-09-11 19:40:28 +0000424/// Check whether we should create a DIE for the given Scope, return true
425/// if we don't create a DIE (the corresponding DIE is null).
Manman Ren2312ed32013-09-10 18:40:41 +0000426bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
427 if (Scope->isAbstractScope())
428 return false;
429
Manman Ren5b2f4b02013-09-11 19:40:28 +0000430 // We don't create a DIE if there is no Range.
Manman Ren2312ed32013-09-10 18:40:41 +0000431 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
432 if (Ranges.empty())
433 return true;
434
435 if (Ranges.size() > 1)
436 return false;
437
Manman Ren5b2f4b02013-09-11 19:40:28 +0000438 // We don't create a DIE if we have a single Range and the end label
439 // is null.
Manman Ren2312ed32013-09-10 18:40:41 +0000440 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
441 MCSymbol *End = getLabelAfterInsn(RI->second);
442 return !End;
443}
444
Eric Christophera5a79422013-12-09 23:32:48 +0000445static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
Eric Christopherc31fe2d2013-12-05 00:36:17 +0000446 dwarf::Attribute A, const MCSymbol *L,
447 const MCSymbol *Sec) {
448 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
449 U->addSectionLabel(D, A, L);
450 else
451 U->addSectionDelta(D, A, L, Sec);
452}
453
Eric Christopher4287a492013-12-09 23:57:44 +0000454void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
Eric Christopherbe2513e2013-12-03 00:45:59 +0000455 const SmallVectorImpl<InsnRange> &Range) {
456 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
457 // emitting it appropriately.
Eric Christopherf8790642013-12-04 22:04:50 +0000458 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
David Blaikie26b2bd02014-03-24 21:07:27 +0000459
460 // Under fission, ranges are specified by constant offsets relative to the
461 // CU's DW_AT_GNU_ranges_base.
462 if (useSplitDwarf())
463 TheCU->addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
464 DwarfDebugRangeSectionSym);
465 else
466 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
467 DwarfDebugRangeSectionSym);
Eric Christopherc31fe2d2013-12-05 00:36:17 +0000468
Eric Christopherf8790642013-12-04 22:04:50 +0000469 RangeSpanList List(RangeSym);
Benjamin Kramer15596c72014-03-07 19:09:39 +0000470 for (const InsnRange &R : Range) {
471 RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
Chandler Carruth002da5d2014-03-02 04:08:41 +0000472 List.addRange(std::move(Span));
Eric Christopherbe2513e2013-12-03 00:45:59 +0000473 }
474
475 // Add the range list to the set of ranges to be emitted.
Chandler Carruth002da5d2014-03-02 04:08:41 +0000476 TheCU->addRangeList(std::move(List));
Eric Christopherbe2513e2013-12-03 00:45:59 +0000477}
478
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000479// Construct new DW_TAG_lexical_block for this scope and attach
480// DW_AT_low_pc/DW_AT_high_pc labels.
Eric Christopher4287a492013-12-09 23:57:44 +0000481DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000482 LexicalScope *Scope) {
Manman Ren2312ed32013-09-10 18:40:41 +0000483 if (isLexicalScopeDIENull(Scope))
484 return 0;
485
Devang Patel6c74a872010-04-27 19:46:33 +0000486 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
487 if (Scope->isAbstractScope())
488 return ScopeDIE;
489
Eric Christopher0f63d062013-12-03 00:45:45 +0000490 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
Eric Christopherbe2513e2013-12-03 00:45:59 +0000491
Eric Christopherdc42ea82013-07-03 01:57:28 +0000492 // If we have multiple ranges, emit them into the range section.
Eric Christopher0f63d062013-12-03 00:45:45 +0000493 if (ScopeRanges.size() > 1) {
Eric Christopherbe2513e2013-12-03 00:45:59 +0000494 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
Devang Patel6c74a872010-04-27 19:46:33 +0000495 return ScopeDIE;
496 }
497
Eric Christopherdc42ea82013-07-03 01:57:28 +0000498 // Construct the address range for this DIE.
Eric Christopher0f63d062013-12-03 00:45:45 +0000499 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
Eric Christopher962c9082013-01-15 23:56:56 +0000500 MCSymbol *Start = getLabelBeforeInsn(RI->first);
501 MCSymbol *End = getLabelAfterInsn(RI->second);
Manman Ren2312ed32013-09-10 18:40:41 +0000502 assert(End && "End label should not be null!");
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000503
Chris Lattnere13c3722010-03-09 01:58:53 +0000504 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
505 assert(End->isDefined() && "Invalid end label for an inlined scope!");
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000506
David Blaikie26ab6c62014-03-08 00:58:20 +0000507 attachLowHighPC(TheCU, ScopeDIE, Start, End);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000508
509 return ScopeDIE;
510}
511
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000512// This scope represents inlined body of a function. Construct DIE to
513// represent this concrete inlined copy of the function.
Eric Christopher4287a492013-12-09 23:57:44 +0000514DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000515 LexicalScope *Scope) {
Eric Christopher0f63d062013-12-03 00:45:45 +0000516 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
Eric Christopher1cdb63d2013-12-04 21:20:15 +0000517 assert(!ScopeRanges.empty() &&
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000518 "LexicalScope does not have instruction markers!");
Devang Patel6c74a872010-04-27 19:46:33 +0000519
Devang Patelf098ce22011-07-27 00:34:13 +0000520 if (!Scope->getScopeNode())
521 return NULL;
522 DIScope DS(Scope->getScopeNode());
523 DISubprogram InlinedSP = getDISubprogram(DS);
Eric Christophere595bae2013-10-04 17:08:38 +0000524 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
Devang Patelf098ce22011-07-27 00:34:13 +0000525 if (!OriginDIE) {
Bill Wendling10e0e2e2012-10-30 17:51:02 +0000526 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
Devang Patelf098ce22011-07-27 00:34:13 +0000527 return NULL;
528 }
529
Devang Patel73bc1722011-05-05 17:54:26 +0000530 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
Manman Ren4c4b69c2013-10-11 23:58:05 +0000531 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000532
Eric Christopherbe2513e2013-12-03 00:45:59 +0000533 // If we have multiple ranges, emit them into the range section.
534 if (ScopeRanges.size() > 1)
535 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
536 else {
Eric Christopher0f63d062013-12-03 00:45:45 +0000537 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
Eric Christopherf94eb2b2013-07-03 02:23:53 +0000538 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
539 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
540
541 if (StartLabel == 0 || EndLabel == 0)
542 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
543
544 assert(StartLabel->isDefined() &&
545 "Invalid starting label for an inlined scope!");
546 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
547
David Blaikie555e79a2014-03-07 22:00:56 +0000548 attachLowHighPC(TheCU, ScopeDIE, StartLabel, EndLabel);
Devang Patelf098ce22011-07-27 00:34:13 +0000549 }
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000550
551 InlinedSubprogramDIEs.insert(OriginDIE);
552
Eric Christopherf94eb2b2013-07-03 02:23:53 +0000553 // Add the call site information to the DIE.
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000554 DILocation DL(Scope->getInlinedAt());
David Blaikie0e8d4012014-03-17 23:53:25 +0000555 TheCU->addUInt(
556 ScopeDIE, dwarf::DW_AT_call_file, None,
557 TheCU->getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
David Blaikief2443192013-10-21 17:28:37 +0000558 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000559
Eric Christopher8dda5d02011-12-04 06:02:38 +0000560 // Add name to the name table, we do this here because we're guaranteed
561 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
562 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
Eric Christopher6a841382012-11-19 22:42:10 +0000563
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000564 return ScopeDIE;
565}
566
Eric Christopher4287a492013-12-09 23:57:44 +0000567DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
568 LexicalScope *Scope,
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000569 SmallVectorImpl<DIE *> &Children) {
570 DIE *ObjectPointer = NULL;
Devang Patel6c622ef2011-03-01 22:58:55 +0000571
572 // Collect arguments for current function.
Adrian Prantl3f49c892014-02-25 19:57:42 +0000573 if (LScopes.isCurrentFunctionScope(Scope)) {
Benjamin Kramer15596c72014-03-07 19:09:39 +0000574 for (DbgVariable *ArgDV : CurrentFnArguments)
575 if (ArgDV)
Eric Christopher6a841382012-11-19 22:42:10 +0000576 if (DIE *Arg =
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000577 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
Devang Patel6c622ef2011-03-01 22:58:55 +0000578 Children.push_back(Arg);
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000579 if (ArgDV->isObjectPointer())
580 ObjectPointer = Arg;
Eric Christophere3417762012-09-12 23:36:19 +0000581 }
Devang Patel6c622ef2011-03-01 22:58:55 +0000582
Adrian Prantl69140d22014-02-25 22:27:14 +0000583 // If this is a variadic function, add an unspecified parameter.
Adrian Prantl3f49c892014-02-25 19:57:42 +0000584 DISubprogram SP(Scope->getScopeNode());
Adrian Prantl3f49c892014-02-25 19:57:42 +0000585 DIArray FnArgs = SP.getType().getTypeArray();
Eric Christopher73ffdb82014-02-26 02:50:56 +0000586 if (FnArgs.getElement(FnArgs.getNumElements() - 1)
587 .isUnspecifiedParameter()) {
Adrian Prantl3f49c892014-02-25 19:57:42 +0000588 DIE *Ellipsis = new DIE(dwarf::DW_TAG_unspecified_parameters);
589 Children.push_back(Ellipsis);
590 }
591 }
592
Eric Christopherf84354b2011-10-03 15:49:16 +0000593 // Collect lexical scope children first.
Benjamin Kramer15596c72014-03-07 19:09:39 +0000594 for (DbgVariable *DV : ScopeVariables.lookup(Scope))
595 if (DIE *Variable = TheCU->constructVariableDIE(*DV,
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000596 Scope->isAbstractScope())) {
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000597 Children.push_back(Variable);
Benjamin Kramer15596c72014-03-07 19:09:39 +0000598 if (DV->isObjectPointer())
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000599 ObjectPointer = Variable;
Eric Christopherc1c8a1b2012-09-21 22:18:52 +0000600 }
Benjamin Kramer15596c72014-03-07 19:09:39 +0000601 for (LexicalScope *LS : Scope->getChildren())
602 if (DIE *Nested = constructScopeDIE(TheCU, LS))
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000603 Children.push_back(Nested);
Manman Ren2312ed32013-09-10 18:40:41 +0000604 return ObjectPointer;
605}
606
607// Construct a DIE for this scope.
Eric Christopher4287a492013-12-09 23:57:44 +0000608DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
609 LexicalScope *Scope) {
Manman Ren2312ed32013-09-10 18:40:41 +0000610 if (!Scope || !Scope->getScopeNode())
611 return NULL;
612
Adrian Prantl78619f72014-03-21 22:16:32 +0000613 DIScope DS(Scope->getScopeNode());
Manman Ren2312ed32013-09-10 18:40:41 +0000614
615 SmallVector<DIE *, 8> Children;
616 DIE *ObjectPointer = NULL;
617 bool ChildrenCreated = false;
618
Manman Ren5b2f4b02013-09-11 19:40:28 +0000619 // We try to create the scope DIE first, then the children DIEs. This will
620 // avoid creating un-used children then removing them later when we find out
621 // the scope DIE is null.
Devang Patel3b548aa2010-03-08 20:52:55 +0000622 DIE *ScopeDIE = NULL;
623 if (Scope->getInlinedAt())
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000624 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
Devang Patel3b548aa2010-03-08 20:52:55 +0000625 else if (DS.isSubprogram()) {
Devang Pateld10b2af2010-06-28 20:53:04 +0000626 ProcessedSPNodes.insert(DS);
Devang Patela37a95e2010-07-07 22:20:57 +0000627 if (Scope->isAbstractScope()) {
Eric Christophere595bae2013-10-04 17:08:38 +0000628 ScopeDIE = TheCU->getDIE(DS);
Devang Patela37a95e2010-07-07 22:20:57 +0000629 // Note down abstract DIE.
630 if (ScopeDIE)
631 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
David Blaikiee26a3772013-11-18 23:59:04 +0000632 } else
David Blaikie25bc7192013-11-15 23:13:08 +0000633 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
David Blaikiee26a3772013-11-18 23:59:04 +0000634 } else {
Manman Ren5b2f4b02013-09-11 19:40:28 +0000635 // Early exit when we know the scope DIE is going to be null.
Manman Ren2312ed32013-09-10 18:40:41 +0000636 if (isLexicalScopeDIENull(Scope))
637 return NULL;
Manman Ren5b2f4b02013-09-11 19:40:28 +0000638
639 // We create children here when we know the scope DIE is not going to be
640 // null and the children will be added to the scope DIE.
Manman Ren2312ed32013-09-10 18:40:41 +0000641 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
642 ChildrenCreated = true;
Manman Ren5b2f4b02013-09-11 19:40:28 +0000643
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000644 // There is no need to emit empty lexical block DIE.
David Blaikie684fc532013-05-06 23:33:07 +0000645 std::pair<ImportedEntityMap::const_iterator,
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000646 ImportedEntityMap::const_iterator> Range =
647 std::equal_range(
648 ScopesWithImportedEntities.begin(),
649 ScopesWithImportedEntities.end(),
650 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
651 less_first());
David Blaikie684fc532013-05-06 23:33:07 +0000652 if (Children.empty() && Range.first == Range.second)
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000653 return NULL;
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000654 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
Manman Ren2312ed32013-09-10 18:40:41 +0000655 assert(ScopeDIE && "Scope DIE should not be null.");
Eric Christopher5fdd68e2013-06-24 23:20:02 +0000656 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
657 ++i)
David Blaikie4dd2de72013-05-08 06:01:38 +0000658 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000659 }
Eric Christopher6a841382012-11-19 22:42:10 +0000660
Benjamin Kramer892daba2013-08-24 11:55:49 +0000661 if (!ScopeDIE) {
Manman Ren2312ed32013-09-10 18:40:41 +0000662 assert(Children.empty() &&
663 "We create children only when the scope DIE is not null.");
Benjamin Kramer892daba2013-08-24 11:55:49 +0000664 return NULL;
665 }
Manman Ren2312ed32013-09-10 18:40:41 +0000666 if (!ChildrenCreated)
Manman Ren5b2f4b02013-09-11 19:40:28 +0000667 // We create children when the scope DIE is not null.
Manman Ren2312ed32013-09-10 18:40:41 +0000668 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000669
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000670 // Add children
Benjamin Kramer15596c72014-03-07 19:09:39 +0000671 for (DIE *I : Children)
672 ScopeDIE->addChild(I);
Devang Patel04d2f2d2009-11-24 01:14:22 +0000673
Eric Christophere3417762012-09-12 23:36:19 +0000674 if (DS.isSubprogram() && ObjectPointer != NULL)
Manman Ren4c4b69c2013-10-11 23:58:05 +0000675 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
Eric Christophere3417762012-09-12 23:36:19 +0000676
Eric Christopherd9843b32011-11-10 19:25:34 +0000677 return ScopeDIE;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000678}
679
Eric Christophera5a79422013-12-09 23:32:48 +0000680void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
David Blaikie3c842622013-12-04 21:31:26 +0000681 if (!GenerateGnuPubSections)
682 return;
683
David Blaikie47c254b2014-03-06 05:47:39 +0000684 U->addFlag(D, dwarf::DW_AT_GNU_pubnames);
David Blaikie3c842622013-12-04 21:31:26 +0000685}
686
Eric Christopher4287a492013-12-09 23:57:44 +0000687// Create new DwarfCompileUnit for the given metadata node with tag
Eric Christopher48fef592012-12-20 21:58:40 +0000688// DW_TAG_compile_unit.
David Blaikie47f4b822014-03-19 00:11:28 +0000689DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
Devang Patel2d9caf92009-11-25 17:36:49 +0000690 StringRef FN = DIUnit.getFilename();
Nick Lewyckyd1ee7f82011-11-02 20:55:33 +0000691 CompilationDir = DIUnit.getDirectory();
Bill Wendling2b128d72009-05-20 23:19:06 +0000692
693 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Eric Christopher4287a492013-12-09 23:57:44 +0000694 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
695 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
David Blaikie2666e242013-12-06 19:38:46 +0000696 InfoHolder.addUnit(NewCU);
David Blaikie7ac51492014-03-20 17:05:45 +0000697
698 // LTO with assembly output shares a single line table amongst multiple CUs.
699 // To avoid the compilation directory being ambiguous, let the line table
700 // explicitly describe the directory of all files, never relying on the
701 // compilation directory.
David Blaikie47f4b822014-03-19 00:11:28 +0000702 if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
David Blaikiee05274d2014-03-18 00:11:48 +0000703 Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
704 NewCU->getUniqueID(), CompilationDir);
David Blaikie2666e242013-12-06 19:38:46 +0000705
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000706 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
Devang Patelf20c4f72011-04-12 22:53:02 +0000707 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
708 DIUnit.getLanguage());
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000709 NewCU->addString(Die, dwarf::DW_AT_name, FN);
Eric Christopher52ce7182013-04-09 19:23:15 +0000710
Eric Christopher52ce7182013-04-09 19:23:15 +0000711 if (!useSplitDwarf()) {
David Blaikie2494fdb2014-02-14 22:41:51 +0000712 NewCU->initStmtList(DwarfLineSectionSym);
Eric Christophera51d3fc2013-09-27 22:50:48 +0000713
714 // If we're using split dwarf the compilation dir is going to be in the
715 // skeleton CU and so we don't need to duplicate it here.
716 if (!CompilationDir.empty())
717 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
718
David Blaikie3c842622013-12-04 21:31:26 +0000719 addGnuPubAttributes(NewCU, Die);
Eric Christopher52ce7182013-04-09 19:23:15 +0000720 }
Bill Wendling2b128d72009-05-20 23:19:06 +0000721
Bill Wendling2b128d72009-05-20 23:19:06 +0000722 if (DIUnit.isOptimized())
Eric Christopherbb69a272012-08-24 01:14:27 +0000723 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
Bill Wendling2b128d72009-05-20 23:19:06 +0000724
Devang Patel2d9caf92009-11-25 17:36:49 +0000725 StringRef Flags = DIUnit.getFlags();
726 if (!Flags.empty())
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000727 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
Eric Christopher6a841382012-11-19 22:42:10 +0000728
Nick Lewycky479a8fe2011-10-17 23:27:36 +0000729 if (unsigned RVer = DIUnit.getRunTimeVersion())
Devang Patelf20c4f72011-04-12 22:53:02 +0000730 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000731 dwarf::DW_FORM_data1, RVer);
Bill Wendling2b128d72009-05-20 23:19:06 +0000732
Devang Patel1a0df9a2010-05-10 22:49:55 +0000733 if (!FirstCU)
734 FirstCU = NewCU;
Eric Christopher7a2cdf72013-02-05 07:31:55 +0000735
Eric Christopherd4368fd2014-01-02 21:03:28 +0000736 if (useSplitDwarf()) {
737 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
738 DwarfInfoDWOSectionSym);
Eric Christopherd8667202013-12-30 17:22:27 +0000739 NewCU->setSkeleton(constructSkeletonCU(NewCU));
Eric Christopherd4368fd2014-01-02 21:03:28 +0000740 } else
741 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
742 DwarfInfoSectionSym);
Eric Christopherd039baa2013-12-30 03:40:32 +0000743
David Blaikie5a152402013-11-15 23:52:02 +0000744 CUMap.insert(std::make_pair(DIUnit, NewCU));
Manman Rence20d462013-10-29 22:57:10 +0000745 CUDieMap.insert(std::make_pair(Die, NewCU));
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000746 return NewCU;
Devang Patel1a0df9a2010-05-10 22:49:55 +0000747}
748
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000749// Construct subprogram DIE.
Eric Christopher4287a492013-12-09 23:57:44 +0000750void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
751 const MDNode *N) {
Eric Christopherffbc4de2013-10-18 01:57:30 +0000752 // FIXME: We should only call this routine once, however, during LTO if a
753 // program is defined in multiple CUs we could end up calling it out of
754 // beginModule as we walk the CUs.
755
Eric Christopher4287a492013-12-09 23:57:44 +0000756 DwarfCompileUnit *&CURef = SPMap[N];
Eric Christopherffbc4de2013-10-18 01:57:30 +0000757 if (CURef)
758 return;
759 CURef = TheCU;
Rafael Espindola6cf4e832011-11-04 19:00:29 +0000760
Devang Patel80ae3492009-08-28 23:24:31 +0000761 DISubprogram SP(N);
Bill Wendling2b128d72009-05-20 23:19:06 +0000762 if (!SP.isDefinition())
763 // This is a method declaration which will be handled while constructing
764 // class type.
Devang Patel0751a282009-06-26 01:49:18 +0000765 return;
Bill Wendling2b128d72009-05-20 23:19:06 +0000766
Devang Patel89543712011-08-15 17:24:54 +0000767 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
Stuart Hastings4bd3dd92010-04-06 21:38:29 +0000768
Eric Christopherba506db2013-09-09 20:03:20 +0000769 // Expose as a global name.
Eric Christopher2c8b7902013-10-17 02:06:06 +0000770 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
Bill Wendling2b128d72009-05-20 23:19:06 +0000771}
772
Eric Christopher4287a492013-12-09 23:57:44 +0000773void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
David Blaikief55abea2013-04-22 06:12:31 +0000774 const MDNode *N) {
David Blaikie1fd43652013-05-07 21:35:53 +0000775 DIImportedEntity Module(N);
David Blaikie5e390e42014-02-04 01:23:52 +0000776 assert(Module.Verify());
David Blaikie684fc532013-05-06 23:33:07 +0000777 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
David Blaikie4dd2de72013-05-08 06:01:38 +0000778 constructImportedEntityDIE(TheCU, Module, D);
David Blaikie684fc532013-05-06 23:33:07 +0000779}
780
Eric Christopher4287a492013-12-09 23:57:44 +0000781void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
782 const MDNode *N, DIE *Context) {
David Blaikie1fd43652013-05-07 21:35:53 +0000783 DIImportedEntity Module(N);
David Blaikie5e390e42014-02-04 01:23:52 +0000784 assert(Module.Verify());
David Blaikie4dd2de72013-05-08 06:01:38 +0000785 return constructImportedEntityDIE(TheCU, Module, Context);
David Blaikie684fc532013-05-06 23:33:07 +0000786}
787
Eric Christopher4287a492013-12-09 23:57:44 +0000788void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
David Blaikie1fd43652013-05-07 21:35:53 +0000789 const DIImportedEntity &Module,
David Blaikie684fc532013-05-06 23:33:07 +0000790 DIE *Context) {
791 assert(Module.Verify() &&
792 "Use one of the MDNode * overloads to handle invalid metadata");
793 assert(Context && "Should always have a context for an imported_module");
David Blaikie1fd43652013-05-07 21:35:53 +0000794 DIE *IMDie = new DIE(Module.getTag());
David Blaikief55abea2013-04-22 06:12:31 +0000795 TheCU->insertDIE(Module, IMDie);
David Blaikie1fd43652013-05-07 21:35:53 +0000796 DIE *EntityDie;
797 DIDescriptor Entity = Module.getEntity();
798 if (Entity.isNameSpace())
799 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
800 else if (Entity.isSubprogram())
801 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
David Blaikie3b6038b2013-05-08 06:01:41 +0000802 else if (Entity.isType())
803 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
David Blaikie1fd43652013-05-07 21:35:53 +0000804 else
David Blaikie3b6038b2013-05-08 06:01:41 +0000805 EntityDie = TheCU->getDIE(Entity);
David Blaikie7066f7b2014-03-12 16:51:06 +0000806 TheCU->addSourceLine(IMDie, Module.getLineNumber(),
807 Module.getContext().getFilename(),
808 Module.getContext().getDirectory());
Manman Ren4c4b69c2013-10-11 23:58:05 +0000809 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
David Blaikiee63d5d12013-05-20 22:50:35 +0000810 StringRef Name = Module.getName();
811 if (!Name.empty())
812 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
David Blaikie684fc532013-05-06 23:33:07 +0000813 Context->addChild(IMDie);
David Blaikief55abea2013-04-22 06:12:31 +0000814}
815
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000816// Emit all Dwarf sections that should come prior to the content. Create
817// global DIEs and emit initial debug info sections. This is invoked by
818// the target AsmPrinter.
Eric Christopher58f41952012-11-19 22:42:15 +0000819void DwarfDebug::beginModule() {
Devang Patel6c74a872010-04-27 19:46:33 +0000820 if (DisableDebugInfoPrinting)
821 return;
822
Eric Christopher58f41952012-11-19 22:42:15 +0000823 const Module *M = MMI->getModule();
824
Nick Lewycky019d2552011-07-29 03:49:23 +0000825 // If module has named metadata anchors then use them, otherwise scan the
826 // module using debug info finder to collect debug info.
Devang Patele02e5852011-05-03 16:45:22 +0000827 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
David Blaikiedc69ebb2013-03-11 23:39:23 +0000828 if (!CU_Nodes)
Devang Patel07bb9ee2011-08-15 23:47:24 +0000829 return;
Manman Ren60352032013-09-05 18:48:31 +0000830 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
Devang Patele02e5852011-05-03 16:45:22 +0000831
David Blaikiedc69ebb2013-03-11 23:39:23 +0000832 // Emit initial sections so we can reference labels later.
833 emitSectionLabels();
834
David Blaikie47f4b822014-03-19 00:11:28 +0000835 SingleCU = CU_Nodes->getNumOperands() == 1;
David Blaikiee05274d2014-03-18 00:11:48 +0000836
David Blaikie47f4b822014-03-19 00:11:28 +0000837 for (MDNode *N : CU_Nodes->operands()) {
Benjamin Kramer15596c72014-03-07 19:09:39 +0000838 DICompileUnit CUNode(N);
David Blaikie47f4b822014-03-19 00:11:28 +0000839 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
David Blaikie1fd43652013-05-07 21:35:53 +0000840 DIArray ImportedEntities = CUNode.getImportedEntities();
841 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
David Blaikie684fc532013-05-06 23:33:07 +0000842 ScopesWithImportedEntities.push_back(std::make_pair(
David Blaikie1fd43652013-05-07 21:35:53 +0000843 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
844 ImportedEntities.getElement(i)));
David Blaikie684fc532013-05-06 23:33:07 +0000845 std::sort(ScopesWithImportedEntities.begin(),
Benjamin Kramerb12cf012013-08-24 12:54:27 +0000846 ScopesWithImportedEntities.end(), less_first());
David Blaikiedc69ebb2013-03-11 23:39:23 +0000847 DIArray GVs = CUNode.getGlobalVariables();
848 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
David Blaikiea781b25b2013-11-17 21:55:13 +0000849 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
David Blaikiedc69ebb2013-03-11 23:39:23 +0000850 DIArray SPs = CUNode.getSubprograms();
851 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
852 constructSubprogramDIE(CU, SPs.getElement(i));
853 DIArray EnumTypes = CUNode.getEnumTypes();
854 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
855 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
856 DIArray RetainedTypes = CUNode.getRetainedTypes();
Adrian Prantl0aa1aa22014-03-18 02:35:03 +0000857 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
858 DIType Ty(RetainedTypes.getElement(i));
859 // The retained types array by design contains pointers to
860 // MDNodes rather than DIRefs. Unique them here.
861 DIType UniqueTy(resolve(Ty.getRef()));
862 CU->getOrCreateTypeDIE(UniqueTy);
863 }
David Blaikief55abea2013-04-22 06:12:31 +0000864 // Emit imported_modules last so that the relevant context is already
865 // available.
David Blaikie1fd43652013-05-07 21:35:53 +0000866 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
867 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
David Blaikiedc69ebb2013-03-11 23:39:23 +0000868 }
Eric Christopher6a841382012-11-19 22:42:10 +0000869
Chris Lattner7cfa70e2010-04-05 02:19:28 +0000870 // Tell MMI that we have debug info.
871 MMI->setDebugInfoAvailability(true);
Eric Christopher6a841382012-11-19 22:42:10 +0000872
Bill Wendling2b128d72009-05-20 23:19:06 +0000873 // Prime section data.
Richard Mitton21101b32013-09-19 23:21:01 +0000874 SectionMap[Asm->getObjFileLowering().getTextSection()];
Bill Wendling2b128d72009-05-20 23:19:06 +0000875}
876
Eric Christopher960ac372012-11-22 00:59:49 +0000877// Attach DW_AT_inline attribute with inlined subprogram DIEs.
878void DwarfDebug::computeInlinedDIEs() {
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000879 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
Benjamin Kramer15596c72014-03-07 19:09:39 +0000880 for (DIE *ISP : InlinedSubprogramDIEs)
David Blaikief2443192013-10-21 17:28:37 +0000881 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
Benjamin Kramer15596c72014-03-07 19:09:39 +0000882
883 for (const auto &AI : AbstractSPDies) {
884 DIE *ISP = AI.second;
Rafael Espindolae7cc8bf2011-11-12 01:57:54 +0000885 if (InlinedSubprogramDIEs.count(ISP))
886 continue;
David Blaikief2443192013-10-21 17:28:37 +0000887 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
Rafael Espindolae7cc8bf2011-11-12 01:57:54 +0000888 }
Eric Christopher960ac372012-11-22 00:59:49 +0000889}
890
891// Collect info for variables that were optimized out.
892void DwarfDebug::collectDeadVariables() {
893 const Module *M = MMI->getModule();
Eric Christopher960ac372012-11-22 00:59:49 +0000894
895 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
Benjamin Kramer15596c72014-03-07 19:09:39 +0000896 for (MDNode *N : CU_Nodes->operands()) {
897 DICompileUnit TheCU(N);
Eric Christopher960ac372012-11-22 00:59:49 +0000898 DIArray Subprograms = TheCU.getSubprograms();
899 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
Eric Christopher735401c2012-11-27 00:13:51 +0000900 DISubprogram SP(Subprograms.getElement(i));
Eric Christophera6c38a32013-10-15 23:31:38 +0000901 if (ProcessedSPNodes.count(SP) != 0)
902 continue;
903 if (!SP.isSubprogram())
904 continue;
905 if (!SP.isDefinition())
906 continue;
Eric Christopher735401c2012-11-27 00:13:51 +0000907 DIArray Variables = SP.getVariables();
Eric Christophera6c38a32013-10-15 23:31:38 +0000908 if (Variables.getNumElements() == 0)
909 continue;
Eric Christopher960ac372012-11-22 00:59:49 +0000910
Eric Christopher735401c2012-11-27 00:13:51 +0000911 // Construct subprogram DIE and add variables DIEs.
Eric Christopher4287a492013-12-09 23:57:44 +0000912 DwarfCompileUnit *SPCU =
913 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
Eric Christopher735401c2012-11-27 00:13:51 +0000914 assert(SPCU && "Unable to find Compile Unit!");
Eric Christopherc798d8a2013-10-22 00:22:39 +0000915 // FIXME: See the comment in constructSubprogramDIE about duplicate
916 // subprogram DIEs.
917 constructSubprogramDIE(SPCU, SP);
918 DIE *SPDIE = SPCU->getDIE(SP);
Eric Christopher735401c2012-11-27 00:13:51 +0000919 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
920 DIVariable DV(Variables.getElement(vi));
Eric Christophera6c38a32013-10-15 23:31:38 +0000921 if (!DV.isVariable())
922 continue;
Manman Renb3388602013-10-05 01:43:03 +0000923 DbgVariable NewVar(DV, NULL, this);
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000924 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
Eric Christophera6c38a32013-10-15 23:31:38 +0000925 SPDIE->addChild(VariableDIE);
Eric Christopher735401c2012-11-27 00:13:51 +0000926 }
Eric Christopher960ac372012-11-22 00:59:49 +0000927 }
928 }
929 }
Eric Christopher960ac372012-11-22 00:59:49 +0000930}
931
932void DwarfDebug::finalizeModuleInfo() {
933 // Collect info for variables that were optimized out.
934 collectDeadVariables();
935
936 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
937 computeInlinedDIEs();
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000938
Eric Christopherad10cb52013-12-04 23:24:38 +0000939 // Handle anything that needs to be done on a per-unit basis after
940 // all other generation.
Benjamin Kramer15596c72014-03-07 19:09:39 +0000941 for (DwarfUnit *TheU : getUnits()) {
Eric Christopher60eb7692013-08-12 20:27:48 +0000942 // Emit DW_AT_containing_type attribute to connect types with their
943 // vtable holding type.
David Blaikie2a80e442013-12-02 22:09:48 +0000944 TheU->constructContainingTypeDIEs();
Eric Christopher60eb7692013-08-12 20:27:48 +0000945
Eric Christopher46e23432013-12-20 04:16:18 +0000946 // Add CU specific attributes if we need to add any.
947 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
948 // If we're splitting the dwarf out now that we've got the entire
Eric Christopherd8667202013-12-30 17:22:27 +0000949 // CU then add the dwo id to it.
950 DwarfCompileUnit *SkCU =
951 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
Eric Christopher46e23432013-12-20 04:16:18 +0000952 if (useSplitDwarf()) {
Eric Christopher09d1c0f2014-03-14 21:20:07 +0000953 // Emit a unique identifier for this CU.
954 uint64_t ID = DIEHash(Asm).computeCUSignature(*TheU->getUnitDie());
Eric Christopher46e23432013-12-20 04:16:18 +0000955 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
956 dwarf::DW_FORM_data8, ID);
Eric Christopher46e23432013-12-20 04:16:18 +0000957 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
958 dwarf::DW_FORM_data8, ID);
David Blaikie3ffe4dd2014-03-25 05:34:24 +0000959
960 // We don't keep track of which addresses are used in which CU so this
961 // is a bit pessimistic under LTO.
962 if (!InfoHolder.getAddrPool()->empty())
963 addSectionLabel(Asm, SkCU, SkCU->getUnitDie(),
964 dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
965 DwarfAddrSectionSym);
966 if (!TheU->getRangeLists().empty())
967 addSectionLabel(Asm, SkCU, SkCU->getUnitDie(),
968 dwarf::DW_AT_GNU_ranges_base,
969 DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
Eric Christopherd29614f2013-08-13 01:21:55 +0000970 }
Eric Christopherd8667202013-12-30 17:22:27 +0000971
Eric Christopher384f3fe2014-03-20 19:16:16 +0000972 // If we have code split among multiple sections or non-contiguous
973 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
974 // remain in the .o file, otherwise add a DW_AT_low_pc.
975 // FIXME: We should use ranges allow reordering of code ala
976 // .subsections_via_symbols in mach-o. This would mean turning on
977 // ranges for all subprogram DIEs for mach-o.
Eric Christopherd8667202013-12-30 17:22:27 +0000978 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
Eric Christopher384f3fe2014-03-20 19:16:16 +0000979 unsigned NumRanges = TheU->getRanges().size();
980 if (NumRanges) {
981 if (NumRanges > 1) {
982 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
983 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
984 DwarfDebugRangeSectionSym);
Eric Christopher8873ada2014-01-29 22:22:56 +0000985
Eric Christopher384f3fe2014-03-20 19:16:16 +0000986 // A DW_AT_low_pc attribute may also be specified in combination with
987 // DW_AT_ranges to specify the default base address for use in
988 // location lists (see Section 2.6.2) and range lists (see Section
989 // 2.17.3).
990 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
991 0);
992 } else {
993 RangeSpan &Range = TheU->getRanges().back();
994 U->addLocalLabelAddress(U->getUnitDie(), dwarf::DW_AT_low_pc,
995 Range.getStart());
996 U->addLabelDelta(U->getUnitDie(), dwarf::DW_AT_high_pc,
997 Range.getEnd(), Range.getStart());
998 }
999 }
Eric Christopher60eb7692013-08-12 20:27:48 +00001000 }
1001 }
1002
1003 // Compute DIE offsets and sizes.
Eric Christopherc8a310e2012-12-10 23:34:43 +00001004 InfoHolder.computeSizeAndOffsets();
1005 if (useSplitDwarf())
1006 SkeletonHolder.computeSizeAndOffsets();
Eric Christopher960ac372012-11-22 00:59:49 +00001007}
1008
1009void DwarfDebug::endSections() {
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001010 // Filter labels by section.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001011 for (const SymbolCU &SCU : ArangeLabels) {
Richard Mitton21101b32013-09-19 23:21:01 +00001012 if (SCU.Sym->isInSection()) {
1013 // Make a note of this symbol and it's section.
1014 const MCSection *Section = &SCU.Sym->getSection();
1015 if (!Section->getKind().isMetadata())
1016 SectionMap[Section].push_back(SCU);
1017 } else {
1018 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1019 // appear in the output. This sucks as we rely on sections to build
1020 // arange spans. We can do it without, but it's icky.
1021 SectionMap[NULL].push_back(SCU);
1022 }
1023 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001024
Richard Mittonc2508242013-10-03 22:07:08 +00001025 // Build a list of sections used.
1026 std::vector<const MCSection *> Sections;
Benjamin Kramer15596c72014-03-07 19:09:39 +00001027 for (const auto &it : SectionMap) {
1028 const MCSection *Section = it.first;
Richard Mittonc2508242013-10-03 22:07:08 +00001029 Sections.push_back(Section);
1030 }
1031
1032 // Sort the sections into order.
1033 // This is only done to ensure consistent output order across different runs.
1034 std::sort(Sections.begin(), Sections.end(), SectionSort);
1035
1036 // Add terminating symbols for each section.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001037 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
Richard Mittonc2508242013-10-03 22:07:08 +00001038 const MCSection *Section = Sections[ID];
Richard Mitton21101b32013-09-19 23:21:01 +00001039 MCSymbol *Sym = NULL;
1040
1041 if (Section) {
Richard Mittonc2508242013-10-03 22:07:08 +00001042 // We can't call MCSection::getLabelEndName, as it's only safe to do so
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001043 // if we know the section name up-front. For user-created sections, the
Eric Christopher95531b62014-01-29 22:06:21 +00001044 // resulting label may not be valid to use as a label. (section names can
1045 // use a greater set of characters on some systems)
Richard Mittonc2508242013-10-03 22:07:08 +00001046 Sym = Asm->GetTempSymbol("debug_end", ID);
Richard Mitton21101b32013-09-19 23:21:01 +00001047 Asm->OutStreamer.SwitchSection(Section);
1048 Asm->OutStreamer.EmitLabel(Sym);
1049 }
1050
1051 // Insert a final terminator.
Alexey Samsonov4436bf02013-10-03 08:54:43 +00001052 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
Bill Wendling2b128d72009-05-20 23:19:06 +00001053 }
Eric Christopher960ac372012-11-22 00:59:49 +00001054}
Bill Wendling2b128d72009-05-20 23:19:06 +00001055
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001056// Emit all Dwarf sections that should come after the content.
Eric Christopher960ac372012-11-22 00:59:49 +00001057void DwarfDebug::endModule() {
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001058 assert(CurFn == 0);
1059 assert(CurMI == 0);
Eric Christopher960ac372012-11-22 00:59:49 +00001060
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001061 if (!FirstCU)
1062 return;
Eric Christopher960ac372012-11-22 00:59:49 +00001063
1064 // End any existing sections.
1065 // TODO: Does this need to happen?
1066 endSections();
1067
1068 // Finalize the debug info for the module.
1069 finalizeModuleInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +00001070
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001071 emitDebugStr();
Eric Christopher9cd26af2013-09-20 23:22:52 +00001072
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001073 // Emit all the DIEs into a debug info section.
1074 emitDebugInfo();
Eric Christopher4c9b1192012-11-27 00:41:54 +00001075
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001076 // Corresponding abbreviations into a abbrev section.
1077 emitAbbreviations();
Eric Christopher95198f502012-11-27 22:43:42 +00001078
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001079 // Emit info into a debug loc section.
1080 emitDebugLoc();
Eric Christopher95198f502012-11-27 22:43:42 +00001081
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001082 // Emit info into a debug aranges section.
Eric Christopher02dbadb2014-02-14 01:26:55 +00001083 if (GenerateARangeSection)
1084 emitDebugARanges();
Eric Christopher95198f502012-11-27 22:43:42 +00001085
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001086 // Emit info into a debug ranges section.
1087 emitDebugRanges();
Eric Christopher95198f502012-11-27 22:43:42 +00001088
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001089 if (useSplitDwarf()) {
1090 emitDebugStrDWO();
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001091 emitDebugInfoDWO();
Eric Christopher3c5a1912012-12-19 22:02:53 +00001092 emitDebugAbbrevDWO();
David Blaikie4a2f95f2014-03-18 01:17:26 +00001093 emitDebugLineDWO();
Eric Christopher962c9082013-01-15 23:56:56 +00001094 // Emit DWO addresses.
1095 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
Eric Christopher95198f502012-11-27 22:43:42 +00001096 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001097
Eric Christophera876b822012-08-23 07:32:06 +00001098 // Emit info into the dwarf accelerator table sections.
Eric Christopher20b76a72012-08-23 22:36:40 +00001099 if (useDwarfAccelTables()) {
Eric Christopher4996c702011-11-07 09:24:32 +00001100 emitAccelNames();
1101 emitAccelObjC();
1102 emitAccelNamespaces();
1103 emitAccelTypes();
1104 }
Eric Christopher6a841382012-11-19 22:42:10 +00001105
Eric Christopher4b358182013-08-30 00:40:17 +00001106 // Emit the pubnames and pubtypes sections if requested.
1107 if (HasDwarfPubSections) {
David Blaikie70a33202013-09-19 17:33:35 +00001108 emitDebugPubNames(GenerateGnuPubSections);
1109 emitDebugPubTypes(GenerateGnuPubSections);
Eric Christopher4b358182013-08-30 00:40:17 +00001110 }
Devang Patel04d2f2d2009-11-24 01:14:22 +00001111
Devang Pateld0701282010-08-02 17:32:15 +00001112 // clean up.
Devang Pateleb1bb4e2011-08-16 22:09:43 +00001113 SPMap.clear();
Eric Christopher8afd7b62012-12-10 19:51:18 +00001114
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001115 // Reset these for the next Module if we have one.
1116 FirstCU = NULL;
Bill Wendling2b128d72009-05-20 23:19:06 +00001117}
1118
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001119// Find abstract variable, if any, associated with Var.
Devang Patelbb23a4a2011-08-10 21:50:54 +00001120DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
Chris Lattner915c5f92010-04-02 19:42:39 +00001121 DebugLoc ScopeLoc) {
Devang Patelbb23a4a2011-08-10 21:50:54 +00001122 LLVMContext &Ctx = DV->getContext();
1123 // More then one inlined variable corresponds to one abstract variable.
1124 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001125 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001126 if (AbsDbgVariable)
1127 return AbsDbgVariable;
1128
Devang Patel7e623022011-08-10 20:55:27 +00001129 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001130 if (!Scope)
1131 return NULL;
1132
Manman Renb3388602013-10-05 01:43:03 +00001133 AbsDbgVariable = new DbgVariable(Var, NULL, this);
Devang Patel7e623022011-08-10 20:55:27 +00001134 addScopeVariable(Scope, AbsDbgVariable);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001135 AbstractVariables[Var] = AbsDbgVariable;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001136 return AbsDbgVariable;
1137}
1138
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001139// If Var is a current function argument then add it to CurrentFnArguments list.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001140bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
Devang Patel7e623022011-08-10 20:55:27 +00001141 if (!LScopes.isCurrentFunctionScope(Scope))
Devang Patel6c622ef2011-03-01 22:58:55 +00001142 return false;
1143 DIVariable DV = Var->getVariable();
1144 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1145 return false;
1146 unsigned ArgNo = DV.getArgNumber();
Eric Christopher6a841382012-11-19 22:42:10 +00001147 if (ArgNo == 0)
Devang Patel6c622ef2011-03-01 22:58:55 +00001148 return false;
1149
Devang Patel4ab660b2011-03-03 20:02:02 +00001150 size_t Size = CurrentFnArguments.size();
1151 if (Size == 0)
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001152 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
Devang Patel63b3e762011-03-03 21:49:41 +00001153 // llvm::Function argument size is not good indicator of how many
Devang Patel34a7ab42011-03-03 20:08:10 +00001154 // arguments does the function have at source level.
1155 if (ArgNo > Size)
Devang Patel4ab660b2011-03-03 20:02:02 +00001156 CurrentFnArguments.resize(ArgNo * 2);
Devang Patel6c622ef2011-03-01 22:58:55 +00001157 CurrentFnArguments[ArgNo - 1] = Var;
1158 return true;
1159}
1160
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001161// Collect variable information from side table maintained by MMI.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001162void DwarfDebug::collectVariableInfoFromMMITable(
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001163 SmallPtrSet<const MDNode *, 16> &Processed) {
Benjamin Kramer15596c72014-03-07 19:09:39 +00001164 for (const auto &VI : MMI->getVariableDbgInfo()) {
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +00001165 if (!VI.Var)
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001166 continue;
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +00001167 Processed.insert(VI.Var);
1168 DIVariable DV(VI.Var);
1169 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001170
Devang Patelcdb7d442009-11-10 23:20:04 +00001171 // If variable scope is not found then skip this variable.
Chris Lattner915c5f92010-04-02 19:42:39 +00001172 if (Scope == 0)
Devang Patelcdb7d442009-11-10 23:20:04 +00001173 continue;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001174
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +00001175 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VI.Loc);
Manman Renb3388602013-10-05 01:43:03 +00001176 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +00001177 RegVar->setFrameIndex(VI.Slot);
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001178 if (!addCurrentFnArgument(RegVar, Scope))
Devang Patel7e623022011-08-10 20:55:27 +00001179 addScopeVariable(Scope, RegVar);
Devang Patel99819b52011-08-15 19:01:20 +00001180 if (AbsDbgVariable)
Benjamin Kramer2abfd6c72014-03-09 15:44:39 +00001181 AbsDbgVariable->setFrameIndex(VI.Slot);
Devang Patel475d32a2009-10-06 01:26:37 +00001182 }
Devang Patel490c8ab2010-05-20 19:57:06 +00001183}
Devang Patela3e9c9c2010-03-15 18:33:46 +00001184
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001185// Return true if debug value, encoded by DBG_VALUE instruction, is in a
1186// defined reg.
Devang Patel9fc11702010-05-25 23:40:22 +00001187static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
Nick Lewycky654f5ce2011-10-26 22:55:33 +00001188 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001189 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1190 MI->getOperand(0).getReg() &&
Adrian Prantl418d1d12013-07-09 20:28:37 +00001191 (MI->getOperand(1).isImm() ||
1192 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
Devang Patel9fc11702010-05-25 23:40:22 +00001193}
1194
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001195// Get .debug_loc entry for the instruction range starting at MI.
Eric Christopher05135fb2014-03-18 02:18:24 +00001196static DebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
Eric Christopher384f3fe2014-03-20 19:16:16 +00001197 const MCSymbol *FLabel,
1198 const MCSymbol *SLabel,
1199 const MachineInstr *MI,
1200 DwarfCompileUnit *Unit) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001201 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
Devang Patel2442a892011-07-08 17:09:57 +00001202
David Blaikie0252265b2013-06-16 20:34:15 +00001203 assert(MI->getNumOperands() == 3);
Adrian Prantl418d1d12013-07-09 20:28:37 +00001204 if (MI->getOperand(0).isReg()) {
Devang Patel2442a892011-07-08 17:09:57 +00001205 MachineLocation MLoc;
Adrian Prantl418d1d12013-07-09 20:28:37 +00001206 // If the second operand is an immediate, this is a
1207 // register-indirect address.
1208 if (!MI->getOperand(1).isImm())
Adrian Prantld4c0dd42013-04-26 21:57:17 +00001209 MLoc.set(MI->getOperand(0).getReg());
1210 else
1211 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
Eric Christopher384f3fe2014-03-20 19:16:16 +00001212 return DebugLocEntry(FLabel, SLabel, MLoc, Var, Unit);
Devang Patel2442a892011-07-08 17:09:57 +00001213 }
1214 if (MI->getOperand(0).isImm())
Eric Christopher384f3fe2014-03-20 19:16:16 +00001215 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm(), Unit);
Devang Patel2442a892011-07-08 17:09:57 +00001216 if (MI->getOperand(0).isFPImm())
Eric Christopher384f3fe2014-03-20 19:16:16 +00001217 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm(), Unit);
Devang Patel2442a892011-07-08 17:09:57 +00001218 if (MI->getOperand(0).isCImm())
Eric Christopher384f3fe2014-03-20 19:16:16 +00001219 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm(), Unit);
Devang Patel2442a892011-07-08 17:09:57 +00001220
Craig Topperee4dab52012-02-05 08:31:47 +00001221 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
Devang Patel2442a892011-07-08 17:09:57 +00001222}
1223
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001224// Find variables for each lexical scope.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001225void
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001226DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001227
Eric Christopher270a12c2013-07-03 21:37:03 +00001228 // Grab the variable info that was squirreled away in the MMI side-table.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001229 collectVariableInfoFromMMITable(Processed);
Devang Patel490c8ab2010-05-20 19:57:06 +00001230
Benjamin Kramer15596c72014-03-07 19:09:39 +00001231 for (const MDNode *Var : UserVariables) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001232 if (Processed.count(Var))
Devang Patel490c8ab2010-05-20 19:57:06 +00001233 continue;
1234
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001235 // History contains relevant DBG_VALUE instructions for Var and instructions
1236 // clobbering it.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001237 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001238 if (History.empty())
1239 continue;
1240 const MachineInstr *MInsn = History.front();
Devang Patel9fc11702010-05-25 23:40:22 +00001241
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001242 DIVariable DV(Var);
Devang Patel7e623022011-08-10 20:55:27 +00001243 LexicalScope *Scope = NULL;
Devang Patel7a9dedf2010-05-27 20:25:04 +00001244 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001245 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
Devang Patel7e623022011-08-10 20:55:27 +00001246 Scope = LScopes.getCurrentFunctionScope();
David Blaikiedc69ebb2013-03-11 23:39:23 +00001247 else if (MDNode *IA = DV.getInlinedAt())
1248 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1249 else
1250 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
Devang Patel490c8ab2010-05-20 19:57:06 +00001251 // If variable scope is not found then skip this variable.
Devang Patelfbd6c452010-05-21 00:10:20 +00001252 if (!Scope)
Devang Patel490c8ab2010-05-20 19:57:06 +00001253 continue;
1254
1255 Processed.insert(DV);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001256 assert(MInsn->isDebugValue() && "History must begin with debug value");
Devang Patel99819b52011-08-15 19:01:20 +00001257 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
Manman Renb3388602013-10-05 01:43:03 +00001258 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001259 if (!addCurrentFnArgument(RegVar, Scope))
Devang Patel7e623022011-08-10 20:55:27 +00001260 addScopeVariable(Scope, RegVar);
Devang Patel99819b52011-08-15 19:01:20 +00001261 if (AbsVar)
Devang Patel3e4a9652011-08-15 21:24:36 +00001262 AbsVar->setMInsn(MInsn);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001263
Eric Christophercc10d202012-10-08 20:48:54 +00001264 // Simplify ranges that are fully coalesced.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001265 if (History.size() <= 1 ||
1266 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
Devang Patel3e4a9652011-08-15 21:24:36 +00001267 RegVar->setMInsn(MInsn);
Devang Patel9fc11702010-05-25 23:40:22 +00001268 continue;
1269 }
1270
Eric Christopher59cc0712013-01-28 17:33:26 +00001271 // Handle multiple DBG_VALUE instructions describing one variable.
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001272 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001273
David Blaikie84d8e182014-03-24 22:38:38 +00001274 SmallVector<DebugLocEntry, 4> DebugLoc;
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001275 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1276 HI = History.begin(),
1277 HE = History.end();
1278 HI != HE; ++HI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001279 const MachineInstr *Begin = *HI;
1280 assert(Begin->isDebugValue() && "Invalid History entry");
Jakob Stoklund Olesen9c057ee2011-03-22 00:21:41 +00001281
Devang Patele7181b52011-06-01 23:00:17 +00001282 // Check if DBG_VALUE is truncating a range.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001283 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1284 !Begin->getOperand(0).getReg())
Devang Patele7181b52011-06-01 23:00:17 +00001285 continue;
1286
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001287 // Compute the range for a register location.
1288 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1289 const MCSymbol *SLabel = 0;
1290
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001291 if (HI + 1 == HE)
1292 // If Begin is the last instruction in History then its value is valid
Chris Lattner0ab5e2c2011-04-15 05:18:47 +00001293 // until the end of the function.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001294 SLabel = FunctionEndSym;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001295 else {
1296 const MachineInstr *End = HI[1];
Eric Christopher6a841382012-11-19 22:42:10 +00001297 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001298 << "\t" << *Begin << "\t" << *End << "\n");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001299 if (End->isDebugValue())
1300 SLabel = getLabelBeforeInsn(End);
1301 else {
1302 // End is a normal instruction clobbering the range.
1303 SLabel = getLabelAfterInsn(End);
1304 assert(SLabel && "Forgot label after clobber instruction");
1305 ++HI;
1306 }
1307 }
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001308
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001309 // The value is valid until the next DBG_VALUE or clobber.
Eric Christopher384f3fe2014-03-20 19:16:16 +00001310 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1311 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
David Blaikie34ec5d02014-03-24 22:27:06 +00001312 DebugLocEntry Loc = getDebugLocEntry(Asm, FLabel, SLabel, Begin, TheCU);
David Blaikie84d8e182014-03-24 22:38:38 +00001313 if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1314 DebugLoc.push_back(std::move(Loc));
Devang Patel9fc11702010-05-25 23:40:22 +00001315 }
David Blaikie84d8e182014-03-24 22:38:38 +00001316 DotDebugLocEntries.push_back(std::move(DebugLoc));
Devang Patela3e9c9c2010-03-15 18:33:46 +00001317 }
Devang Patele0a94bf2010-05-14 21:01:35 +00001318
1319 // Collect info for variables that were optimized out.
Devang Patel59e27c52011-08-19 23:28:12 +00001320 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1321 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1322 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1323 DIVariable DV(Variables.getElement(i));
Manman Ren7504ed42013-07-08 18:33:29 +00001324 if (!DV || !DV.isVariable() || !Processed.insert(DV))
Devang Patel59e27c52011-08-19 23:28:12 +00001325 continue;
1326 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
Manman Renb3388602013-10-05 01:43:03 +00001327 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
Devang Patele0a94bf2010-05-14 21:01:35 +00001328 }
Devang Patel9fc11702010-05-25 23:40:22 +00001329}
Devang Patele0a94bf2010-05-14 21:01:35 +00001330
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001331// Return Label preceding the instruction.
Eric Christopher962c9082013-01-15 23:56:56 +00001332MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001333 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1334 assert(Label && "Didn't insert label before instruction");
1335 return Label;
Devang Patel9fc11702010-05-25 23:40:22 +00001336}
1337
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001338// Return Label immediately following the instruction.
Eric Christopher962c9082013-01-15 23:56:56 +00001339MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001340 return LabelsAfterInsn.lookup(MI);
Devang Patel475d32a2009-10-06 01:26:37 +00001341}
1342
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001343// Process beginning of an instruction.
Devang Patelb5694e72010-10-26 17:49:02 +00001344void DwarfDebug::beginInstruction(const MachineInstr *MI) {
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001345 assert(CurMI == 0);
1346 CurMI = MI;
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001347 // Check if source location changes, but ignore DBG_VALUE locations.
1348 if (!MI->isDebugValue()) {
1349 DebugLoc DL = MI->getDebugLoc();
1350 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
Eric Christopheraec8a822012-04-05 20:39:05 +00001351 unsigned Flags = 0;
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001352 PrevInstLoc = DL;
Devang Patel34a66202011-05-11 19:22:19 +00001353 if (DL == PrologEndLoc) {
1354 Flags |= DWARF2_FLAG_PROLOGUE_END;
1355 PrologEndLoc = DebugLoc();
1356 }
Eric Christopheraec8a822012-04-05 20:39:05 +00001357 if (PrologEndLoc.isUnknown())
1358 Flags |= DWARF2_FLAG_IS_STMT;
1359
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001360 if (!DL.isUnknown()) {
1361 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
Devang Patel34a66202011-05-11 19:22:19 +00001362 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001363 } else
Devang Patel34a66202011-05-11 19:22:19 +00001364 recordSourceLine(0, 0, 0, 0);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001365 }
Devang Patel9fc11702010-05-25 23:40:22 +00001366 }
Devang Patel23b2ae62010-03-29 22:59:58 +00001367
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001368 // Insert labels where requested.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001369 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1370 LabelsBeforeInsn.find(MI);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001371
1372 // No label needed.
1373 if (I == LabelsBeforeInsn.end())
1374 return;
1375
1376 // Label already assigned.
1377 if (I->second)
Devang Patel002d54d2010-05-26 19:37:24 +00001378 return;
Devang Patelbd477be2010-03-29 17:20:31 +00001379
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001380 if (!PrevLabel) {
Devang Patelacc32a52010-05-26 21:23:46 +00001381 PrevLabel = MMI->getContext().CreateTempSymbol();
1382 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel002d54d2010-05-26 19:37:24 +00001383 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001384 I->second = PrevLabel;
Devang Patel8db360d2009-10-06 01:50:42 +00001385}
1386
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001387// Process end of an instruction.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001388void DwarfDebug::endInstruction() {
1389 assert(CurMI != 0);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001390 // Don't create a new label after DBG_VALUE instructions.
1391 // They don't generate code.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001392 if (!CurMI->isDebugValue())
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001393 PrevLabel = 0;
1394
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001395 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001396 LabelsAfterInsn.find(CurMI);
1397 CurMI = 0;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001398
1399 // No label needed.
1400 if (I == LabelsAfterInsn.end())
1401 return;
1402
1403 // Label already assigned.
1404 if (I->second)
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001405 return;
1406
1407 // We need a label after this instruction.
1408 if (!PrevLabel) {
1409 PrevLabel = MMI->getContext().CreateTempSymbol();
1410 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel3ebd8932010-04-08 16:50:29 +00001411 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001412 I->second = PrevLabel;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001413}
1414
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001415// Each LexicalScope has first instruction and last instruction to mark
1416// beginning and end of a scope respectively. Create an inverse map that list
1417// scopes starts (and ends) with an instruction. One instruction may start (or
1418// end) multiple scopes. Ignore scopes that are not reachable.
Devang Patel359b0132010-04-08 18:43:56 +00001419void DwarfDebug::identifyScopeMarkers() {
Devang Patel7e623022011-08-10 20:55:27 +00001420 SmallVector<LexicalScope *, 4> WorkList;
1421 WorkList.push_back(LScopes.getCurrentFunctionScope());
Devang Patel7771b7c2010-01-20 02:05:23 +00001422 while (!WorkList.empty()) {
Devang Patel7e623022011-08-10 20:55:27 +00001423 LexicalScope *S = WorkList.pop_back_val();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001424
Craig Topper977e9cd2013-07-03 04:24:43 +00001425 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001426 if (!Children.empty())
Benjamin Kramer15596c72014-03-07 19:09:39 +00001427 WorkList.append(Children.begin(), Children.end());
Devang Patel7771b7c2010-01-20 02:05:23 +00001428
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001429 if (S->isAbstractScope())
1430 continue;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001431
Benjamin Kramer15596c72014-03-07 19:09:39 +00001432 for (const InsnRange &R : S->getRanges()) {
1433 assert(R.first && "InsnRange does not have first instruction!");
1434 assert(R.second && "InsnRange does not have second instruction!");
1435 requestLabelBeforeInsn(R.first);
1436 requestLabelAfterInsn(R.second);
Devang Patel6c74a872010-04-27 19:46:33 +00001437 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001438 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001439}
1440
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001441// Gather pre-function debug information. Assumes being called immediately
1442// after the function entry point has been emitted.
Chris Lattner76555b52010-01-26 23:18:02 +00001443void DwarfDebug::beginFunction(const MachineFunction *MF) {
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001444 CurFn = MF;
Eric Christopherfedfa442013-11-01 23:14:17 +00001445
1446 // If there's no debug info for the function we're not going to do anything.
1447 if (!MMI->hasDebugInfo())
1448 return;
1449
1450 // Grab the lexical scopes for the function, if we don't have any of those
1451 // then we're not going to be able to do anything.
Devang Patel7e623022011-08-10 20:55:27 +00001452 LScopes.initialize(*MF);
Eric Christopher384f3fe2014-03-20 19:16:16 +00001453 if (LScopes.empty())
Eric Christopherfedfa442013-11-01 23:14:17 +00001454 return;
1455
1456 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1457
1458 // Make sure that each lexical scope will have a begin/end label.
Devang Patel7e623022011-08-10 20:55:27 +00001459 identifyScopeMarkers();
Devang Patel4598eb62009-10-06 18:37:31 +00001460
Eric Christopher4287a492013-12-09 23:57:44 +00001461 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
Eric Christopherfedfa442013-11-01 23:14:17 +00001462 // belongs to so that we add to the correct per-cu line table in the
1463 // non-asm case.
Manman Ren4e042a62013-02-05 21:52:47 +00001464 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
Eric Christopher4287a492013-12-09 23:57:44 +00001465 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
Manman Ren4e042a62013-02-05 21:52:47 +00001466 assert(TheCU && "Unable to find compile unit!");
Rafael Espindolab4eec1d2014-02-05 18:00:21 +00001467 if (Asm->OutStreamer.hasRawTextSupport())
1468 // Use a single line table if we are generating assembly.
Manman Ren9d4c7352013-05-21 00:57:22 +00001469 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1470 else
1471 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
Manman Ren4e042a62013-02-05 21:52:47 +00001472
Eric Christopherfedfa442013-11-01 23:14:17 +00001473 // Emit a label for the function so that we have a beginning address.
1474 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
Bill Wendling2b128d72009-05-20 23:19:06 +00001475 // Assumes in correct section after the entry point.
Devang Patel6c74a872010-04-27 19:46:33 +00001476 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
Bill Wendling2b128d72009-05-20 23:19:06 +00001477
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001478 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001479 // LiveUserVar - Map physreg numbers to the MDNode they contain.
Eric Christopherfedfa442013-11-01 23:14:17 +00001480 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001481
Eric Christopherfedfa442013-11-01 23:14:17 +00001482 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1483 ++I) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001484 bool AtBlockEntry = true;
Devang Patel002d54d2010-05-26 19:37:24 +00001485 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1486 II != IE; ++II) {
1487 const MachineInstr *MI = II;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001488
Devang Patel002d54d2010-05-26 19:37:24 +00001489 if (MI->isDebugValue()) {
Nick Lewycky654f5ce2011-10-26 22:55:33 +00001490 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001491
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001492 // Keep track of user variables.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001493 const MDNode *Var =
Eric Christopherfedfa442013-11-01 23:14:17 +00001494 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001495
1496 // Variable is in a register, we need to check for clobbers.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001497 if (isDbgValueInDefinedReg(MI))
1498 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1499
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001500 // Check the history of this variable.
Eric Christopherfedfa442013-11-01 23:14:17 +00001501 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001502 if (History.empty()) {
1503 UserVariables.push_back(Var);
1504 // The first mention of a function argument gets the FunctionBeginSym
1505 // label, so arguments are visible when breaking at function entry.
1506 DIVariable DV(Var);
Manman Ren7504ed42013-07-08 18:33:29 +00001507 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
David Blaikie5af2aca2013-11-18 23:57:26 +00001508 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001509 LabelsBeforeInsn[MI] = FunctionBeginSym;
1510 } else {
1511 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1512 const MachineInstr *Prev = History.back();
1513 if (Prev->isDebugValue()) {
1514 // Coalesce identical entries at the end of History.
1515 if (History.size() >= 2 &&
Devang Patelb7a328e2011-07-07 00:14:27 +00001516 Prev->isIdenticalTo(History[History.size() - 2])) {
Eric Christopher85a495e2012-10-08 20:48:49 +00001517 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
Eric Christopherfedfa442013-11-01 23:14:17 +00001518 << "\t" << *Prev << "\t"
1519 << *History[History.size() - 2] << "\n");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001520 History.pop_back();
Devang Patelb7a328e2011-07-07 00:14:27 +00001521 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001522
1523 // Terminate old register assignments that don't reach MI;
1524 MachineFunction::const_iterator PrevMBB = Prev->getParent();
Benjamin Kramerb6d0bd42014-03-02 12:27:27 +00001525 if (PrevMBB != I && (!AtBlockEntry || std::next(PrevMBB) != I) &&
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001526 isDbgValueInDefinedReg(Prev)) {
1527 // Previous register assignment needs to terminate at the end of
1528 // its basic block.
1529 MachineBasicBlock::const_iterator LastMI =
Eric Christopherfedfa442013-11-01 23:14:17 +00001530 PrevMBB->getLastNonDebugInstr();
Devang Patelb7a328e2011-07-07 00:14:27 +00001531 if (LastMI == PrevMBB->end()) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001532 // Drop DBG_VALUE for empty range.
Eric Christopher85a495e2012-10-08 20:48:49 +00001533 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
Eric Christopherfedfa442013-11-01 23:14:17 +00001534 << "\t" << *Prev << "\n");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001535 History.pop_back();
Benjamin Kramerb6d0bd42014-03-02 12:27:27 +00001536 } else if (std::next(PrevMBB) != PrevMBB->getParent()->end())
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001537 // Terminate after LastMI.
1538 History.push_back(LastMI);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001539 }
1540 }
1541 }
1542 History.push_back(MI);
Devang Patel002d54d2010-05-26 19:37:24 +00001543 } else {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001544 // Not a DBG_VALUE instruction.
Rafael Espindolab1f25f12014-03-07 06:08:31 +00001545 if (!MI->isPosition())
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001546 AtBlockEntry = false;
1547
Eric Christopher133195782012-10-04 20:46:14 +00001548 // First known non-DBG_VALUE and non-frame setup location marks
1549 // the beginning of the function body.
1550 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1551 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
Devang Patel34a66202011-05-11 19:22:19 +00001552 PrologEndLoc = MI->getDebugLoc();
1553
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001554 // Check if the instruction clobbers any registers with debug vars.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001555 for (const MachineOperand &MO : MI->operands()) {
1556 if (!MO.isReg() || !MO.isDef() || !MO.getReg())
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001557 continue;
Benjamin Kramer15596c72014-03-07 19:09:39 +00001558 for (MCRegAliasIterator AI(MO.getReg(), TRI, true); AI.isValid();
Eric Christopherfedfa442013-11-01 23:14:17 +00001559 ++AI) {
Jakob Stoklund Olesen54038d72012-06-01 23:28:30 +00001560 unsigned Reg = *AI;
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001561 const MDNode *Var = LiveUserVar[Reg];
1562 if (!Var)
1563 continue;
1564 // Reg is now clobbered.
1565 LiveUserVar[Reg] = 0;
1566
1567 // Was MD last defined by a DBG_VALUE referring to Reg?
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001568 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1569 if (HistI == DbgValues.end())
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001570 continue;
Eric Christopherfedfa442013-11-01 23:14:17 +00001571 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001572 if (History.empty())
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001573 continue;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001574 const MachineInstr *Prev = History.back();
1575 // Sanity-check: Register assignments are terminated at the end of
1576 // their block.
1577 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1578 continue;
1579 // Is the variable still in Reg?
1580 if (!isDbgValueInDefinedReg(Prev) ||
1581 Prev->getOperand(0).getReg() != Reg)
1582 continue;
1583 // Var is clobbered. Make sure the next instruction gets a label.
1584 History.push_back(MI);
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001585 }
1586 }
Devang Patel002d54d2010-05-26 19:37:24 +00001587 }
Devang Patel002d54d2010-05-26 19:37:24 +00001588 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001589 }
1590
Benjamin Kramer15596c72014-03-07 19:09:39 +00001591 for (auto &I : DbgValues) {
1592 SmallVectorImpl<const MachineInstr *> &History = I.second;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001593 if (History.empty())
1594 continue;
1595
1596 // Make sure the final register assignments are terminated.
1597 const MachineInstr *Prev = History.back();
1598 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1599 const MachineBasicBlock *PrevMBB = Prev->getParent();
Eric Christopher6a841382012-11-19 22:42:10 +00001600 MachineBasicBlock::const_iterator LastMI =
Eric Christopherfedfa442013-11-01 23:14:17 +00001601 PrevMBB->getLastNonDebugInstr();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001602 if (LastMI == PrevMBB->end())
1603 // Drop DBG_VALUE for empty range.
1604 History.pop_back();
David Blaikieea2605d2013-06-20 00:25:24 +00001605 else if (PrevMBB != &PrevMBB->getParent()->back()) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001606 // Terminate after LastMI.
1607 History.push_back(LastMI);
1608 }
1609 }
1610 // Request labels for the full history.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001611 for (const MachineInstr *MI : History) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001612 if (MI->isDebugValue())
1613 requestLabelBeforeInsn(MI);
1614 else
1615 requestLabelAfterInsn(MI);
1616 }
1617 }
Devang Patel002d54d2010-05-26 19:37:24 +00001618
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001619 PrevInstLoc = DebugLoc();
Devang Patel002d54d2010-05-26 19:37:24 +00001620 PrevLabel = FunctionBeginSym;
Devang Patel34a66202011-05-11 19:22:19 +00001621
1622 // Record beginning of function.
1623 if (!PrologEndLoc.isUnknown()) {
Eric Christopherfedfa442013-11-01 23:14:17 +00001624 DebugLoc FnStartDL =
Timur Iskhodzhanovf166f6c2014-01-30 01:39:17 +00001625 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
Eric Christopherfedfa442013-11-01 23:14:17 +00001626 recordSourceLine(
1627 FnStartDL.getLine(), FnStartDL.getCol(),
1628 FnStartDL.getScope(MF->getFunction()->getContext()),
1629 // We'd like to list the prologue as "not statements" but GDB behaves
1630 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1631 DWARF2_FLAG_IS_STMT);
Devang Patel34a66202011-05-11 19:22:19 +00001632 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001633}
1634
Devang Patel7e623022011-08-10 20:55:27 +00001635void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
David Blaikie6f1a8062013-06-05 05:39:59 +00001636 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1637 DIVariable DV = Var->getVariable();
David Blaikie36d5d2f2013-06-06 21:04:51 +00001638 // Variables with positive arg numbers are parameters.
1639 if (unsigned ArgNum = DV.getArgNumber()) {
1640 // Keep all parameters in order at the start of the variable list to ensure
1641 // function types are correct (no out-of-order parameters)
1642 //
1643 // This could be improved by only doing it for optimized builds (unoptimized
1644 // builds have the right order to begin with), searching from the back (this
1645 // would catch the unoptimized case quickly), or doing a binary search
1646 // rather than linear search.
1647 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1648 while (I != Vars.end()) {
1649 unsigned CurNum = (*I)->getVariable().getArgNumber();
1650 // A local (non-parameter) variable has been found, insert immediately
1651 // before it.
1652 if (CurNum == 0)
1653 break;
1654 // A later indexed parameter has been found, insert immediately before it.
David Blaikieb272a752013-06-06 22:28:26 +00001655 if (CurNum > ArgNum)
David Blaikie36d5d2f2013-06-06 21:04:51 +00001656 break;
David Blaikieb272a752013-06-06 22:28:26 +00001657 ++I;
David Blaikie6f1a8062013-06-05 05:39:59 +00001658 }
David Blaikie36d5d2f2013-06-06 21:04:51 +00001659 Vars.insert(I, Var);
1660 return;
David Blaikie6f1a8062013-06-05 05:39:59 +00001661 }
1662
1663 Vars.push_back(Var);
Devang Patel7e623022011-08-10 20:55:27 +00001664}
1665
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001666// Gather and emit post-function debug information.
NAKAMURA Takumib9271612013-12-03 13:15:54 +00001667void DwarfDebug::endFunction(const MachineFunction *MF) {
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001668 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1669 // though the beginFunction may not be called at all.
1670 // We should handle both cases.
1671 if (CurFn == 0)
1672 CurFn = MF;
1673 else
1674 assert(CurFn == MF);
1675 assert(CurFn != 0);
1676
1677 if (!MMI->hasDebugInfo() || LScopes.empty()) {
Eric Christopher384f3fe2014-03-20 19:16:16 +00001678 // If we don't have a lexical scope for this function then there will
1679 // be a hole in the range information. Keep note of this by setting the
1680 // previously used section to nullptr.
1681 PrevSection = nullptr;
1682 PrevCU = nullptr;
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001683 CurFn = 0;
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001684 return;
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001685 }
Devang Patel2904aa92009-11-12 19:02:56 +00001686
Devang Patel7e623022011-08-10 20:55:27 +00001687 // Define end label for subprogram.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001688 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
Devang Patel7e623022011-08-10 20:55:27 +00001689 // Assumes in correct section after the entry point.
1690 Asm->OutStreamer.EmitLabel(FunctionEndSym);
Eric Christopher1a972152014-01-29 23:05:43 +00001691
Eric Christopher4287a492013-12-09 23:57:44 +00001692 // Set DwarfDwarfCompileUnitID in MCContext to default value.
Manman Ren4e042a62013-02-05 21:52:47 +00001693 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
Eric Christopher6a841382012-11-19 22:42:10 +00001694
Devang Patel7e623022011-08-10 20:55:27 +00001695 SmallPtrSet<const MDNode *, 16> ProcessedVars;
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001696 collectVariableInfo(ProcessedVars);
Eric Christopher6a841382012-11-19 22:42:10 +00001697
Devang Patel3acc70e2011-08-15 22:04:40 +00001698 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
Eric Christopher4287a492013-12-09 23:57:44 +00001699 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
Nick Lewycky654f5ce2011-10-26 22:55:33 +00001700 assert(TheCU && "Unable to find compile unit!");
Devang Patel3acc70e2011-08-15 22:04:40 +00001701
Devang Patel7e623022011-08-10 20:55:27 +00001702 // Construct abstract scopes.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001703 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
Devang Patel44403472011-08-12 18:10:19 +00001704 DISubprogram SP(AScope->getScopeNode());
Manman Ren7504ed42013-07-08 18:33:29 +00001705 if (SP.isSubprogram()) {
Devang Patel7e623022011-08-10 20:55:27 +00001706 // Collect info for variables that were optimized out.
Devang Patel59e27c52011-08-19 23:28:12 +00001707 DIArray Variables = SP.getVariables();
1708 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1709 DIVariable DV(Variables.getElement(i));
Manman Ren7504ed42013-07-08 18:33:29 +00001710 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
Devang Patel59e27c52011-08-19 23:28:12 +00001711 continue;
Alexey Samsonov39602782012-07-06 08:45:08 +00001712 // Check that DbgVariable for DV wasn't created earlier, when
1713 // findAbstractVariable() was called for inlined instance of DV.
1714 LLVMContext &Ctx = DV->getContext();
1715 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1716 if (AbstractVariables.lookup(CleanDV))
1717 continue;
Devang Patel59e27c52011-08-19 23:28:12 +00001718 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
Manman Renb3388602013-10-05 01:43:03 +00001719 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
Devang Patel5c0f85c2010-06-25 22:07:34 +00001720 }
1721 }
Devang Patel44403472011-08-12 18:10:19 +00001722 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
Manman Ren4213c392013-05-29 17:16:59 +00001723 constructScopeDIE(TheCU, AScope);
Bill Wendling2b128d72009-05-20 23:19:06 +00001724 }
Eric Christopher6a841382012-11-19 22:42:10 +00001725
Devang Patel3acc70e2011-08-15 22:04:40 +00001726 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001727 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
Eric Christopherbb69a272012-08-24 01:14:27 +00001728 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
Devang Patel3acc70e2011-08-15 22:04:40 +00001729
Eric Christopher1a972152014-01-29 23:05:43 +00001730 // Add the range of this function to the list of ranges for the CU.
1731 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
Chandler Carruth002da5d2014-03-02 04:08:41 +00001732 TheCU->addRange(std::move(Span));
Eric Christopher384f3fe2014-03-20 19:16:16 +00001733 PrevSection = Asm->getCurrentSection();
1734 PrevCU = TheCU;
Eric Christopher1a972152014-01-29 23:05:43 +00001735
Bill Wendling2b128d72009-05-20 23:19:06 +00001736 // Clear debug info
Benjamin Kramer15596c72014-03-07 19:09:39 +00001737 for (auto &I : ScopeVariables)
1738 DeleteContainerPointers(I.second);
Devang Patel7e623022011-08-10 20:55:27 +00001739 ScopeVariables.clear();
Devang Patelad45d912011-04-22 18:09:57 +00001740 DeleteContainerPointers(CurrentFnArguments);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001741 UserVariables.clear();
1742 DbgValues.clear();
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00001743 AbstractVariables.clear();
Devang Patel6c74a872010-04-27 19:46:33 +00001744 LabelsBeforeInsn.clear();
1745 LabelsAfterInsn.clear();
Devang Patel12563b32010-04-16 23:33:45 +00001746 PrevLabel = NULL;
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001747 CurFn = 0;
Bill Wendling2b128d72009-05-20 23:19:06 +00001748}
1749
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001750// Register a source line with debug info. Returns the unique label that was
1751// emitted and which provides correspondence to the source line list.
Devang Patel34a66202011-05-11 19:22:19 +00001752void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1753 unsigned Flags) {
Devang Patel2d9caf92009-11-25 17:36:49 +00001754 StringRef Fn;
Devang Patele01b75c2011-03-24 20:30:50 +00001755 StringRef Dir;
Dan Gohman50849c62010-05-05 23:41:32 +00001756 unsigned Src = 1;
Diego Novillo282450d2014-03-03 18:53:17 +00001757 unsigned Discriminator = 0;
Dan Gohman50849c62010-05-05 23:41:32 +00001758 if (S) {
1759 DIDescriptor Scope(S);
Devang Patel2089d162009-10-05 18:03:19 +00001760
Dan Gohman50849c62010-05-05 23:41:32 +00001761 if (Scope.isCompileUnit()) {
1762 DICompileUnit CU(S);
Dan Gohman50849c62010-05-05 23:41:32 +00001763 Fn = CU.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001764 Dir = CU.getDirectory();
Devang Patelc4b69052010-10-28 17:30:52 +00001765 } else if (Scope.isFile()) {
1766 DIFile F(S);
Devang Patelc4b69052010-10-28 17:30:52 +00001767 Fn = F.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001768 Dir = F.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00001769 } else if (Scope.isSubprogram()) {
1770 DISubprogram SP(S);
Dan Gohman50849c62010-05-05 23:41:32 +00001771 Fn = SP.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001772 Dir = SP.getDirectory();
Eric Christopher6647b832011-10-11 22:59:11 +00001773 } else if (Scope.isLexicalBlockFile()) {
1774 DILexicalBlockFile DBF(S);
1775 Fn = DBF.getFilename();
1776 Dir = DBF.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00001777 } else if (Scope.isLexicalBlock()) {
1778 DILexicalBlock DB(S);
Dan Gohman50849c62010-05-05 23:41:32 +00001779 Fn = DB.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001780 Dir = DB.getDirectory();
Diego Novillo282450d2014-03-03 18:53:17 +00001781 Discriminator = DB.getDiscriminator();
Dan Gohman50849c62010-05-05 23:41:32 +00001782 } else
Craig Topperee4dab52012-02-05 08:31:47 +00001783 llvm_unreachable("Unexpected scope info");
Dan Gohman50849c62010-05-05 23:41:32 +00001784
David Blaikie0e8d4012014-03-17 23:53:25 +00001785 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1786 Src = static_cast<DwarfCompileUnit *>(InfoHolder.getUnits()[CUID])
1787 ->getOrCreateSourceID(Fn, Dir);
Dan Gohman50849c62010-05-05 23:41:32 +00001788 }
Diego Novillo282450d2014-03-03 18:53:17 +00001789 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1790 Discriminator, Fn);
Bill Wendling2b128d72009-05-20 23:19:06 +00001791}
1792
Bill Wendling806535f2009-05-20 23:22:40 +00001793//===----------------------------------------------------------------------===//
1794// Emit Methods
1795//===----------------------------------------------------------------------===//
1796
Manman Rence20d462013-10-29 22:57:10 +00001797// Compute the size and offset of a DIE. The offset is relative to start of the
1798// CU. It returns the offset after laying out the DIE.
Eric Christopherf8194852013-12-05 18:06:10 +00001799unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
Bill Wendling480ff322009-05-20 23:21:38 +00001800 // Record the abbreviation.
Devang Patel930143b2009-11-21 02:48:08 +00001801 assignAbbrevNumber(Die->getAbbrev());
Bill Wendling480ff322009-05-20 23:21:38 +00001802
1803 // Get the abbreviation for this DIE.
David Blaikieff3ab2c2013-12-05 01:01:41 +00001804 const DIEAbbrev &Abbrev = Die->getAbbrev();
Bill Wendling480ff322009-05-20 23:21:38 +00001805
1806 // Set DIE offset
1807 Die->setOffset(Offset);
1808
1809 // Start the size with the size of abbreviation code.
Logan Chien5b776b72014-02-22 14:00:39 +00001810 Offset += getULEB128Size(Die->getAbbrevNumber());
Bill Wendling480ff322009-05-20 23:21:38 +00001811
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001812 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
David Blaikieff3ab2c2013-12-05 01:01:41 +00001813 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
Bill Wendling480ff322009-05-20 23:21:38 +00001814
1815 // Size the DIE attribute values.
1816 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1817 // Size attribute value.
Chris Lattner5a00dea2010-04-05 00:18:22 +00001818 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
Bill Wendling480ff322009-05-20 23:21:38 +00001819
Benjamin Kramer15596c72014-03-07 19:09:39 +00001820 // Get the children.
1821 const std::vector<DIE *> &Children = Die->getChildren();
1822
Bill Wendling480ff322009-05-20 23:21:38 +00001823 // Size the DIE children if any.
1824 if (!Children.empty()) {
Eric Christophere8f10722014-03-05 01:44:58 +00001825 assert(Abbrev.hasChildren() && "Children flag not set");
Bill Wendling480ff322009-05-20 23:21:38 +00001826
Benjamin Kramer15596c72014-03-07 19:09:39 +00001827 for (DIE *Child : Children)
1828 Offset = computeSizeAndOffset(Child, Offset);
Bill Wendling480ff322009-05-20 23:21:38 +00001829
1830 // End of children marker.
1831 Offset += sizeof(int8_t);
1832 }
1833
1834 Die->setSize(Offset - Die->getOffset());
1835 return Offset;
1836}
1837
Eric Christopherb088d2d2013-10-24 21:05:08 +00001838// Compute the size and offset for each DIE.
Eric Christopherf8194852013-12-05 18:06:10 +00001839void DwarfFile::computeSizeAndOffsets() {
Manman Rence20d462013-10-29 22:57:10 +00001840 // Offset from the first CU in the debug info section is 0 initially.
1841 unsigned SecOffset = 0;
1842
Eric Christopherb088d2d2013-10-24 21:05:08 +00001843 // Iterate over each compile unit and set the size and offsets for each
1844 // DIE within each compile unit. All offsets are CU relative.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001845 for (DwarfUnit *TheU : CUs) {
1846 TheU->setDebugInfoOffset(SecOffset);
Manman Rence20d462013-10-29 22:57:10 +00001847
1848 // CU-relative offset is reset to 0 here.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001849 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
Benjamin Kramer15596c72014-03-07 19:09:39 +00001850 TheU->getHeaderSize(); // Unit-specific headers
Manman Rence20d462013-10-29 22:57:10 +00001851
1852 // EndOffset here is CU-relative, after laying out
1853 // all of the CU DIE.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001854 unsigned EndOffset = computeSizeAndOffset(TheU->getUnitDie(), Offset);
Manman Rence20d462013-10-29 22:57:10 +00001855 SecOffset += EndOffset;
Devang Patel1a0df9a2010-05-10 22:49:55 +00001856 }
Bill Wendling480ff322009-05-20 23:21:38 +00001857}
1858
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001859// Emit initial Dwarf sections with a label at the start of each one.
Eric Christopher7b30f2e42012-11-21 00:34:35 +00001860void DwarfDebug::emitSectionLabels() {
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001861 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00001862
Bill Wendling480ff322009-05-20 23:21:38 +00001863 // Dwarf sections base addresses.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001864 DwarfInfoSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001865 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
Eric Christopherd8667202013-12-30 17:22:27 +00001866 if (useSplitDwarf())
1867 DwarfInfoDWOSectionSym =
1868 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001869 DwarfAbbrevSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001870 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
Eric Christopher3c5a1912012-12-19 22:02:53 +00001871 if (useSplitDwarf())
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001872 DwarfAbbrevDWOSectionSym = emitSectionSym(
1873 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
David Blaikie20474102014-02-25 22:46:44 +00001874 if (GenerateARangeSection)
1875 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001876
Eric Christopher74804332013-02-07 21:19:50 +00001877 DwarfLineSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001878 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
Eric Christopher261d2342013-09-23 20:55:35 +00001879 if (GenerateGnuPubSections) {
Eric Christopher39eebfa2013-09-30 23:14:16 +00001880 DwarfGnuPubNamesSectionSym =
1881 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1882 DwarfGnuPubTypesSectionSym =
1883 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
Eric Christopher261d2342013-09-23 20:55:35 +00001884 } else if (HasDwarfPubSections) {
1885 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1886 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
Michael Gottesmanc89466f2013-09-04 04:39:38 +00001887 }
Eric Christopherdd1a0122013-09-13 00:35:05 +00001888
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001889 DwarfStrSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001890 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
Eric Christopher55863be2013-04-07 03:43:09 +00001891 if (useSplitDwarf()) {
Eric Christopher3bf29fd2012-12-27 02:14:01 +00001892 DwarfStrDWOSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001893 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
Eric Christopher55863be2013-04-07 03:43:09 +00001894 DwarfAddrSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001895 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
David Blaikie9c550ac2014-03-25 01:44:02 +00001896 DwarfDebugLocDWOSectionSym =
1897 emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1898 } else
1899 DwarfDebugLocSectionSym =
1900 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001901 DwarfDebugRangeSectionSym =
1902 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
Bill Wendling480ff322009-05-20 23:21:38 +00001903}
1904
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001905// Recursively emits a debug information entry.
David Blaikieff3ab2c2013-12-05 01:01:41 +00001906void DwarfDebug::emitDIE(DIE *Die) {
Bill Wendling480ff322009-05-20 23:21:38 +00001907 // Get the abbreviation for this DIE.
David Blaikieff3ab2c2013-12-05 01:01:41 +00001908 const DIEAbbrev &Abbrev = Die->getAbbrev();
Bill Wendling480ff322009-05-20 23:21:38 +00001909
Bill Wendling480ff322009-05-20 23:21:38 +00001910 // Emit the code (index) for the abbreviation.
Chris Lattner7bde8c02010-04-04 18:52:31 +00001911 if (Asm->isVerbose())
David Blaikieff3ab2c2013-12-05 01:01:41 +00001912 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1913 "] 0x" + Twine::utohexstr(Die->getOffset()) +
1914 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
1915 dwarf::TagString(Abbrev.getTag()));
1916 Asm->EmitULEB128(Abbrev.getNumber());
Bill Wendling480ff322009-05-20 23:21:38 +00001917
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001918 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
David Blaikieff3ab2c2013-12-05 01:01:41 +00001919 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
Bill Wendling480ff322009-05-20 23:21:38 +00001920
1921 // Emit the DIE attribute values.
1922 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
David Blaikief2443192013-10-21 17:28:37 +00001923 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1924 dwarf::Form Form = AbbrevData[i].getForm();
Bill Wendling480ff322009-05-20 23:21:38 +00001925 assert(Form && "Too many attributes for DIE (check abbreviation)");
1926
Eric Christopher13a1bb32014-03-06 00:00:49 +00001927 if (Asm->isVerbose()) {
Chris Lattner5adf9872010-01-24 18:54:17 +00001928 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
Eric Christopher13a1bb32014-03-06 00:00:49 +00001929 if (Attr == dwarf::DW_AT_accessibility)
1930 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1931 cast<DIEInteger>(Values[i])->getValue()));
1932 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001933
Eric Christopherdd508382014-03-06 00:00:56 +00001934 // Emit an attribute using the defined form.
1935 Values[i]->EmitValue(Asm, Form);
Bill Wendling480ff322009-05-20 23:21:38 +00001936 }
1937
1938 // Emit the DIE children if any.
Eric Christophere8f10722014-03-05 01:44:58 +00001939 if (Abbrev.hasChildren()) {
Bill Wendling480ff322009-05-20 23:21:38 +00001940 const std::vector<DIE *> &Children = Die->getChildren();
1941
Benjamin Kramer15596c72014-03-07 19:09:39 +00001942 for (DIE *Child : Children)
1943 emitDIE(Child);
Bill Wendling480ff322009-05-20 23:21:38 +00001944
David Blaikie155f8812013-12-04 21:51:05 +00001945 Asm->OutStreamer.AddComment("End Of Children Mark");
Chris Lattner566cae92010-03-09 23:52:58 +00001946 Asm->EmitInt8(0);
Bill Wendling480ff322009-05-20 23:21:38 +00001947 }
1948}
1949
Eric Christophera2de8262012-12-15 00:04:07 +00001950// Emit the various dwarf units to the unit section USection with
1951// the abbreviations going into ASection.
David Blaikief72ed5f2014-03-24 20:31:01 +00001952void DwarfFile::emitUnits(DwarfDebug *DD, const MCSymbol *ASectionSym) {
Benjamin Kramer15596c72014-03-07 19:09:39 +00001953 for (DwarfUnit *TheU : CUs) {
David Blaikie2a80e442013-12-02 22:09:48 +00001954 DIE *Die = TheU->getUnitDie();
David Blaikie03073f72013-12-06 22:14:48 +00001955 const MCSection *USection = TheU->getSection();
1956 Asm->OutStreamer.SwitchSection(USection);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001957
Devang Patel1a0df9a2010-05-10 22:49:55 +00001958 // Emit the compile units header.
David Blaikie7d734602013-12-06 22:33:05 +00001959 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001960
Devang Patel1a0df9a2010-05-10 22:49:55 +00001961 // Emit size of content not including length itself
David Blaikie6b288cf2013-10-30 20:42:41 +00001962 Asm->OutStreamer.AddComment("Length of Unit");
David Blaikie2a80e442013-12-02 22:09:48 +00001963 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001964
David Blaikied82b2372014-03-24 20:28:10 +00001965 TheU->emitHeader(ASectionSym);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001966
David Blaikieff3ab2c2013-12-05 01:01:41 +00001967 DD->emitDIE(Die);
David Blaikie7d734602013-12-06 22:33:05 +00001968 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
Devang Patel1a0df9a2010-05-10 22:49:55 +00001969 }
Bill Wendling480ff322009-05-20 23:21:38 +00001970}
1971
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001972// Emit the debug info section.
1973void DwarfDebug::emitDebugInfo() {
Eric Christopherf8194852013-12-05 18:06:10 +00001974 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Eric Christophera2de8262012-12-15 00:04:07 +00001975
David Blaikief72ed5f2014-03-24 20:31:01 +00001976 Holder.emitUnits(this, DwarfAbbrevSectionSym);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001977}
1978
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001979// Emit the abbreviation section.
Eric Christopher38371952012-11-20 23:30:11 +00001980void DwarfDebug::emitAbbreviations() {
Eric Christopherf8194852013-12-05 18:06:10 +00001981 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
David Blaikie0504cda2013-12-05 07:43:55 +00001982
1983 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
Eric Christopher3c5a1912012-12-19 22:02:53 +00001984}
Bill Wendling480ff322009-05-20 23:21:38 +00001985
Eric Christopherf8194852013-12-05 18:06:10 +00001986void DwarfFile::emitAbbrevs(const MCSection *Section) {
Eric Christopher3c5a1912012-12-19 22:02:53 +00001987 // Check to see if it is worth the effort.
David Blaikie0504cda2013-12-05 07:43:55 +00001988 if (!Abbreviations.empty()) {
Eric Christopher3c5a1912012-12-19 22:02:53 +00001989 // Start the debug abbrev section.
1990 Asm->OutStreamer.SwitchSection(Section);
1991
Bill Wendling480ff322009-05-20 23:21:38 +00001992 // For each abbrevation.
Benjamin Kramer15596c72014-03-07 19:09:39 +00001993 for (const DIEAbbrev *Abbrev : Abbreviations) {
Bill Wendling480ff322009-05-20 23:21:38 +00001994 // Emit the abbrevations code (base 1 index.)
Chris Lattner9efd1182010-04-04 19:09:29 +00001995 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
Bill Wendling480ff322009-05-20 23:21:38 +00001996
1997 // Emit the abbreviations data.
Chris Lattner3a383cb2010-04-05 00:13:49 +00001998 Abbrev->Emit(Asm);
Bill Wendling480ff322009-05-20 23:21:38 +00001999 }
2000
2001 // Mark end of abbreviations.
Chris Lattner9efd1182010-04-04 19:09:29 +00002002 Asm->EmitULEB128(0, "EOM(3)");
Bill Wendling480ff322009-05-20 23:21:38 +00002003 }
2004}
2005
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002006// Emit the last address of the section and the end of the line matrix.
Devang Patel930143b2009-11-21 02:48:08 +00002007void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling480ff322009-05-20 23:21:38 +00002008 // Define last address of section.
Chris Lattner566cae92010-03-09 23:52:58 +00002009 Asm->OutStreamer.AddComment("Extended Op");
2010 Asm->EmitInt8(0);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002011
Chris Lattner566cae92010-03-09 23:52:58 +00002012 Asm->OutStreamer.AddComment("Op size");
Chandler Carruth5da3f052012-11-01 09:14:31 +00002013 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
Chris Lattner566cae92010-03-09 23:52:58 +00002014 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2015 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2016
2017 Asm->OutStreamer.AddComment("Section end label");
Chris Lattnerb245dfb2010-03-10 01:17:49 +00002018
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002019 Asm->OutStreamer.EmitSymbolValue(
2020 Asm->GetTempSymbol("section_end", SectionEnd),
2021 Asm->getDataLayout().getPointerSize());
Bill Wendling480ff322009-05-20 23:21:38 +00002022
2023 // Mark end of matrix.
Chris Lattner566cae92010-03-09 23:52:58 +00002024 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2025 Asm->EmitInt8(0);
Chris Lattnerf5c834f2010-01-22 22:09:00 +00002026 Asm->EmitInt8(1);
Chris Lattnerfa823552010-01-22 23:18:42 +00002027 Asm->EmitInt8(1);
Bill Wendling480ff322009-05-20 23:21:38 +00002028}
2029
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002030// Emit visible names into a hashed accelerator table section.
Eric Christopher4996c702011-11-07 09:24:32 +00002031void DwarfDebug::emitAccelNames() {
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002032 DwarfAccelTable AT(
2033 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
Benjamin Kramer15596c72014-03-07 19:09:39 +00002034 for (DwarfUnit *TheU : getUnits()) {
2035 for (const auto &GI : TheU->getAccelNames()) {
2036 StringRef Name = GI.getKey();
2037 for (const DIE *D : GI.second)
2038 AT.AddName(Name, D);
Eric Christopher4996c702011-11-07 09:24:32 +00002039 }
2040 }
2041
2042 AT.FinalizeTable(Asm, "Names");
2043 Asm->OutStreamer.SwitchSection(
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002044 Asm->getObjFileLowering().getDwarfAccelNamesSection());
Eric Christopher4996c702011-11-07 09:24:32 +00002045 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2046 Asm->OutStreamer.EmitLabel(SectionBegin);
2047
2048 // Emit the full data.
Eric Christophere698f532012-12-20 21:58:36 +00002049 AT.Emit(Asm, SectionBegin, &InfoHolder);
Eric Christopher4996c702011-11-07 09:24:32 +00002050}
2051
Eric Christopher48fef592012-12-20 21:58:40 +00002052// Emit objective C classes and categories into a hashed accelerator table
2053// section.
Eric Christopher4996c702011-11-07 09:24:32 +00002054void DwarfDebug::emitAccelObjC() {
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002055 DwarfAccelTable AT(
2056 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
Benjamin Kramer15596c72014-03-07 19:09:39 +00002057 for (DwarfUnit *TheU : getUnits()) {
2058 for (const auto &GI : TheU->getAccelObjC()) {
2059 StringRef Name = GI.getKey();
2060 for (const DIE *D : GI.second)
2061 AT.AddName(Name, D);
Eric Christopher4996c702011-11-07 09:24:32 +00002062 }
2063 }
2064
2065 AT.FinalizeTable(Asm, "ObjC");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002066 Asm->OutStreamer.SwitchSection(
2067 Asm->getObjFileLowering().getDwarfAccelObjCSection());
Eric Christopher4996c702011-11-07 09:24:32 +00002068 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2069 Asm->OutStreamer.EmitLabel(SectionBegin);
2070
2071 // Emit the full data.
Eric Christophere698f532012-12-20 21:58:36 +00002072 AT.Emit(Asm, SectionBegin, &InfoHolder);
Eric Christopher4996c702011-11-07 09:24:32 +00002073}
2074
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002075// Emit namespace dies into a hashed accelerator table.
Eric Christopher4996c702011-11-07 09:24:32 +00002076void DwarfDebug::emitAccelNamespaces() {
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002077 DwarfAccelTable AT(
2078 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
Benjamin Kramer15596c72014-03-07 19:09:39 +00002079 for (DwarfUnit *TheU : getUnits()) {
2080 for (const auto &GI : TheU->getAccelNamespace()) {
2081 StringRef Name = GI.getKey();
2082 for (const DIE *D : GI.second)
2083 AT.AddName(Name, D);
Eric Christopher4996c702011-11-07 09:24:32 +00002084 }
2085 }
2086
2087 AT.FinalizeTable(Asm, "namespac");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002088 Asm->OutStreamer.SwitchSection(
2089 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
Eric Christopher4996c702011-11-07 09:24:32 +00002090 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2091 Asm->OutStreamer.EmitLabel(SectionBegin);
2092
2093 // Emit the full data.
Eric Christophere698f532012-12-20 21:58:36 +00002094 AT.Emit(Asm, SectionBegin, &InfoHolder);
Eric Christopher4996c702011-11-07 09:24:32 +00002095}
2096
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002097// Emit type dies into a hashed accelerator table.
Eric Christopher4996c702011-11-07 09:24:32 +00002098void DwarfDebug::emitAccelTypes() {
Eric Christopher21bde872012-01-06 04:35:23 +00002099 std::vector<DwarfAccelTable::Atom> Atoms;
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002100 Atoms.push_back(
2101 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2102 Atoms.push_back(
2103 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2104 Atoms.push_back(
2105 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
Eric Christopher21bde872012-01-06 04:35:23 +00002106 DwarfAccelTable AT(Atoms);
Benjamin Kramer15596c72014-03-07 19:09:39 +00002107 for (DwarfUnit *TheU : getUnits()) {
2108 for (const auto &GI : TheU->getAccelTypes()) {
2109 StringRef Name = GI.getKey();
2110 for (const auto &DI : GI.second)
2111 AT.AddName(Name, DI.first, DI.second);
Eric Christopher4996c702011-11-07 09:24:32 +00002112 }
2113 }
2114
2115 AT.FinalizeTable(Asm, "types");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002116 Asm->OutStreamer.SwitchSection(
2117 Asm->getObjFileLowering().getDwarfAccelTypesSection());
Eric Christopher4996c702011-11-07 09:24:32 +00002118 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2119 Asm->OutStreamer.EmitLabel(SectionBegin);
2120
2121 // Emit the full data.
Eric Christophere698f532012-12-20 21:58:36 +00002122 AT.Emit(Asm, SectionBegin, &InfoHolder);
Eric Christopher4996c702011-11-07 09:24:32 +00002123}
2124
Eric Christopherdd1a0122013-09-13 00:35:05 +00002125// Public name handling.
2126// The format for the various pubnames:
2127//
2128// dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2129// for the DIE that is named.
2130//
2131// gnu pubnames - offset/index value/name tuples where the offset is the offset
2132// into the CU and the index value is computed according to the type of value
2133// for the DIE that is named.
2134//
2135// For type units the offset is the offset of the skeleton DIE. For split dwarf
2136// it's the offset within the debug_info/debug_types dwo section, however, the
2137// reference in the pubname header doesn't change.
2138
2139/// computeIndexValue - Compute the gdb index value for the DIE and CU.
Eric Christophera5a79422013-12-09 23:32:48 +00002140static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
Eric Christopher0fe676a2013-11-21 00:48:22 +00002141 const DIE *Die) {
Eric Christopherd2b497b2013-10-16 01:37:49 +00002142 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2143
2144 // We could have a specification DIE that has our most of our knowledge,
2145 // look for that now.
2146 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2147 if (SpecVal) {
2148 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2149 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2150 Linkage = dwarf::GIEL_EXTERNAL;
2151 } else if (Die->findAttribute(dwarf::DW_AT_external))
2152 Linkage = dwarf::GIEL_EXTERNAL;
Eric Christopherdd1a0122013-09-13 00:35:05 +00002153
2154 switch (Die->getTag()) {
2155 case dwarf::DW_TAG_class_type:
2156 case dwarf::DW_TAG_structure_type:
2157 case dwarf::DW_TAG_union_type:
2158 case dwarf::DW_TAG_enumeration_type:
Eric Christopher261d2342013-09-23 20:55:35 +00002159 return dwarf::PubIndexEntryDescriptor(
2160 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2161 ? dwarf::GIEL_STATIC
2162 : dwarf::GIEL_EXTERNAL);
Eric Christopherdd1a0122013-09-13 00:35:05 +00002163 case dwarf::DW_TAG_typedef:
2164 case dwarf::DW_TAG_base_type:
2165 case dwarf::DW_TAG_subrange_type:
David Blaikie8dec4072013-09-19 20:40:26 +00002166 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
Eric Christopherdd1a0122013-09-13 00:35:05 +00002167 case dwarf::DW_TAG_namespace:
David Blaikie8dec4072013-09-19 20:40:26 +00002168 return dwarf::GIEK_TYPE;
Eric Christopherdd1a0122013-09-13 00:35:05 +00002169 case dwarf::DW_TAG_subprogram:
Eric Christopherccac5c42013-09-23 22:59:14 +00002170 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
Eric Christopherdd1a0122013-09-13 00:35:05 +00002171 case dwarf::DW_TAG_constant:
2172 case dwarf::DW_TAG_variable:
Eric Christopherccac5c42013-09-23 22:59:14 +00002173 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
Eric Christopherdd1a0122013-09-13 00:35:05 +00002174 case dwarf::DW_TAG_enumerator:
David Blaikie8dec4072013-09-19 20:40:26 +00002175 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2176 dwarf::GIEL_STATIC);
Eric Christopherdd1a0122013-09-13 00:35:05 +00002177 default:
David Blaikie8dec4072013-09-19 20:40:26 +00002178 return dwarf::GIEK_NONE;
Eric Christopherdd1a0122013-09-13 00:35:05 +00002179 }
Eric Christopherdd1a0122013-09-13 00:35:05 +00002180}
2181
Eric Christopher5f93bb92013-09-09 20:03:17 +00002182/// emitDebugPubNames - Emit visible names into a debug pubnames section.
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002183///
Eric Christopherdd1a0122013-09-13 00:35:05 +00002184void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
Eric Christopherdd1a0122013-09-13 00:35:05 +00002185 const MCSection *PSec =
2186 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2187 : Asm->getObjFileLowering().getDwarfPubNamesSection();
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002188
David Blaikie0f55e832014-03-11 23:18:15 +00002189 emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
2190}
2191
2192void DwarfDebug::emitDebugPubSection(
2193 bool GnuStyle, const MCSection *PSec, StringRef Name,
2194 const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
David Blaikiec3d9e9e2014-03-06 01:42:00 +00002195 for (const auto &NU : CUMap) {
2196 DwarfCompileUnit *TheU = NU.second;
David Blaikie55bb8ac2014-03-11 23:23:39 +00002197
2198 const auto &Globals = (TheU->*Accessor)();
2199
David Blaikiece2f1cb2014-03-11 23:35:06 +00002200 if (Globals.empty())
2201 continue;
2202
David Blaikiec3d9e9e2014-03-06 01:42:00 +00002203 if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
2204 TheU = Skeleton;
David Blaikie2a80e442013-12-02 22:09:48 +00002205 unsigned ID = TheU->getUniqueID();
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002206
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002207 // Start the dwarf pubnames section.
Eric Christopher13b99d22013-09-10 21:49:37 +00002208 Asm->OutStreamer.SwitchSection(PSec);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002209
Eric Christopherdd1a0122013-09-13 00:35:05 +00002210 // Emit the header.
David Blaikie0f55e832014-03-11 23:18:15 +00002211 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
2212 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
2213 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
David Blaikieb7a1c4d2013-12-04 17:55:41 +00002214 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002215
David Blaikieb7a1c4d2013-12-04 17:55:41 +00002216 Asm->OutStreamer.EmitLabel(BeginLabel);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002217
2218 Asm->OutStreamer.AddComment("DWARF Version");
David Majnemered89b5c2013-08-21 06:13:34 +00002219 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002220
2221 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
David Blaikie7d734602013-12-06 22:33:05 +00002222 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002223
2224 Asm->OutStreamer.AddComment("Compilation Unit Length");
David Blaikie7d734602013-12-06 22:33:05 +00002225 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002226
Eric Christopherdd1a0122013-09-13 00:35:05 +00002227 // Emit the pubnames for this compilation unit.
David Blaikie55bb8ac2014-03-11 23:23:39 +00002228 for (const auto &GI : Globals) {
Benjamin Kramer15596c72014-03-07 19:09:39 +00002229 const char *Name = GI.getKeyData();
2230 const DIE *Entity = GI.second;
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002231
2232 Asm->OutStreamer.AddComment("DIE offset");
2233 Asm->EmitInt32(Entity->getOffset());
2234
Eric Christopherdd1a0122013-09-13 00:35:05 +00002235 if (GnuStyle) {
David Blaikie2a80e442013-12-02 22:09:48 +00002236 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
David Blaikied0a869d2013-09-19 22:19:37 +00002237 Asm->OutStreamer.AddComment(
David Blaikieefd0bcb2013-09-20 00:33:15 +00002238 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
David Blaikie404d3042013-09-19 23:01:29 +00002239 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
David Blaikied0a869d2013-09-19 22:19:37 +00002240 Asm->EmitInt8(Desc.toBits());
Eric Christopherdd1a0122013-09-13 00:35:05 +00002241 }
2242
David Blaikie155f8812013-12-04 21:51:05 +00002243 Asm->OutStreamer.AddComment("External Name");
Benjamin Kramer15596c72014-03-07 19:09:39 +00002244 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002245 }
2246
2247 Asm->OutStreamer.AddComment("End Mark");
2248 Asm->EmitInt32(0);
David Blaikieb7a1c4d2013-12-04 17:55:41 +00002249 Asm->OutStreamer.EmitLabel(EndLabel);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002250 }
2251}
2252
Eric Christopherdd1a0122013-09-13 00:35:05 +00002253void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
Eric Christopher261d2342013-09-23 20:55:35 +00002254 const MCSection *PSec =
2255 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2256 : Asm->getObjFileLowering().getDwarfPubTypesSection();
Eric Christopher8b3737f2013-09-13 00:34:58 +00002257
David Blaikie0f55e832014-03-11 23:18:15 +00002258 emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
Devang Patel04d2f2d2009-11-24 01:14:22 +00002259}
2260
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002261// Emit strings into a string section.
Eric Christopherf8194852013-12-05 18:06:10 +00002262void DwarfFile::emitStrings(const MCSection *StrSection,
Eric Christophera5a79422013-12-09 23:32:48 +00002263 const MCSection *OffsetSection = NULL,
2264 const MCSymbol *StrSecSym = NULL) {
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002265
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002266 if (StringPool.empty())
2267 return;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002268
Chris Lattner3d72a672010-03-09 23:38:23 +00002269 // Start the dwarf str section.
Eric Christopher2cbd5762013-01-07 19:32:41 +00002270 Asm->OutStreamer.SwitchSection(StrSection);
Bill Wendling480ff322009-05-20 23:21:38 +00002271
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002272 // Get all of the string pool entries and put them in an array by their ID so
2273 // we can sort them.
Benjamin Kramer15596c72014-03-07 19:09:39 +00002274 SmallVector<std::pair<unsigned, const StrPool::value_type *>, 64 > Entries;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002275
Benjamin Kramer15596c72014-03-07 19:09:39 +00002276 for (const auto &I : StringPool)
2277 Entries.push_back(std::make_pair(I.second.second, &I));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002278
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002279 array_pod_sort(Entries.begin(), Entries.end());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002280
Benjamin Kramer15596c72014-03-07 19:09:39 +00002281 for (const auto &Entry : Entries) {
Chris Lattner3d72a672010-03-09 23:38:23 +00002282 // Emit a label for reference from debug information entries.
Benjamin Kramer15596c72014-03-07 19:09:39 +00002283 Asm->OutStreamer.EmitLabel(Entry.second->getValue().first);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002284
Benjamin Kramer966ed1b2011-11-09 18:16:11 +00002285 // Emit the string itself with a terminating null byte.
Benjamin Kramer15596c72014-03-07 19:09:39 +00002286 Asm->OutStreamer.EmitBytes(StringRef(Entry.second->getKeyData(),
2287 Entry.second->getKeyLength() + 1));
Bill Wendling480ff322009-05-20 23:21:38 +00002288 }
Eric Christopher2cbd5762013-01-07 19:32:41 +00002289
2290 // If we've got an offset section go ahead and emit that now as well.
2291 if (OffsetSection) {
2292 Asm->OutStreamer.SwitchSection(OffsetSection);
2293 unsigned offset = 0;
Eric Christopher962c9082013-01-15 23:56:56 +00002294 unsigned size = 4; // FIXME: DWARF64 is 8.
Benjamin Kramer15596c72014-03-07 19:09:39 +00002295 for (const auto &Entry : Entries) {
Eric Christopherbf7bc492013-01-09 03:52:05 +00002296 Asm->OutStreamer.EmitIntValue(offset, size);
Benjamin Kramer15596c72014-03-07 19:09:39 +00002297 offset += Entry.second->getKeyLength() + 1;
Eric Christopher2cbd5762013-01-07 19:32:41 +00002298 }
2299 }
Bill Wendling480ff322009-05-20 23:21:38 +00002300}
2301
Eric Christopher65132a82013-11-19 09:11:26 +00002302// Emit addresses into the section given.
Eric Christopherf8194852013-12-05 18:06:10 +00002303void DwarfFile::emitAddresses(const MCSection *AddrSection) {
Eric Christopher962c9082013-01-15 23:56:56 +00002304
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002305 if (AddressPool.empty())
2306 return;
Eric Christopher962c9082013-01-15 23:56:56 +00002307
2308 // Start the dwarf addr section.
2309 Asm->OutStreamer.SwitchSection(AddrSection);
2310
David Blaikiece1960f2013-07-08 17:51:28 +00002311 // Order the address pool entries by ID
David Blaikieac569a62013-07-08 17:33:10 +00002312 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
Eric Christopher962c9082013-01-15 23:56:56 +00002313
Benjamin Kramer15596c72014-03-07 19:09:39 +00002314 for (const auto &I : AddressPool)
2315 Entries[I.second.Number] =
2316 I.second.TLS
2317 ? Asm->getObjFileLowering().getDebugThreadLocalSymbol(I.first)
2318 : MCSymbolRefExpr::Create(I.first, Asm->OutContext);
Eric Christopher962c9082013-01-15 23:56:56 +00002319
Benjamin Kramer15596c72014-03-07 19:09:39 +00002320 for (const MCExpr *Entry : Entries)
2321 Asm->OutStreamer.EmitValue(Entry, Asm->getDataLayout().getPointerSize());
Eric Christopher962c9082013-01-15 23:56:56 +00002322}
2323
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002324// Emit visible names into a debug str section.
2325void DwarfDebug::emitDebugStr() {
Eric Christopherf8194852013-12-05 18:06:10 +00002326 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002327 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2328}
2329
Eric Christopher29e874d2014-03-07 22:40:37 +00002330void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
Eric Christopher05135fb2014-03-18 02:18:24 +00002331 const DebugLocEntry &Entry) {
Eric Christopher29e874d2014-03-07 22:40:37 +00002332 DIVariable DV(Entry.getVariable());
2333 if (Entry.isInt()) {
Adrian Prantl1a1647c2014-03-18 02:34:58 +00002334 DIBasicType BTy(resolve(DV.getType()));
Eric Christopher29e874d2014-03-07 22:40:37 +00002335 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2336 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2337 Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
2338 Streamer.EmitSLEB128(Entry.getInt());
2339 } else {
2340 Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
2341 Streamer.EmitULEB128(Entry.getInt());
2342 }
2343 } else if (Entry.isLocation()) {
2344 MachineLocation Loc = Entry.getLoc();
2345 if (!DV.hasComplexAddress())
2346 // Regular entry.
2347 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2348 else {
2349 // Complex address entry.
2350 unsigned N = DV.getNumAddrElements();
2351 unsigned i = 0;
2352 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2353 if (Loc.getOffset()) {
2354 i = 2;
2355 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2356 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2357 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2358 Streamer.EmitSLEB128(DV.getAddrElement(1));
2359 } else {
2360 // If first address element is OpPlus then emit
2361 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2362 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2363 Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
2364 i = 2;
2365 }
2366 } else {
2367 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2368 }
2369
2370 // Emit remaining complex address elements.
2371 for (; i < N; ++i) {
2372 uint64_t Element = DV.getAddrElement(i);
2373 if (Element == DIBuilder::OpPlus) {
2374 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2375 Streamer.EmitULEB128(DV.getAddrElement(++i));
2376 } else if (Element == DIBuilder::OpDeref) {
2377 if (!Loc.isReg())
2378 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2379 } else
2380 llvm_unreachable("unknown Opcode found in complex address");
2381 }
2382 }
2383 }
2384 // else ... ignore constant fp. There is not any good way to
2385 // to represent them here in dwarf.
2386 // FIXME: ^
2387}
2388
Eric Christopher9046f942013-07-02 21:36:07 +00002389// Emit locations into the debug loc section.
Devang Patel930143b2009-11-21 02:48:08 +00002390void DwarfDebug::emitDebugLoc() {
Daniel Dunbarfd95b012011-03-16 22:16:39 +00002391 // Start the dwarf loc section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002392 Asm->OutStreamer.SwitchSection(
David Blaikie9c550ac2014-03-25 01:44:02 +00002393 useSplitDwarf() ? Asm->getObjFileLowering().getDwarfLocDWOSection()
2394 : Asm->getObjFileLowering().getDwarfLocSection());
Chandler Carruth5da3f052012-11-01 09:14:31 +00002395 unsigned char Size = Asm->getDataLayout().getPointerSize();
David Blaikie84d8e182014-03-24 22:38:38 +00002396 unsigned index = 0;
2397 for (const auto &DebugLoc : DotDebugLocEntries) {
2398 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2399 for (const auto &Entry : DebugLoc) {
Eric Christopher384f3fe2014-03-20 19:16:16 +00002400 // Set up the range. This range is relative to the entry point of the
2401 // compile unit. This is a hard coded 0 for low_pc when we're emitting
2402 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2403 const DwarfCompileUnit *CU = Entry.getCU();
David Blaikie9c550ac2014-03-25 01:44:02 +00002404 if (useSplitDwarf()) {
2405 // Just always use start_length for now - at least that's one address
2406 // rather than two. We could get fancier and try to, say, reuse an
2407 // address we know we've emitted elsewhere (the start of the function?
2408 // The start of the CU or CU subrange that encloses this range?)
2409 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2410 unsigned idx = InfoHolder.getAddrPoolIndex(Entry.getBeginSym());
2411 Asm->EmitULEB128(idx);
2412 Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2413 } else if (CU->getRanges().size() == 1) {
Eric Christopher384f3fe2014-03-20 19:16:16 +00002414 // Grab the begin symbol from the first range as our base.
2415 const MCSymbol *Base = CU->getRanges()[0].getStart();
2416 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2417 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2418 } else {
2419 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2420 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2421 }
Rafael Espindolad23bfb82011-05-27 22:05:41 +00002422 Asm->OutStreamer.AddComment("Loc expr size");
2423 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2424 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2425 Asm->EmitLabelDifference(end, begin, 2);
2426 Asm->OutStreamer.EmitLabel(begin);
Eric Christopher29e874d2014-03-07 22:40:37 +00002427 // Emit the entry.
2428 APByteStreamer Streamer(*Asm);
2429 emitDebugLocEntry(Streamer, Entry);
2430 // Close the range.
Rafael Espindolad23bfb82011-05-27 22:05:41 +00002431 Asm->OutStreamer.EmitLabel(end);
Devang Patel9fc11702010-05-25 23:40:22 +00002432 }
David Blaikie9c550ac2014-03-25 01:44:02 +00002433 if (useSplitDwarf())
2434 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2435 else {
2436 Asm->OutStreamer.EmitIntValue(0, Size);
2437 Asm->OutStreamer.EmitIntValue(0, Size);
2438 }
David Blaikie84d8e182014-03-24 22:38:38 +00002439 ++index;
Devang Patel9fc11702010-05-25 23:40:22 +00002440 }
Bill Wendling480ff322009-05-20 23:21:38 +00002441}
2442
Richard Mitton21101b32013-09-19 23:21:01 +00002443struct ArangeSpan {
2444 const MCSymbol *Start, *End;
2445};
2446
2447// Emit a debug aranges section, containing a CU lookup for any
2448// address we can tie back to a CU.
Eric Christopher7b30f2e42012-11-21 00:34:35 +00002449void DwarfDebug::emitDebugARanges() {
Bill Wendling480ff322009-05-20 23:21:38 +00002450 // Start the dwarf aranges section.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002451 Asm->OutStreamer.SwitchSection(
2452 Asm->getObjFileLowering().getDwarfARangesSection());
Richard Mitton21101b32013-09-19 23:21:01 +00002453
Eric Christopher4287a492013-12-09 23:57:44 +00002454 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
Richard Mitton21101b32013-09-19 23:21:01 +00002455
2456 SpansType Spans;
2457
2458 // Build a list of sections used.
2459 std::vector<const MCSection *> Sections;
Benjamin Kramer15596c72014-03-07 19:09:39 +00002460 for (const auto &it : SectionMap) {
2461 const MCSection *Section = it.first;
Richard Mitton21101b32013-09-19 23:21:01 +00002462 Sections.push_back(Section);
2463 }
2464
2465 // Sort the sections into order.
2466 // This is only done to ensure consistent output order across different runs.
2467 std::sort(Sections.begin(), Sections.end(), SectionSort);
2468
2469 // Build a set of address spans, sorted by CU.
Benjamin Kramer15596c72014-03-07 19:09:39 +00002470 for (const MCSection *Section : Sections) {
Richard Mitton21101b32013-09-19 23:21:01 +00002471 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2472 if (List.size() < 2)
2473 continue;
2474
2475 // Sort the symbols by offset within the section.
Benjamin Kramer571e2fe2014-03-07 19:41:22 +00002476 std::sort(List.begin(), List.end(),
2477 [&](const SymbolCU &A, const SymbolCU &B) {
2478 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2479 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2480
2481 // Symbols with no order assigned should be placed at the end.
2482 // (e.g. section end labels)
2483 if (IA == 0)
2484 return false;
2485 if (IB == 0)
2486 return true;
2487 return IA < IB;
2488 });
Richard Mitton21101b32013-09-19 23:21:01 +00002489
2490 // If we have no section (e.g. common), just write out
2491 // individual spans for each symbol.
2492 if (Section == NULL) {
Benjamin Kramer15596c72014-03-07 19:09:39 +00002493 for (const SymbolCU &Cur : List) {
Richard Mitton21101b32013-09-19 23:21:01 +00002494 ArangeSpan Span;
2495 Span.Start = Cur.Sym;
2496 Span.End = NULL;
2497 if (Cur.CU)
2498 Spans[Cur.CU].push_back(Span);
2499 }
2500 } else {
2501 // Build spans between each label.
2502 const MCSymbol *StartSym = List[0].Sym;
Benjamin Kramer15596c72014-03-07 19:09:39 +00002503 for (size_t n = 1, e = List.size(); n < e; n++) {
Richard Mitton21101b32013-09-19 23:21:01 +00002504 const SymbolCU &Prev = List[n - 1];
2505 const SymbolCU &Cur = List[n];
2506
2507 // Try and build the longest span we can within the same CU.
2508 if (Cur.CU != Prev.CU) {
2509 ArangeSpan Span;
2510 Span.Start = StartSym;
2511 Span.End = Cur.Sym;
2512 Spans[Prev.CU].push_back(Span);
2513 StartSym = Cur.Sym;
2514 }
2515 }
2516 }
2517 }
2518
Richard Mitton21101b32013-09-19 23:21:01 +00002519 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2520
2521 // Build a list of CUs used.
Eric Christopher4287a492013-12-09 23:57:44 +00002522 std::vector<DwarfCompileUnit *> CUs;
Benjamin Kramer15596c72014-03-07 19:09:39 +00002523 for (const auto &it : Spans) {
2524 DwarfCompileUnit *CU = it.first;
Richard Mitton21101b32013-09-19 23:21:01 +00002525 CUs.push_back(CU);
2526 }
2527
2528 // Sort the CU list (again, to ensure consistent output order).
Benjamin Kramer571e2fe2014-03-07 19:41:22 +00002529 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2530 return A->getUniqueID() < B->getUniqueID();
2531 });
Richard Mitton21101b32013-09-19 23:21:01 +00002532
2533 // Emit an arange table for each CU we used.
Benjamin Kramer15596c72014-03-07 19:09:39 +00002534 for (DwarfCompileUnit *CU : CUs) {
Richard Mitton21101b32013-09-19 23:21:01 +00002535 std::vector<ArangeSpan> &List = Spans[CU];
2536
2537 // Emit size of content not including length itself.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002538 unsigned ContentSize =
2539 sizeof(int16_t) + // DWARF ARange version number
2540 sizeof(int32_t) + // Offset of CU in the .debug_info section
2541 sizeof(int8_t) + // Pointer Size (in bytes)
2542 sizeof(int8_t); // Segment Size (in bytes)
Richard Mitton21101b32013-09-19 23:21:01 +00002543
2544 unsigned TupleSize = PtrSize * 2;
2545
2546 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
Benjamin Kramer8a68ab32014-01-07 19:28:14 +00002547 unsigned Padding =
2548 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
Richard Mitton21101b32013-09-19 23:21:01 +00002549
2550 ContentSize += Padding;
2551 ContentSize += (List.size() + 1) * TupleSize;
2552
2553 // For each compile unit, write the list of spans it covers.
2554 Asm->OutStreamer.AddComment("Length of ARange Set");
2555 Asm->EmitInt32(ContentSize);
2556 Asm->OutStreamer.AddComment("DWARF Arange version number");
2557 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2558 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
Eric Christopherd8667202013-12-30 17:22:27 +00002559 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
Richard Mitton21101b32013-09-19 23:21:01 +00002560 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2561 Asm->EmitInt8(PtrSize);
2562 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2563 Asm->EmitInt8(0);
2564
Benjamin Kramer8a68ab32014-01-07 19:28:14 +00002565 Asm->OutStreamer.EmitFill(Padding, 0xff);
Richard Mitton21101b32013-09-19 23:21:01 +00002566
Benjamin Kramer15596c72014-03-07 19:09:39 +00002567 for (const ArangeSpan &Span : List) {
Richard Mitton21101b32013-09-19 23:21:01 +00002568 Asm->EmitLabelReference(Span.Start, PtrSize);
2569
2570 // Calculate the size as being from the span start to it's end.
Richard Mitton089ed892013-09-23 17:56:20 +00002571 if (Span.End) {
Richard Mitton21101b32013-09-19 23:21:01 +00002572 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
Richard Mitton089ed892013-09-23 17:56:20 +00002573 } else {
2574 // For symbols without an end marker (e.g. common), we
2575 // write a single arange entry containing just that one symbol.
2576 uint64_t Size = SymSize[Span.Start];
2577 if (Size == 0)
2578 Size = 1;
2579
2580 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2581 }
Richard Mitton21101b32013-09-19 23:21:01 +00002582 }
2583
2584 Asm->OutStreamer.AddComment("ARange terminator");
2585 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2586 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2587 }
Bill Wendling480ff322009-05-20 23:21:38 +00002588}
2589
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002590// Emit visible names into a debug ranges section.
Devang Patel930143b2009-11-21 02:48:08 +00002591void DwarfDebug::emitDebugRanges() {
Bill Wendling480ff322009-05-20 23:21:38 +00002592 // Start the dwarf ranges section.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002593 Asm->OutStreamer.SwitchSection(
2594 Asm->getObjFileLowering().getDwarfRangesSection());
Eric Christopher4751d702013-11-23 00:05:29 +00002595
Eric Christopher0f63d062013-12-03 00:45:45 +00002596 // Size for our labels.
2597 unsigned char Size = Asm->getDataLayout().getPointerSize();
2598
2599 // Grab the specific ranges for the compile units in the module.
Benjamin Kramer15596c72014-03-07 19:09:39 +00002600 for (const auto &I : CUMap) {
2601 DwarfCompileUnit *TheCU = I.second;
Eric Christopher0f63d062013-12-03 00:45:45 +00002602
2603 // Emit a symbol so we can find the beginning of our ranges.
David Blaikie1ab7c2d2013-12-09 17:51:30 +00002604 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
Eric Christopher0f63d062013-12-03 00:45:45 +00002605
2606 // Iterate over the misc ranges for the compile units in the module.
Benjamin Kramer15596c72014-03-07 19:09:39 +00002607 for (const RangeSpanList &List : TheCU->getRangeLists()) {
Eric Christopherf8790642013-12-04 22:04:50 +00002608 // Emit our symbol so we can find the beginning of the range.
2609 Asm->OutStreamer.EmitLabel(List.getSym());
Eric Christopher0f63d062013-12-03 00:45:45 +00002610
Benjamin Kramer15596c72014-03-07 19:09:39 +00002611 for (const RangeSpan &Range : List.getRanges()) {
Eric Christopher0f63d062013-12-03 00:45:45 +00002612 const MCSymbol *Begin = Range.getStart();
2613 const MCSymbol *End = Range.getEnd();
Eric Christopher565ab112013-12-20 04:34:22 +00002614 assert(Begin && "Range without a begin symbol?");
2615 assert(End && "Range without an end symbol?");
2616 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2617 Asm->OutStreamer.EmitSymbolValue(End, Size);
Eric Christopher0f63d062013-12-03 00:45:45 +00002618 }
2619
2620 // And terminate the list with two 0 values.
Eric Christopherce0cfce2013-01-09 01:35:34 +00002621 Asm->OutStreamer.EmitIntValue(0, Size);
Eric Christopher0f63d062013-12-03 00:45:45 +00002622 Asm->OutStreamer.EmitIntValue(0, Size);
2623 }
Eric Christopher46e23432013-12-20 04:16:18 +00002624
2625 // Now emit a range for the CU itself.
Eric Christopher384f3fe2014-03-20 19:16:16 +00002626 if (TheCU->getRanges().size() > 1) {
Eric Christopher46e23432013-12-20 04:16:18 +00002627 Asm->OutStreamer.EmitLabel(
2628 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
Benjamin Kramer15596c72014-03-07 19:09:39 +00002629 for (const RangeSpan &Range : TheCU->getRanges()) {
Eric Christopher46e23432013-12-20 04:16:18 +00002630 const MCSymbol *Begin = Range.getStart();
2631 const MCSymbol *End = Range.getEnd();
Eric Christopher565ab112013-12-20 04:34:22 +00002632 assert(Begin && "Range without a begin symbol?");
2633 assert(End && "Range without an end symbol?");
2634 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2635 Asm->OutStreamer.EmitSymbolValue(End, Size);
Eric Christopher46e23432013-12-20 04:16:18 +00002636 }
2637 // And terminate the list with two 0 values.
2638 Asm->OutStreamer.EmitIntValue(0, Size);
2639 Asm->OutStreamer.EmitIntValue(0, Size);
2640 }
Devang Patel12563b32010-04-16 23:33:45 +00002641 }
Bill Wendling480ff322009-05-20 23:21:38 +00002642}
2643
Eric Christopherd692c1d2012-12-11 19:42:09 +00002644// DWARF5 Experimental Separate Dwarf emitters.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002645
David Blaikie38fe6342014-01-09 04:28:46 +00002646void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2647 DwarfUnit *NewU) {
2648 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2649 U->getCUNode().getSplitDebugFilename());
2650
David Blaikie38fe6342014-01-09 04:28:46 +00002651 if (!CompilationDir.empty())
2652 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2653
2654 addGnuPubAttributes(NewU, Die);
2655
2656 SkeletonHolder.addUnit(NewU);
2657}
2658
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002659// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2660// DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
David Blaikie96dea052014-03-24 21:31:35 +00002661// DW_AT_addr_base, DW_AT_ranges_base.
Eric Christopher4287a492013-12-09 23:57:44 +00002662DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002663
2664 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Eric Christopher4287a492013-12-09 23:57:44 +00002665 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
David Blaikief645f962014-01-09 03:23:41 +00002666 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
David Blaikie1ab7c2d2013-12-09 17:51:30 +00002667 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2668 DwarfInfoSectionSym);
Eric Christopher4c7765f2013-01-17 03:00:04 +00002669
David Blaikie2494fdb2014-02-14 22:41:51 +00002670 NewCU->initStmtList(DwarfLineSectionSym);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002671
David Blaikie38fe6342014-01-09 04:28:46 +00002672 initSkeletonUnit(CU, Die, NewCU);
Eric Christopherc8a310e2012-12-10 23:34:43 +00002673
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002674 return NewCU;
2675}
2676
David Blaikie15ed5eb2014-01-10 01:38:41 +00002677// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2678// DW_AT_addr_base.
David Blaikie15632ae2014-02-12 00:31:30 +00002679DwarfTypeUnit *DwarfDebug::constructSkeletonTU(DwarfTypeUnit *TU) {
David Blaikie60e63862014-02-14 23:58:13 +00002680 DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2681 *SkeletonHolder.getUnits()[TU->getCU().getUniqueID()]);
David Blaikie15ed5eb2014-01-10 01:38:41 +00002682
2683 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
David Blaikie60e63862014-02-14 23:58:13 +00002684 DwarfTypeUnit *NewTU =
2685 new DwarfTypeUnit(TU->getUniqueID(), Die, CU, Asm, this, &SkeletonHolder);
David Blaikie15ed5eb2014-01-10 01:38:41 +00002686 NewTU->setTypeSignature(TU->getTypeSignature());
2687 NewTU->setType(NULL);
2688 NewTU->initSection(
2689 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
2690
2691 initSkeletonUnit(TU, Die, NewTU);
2692 return NewTU;
2693}
2694
Eric Christopherd692c1d2012-12-11 19:42:09 +00002695// Emit the .debug_info.dwo section for separated dwarf. This contains the
2696// compile units that would normally be in debug_info.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002697void DwarfDebug::emitDebugInfoDWO() {
Eric Christophercdf218d2012-12-10 19:51:21 +00002698 assert(useSplitDwarf() && "No split dwarf debug info?");
David Blaikie3c9a3cc2014-03-24 20:53:02 +00002699 InfoHolder.emitUnits(this, nullptr);
Eric Christopher3c5a1912012-12-19 22:02:53 +00002700}
2701
2702// Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2703// abbreviations for the .debug_info.dwo section.
2704void DwarfDebug::emitDebugAbbrevDWO() {
2705 assert(useSplitDwarf() && "No split dwarf?");
David Blaikie0504cda2013-12-05 07:43:55 +00002706 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002707}
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002708
David Blaikie4a2f95f2014-03-18 01:17:26 +00002709void DwarfDebug::emitDebugLineDWO() {
2710 assert(useSplitDwarf() && "No split dwarf?");
2711 Asm->OutStreamer.SwitchSection(
2712 Asm->getObjFileLowering().getDwarfLineDWOSection());
David Blaikie8287aff2014-03-18 02:13:23 +00002713 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
David Blaikie4a2f95f2014-03-18 01:17:26 +00002714}
2715
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002716// Emit the .debug_str.dwo section for separated dwarf. This contains the
2717// string section and is identical in format to traditional .debug_str
2718// sections.
2719void DwarfDebug::emitDebugStrDWO() {
2720 assert(useSplitDwarf() && "No split dwarf?");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002721 const MCSection *OffSec =
2722 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
Eric Christopher2cbd5762013-01-07 19:32:41 +00002723 const MCSymbol *StrSym = DwarfStrSectionSym;
2724 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2725 OffSec, StrSym);
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002726}
David Blaikie409dd9c2013-11-19 23:08:21 +00002727
David Blaikie47f4b822014-03-19 00:11:28 +00002728MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2729 if (!useSplitDwarf())
2730 return nullptr;
2731 if (SingleCU)
2732 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2733 return &SplitTypeUnitFileTable;
2734}
2735
David Blaikie15632ae2014-02-12 00:31:30 +00002736void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
David Blaikief645f962014-01-09 03:23:41 +00002737 StringRef Identifier, DIE *RefDie,
2738 DICompositeType CTy) {
David Blaikie322d79b2014-01-31 19:52:26 +00002739 // Flag the type unit reference as a declaration so that if it contains
2740 // members (implicit special members, static data member definitions, member
2741 // declarations for definitions in this CU, etc) consumers don't get confused
2742 // and think this is a full definition.
David Blaikie15632ae2014-02-12 00:31:30 +00002743 CU.addFlag(RefDie, dwarf::DW_AT_declaration);
Chandler Carruthb587ab62014-01-20 08:07:07 +00002744
David Blaikie47f615e2013-12-17 23:32:35 +00002745 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
Chandler Carruthb587ab62014-01-20 08:07:07 +00002746 if (TU) {
David Blaikie15632ae2014-02-12 00:31:30 +00002747 CU.addDIETypeSignature(RefDie, *TU);
Chandler Carruthb587ab62014-01-20 08:07:07 +00002748 return;
David Blaikie409dd9c2013-11-19 23:08:21 +00002749 }
2750
Chandler Carruthb587ab62014-01-20 08:07:07 +00002751 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
David Blaikie47f4b822014-03-19 00:11:28 +00002752 DwarfTypeUnit *NewTU =
2753 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, CU, Asm, this,
2754 &InfoHolder, getDwoLineTable(CU));
Chandler Carruthb587ab62014-01-20 08:07:07 +00002755 TU = NewTU;
2756 InfoHolder.addUnit(NewTU);
2757
2758 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
David Blaikie15632ae2014-02-12 00:31:30 +00002759 CU.getLanguage());
Chandler Carruthb587ab62014-01-20 08:07:07 +00002760
2761 MD5 Hash;
2762 Hash.update(Identifier);
2763 // ... take the least significant 8 bytes and return those. Our MD5
2764 // implementation always returns its results in little endian, swap bytes
2765 // appropriately.
2766 MD5::MD5Result Result;
2767 Hash.final(Result);
2768 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2769 NewTU->setTypeSignature(Signature);
2770 if (useSplitDwarf())
2771 NewTU->setSkeleton(constructSkeletonTU(NewTU));
David Blaikie60e63862014-02-14 23:58:13 +00002772 else
2773 CU.applyStmtList(*UnitDie);
Chandler Carruthb587ab62014-01-20 08:07:07 +00002774
2775 NewTU->setType(NewTU->createTypeDIE(CTy));
2776
2777 NewTU->initSection(
2778 useSplitDwarf()
2779 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2780 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2781
David Blaikie15632ae2014-02-12 00:31:30 +00002782 CU.addDIETypeSignature(RefDie, *NewTU);
David Blaikie409dd9c2013-11-19 23:08:21 +00002783}
David Blaikie4bd13b72014-03-07 18:49:45 +00002784
2785void DwarfDebug::attachLowHighPC(DwarfCompileUnit *Unit, DIE *D,
2786 MCSymbol *Begin, MCSymbol *End) {
2787 Unit->addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
Adrian Prantl887e7072014-03-07 23:07:21 +00002788 if (DwarfVersion < 4)
David Blaikie4bd13b72014-03-07 18:49:45 +00002789 Unit->addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2790 else
2791 Unit->addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2792}