blob: a0052f605d70a2ef1805b36bf1ba763b92f3a6c1 [file] [log] [blame]
Bill Wendling2f921f82009-05-15 09:23:25 +00001//===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains support for writing dwarf debug info into asm files.
11//
12//===----------------------------------------------------------------------===//
Chris Lattnerb14490d2010-03-09 00:39:24 +000013
Devang Patel80ae3492009-08-28 23:24:31 +000014#define DEBUG_TYPE "dwarfdebug"
Bill Wendling2f921f82009-05-15 09:23:25 +000015#include "DwarfDebug.h"
Chris Lattner3f3fb972010-04-05 05:24:55 +000016#include "DIE.h"
Eric Christopher45731982013-08-08 23:45:55 +000017#include "DIEHash.h"
Eric Christopher4996c702011-11-07 09:24:32 +000018#include "DwarfAccelTable.h"
David Blaikie2c86a722013-12-02 19:33:15 +000019#include "DwarfUnit.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000020#include "llvm/ADT/STLExtras.h"
21#include "llvm/ADT/Statistic.h"
22#include "llvm/ADT/StringExtras.h"
23#include "llvm/ADT/Triple.h"
David Greene829b3e82009-08-19 21:52:55 +000024#include "llvm/CodeGen/MachineFunction.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000025#include "llvm/CodeGen/MachineModuleInfo.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000026#include "llvm/DIBuilder.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000027#include "llvm/DebugInfo.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000028#include "llvm/IR/Constants.h"
29#include "llvm/IR/DataLayout.h"
30#include "llvm/IR/Instructions.h"
31#include "llvm/IR/Module.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000032#include "llvm/MC/MCAsmInfo.h"
Chris Lattner4d2c0f92009-07-31 18:48:30 +000033#include "llvm/MC/MCSection.h"
Chris Lattner4b7dadb2009-08-19 05:49:37 +000034#include "llvm/MC/MCStreamer.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000035#include "llvm/MC/MCSymbol.h"
Devang Patel6c74a872010-04-27 19:46:33 +000036#include "llvm/Support/CommandLine.h"
Daniel Dunbarcdf01b52009-10-13 06:47:08 +000037#include "llvm/Support/Debug.h"
David Majnemered89b5c2013-08-21 06:13:34 +000038#include "llvm/Support/Dwarf.h"
Daniel Dunbarcdf01b52009-10-13 06:47:08 +000039#include "llvm/Support/ErrorHandling.h"
Chris Lattnerf5c834f2010-01-22 22:09:00 +000040#include "llvm/Support/FormattedStream.h"
Eric Christopher67646432013-07-26 17:02:41 +000041#include "llvm/Support/MD5.h"
Michael J. Spencer447762d2010-11-29 18:16:10 +000042#include "llvm/Support/Path.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000043#include "llvm/Support/Timer.h"
44#include "llvm/Support/ValueHandle.h"
45#include "llvm/Target/TargetFrameLowering.h"
46#include "llvm/Target/TargetLoweringObjectFile.h"
47#include "llvm/Target/TargetMachine.h"
48#include "llvm/Target/TargetOptions.h"
49#include "llvm/Target/TargetRegisterInfo.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000050using namespace llvm;
51
Eric Christopher7f2b5512013-07-23 22:16:41 +000052static cl::opt<bool>
53DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
54 cl::desc("Disable debug info printing"));
Devang Patel6c74a872010-04-27 19:46:33 +000055
Eric Christopher7f2b5512013-07-23 22:16:41 +000056static cl::opt<bool> UnknownLocations(
57 "use-unknown-locations", cl::Hidden,
58 cl::desc("Make an absence of debug location information explicit."),
59 cl::init(false));
Dan Gohman7421ae42010-05-07 01:08:53 +000060
Eric Christopher7f2b5512013-07-23 22:16:41 +000061static cl::opt<bool>
Eric Christopher67646432013-07-26 17:02:41 +000062GenerateODRHash("generate-odr-hash", cl::Hidden,
63 cl::desc("Add an ODR hash to external type DIEs."),
64 cl::init(false));
65
Eric Christopherb4bef6d2013-11-19 09:04:36 +000066static cl::opt<bool> GenerateCUHash("generate-cu-hash", cl::Hidden,
67 cl::desc("Add the CU hash as the dwo_id."),
68 cl::init(false));
Eric Christopherd29614f2013-08-13 01:21:55 +000069
Eric Christopherdd1a0122013-09-13 00:35:05 +000070static cl::opt<bool>
71GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
72 cl::desc("Generate GNU-style pubnames and pubtypes"),
73 cl::init(false));
74
Eric Christopher20b76a72012-08-23 22:36:40 +000075namespace {
Eric Christopher7f2b5512013-07-23 22:16:41 +000076enum DefaultOnOff {
77 Default,
78 Enable,
79 Disable
80};
Eric Christopher20b76a72012-08-23 22:36:40 +000081}
Eric Christopher4996c702011-11-07 09:24:32 +000082
Eric Christopher7f2b5512013-07-23 22:16:41 +000083static cl::opt<DefaultOnOff>
84DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
85 cl::desc("Output prototype dwarf accelerator tables."),
86 cl::values(clEnumVal(Default, "Default for platform"),
87 clEnumVal(Enable, "Enabled"),
88 clEnumVal(Disable, "Disabled"), clEnumValEnd),
89 cl::init(Default));
Eric Christopher20b76a72012-08-23 22:36:40 +000090
Eric Christopher7f2b5512013-07-23 22:16:41 +000091static cl::opt<DefaultOnOff>
Eric Christopher7f2b5512013-07-23 22:16:41 +000092SplitDwarf("split-dwarf", cl::Hidden,
Eric Christopher5d008fe2013-12-04 23:24:28 +000093 cl::desc("Output DWARF5 split debug info."),
Eric Christopher7f2b5512013-07-23 22:16:41 +000094 cl::values(clEnumVal(Default, "Default for platform"),
95 clEnumVal(Enable, "Enabled"),
96 clEnumVal(Disable, "Disabled"), clEnumValEnd),
97 cl::init(Default));
Eric Christopher29424312012-11-12 22:22:20 +000098
Eric Christopher7da24882013-08-19 21:07:38 +000099static cl::opt<DefaultOnOff>
Eric Christopher4d36ca02013-08-26 23:24:35 +0000100DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
101 cl::desc("Generate DWARF pubnames and pubtypes sections"),
102 cl::values(clEnumVal(Default, "Default for platform"),
103 clEnumVal(Enable, "Enabled"),
104 clEnumVal(Disable, "Disabled"), clEnumValEnd),
105 cl::init(Default));
Eric Christopher7da24882013-08-19 21:07:38 +0000106
Eric Christopher33ff6972013-11-21 23:46:41 +0000107static cl::opt<unsigned>
108DwarfVersionNumber("dwarf-version", cl::Hidden,
Eric Christophera5a79422013-12-09 23:32:48 +0000109 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
Eric Christopher33ff6972013-11-21 23:46:41 +0000110
Eric Christopher46e23432013-12-20 04:16:18 +0000111static cl::opt<bool>
112DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
113 cl::desc("Generate DW_AT_ranges for compile units"),
114 cl::init(false));
115
Benjamin Kramerb12cf012013-08-24 12:54:27 +0000116static const char *const DWARFGroupName = "DWARF Emission";
117static const char *const DbgTimerName = "DWARF Debug Writer";
Bill Wendlingfcc14142010-04-07 09:28:04 +0000118
Bill Wendling2f921f82009-05-15 09:23:25 +0000119//===----------------------------------------------------------------------===//
120
Bill Wendling2f921f82009-05-15 09:23:25 +0000121namespace llvm {
122
Manman Renbe5576f2013-10-08 19:07:44 +0000123/// resolve - Look in the DwarfDebug map for the MDNode that
124/// corresponds to the reference.
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000125template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
Manman Renbe5576f2013-10-08 19:07:44 +0000126 return DD->resolve(Ref);
127}
128
Nick Lewycky019d2552011-07-29 03:49:23 +0000129DIType DbgVariable::getType() const {
Devang Patelf20c4f72011-04-12 22:53:02 +0000130 DIType Ty = Var.getType();
131 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
132 // addresses instead.
133 if (Var.isBlockByrefVariable()) {
134 /* Byref variables, in Blocks, are declared by the programmer as
135 "SomeType VarName;", but the compiler creates a
136 __Block_byref_x_VarName struct, and gives the variable VarName
137 either the struct, or a pointer to the struct, as its type. This
138 is necessary for various behind-the-scenes things the compiler
139 needs to do with by-reference variables in blocks.
Eric Christopher6a841382012-11-19 22:42:10 +0000140
Devang Patelf20c4f72011-04-12 22:53:02 +0000141 However, as far as the original *programmer* is concerned, the
142 variable should still have type 'SomeType', as originally declared.
Eric Christopher6a841382012-11-19 22:42:10 +0000143
Devang Patelf20c4f72011-04-12 22:53:02 +0000144 The following function dives into the __Block_byref_x_VarName
145 struct to find the original type of the variable. This will be
146 passed back to the code generating the type for the Debug
147 Information Entry for the variable 'VarName'. 'VarName' will then
148 have the original type 'SomeType' in its debug information.
Eric Christopher6a841382012-11-19 22:42:10 +0000149
Devang Patelf20c4f72011-04-12 22:53:02 +0000150 The original type 'SomeType' will be the type of the field named
151 'VarName' inside the __Block_byref_x_VarName struct.
Eric Christopher6a841382012-11-19 22:42:10 +0000152
Devang Patelf20c4f72011-04-12 22:53:02 +0000153 NOTE: In order for this to not completely fail on the debugger
154 side, the Debug Information Entry for the variable VarName needs to
155 have a DW_AT_location that tells the debugger how to unwind through
156 the pointers and __Block_byref_x_VarName struct to find the actual
157 value of the variable. The function addBlockByrefType does this. */
158 DIType subType = Ty;
Eric Christopher31b05762013-08-08 01:41:00 +0000159 uint16_t tag = Ty.getTag();
Eric Christopher6a841382012-11-19 22:42:10 +0000160
Eric Christopher9adc55f2013-09-04 19:53:21 +0000161 if (tag == dwarf::DW_TAG_pointer_type)
Manman Renbe5576f2013-10-08 19:07:44 +0000162 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
Eric Christopher6a841382012-11-19 22:42:10 +0000163
Eric Christopher9adc55f2013-09-04 19:53:21 +0000164 DIArray Elements = DICompositeType(subType).getTypeArray();
Devang Patelf20c4f72011-04-12 22:53:02 +0000165 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
David Blaikie5af2aca2013-11-18 23:57:26 +0000166 DIDerivedType DT(Elements.getElement(i));
Devang Patelf20c4f72011-04-12 22:53:02 +0000167 if (getName() == DT.getName())
Manman Renbe5576f2013-10-08 19:07:44 +0000168 return (resolve(DT.getTypeDerivedFrom()));
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000169 }
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000170 }
Devang Patelf20c4f72011-04-12 22:53:02 +0000171 return Ty;
172}
Bill Wendling2f921f82009-05-15 09:23:25 +0000173
Chris Lattnerf5d06362010-04-05 04:09:20 +0000174} // end llvm namespace
Bill Wendling2f921f82009-05-15 09:23:25 +0000175
Manman Renac8062b2013-07-02 23:40:10 +0000176/// Return Dwarf Version by checking module flags.
177static unsigned getDwarfVersionFromModule(const Module *M) {
Manman Ren8bfde892013-07-16 23:21:16 +0000178 Value *Val = M->getModuleFlag("Dwarf Version");
179 if (!Val)
Eric Christophere31e0722013-09-04 22:21:24 +0000180 return dwarf::DWARF_VERSION;
Manman Ren8bfde892013-07-16 23:21:16 +0000181 return cast<ConstantInt>(Val)->getZExtValue();
Manman Renac8062b2013-07-02 23:40:10 +0000182}
183
Chris Lattnerf0d6bd32010-04-05 05:11:15 +0000184DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
David Blaikie0504cda2013-12-05 07:43:55 +0000185 : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
David Blaikie2666e242013-12-06 19:38:46 +0000186 PrevLabel(NULL), GlobalRangeCount(0),
David Blaikie0504cda2013-12-05 07:43:55 +0000187 InfoHolder(A, "info_string", DIEValueAllocator),
188 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000189
Eric Christopher50effa02014-01-03 02:16:44 +0000190 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
Eric Christopher74804332013-02-07 21:19:50 +0000191 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
Eric Christopher55863be2013-04-07 03:43:09 +0000192 DwarfAddrSectionSym = 0;
Eric Christopher3bf29fd2012-12-27 02:14:01 +0000193 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
Devang Patel9fc11702010-05-25 23:40:22 +0000194 FunctionBeginSym = FunctionEndSym = 0;
Eric Christophera5a79422013-12-09 23:32:48 +0000195 CurFn = 0;
196 CurMI = 0;
Eric Christopherad9fe892012-04-02 17:58:52 +0000197
Adrian Prantl5bf1d002013-10-15 20:26:37 +0000198 // Turn on accelerator tables for Darwin by default, pubnames by
199 // default for non-Darwin, and handle split dwarf.
Eric Christopher203e12b2013-04-27 01:07:52 +0000200 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
Eric Christopher4977f212012-08-23 22:36:36 +0000201
Eric Christopher574b5c82013-08-19 21:41:38 +0000202 if (DwarfAccelTables == Default)
203 HasDwarfAccelTables = IsDarwin;
204 else
Eric Christopher5297df02013-08-26 20:58:35 +0000205 HasDwarfAccelTables = DwarfAccelTables == Enable;
Eric Christopher20b76a72012-08-23 22:36:40 +0000206
Eric Christophercdf218d2012-12-10 19:51:21 +0000207 if (SplitDwarf == Default)
208 HasSplitDwarf = false;
Eric Christopher29424312012-11-12 22:22:20 +0000209 else
Eric Christopher574b5c82013-08-19 21:41:38 +0000210 HasSplitDwarf = SplitDwarf == Enable;
Eric Christopher29424312012-11-12 22:22:20 +0000211
Eric Christopher4d36ca02013-08-26 23:24:35 +0000212 if (DwarfPubSections == Default)
213 HasDwarfPubSections = !IsDarwin;
Eric Christopher574b5c82013-08-19 21:41:38 +0000214 else
Eric Christopher4d36ca02013-08-26 23:24:35 +0000215 HasDwarfPubSections = DwarfPubSections == Enable;
Eric Christopher7da24882013-08-19 21:07:38 +0000216
Eric Christopher33ff6972013-11-21 23:46:41 +0000217 DwarfVersion = DwarfVersionNumber
218 ? DwarfVersionNumber
219 : getDwarfVersionFromModule(MMI->getModule());
Manman Renac8062b2013-07-02 23:40:10 +0000220
Dan Gohman6e681a52010-06-18 15:56:31 +0000221 {
222 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
Eric Christopher58f41952012-11-19 22:42:15 +0000223 beginModule();
Torok Edwinf8dba242010-04-07 10:44:46 +0000224 }
Bill Wendling2f921f82009-05-15 09:23:25 +0000225}
Bill Wendling2f921f82009-05-15 09:23:25 +0000226
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000227// Switch to the specified MCSection and emit an assembler
228// temporary label to it if SymbolStem is specified.
Eric Christopher7b30f2e42012-11-21 00:34:35 +0000229static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
Eric Christophera7b61892011-11-07 09:18:38 +0000230 const char *SymbolStem = 0) {
231 Asm->OutStreamer.SwitchSection(Section);
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000232 if (!SymbolStem)
233 return 0;
Eric Christophera7b61892011-11-07 09:18:38 +0000234
235 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
236 Asm->OutStreamer.EmitLabel(TmpSym);
237 return TmpSym;
238}
239
Eric Christopherf8194852013-12-05 18:06:10 +0000240DwarfFile::~DwarfFile() {
Eric Christophera5a79422013-12-09 23:32:48 +0000241 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
242 I != E; ++I)
David Blaikie72f1a3e2013-11-23 01:17:34 +0000243 delete *I;
244}
245
Eric Christopherf8194852013-12-05 18:06:10 +0000246MCSymbol *DwarfFile::getStringPoolSym() {
Eric Christopher3bf29fd2012-12-27 02:14:01 +0000247 return Asm->GetTempSymbol(StringPref);
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000248}
249
Eric Christopherf8194852013-12-05 18:06:10 +0000250MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000251 std::pair<MCSymbol *, unsigned> &Entry =
252 StringPool.GetOrCreateValue(Str).getValue();
253 if (Entry.first)
254 return Entry.first;
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000255
256 Entry.second = NextStringPoolNumber++;
Eric Christopher3bf29fd2012-12-27 02:14:01 +0000257 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000258}
259
Eric Christopherf8194852013-12-05 18:06:10 +0000260unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000261 std::pair<MCSymbol *, unsigned> &Entry =
262 StringPool.GetOrCreateValue(Str).getValue();
263 if (Entry.first)
264 return Entry.second;
Eric Christopher2cbd5762013-01-07 19:32:41 +0000265
266 Entry.second = NextStringPoolNumber++;
267 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
268 return Entry.second;
269}
270
Eric Christopherf8194852013-12-05 18:06:10 +0000271unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym) {
David Blaikie8466ca82013-07-01 23:55:52 +0000272 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
273}
274
Eric Christopherf8194852013-12-05 18:06:10 +0000275unsigned DwarfFile::getAddrPoolIndex(const MCExpr *Sym) {
Ulrich Weigand8b3d2262013-07-02 18:46:46 +0000276 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
David Blaikieb8ef7852013-06-28 18:47:19 +0000277 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
David Blaikiea67de2b2013-06-28 18:55:13 +0000278 if (P.second)
279 ++NextAddrPoolNumber;
David Blaikieb8ef7852013-06-28 18:47:19 +0000280 return P.first->second;
Eric Christopher962c9082013-01-15 23:56:56 +0000281}
282
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000283// Define a unique number for the abbreviation.
284//
Eric Christopherf8194852013-12-05 18:06:10 +0000285void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
Bill Wendling2f921f82009-05-15 09:23:25 +0000286 // Check the set for priors.
David Blaikie0504cda2013-12-05 07:43:55 +0000287 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
Bill Wendling2f921f82009-05-15 09:23:25 +0000288
289 // If it's newly added.
290 if (InSet == &Abbrev) {
291 // Add to abbreviation list.
David Blaikie2d4e1122013-10-30 17:14:24 +0000292 Abbreviations.push_back(&Abbrev);
Bill Wendling2f921f82009-05-15 09:23:25 +0000293
294 // Assign the vector position + 1 as its number.
David Blaikie2d4e1122013-10-30 17:14:24 +0000295 Abbrev.setNumber(Abbreviations.size());
Bill Wendling2f921f82009-05-15 09:23:25 +0000296 } else {
297 // Assign existing abbreviation number.
298 Abbrev.setNumber(InSet->getNumber());
299 }
300}
301
Eric Christopherd9843b32011-11-10 19:25:34 +0000302static bool isObjCClass(StringRef Name) {
303 return Name.startswith("+") || Name.startswith("-");
304}
305
306static bool hasObjCCategory(StringRef Name) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000307 if (!isObjCClass(Name))
308 return false;
Eric Christopherd9843b32011-11-10 19:25:34 +0000309
Benjamin Kramer260de742013-08-24 12:15:54 +0000310 return Name.find(") ") != StringRef::npos;
Eric Christopherd9843b32011-11-10 19:25:34 +0000311}
312
313static void getObjCClassCategory(StringRef In, StringRef &Class,
314 StringRef &Category) {
315 if (!hasObjCCategory(In)) {
316 Class = In.slice(In.find('[') + 1, In.find(' '));
317 Category = "";
318 return;
319 }
320
321 Class = In.slice(In.find('[') + 1, In.find('('));
322 Category = In.slice(In.find('[') + 1, In.find(' '));
323 return;
324}
325
326static StringRef getObjCMethodName(StringRef In) {
327 return In.slice(In.find(' ') + 1, In.find(']'));
328}
329
Richard Mittonc2508242013-10-03 22:07:08 +0000330// Helper for sorting sections into a stable output order.
331static bool SectionSort(const MCSection *A, const MCSection *B) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000332 std::string LA = (A ? A->getLabelBeginName() : "");
333 std::string LB = (B ? B->getLabelBeginName() : "");
334 return LA < LB;
Richard Mittonc2508242013-10-03 22:07:08 +0000335}
336
Eric Christopherd9843b32011-11-10 19:25:34 +0000337// Add the various names to the Dwarf accelerator table names.
Eric Christopher9cd26af2013-09-20 23:22:52 +0000338// TODO: Determine whether or not we should add names for programs
339// that do not have a DW_AT_name or DW_AT_linkage_name field - this
340// is only slightly different than the lookup of non-standard ObjC names.
Eric Christophera5a79422013-12-09 23:32:48 +0000341static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000342 if (!SP.isDefinition())
343 return;
David Blaikie2a80e442013-12-02 22:09:48 +0000344 TheU->addAccelName(SP.getName(), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000345
346 // If the linkage name is different than the name, go ahead and output
347 // that as well into the name table.
348 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
David Blaikie2a80e442013-12-02 22:09:48 +0000349 TheU->addAccelName(SP.getLinkageName(), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000350
351 // If this is an Objective-C selector name add it to the ObjC accelerator
352 // too.
353 if (isObjCClass(SP.getName())) {
354 StringRef Class, Category;
355 getObjCClassCategory(SP.getName(), Class, Category);
David Blaikie2a80e442013-12-02 22:09:48 +0000356 TheU->addAccelObjC(Class, Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000357 if (Category != "")
David Blaikie2a80e442013-12-02 22:09:48 +0000358 TheU->addAccelObjC(Category, Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000359 // Also add the base method name to the name table.
David Blaikie2a80e442013-12-02 22:09:48 +0000360 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
Eric Christopherd9843b32011-11-10 19:25:34 +0000361 }
362}
363
Manman Ren3eb9dff2013-09-09 19:05:21 +0000364/// isSubprogramContext - Return true if Context is either a subprogram
365/// or another context nested inside a subprogram.
366bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
367 if (!Context)
368 return false;
369 DIDescriptor D(Context);
370 if (D.isSubprogram())
371 return true;
372 if (D.isType())
Manman Ren116868e2013-09-09 19:47:11 +0000373 return isSubprogramContext(resolve(DIType(Context).getContext()));
Manman Ren3eb9dff2013-09-09 19:05:21 +0000374 return false;
375}
376
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000377// Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
378// and DW_AT_high_pc attributes. If there are global variables in this
379// scope then create and insert DIEs for these variables.
Eric Christopher4287a492013-12-09 23:57:44 +0000380DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
381 DISubprogram SP) {
David Blaikie25bc7192013-11-15 23:13:08 +0000382 DIE *SPDie = SPCU->getDIE(SP);
Devang Patela37a95e2010-07-07 22:20:57 +0000383
Chris Lattner3a383cb2010-04-05 00:13:49 +0000384 assert(SPDie && "Unable to find subprogram DIE!");
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000385
Bill Wendlingf720bf62012-11-07 05:19:04 +0000386 // If we're updating an abstract DIE, then we will be adding the children and
387 // object pointer later on. But what we don't want to do is process the
388 // concrete DIE twice.
David Blaikie25bc7192013-11-15 23:13:08 +0000389 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
Bill Wendlingf720bf62012-11-07 05:19:04 +0000390 // Pick up abstract subprogram DIE.
David Blaikie2a80e442013-12-02 22:09:48 +0000391 SPDie =
392 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
Manman Ren4c4b69c2013-10-11 23:58:05 +0000393 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000394 } else {
395 DISubprogram SPDecl = SP.getFunctionDeclaration();
396 if (!SPDecl.isSubprogram()) {
397 // There is not any need to generate specification DIE for a function
398 // defined at compile unit level. If a function is defined inside another
399 // function then gdb prefers the definition at top level and but does not
400 // expect specification DIE in parent function. So avoid creating
401 // specification DIE for a function defined inside a function.
Manman Renc50fa112013-10-10 18:40:01 +0000402 DIScope SPContext = resolve(SP.getContext());
403 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000404 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000405 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
406
407 // Add arguments.
408 DICompositeType SPTy = SP.getType();
409 DIArray Args = SPTy.getTypeArray();
Eric Christopher31b05762013-08-08 01:41:00 +0000410 uint16_t SPTag = SPTy.getTag();
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000411 if (SPTag == dwarf::DW_TAG_subroutine_type)
412 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
Manman Ren4a841a82013-10-29 01:03:01 +0000413 DIE *Arg =
414 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
David Blaikie5af2aca2013-11-18 23:57:26 +0000415 DIType ATy(Args.getElement(i));
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000416 SPCU->addType(Arg, ATy);
417 if (ATy.isArtificial())
418 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
419 if (ATy.isObjectPointer())
Manman Ren4c4b69c2013-10-11 23:58:05 +0000420 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000421 }
422 DIE *SPDeclDie = SPDie;
David Blaikie2a80e442013-12-02 22:09:48 +0000423 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
424 *SPCU->getUnitDie());
Manman Ren4c4b69c2013-10-11 23:58:05 +0000425 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
Bill Wendlingd9bb9b62012-11-07 04:42:18 +0000426 }
427 }
Devang Patela37a95e2010-07-07 22:20:57 +0000428 }
429
David Blaikieb7a1c4d2013-12-04 17:55:41 +0000430 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
431 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
Eric Christopher0f63d062013-12-03 00:45:45 +0000432
Eric Christopher46e23432013-12-20 04:16:18 +0000433 // Add this range to the list of ranges for the CU.
434 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
435 SPCU->addRange(llvm_move(Span));
436
Chris Lattner3a383cb2010-04-05 00:13:49 +0000437 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
438 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
Devang Patelf20c4f72011-04-12 22:53:02 +0000439 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
Devang Patel6efc8e52010-02-06 01:02:37 +0000440
Eric Christopherd9843b32011-11-10 19:25:34 +0000441 // Add name to the name table, we do this here because we're guaranteed
442 // to have concrete versions of our DW_TAG_subprogram nodes.
443 addSubprogramNames(SPCU, SP, SPDie);
Eric Christopher6a841382012-11-19 22:42:10 +0000444
Chris Lattner3a383cb2010-04-05 00:13:49 +0000445 return SPDie;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000446}
447
Manman Ren5b2f4b02013-09-11 19:40:28 +0000448/// Check whether we should create a DIE for the given Scope, return true
449/// if we don't create a DIE (the corresponding DIE is null).
Manman Ren2312ed32013-09-10 18:40:41 +0000450bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
451 if (Scope->isAbstractScope())
452 return false;
453
Manman Ren5b2f4b02013-09-11 19:40:28 +0000454 // We don't create a DIE if there is no Range.
Manman Ren2312ed32013-09-10 18:40:41 +0000455 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
456 if (Ranges.empty())
457 return true;
458
459 if (Ranges.size() > 1)
460 return false;
461
Manman Ren5b2f4b02013-09-11 19:40:28 +0000462 // We don't create a DIE if we have a single Range and the end label
463 // is null.
Manman Ren2312ed32013-09-10 18:40:41 +0000464 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
465 MCSymbol *End = getLabelAfterInsn(RI->second);
466 return !End;
467}
468
Eric Christophera5a79422013-12-09 23:32:48 +0000469static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
Eric Christopherc31fe2d2013-12-05 00:36:17 +0000470 dwarf::Attribute A, const MCSymbol *L,
471 const MCSymbol *Sec) {
472 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
473 U->addSectionLabel(D, A, L);
474 else
475 U->addSectionDelta(D, A, L, Sec);
476}
477
Eric Christopher4287a492013-12-09 23:57:44 +0000478void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
Eric Christopherbe2513e2013-12-03 00:45:59 +0000479 const SmallVectorImpl<InsnRange> &Range) {
480 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
481 // emitting it appropriately.
Eric Christopherf8790642013-12-04 22:04:50 +0000482 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
Eric Christopherc31fe2d2013-12-05 00:36:17 +0000483 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
484 DwarfDebugRangeSectionSym);
485
Eric Christopherf8790642013-12-04 22:04:50 +0000486 RangeSpanList List(RangeSym);
Eric Christopherbe2513e2013-12-03 00:45:59 +0000487 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
488 RE = Range.end();
489 RI != RE; ++RI) {
490 RangeSpan Span(getLabelBeforeInsn(RI->first),
491 getLabelAfterInsn(RI->second));
Eric Christopher270ba4a2013-12-04 19:06:58 +0000492 List.addRange(llvm_move(Span));
Eric Christopherbe2513e2013-12-03 00:45:59 +0000493 }
494
495 // Add the range list to the set of ranges to be emitted.
Eric Christopher270ba4a2013-12-04 19:06:58 +0000496 TheCU->addRangeList(llvm_move(List));
Eric Christopherbe2513e2013-12-03 00:45:59 +0000497}
498
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000499// Construct new DW_TAG_lexical_block for this scope and attach
500// DW_AT_low_pc/DW_AT_high_pc labels.
Eric Christopher4287a492013-12-09 23:57:44 +0000501DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000502 LexicalScope *Scope) {
Manman Ren2312ed32013-09-10 18:40:41 +0000503 if (isLexicalScopeDIENull(Scope))
504 return 0;
505
Devang Patel6c74a872010-04-27 19:46:33 +0000506 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
507 if (Scope->isAbstractScope())
508 return ScopeDIE;
509
Eric Christopher0f63d062013-12-03 00:45:45 +0000510 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
Eric Christopherbe2513e2013-12-03 00:45:59 +0000511
Eric Christopherdc42ea82013-07-03 01:57:28 +0000512 // If we have multiple ranges, emit them into the range section.
Eric Christopher0f63d062013-12-03 00:45:45 +0000513 if (ScopeRanges.size() > 1) {
Eric Christopherbe2513e2013-12-03 00:45:59 +0000514 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
Devang Patel6c74a872010-04-27 19:46:33 +0000515 return ScopeDIE;
516 }
517
Eric Christopherdc42ea82013-07-03 01:57:28 +0000518 // Construct the address range for this DIE.
Eric Christopher0f63d062013-12-03 00:45:45 +0000519 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
Eric Christopher962c9082013-01-15 23:56:56 +0000520 MCSymbol *Start = getLabelBeforeInsn(RI->first);
521 MCSymbol *End = getLabelAfterInsn(RI->second);
Manman Ren2312ed32013-09-10 18:40:41 +0000522 assert(End && "End label should not be null!");
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000523
Chris Lattnere13c3722010-03-09 01:58:53 +0000524 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
525 assert(End->isDefined() && "Invalid end label for an inlined scope!");
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000526
Eric Christopher962c9082013-01-15 23:56:56 +0000527 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
528 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000529
530 return ScopeDIE;
531}
532
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000533// This scope represents inlined body of a function. Construct DIE to
534// represent this concrete inlined copy of the function.
Eric Christopher4287a492013-12-09 23:57:44 +0000535DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000536 LexicalScope *Scope) {
Eric Christopher0f63d062013-12-03 00:45:45 +0000537 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
Eric Christopher1cdb63d2013-12-04 21:20:15 +0000538 assert(!ScopeRanges.empty() &&
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000539 "LexicalScope does not have instruction markers!");
Devang Patel6c74a872010-04-27 19:46:33 +0000540
Devang Patelf098ce22011-07-27 00:34:13 +0000541 if (!Scope->getScopeNode())
542 return NULL;
543 DIScope DS(Scope->getScopeNode());
544 DISubprogram InlinedSP = getDISubprogram(DS);
Eric Christophere595bae2013-10-04 17:08:38 +0000545 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
Devang Patelf098ce22011-07-27 00:34:13 +0000546 if (!OriginDIE) {
Bill Wendling10e0e2e2012-10-30 17:51:02 +0000547 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
Devang Patelf098ce22011-07-27 00:34:13 +0000548 return NULL;
549 }
550
Devang Patel73bc1722011-05-05 17:54:26 +0000551 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
Manman Ren4c4b69c2013-10-11 23:58:05 +0000552 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000553
Eric Christopherbe2513e2013-12-03 00:45:59 +0000554 // If we have multiple ranges, emit them into the range section.
555 if (ScopeRanges.size() > 1)
556 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
557 else {
Eric Christopher0f63d062013-12-03 00:45:45 +0000558 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
Eric Christopherf94eb2b2013-07-03 02:23:53 +0000559 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
560 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
561
562 if (StartLabel == 0 || EndLabel == 0)
563 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
564
565 assert(StartLabel->isDefined() &&
566 "Invalid starting label for an inlined scope!");
567 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
568
Eric Christopher962c9082013-01-15 23:56:56 +0000569 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
570 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
Devang Patelf098ce22011-07-27 00:34:13 +0000571 }
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000572
573 InlinedSubprogramDIEs.insert(OriginDIE);
574
Eric Christopherf94eb2b2013-07-03 02:23:53 +0000575 // Add the call site information to the DIE.
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000576 DILocation DL(Scope->getInlinedAt());
David Blaikief2443192013-10-21 17:28:37 +0000577 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
Manman Ren1e427202013-03-07 01:42:00 +0000578 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
579 TheCU->getUniqueID()));
David Blaikief2443192013-10-21 17:28:37 +0000580 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000581
Eric Christopher8dda5d02011-12-04 06:02:38 +0000582 // Add name to the name table, we do this here because we're guaranteed
583 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
584 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
Eric Christopher6a841382012-11-19 22:42:10 +0000585
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000586 return ScopeDIE;
587}
588
Eric Christopher4287a492013-12-09 23:57:44 +0000589DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
590 LexicalScope *Scope,
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000591 SmallVectorImpl<DIE *> &Children) {
592 DIE *ObjectPointer = NULL;
Devang Patel6c622ef2011-03-01 22:58:55 +0000593
594 // Collect arguments for current function.
Devang Patel7e623022011-08-10 20:55:27 +0000595 if (LScopes.isCurrentFunctionScope(Scope))
Devang Patel6c622ef2011-03-01 22:58:55 +0000596 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
597 if (DbgVariable *ArgDV = CurrentFnArguments[i])
Eric Christopher6a841382012-11-19 22:42:10 +0000598 if (DIE *Arg =
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000599 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
Devang Patel6c622ef2011-03-01 22:58:55 +0000600 Children.push_back(Arg);
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000601 if (ArgDV->isObjectPointer())
602 ObjectPointer = Arg;
Eric Christophere3417762012-09-12 23:36:19 +0000603 }
Devang Patel6c622ef2011-03-01 22:58:55 +0000604
Eric Christopherf84354b2011-10-03 15:49:16 +0000605 // Collect lexical scope children first.
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000606 const SmallVectorImpl<DbgVariable *> &Variables =
607 ScopeVariables.lookup(Scope);
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000608 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000609 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
610 Scope->isAbstractScope())) {
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000611 Children.push_back(Variable);
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000612 if (Variables[i]->isObjectPointer())
613 ObjectPointer = Variable;
Eric Christopherc1c8a1b2012-09-21 22:18:52 +0000614 }
Craig Topper977e9cd2013-07-03 04:24:43 +0000615 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000616 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
Devang Patel3acc70e2011-08-15 22:04:40 +0000617 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000618 Children.push_back(Nested);
Manman Ren2312ed32013-09-10 18:40:41 +0000619 return ObjectPointer;
620}
621
622// Construct a DIE for this scope.
Eric Christopher4287a492013-12-09 23:57:44 +0000623DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
624 LexicalScope *Scope) {
Manman Ren2312ed32013-09-10 18:40:41 +0000625 if (!Scope || !Scope->getScopeNode())
626 return NULL;
627
628 DIScope DS(Scope->getScopeNode());
629
630 SmallVector<DIE *, 8> Children;
631 DIE *ObjectPointer = NULL;
632 bool ChildrenCreated = false;
633
Manman Ren5b2f4b02013-09-11 19:40:28 +0000634 // We try to create the scope DIE first, then the children DIEs. This will
635 // avoid creating un-used children then removing them later when we find out
636 // the scope DIE is null.
Devang Patel3b548aa2010-03-08 20:52:55 +0000637 DIE *ScopeDIE = NULL;
638 if (Scope->getInlinedAt())
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000639 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
Devang Patel3b548aa2010-03-08 20:52:55 +0000640 else if (DS.isSubprogram()) {
Devang Pateld10b2af2010-06-28 20:53:04 +0000641 ProcessedSPNodes.insert(DS);
Devang Patela37a95e2010-07-07 22:20:57 +0000642 if (Scope->isAbstractScope()) {
Eric Christophere595bae2013-10-04 17:08:38 +0000643 ScopeDIE = TheCU->getDIE(DS);
Devang Patela37a95e2010-07-07 22:20:57 +0000644 // Note down abstract DIE.
645 if (ScopeDIE)
646 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
David Blaikiee26a3772013-11-18 23:59:04 +0000647 } else
David Blaikie25bc7192013-11-15 23:13:08 +0000648 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
David Blaikiee26a3772013-11-18 23:59:04 +0000649 } else {
Manman Ren5b2f4b02013-09-11 19:40:28 +0000650 // Early exit when we know the scope DIE is going to be null.
Manman Ren2312ed32013-09-10 18:40:41 +0000651 if (isLexicalScopeDIENull(Scope))
652 return NULL;
Manman Ren5b2f4b02013-09-11 19:40:28 +0000653
654 // We create children here when we know the scope DIE is not going to be
655 // null and the children will be added to the scope DIE.
Manman Ren2312ed32013-09-10 18:40:41 +0000656 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
657 ChildrenCreated = true;
Manman Ren5b2f4b02013-09-11 19:40:28 +0000658
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000659 // There is no need to emit empty lexical block DIE.
David Blaikie684fc532013-05-06 23:33:07 +0000660 std::pair<ImportedEntityMap::const_iterator,
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000661 ImportedEntityMap::const_iterator> Range =
662 std::equal_range(
663 ScopesWithImportedEntities.begin(),
664 ScopesWithImportedEntities.end(),
665 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
666 less_first());
David Blaikie684fc532013-05-06 23:33:07 +0000667 if (Children.empty() && Range.first == Range.second)
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000668 return NULL;
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000669 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
Manman Ren2312ed32013-09-10 18:40:41 +0000670 assert(ScopeDIE && "Scope DIE should not be null.");
Eric Christopher5fdd68e2013-06-24 23:20:02 +0000671 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
672 ++i)
David Blaikie4dd2de72013-05-08 06:01:38 +0000673 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000674 }
Eric Christopher6a841382012-11-19 22:42:10 +0000675
Benjamin Kramer892daba2013-08-24 11:55:49 +0000676 if (!ScopeDIE) {
Manman Ren2312ed32013-09-10 18:40:41 +0000677 assert(Children.empty() &&
678 "We create children only when the scope DIE is not null.");
Benjamin Kramer892daba2013-08-24 11:55:49 +0000679 return NULL;
680 }
Manman Ren2312ed32013-09-10 18:40:41 +0000681 if (!ChildrenCreated)
Manman Ren5b2f4b02013-09-11 19:40:28 +0000682 // We create children when the scope DIE is not null.
Manman Ren2312ed32013-09-10 18:40:41 +0000683 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000684
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000685 // Add children
Craig Topperd8e43652013-07-03 04:17:25 +0000686 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000687 E = Children.end();
688 I != E; ++I)
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000689 ScopeDIE->addChild(*I);
Devang Patel04d2f2d2009-11-24 01:14:22 +0000690
Eric Christophere3417762012-09-12 23:36:19 +0000691 if (DS.isSubprogram() && ObjectPointer != NULL)
Manman Ren4c4b69c2013-10-11 23:58:05 +0000692 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
Eric Christophere3417762012-09-12 23:36:19 +0000693
Eric Christopherd9843b32011-11-10 19:25:34 +0000694 return ScopeDIE;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000695}
696
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000697// Look up the source id with the given directory and source file names.
698// If none currently exists, create a new id and insert it in the
699// SourceIds map. This can update DirectoryNames and SourceFileNames maps
700// as well.
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000701unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
702 unsigned CUID) {
Manman Ren1e427202013-03-07 01:42:00 +0000703 // If we use .loc in assembly, we can't separate .file entries according to
704 // compile units. Thus all files will belong to the default compile unit.
Rafael Espindolaac4ad252013-10-05 16:42:21 +0000705
706 // FIXME: add a better feature test than hasRawTextSupport. Even better,
707 // extend .file to support this.
708 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
Manman Ren1e427202013-03-07 01:42:00 +0000709 CUID = 0;
710
Devang Patel871d0b12010-09-16 20:57:49 +0000711 // If FE did not provide a file name, then assume stdin.
712 if (FileName.empty())
Manman Ren1e427202013-03-07 01:42:00 +0000713 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
Devang Patele01b75c2011-03-24 20:30:50 +0000714
Nick Lewyckyd1ee7f82011-11-02 20:55:33 +0000715 // TODO: this might not belong here. See if we can factor this better.
716 if (DirName == CompilationDir)
717 DirName = "";
718
Manman Ren1e427202013-03-07 01:42:00 +0000719 // FileIDCUMap stores the current ID for the given compile unit.
720 unsigned SrcId = FileIDCUMap[CUID] + 1;
Devang Patel871d0b12010-09-16 20:57:49 +0000721
Manman Ren1e427202013-03-07 01:42:00 +0000722 // We look up the CUID/file/dir by concatenating them with a zero byte.
Benjamin Kramer71b19732012-03-11 14:56:26 +0000723 SmallString<128> NamePair;
Manman Ren5b22f9f2013-04-06 01:02:38 +0000724 NamePair += utostr(CUID);
Manman Ren1e427202013-03-07 01:42:00 +0000725 NamePair += '\0';
Benjamin Kramer71b19732012-03-11 14:56:26 +0000726 NamePair += DirName;
727 NamePair += '\0'; // Zero bytes are not allowed in paths.
728 NamePair += FileName;
729
730 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
731 if (Ent.getValue() != SrcId)
732 return Ent.getValue();
Bill Wendling2b128d72009-05-20 23:19:06 +0000733
Manman Ren1e427202013-03-07 01:42:00 +0000734 FileIDCUMap[CUID] = SrcId;
Rafael Espindola67c6ab82010-11-18 02:04:25 +0000735 // Print out a .file directive to specify files for .loc directives.
Manman Ren1e427202013-03-07 01:42:00 +0000736 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
Bill Wendling2b128d72009-05-20 23:19:06 +0000737
738 return SrcId;
739}
740
Eric Christophera5a79422013-12-09 23:32:48 +0000741void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
David Blaikie3c842622013-12-04 21:31:26 +0000742 if (!GenerateGnuPubSections)
743 return;
744
745 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
746 Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
747 DwarfGnuPubNamesSectionSym);
748
749 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
750 Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
751 DwarfGnuPubTypesSectionSym);
752}
753
Eric Christopher4287a492013-12-09 23:57:44 +0000754// Create new DwarfCompileUnit for the given metadata node with tag
Eric Christopher48fef592012-12-20 21:58:40 +0000755// DW_TAG_compile_unit.
Eric Christopher4287a492013-12-09 23:57:44 +0000756DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
Devang Patel2d9caf92009-11-25 17:36:49 +0000757 StringRef FN = DIUnit.getFilename();
Nick Lewyckyd1ee7f82011-11-02 20:55:33 +0000758 CompilationDir = DIUnit.getDirectory();
Bill Wendling2b128d72009-05-20 23:19:06 +0000759
760 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Eric Christopher4287a492013-12-09 23:57:44 +0000761 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
762 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
David Blaikie2666e242013-12-06 19:38:46 +0000763 InfoHolder.addUnit(NewCU);
764
Manman Ren1e427202013-03-07 01:42:00 +0000765 FileIDCUMap[NewCU->getUniqueID()] = 0;
766 // Call this to emit a .file directive if it wasn't emitted for the source
767 // file this CU comes from yet.
768 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
769
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000770 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
Devang Patelf20c4f72011-04-12 22:53:02 +0000771 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
772 DIUnit.getLanguage());
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000773 NewCU->addString(Die, dwarf::DW_AT_name, FN);
Eric Christopher52ce7182013-04-09 19:23:15 +0000774
Manman Ren4e042a62013-02-05 21:52:47 +0000775 // Define start line table label for each Compile Unit.
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000776 MCSymbol *LineTableStartSym =
777 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
Manman Ren4e042a62013-02-05 21:52:47 +0000778 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
779 NewCU->getUniqueID());
780
Manman Ren9d4c7352013-05-21 00:57:22 +0000781 // Use a single line table if we are using .loc and generating assembly.
782 bool UseTheFirstCU =
Rafael Espindolaac4ad252013-10-05 16:42:21 +0000783 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
784 (NewCU->getUniqueID() == 0);
Manman Ren9d4c7352013-05-21 00:57:22 +0000785
Eric Christopher52ce7182013-04-09 19:23:15 +0000786 if (!useSplitDwarf()) {
Eric Christophera51d3fc2013-09-27 22:50:48 +0000787 // DW_AT_stmt_list is a offset of line number information for this
788 // compile unit in debug_line section. For split dwarf this is
789 // left in the skeleton CU and so not included.
790 // The line table entries are not always emitted in assembly, so it
791 // is not okay to use line_table_start here.
Eric Christopher52ce7182013-04-09 19:23:15 +0000792 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
Eric Christophera5a79422013-12-09 23:32:48 +0000793 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
794 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
795 : LineTableStartSym);
Manman Ren9d4c7352013-05-21 00:57:22 +0000796 else if (UseTheFirstCU)
Eric Christopher33ff6972013-11-21 23:46:41 +0000797 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
Eric Christopher52ce7182013-04-09 19:23:15 +0000798 else
Eric Christophera5a79422013-12-09 23:32:48 +0000799 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
800 DwarfLineSectionSym);
Eric Christophera51d3fc2013-09-27 22:50:48 +0000801
802 // If we're using split dwarf the compilation dir is going to be in the
803 // skeleton CU and so we don't need to duplicate it here.
804 if (!CompilationDir.empty())
805 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
806
David Blaikie3c842622013-12-04 21:31:26 +0000807 addGnuPubAttributes(NewCU, Die);
Eric Christopher52ce7182013-04-09 19:23:15 +0000808 }
Bill Wendling2b128d72009-05-20 23:19:06 +0000809
Bill Wendling2b128d72009-05-20 23:19:06 +0000810 if (DIUnit.isOptimized())
Eric Christopherbb69a272012-08-24 01:14:27 +0000811 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
Bill Wendling2b128d72009-05-20 23:19:06 +0000812
Devang Patel2d9caf92009-11-25 17:36:49 +0000813 StringRef Flags = DIUnit.getFlags();
814 if (!Flags.empty())
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000815 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
Eric Christopher6a841382012-11-19 22:42:10 +0000816
Nick Lewycky479a8fe2011-10-17 23:27:36 +0000817 if (unsigned RVer = DIUnit.getRunTimeVersion())
Devang Patelf20c4f72011-04-12 22:53:02 +0000818 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000819 dwarf::DW_FORM_data1, RVer);
Bill Wendling2b128d72009-05-20 23:19:06 +0000820
Devang Patel1a0df9a2010-05-10 22:49:55 +0000821 if (!FirstCU)
822 FirstCU = NewCU;
Eric Christopher7a2cdf72013-02-05 07:31:55 +0000823
Eric Christopherd4368fd2014-01-02 21:03:28 +0000824 if (useSplitDwarf()) {
825 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
826 DwarfInfoDWOSectionSym);
Eric Christopherd8667202013-12-30 17:22:27 +0000827 NewCU->setSkeleton(constructSkeletonCU(NewCU));
Eric Christopherd4368fd2014-01-02 21:03:28 +0000828 } else
829 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
830 DwarfInfoSectionSym);
Eric Christopherd039baa2013-12-30 03:40:32 +0000831
David Blaikie5a152402013-11-15 23:52:02 +0000832 CUMap.insert(std::make_pair(DIUnit, NewCU));
Manman Rence20d462013-10-29 22:57:10 +0000833 CUDieMap.insert(std::make_pair(Die, NewCU));
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000834 return NewCU;
Devang Patel1a0df9a2010-05-10 22:49:55 +0000835}
836
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000837// Construct subprogram DIE.
Eric Christopher4287a492013-12-09 23:57:44 +0000838void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
839 const MDNode *N) {
Eric Christopherffbc4de2013-10-18 01:57:30 +0000840 // FIXME: We should only call this routine once, however, during LTO if a
841 // program is defined in multiple CUs we could end up calling it out of
842 // beginModule as we walk the CUs.
843
Eric Christopher4287a492013-12-09 23:57:44 +0000844 DwarfCompileUnit *&CURef = SPMap[N];
Eric Christopherffbc4de2013-10-18 01:57:30 +0000845 if (CURef)
846 return;
847 CURef = TheCU;
Rafael Espindola6cf4e832011-11-04 19:00:29 +0000848
Devang Patel80ae3492009-08-28 23:24:31 +0000849 DISubprogram SP(N);
Bill Wendling2b128d72009-05-20 23:19:06 +0000850 if (!SP.isDefinition())
851 // This is a method declaration which will be handled while constructing
852 // class type.
Devang Patel0751a282009-06-26 01:49:18 +0000853 return;
Bill Wendling2b128d72009-05-20 23:19:06 +0000854
Devang Patel89543712011-08-15 17:24:54 +0000855 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
Stuart Hastings4bd3dd92010-04-06 21:38:29 +0000856
Eric Christopherba506db2013-09-09 20:03:20 +0000857 // Expose as a global name.
Eric Christopher2c8b7902013-10-17 02:06:06 +0000858 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
Bill Wendling2b128d72009-05-20 23:19:06 +0000859}
860
Eric Christopher4287a492013-12-09 23:57:44 +0000861void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
David Blaikief55abea2013-04-22 06:12:31 +0000862 const MDNode *N) {
David Blaikie1fd43652013-05-07 21:35:53 +0000863 DIImportedEntity Module(N);
David Blaikief55abea2013-04-22 06:12:31 +0000864 if (!Module.Verify())
865 return;
David Blaikie684fc532013-05-06 23:33:07 +0000866 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
David Blaikie4dd2de72013-05-08 06:01:38 +0000867 constructImportedEntityDIE(TheCU, Module, D);
David Blaikie684fc532013-05-06 23:33:07 +0000868}
869
Eric Christopher4287a492013-12-09 23:57:44 +0000870void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
871 const MDNode *N, DIE *Context) {
David Blaikie1fd43652013-05-07 21:35:53 +0000872 DIImportedEntity Module(N);
David Blaikie684fc532013-05-06 23:33:07 +0000873 if (!Module.Verify())
874 return;
David Blaikie4dd2de72013-05-08 06:01:38 +0000875 return constructImportedEntityDIE(TheCU, Module, Context);
David Blaikie684fc532013-05-06 23:33:07 +0000876}
877
Eric Christopher4287a492013-12-09 23:57:44 +0000878void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
David Blaikie1fd43652013-05-07 21:35:53 +0000879 const DIImportedEntity &Module,
David Blaikie684fc532013-05-06 23:33:07 +0000880 DIE *Context) {
881 assert(Module.Verify() &&
882 "Use one of the MDNode * overloads to handle invalid metadata");
883 assert(Context && "Should always have a context for an imported_module");
David Blaikie1fd43652013-05-07 21:35:53 +0000884 DIE *IMDie = new DIE(Module.getTag());
David Blaikief55abea2013-04-22 06:12:31 +0000885 TheCU->insertDIE(Module, IMDie);
David Blaikie1fd43652013-05-07 21:35:53 +0000886 DIE *EntityDie;
887 DIDescriptor Entity = Module.getEntity();
888 if (Entity.isNameSpace())
889 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
890 else if (Entity.isSubprogram())
891 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
David Blaikie3b6038b2013-05-08 06:01:41 +0000892 else if (Entity.isType())
893 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
David Blaikie1fd43652013-05-07 21:35:53 +0000894 else
David Blaikie3b6038b2013-05-08 06:01:41 +0000895 EntityDie = TheCU->getDIE(Entity);
David Blaikief55abea2013-04-22 06:12:31 +0000896 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
897 Module.getContext().getDirectory(),
898 TheCU->getUniqueID());
David Blaikief2443192013-10-21 17:28:37 +0000899 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
900 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
Manman Ren4c4b69c2013-10-11 23:58:05 +0000901 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
David Blaikiee63d5d12013-05-20 22:50:35 +0000902 StringRef Name = Module.getName();
903 if (!Name.empty())
904 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
David Blaikie684fc532013-05-06 23:33:07 +0000905 Context->addChild(IMDie);
David Blaikief55abea2013-04-22 06:12:31 +0000906}
907
Eric Christopheracdcbdb2012-11-27 22:43:45 +0000908// Emit all Dwarf sections that should come prior to the content. Create
909// global DIEs and emit initial debug info sections. This is invoked by
910// the target AsmPrinter.
Eric Christopher58f41952012-11-19 22:42:15 +0000911void DwarfDebug::beginModule() {
Devang Patel6c74a872010-04-27 19:46:33 +0000912 if (DisableDebugInfoPrinting)
913 return;
914
Eric Christopher58f41952012-11-19 22:42:15 +0000915 const Module *M = MMI->getModule();
916
Nick Lewycky019d2552011-07-29 03:49:23 +0000917 // If module has named metadata anchors then use them, otherwise scan the
918 // module using debug info finder to collect debug info.
Devang Patele02e5852011-05-03 16:45:22 +0000919 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
David Blaikiedc69ebb2013-03-11 23:39:23 +0000920 if (!CU_Nodes)
Devang Patel07bb9ee2011-08-15 23:47:24 +0000921 return;
Manman Ren60352032013-09-05 18:48:31 +0000922 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
Devang Patele02e5852011-05-03 16:45:22 +0000923
David Blaikiedc69ebb2013-03-11 23:39:23 +0000924 // Emit initial sections so we can reference labels later.
925 emitSectionLabels();
926
927 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
928 DICompileUnit CUNode(CU_Nodes->getOperand(i));
Eric Christopher4287a492013-12-09 23:57:44 +0000929 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
David Blaikie1fd43652013-05-07 21:35:53 +0000930 DIArray ImportedEntities = CUNode.getImportedEntities();
931 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
David Blaikie684fc532013-05-06 23:33:07 +0000932 ScopesWithImportedEntities.push_back(std::make_pair(
David Blaikie1fd43652013-05-07 21:35:53 +0000933 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
934 ImportedEntities.getElement(i)));
David Blaikie684fc532013-05-06 23:33:07 +0000935 std::sort(ScopesWithImportedEntities.begin(),
Benjamin Kramerb12cf012013-08-24 12:54:27 +0000936 ScopesWithImportedEntities.end(), less_first());
David Blaikiedc69ebb2013-03-11 23:39:23 +0000937 DIArray GVs = CUNode.getGlobalVariables();
938 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
David Blaikiea781b25b2013-11-17 21:55:13 +0000939 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
David Blaikiedc69ebb2013-03-11 23:39:23 +0000940 DIArray SPs = CUNode.getSubprograms();
941 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
942 constructSubprogramDIE(CU, SPs.getElement(i));
943 DIArray EnumTypes = CUNode.getEnumTypes();
944 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
945 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
946 DIArray RetainedTypes = CUNode.getRetainedTypes();
947 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
948 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
David Blaikief55abea2013-04-22 06:12:31 +0000949 // Emit imported_modules last so that the relevant context is already
950 // available.
David Blaikie1fd43652013-05-07 21:35:53 +0000951 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
952 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
David Blaikiedc69ebb2013-03-11 23:39:23 +0000953 }
Eric Christopher6a841382012-11-19 22:42:10 +0000954
Chris Lattner7cfa70e2010-04-05 02:19:28 +0000955 // Tell MMI that we have debug info.
956 MMI->setDebugInfoAvailability(true);
Eric Christopher6a841382012-11-19 22:42:10 +0000957
Bill Wendling2b128d72009-05-20 23:19:06 +0000958 // Prime section data.
Richard Mitton21101b32013-09-19 23:21:01 +0000959 SectionMap[Asm->getObjFileLowering().getTextSection()];
Bill Wendling2b128d72009-05-20 23:19:06 +0000960}
961
Eric Christopher960ac372012-11-22 00:59:49 +0000962// Attach DW_AT_inline attribute with inlined subprogram DIEs.
963void DwarfDebug::computeInlinedDIEs() {
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000964 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
965 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000966 AE = InlinedSubprogramDIEs.end();
967 AI != AE; ++AI) {
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000968 DIE *ISP = *AI;
David Blaikief2443192013-10-21 17:28:37 +0000969 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000970 }
Rafael Espindolae7cc8bf2011-11-12 01:57:54 +0000971 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
Eric Christopherb4bef6d2013-11-19 09:04:36 +0000972 AE = AbstractSPDies.end();
973 AI != AE; ++AI) {
Rafael Espindolae7cc8bf2011-11-12 01:57:54 +0000974 DIE *ISP = AI->second;
975 if (InlinedSubprogramDIEs.count(ISP))
976 continue;
David Blaikief2443192013-10-21 17:28:37 +0000977 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
Rafael Espindolae7cc8bf2011-11-12 01:57:54 +0000978 }
Eric Christopher960ac372012-11-22 00:59:49 +0000979}
980
981// Collect info for variables that were optimized out.
982void DwarfDebug::collectDeadVariables() {
983 const Module *M = MMI->getModule();
Eric Christopher960ac372012-11-22 00:59:49 +0000984
985 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
986 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
987 DICompileUnit TheCU(CU_Nodes->getOperand(i));
988 DIArray Subprograms = TheCU.getSubprograms();
989 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
Eric Christopher735401c2012-11-27 00:13:51 +0000990 DISubprogram SP(Subprograms.getElement(i));
Eric Christophera6c38a32013-10-15 23:31:38 +0000991 if (ProcessedSPNodes.count(SP) != 0)
992 continue;
993 if (!SP.isSubprogram())
994 continue;
995 if (!SP.isDefinition())
996 continue;
Eric Christopher735401c2012-11-27 00:13:51 +0000997 DIArray Variables = SP.getVariables();
Eric Christophera6c38a32013-10-15 23:31:38 +0000998 if (Variables.getNumElements() == 0)
999 continue;
Eric Christopher960ac372012-11-22 00:59:49 +00001000
Eric Christopher735401c2012-11-27 00:13:51 +00001001 // Construct subprogram DIE and add variables DIEs.
Eric Christopher4287a492013-12-09 23:57:44 +00001002 DwarfCompileUnit *SPCU =
1003 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
Eric Christopher735401c2012-11-27 00:13:51 +00001004 assert(SPCU && "Unable to find Compile Unit!");
Eric Christopherc798d8a2013-10-22 00:22:39 +00001005 // FIXME: See the comment in constructSubprogramDIE about duplicate
1006 // subprogram DIEs.
1007 constructSubprogramDIE(SPCU, SP);
1008 DIE *SPDIE = SPCU->getDIE(SP);
Eric Christopher735401c2012-11-27 00:13:51 +00001009 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1010 DIVariable DV(Variables.getElement(vi));
Eric Christophera6c38a32013-10-15 23:31:38 +00001011 if (!DV.isVariable())
1012 continue;
Manman Renb3388602013-10-05 01:43:03 +00001013 DbgVariable NewVar(DV, NULL, this);
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001014 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
Eric Christophera6c38a32013-10-15 23:31:38 +00001015 SPDIE->addChild(VariableDIE);
Eric Christopher735401c2012-11-27 00:13:51 +00001016 }
Eric Christopher960ac372012-11-22 00:59:49 +00001017 }
1018 }
1019 }
Eric Christopher960ac372012-11-22 00:59:49 +00001020}
1021
Eric Christopher45731982013-08-08 23:45:55 +00001022// Type Signature [7.27] and ODR Hash code.
Eric Christopher67646432013-07-26 17:02:41 +00001023
1024/// \brief Grabs the string in whichever attribute is passed in and returns
Eric Christopher8552e222013-08-07 01:18:33 +00001025/// a reference to it. Returns "" if the attribute doesn't exist.
Eric Christopher67646432013-07-26 17:02:41 +00001026static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
Eric Christopher8552e222013-08-07 01:18:33 +00001027 DIEValue *V = Die->findAttribute(Attr);
Eric Christopher67646432013-07-26 17:02:41 +00001028
Eric Christopher8552e222013-08-07 01:18:33 +00001029 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1030 return S->getString();
1031
Eric Christopher67646432013-07-26 17:02:41 +00001032 return StringRef("");
1033}
1034
Eric Christopher67646432013-07-26 17:02:41 +00001035/// Return true if the current DIE is contained within an anonymous namespace.
1036static bool isContainedInAnonNamespace(DIE *Die) {
1037 DIE *Parent = Die->getParent();
1038
1039 while (Parent) {
Eric Christophere414ece2013-07-29 23:53:08 +00001040 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1041 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
Eric Christopher67646432013-07-26 17:02:41 +00001042 return true;
1043 Parent = Parent->getParent();
1044 }
1045
1046 return false;
1047}
1048
Eric Christopheraf15f8d2013-08-07 01:18:24 +00001049/// Test if the current CU language is C++ and that we have
1050/// a named type that is not contained in an anonymous namespace.
Eric Christopher4287a492013-12-09 23:57:44 +00001051static bool shouldAddODRHash(DwarfTypeUnit *CU, DIE *Die) {
Eric Christopher341770d2013-08-07 08:35:10 +00001052 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1053 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1054 !isContainedInAnonNamespace(Die);
Eric Christopher45731982013-08-08 23:45:55 +00001055}
Eric Christopheraf15f8d2013-08-07 01:18:24 +00001056
Eric Christopher960ac372012-11-22 00:59:49 +00001057void DwarfDebug::finalizeModuleInfo() {
1058 // Collect info for variables that were optimized out.
1059 collectDeadVariables();
1060
1061 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1062 computeInlinedDIEs();
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001063
Eric Christopherad10cb52013-12-04 23:24:38 +00001064 // Handle anything that needs to be done on a per-unit basis after
1065 // all other generation.
Eric Christophera5a79422013-12-09 23:32:48 +00001066 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1067 E = getUnits().end();
David Blaikiefd1eff52013-11-26 19:14:34 +00001068 I != E; ++I) {
Eric Christophera5a79422013-12-09 23:32:48 +00001069 DwarfUnit *TheU = *I;
Eric Christopher60eb7692013-08-12 20:27:48 +00001070 // Emit DW_AT_containing_type attribute to connect types with their
1071 // vtable holding type.
David Blaikie2a80e442013-12-02 22:09:48 +00001072 TheU->constructContainingTypeDIEs();
Eric Christopher60eb7692013-08-12 20:27:48 +00001073
Eric Christopher46e23432013-12-20 04:16:18 +00001074 // Add CU specific attributes if we need to add any.
1075 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1076 // If we're splitting the dwarf out now that we've got the entire
Eric Christopherd8667202013-12-30 17:22:27 +00001077 // CU then add the dwo id to it.
1078 DwarfCompileUnit *SkCU =
1079 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
Eric Christopher46e23432013-12-20 04:16:18 +00001080 if (useSplitDwarf()) {
1081 // This should be a unique identifier when we want to build .dwp files.
1082 uint64_t ID = 0;
1083 if (GenerateCUHash) {
1084 DIEHash CUHash;
1085 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1086 }
1087 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1088 dwarf::DW_FORM_data8, ID);
Eric Christopher46e23432013-12-20 04:16:18 +00001089 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1090 dwarf::DW_FORM_data8, ID);
Eric Christopherd29614f2013-08-13 01:21:55 +00001091 }
Eric Christopherd8667202013-12-30 17:22:27 +00001092
1093 // If we've requested ranges and have them emit a DW_AT_ranges attribute
Eric Christopher4d214b92014-01-03 02:17:35 +00001094 // on the unit that will remain in the .o file, otherwise add a
1095 // DW_AT_low_pc.
Eric Christopherd8667202013-12-30 17:22:27 +00001096 // FIXME: Also add a high pc if we can.
1097 // FIXME: We should use ranges if we have multiple compile units.
1098 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1099 if (DwarfCURanges && TheU->getRanges().size())
1100 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1101 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1102 DwarfDebugRangeSectionSym);
1103 else
Eric Christopher4d214b92014-01-03 02:17:35 +00001104 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1105 0);
Eric Christopher60eb7692013-08-12 20:27:48 +00001106 }
1107 }
1108
1109 // Compute DIE offsets and sizes.
Eric Christopherc8a310e2012-12-10 23:34:43 +00001110 InfoHolder.computeSizeAndOffsets();
1111 if (useSplitDwarf())
1112 SkeletonHolder.computeSizeAndOffsets();
Eric Christopher960ac372012-11-22 00:59:49 +00001113}
1114
1115void DwarfDebug::endSections() {
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001116 // Filter labels by section.
Alexey Samsonov4436bf02013-10-03 08:54:43 +00001117 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1118 const SymbolCU &SCU = ArangeLabels[n];
Richard Mitton21101b32013-09-19 23:21:01 +00001119 if (SCU.Sym->isInSection()) {
1120 // Make a note of this symbol and it's section.
1121 const MCSection *Section = &SCU.Sym->getSection();
1122 if (!Section->getKind().isMetadata())
1123 SectionMap[Section].push_back(SCU);
1124 } else {
1125 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1126 // appear in the output. This sucks as we rely on sections to build
1127 // arange spans. We can do it without, but it's icky.
1128 SectionMap[NULL].push_back(SCU);
1129 }
1130 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001131
Richard Mittonc2508242013-10-03 22:07:08 +00001132 // Build a list of sections used.
1133 std::vector<const MCSection *> Sections;
Richard Mitton21101b32013-09-19 23:21:01 +00001134 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1135 it++) {
1136 const MCSection *Section = it->first;
Richard Mittonc2508242013-10-03 22:07:08 +00001137 Sections.push_back(Section);
1138 }
1139
1140 // Sort the sections into order.
1141 // This is only done to ensure consistent output order across different runs.
1142 std::sort(Sections.begin(), Sections.end(), SectionSort);
1143
1144 // Add terminating symbols for each section.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001145 for (unsigned ID = 0; ID < Sections.size(); ID++) {
Richard Mittonc2508242013-10-03 22:07:08 +00001146 const MCSection *Section = Sections[ID];
Richard Mitton21101b32013-09-19 23:21:01 +00001147 MCSymbol *Sym = NULL;
1148
1149 if (Section) {
Richard Mittonc2508242013-10-03 22:07:08 +00001150 // We can't call MCSection::getLabelEndName, as it's only safe to do so
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001151 // if we know the section name up-front. For user-created sections, the
1152 // resulting
1153 // label may not be valid to use as a label. (section names can use a
1154 // greater
Richard Mittonc2508242013-10-03 22:07:08 +00001155 // set of characters on some systems)
1156 Sym = Asm->GetTempSymbol("debug_end", ID);
Richard Mitton21101b32013-09-19 23:21:01 +00001157 Asm->OutStreamer.SwitchSection(Section);
1158 Asm->OutStreamer.EmitLabel(Sym);
1159 }
1160
1161 // Insert a final terminator.
Alexey Samsonov4436bf02013-10-03 08:54:43 +00001162 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
Bill Wendling2b128d72009-05-20 23:19:06 +00001163 }
Eric Christopher960ac372012-11-22 00:59:49 +00001164}
Bill Wendling2b128d72009-05-20 23:19:06 +00001165
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001166// Emit all Dwarf sections that should come after the content.
Eric Christopher960ac372012-11-22 00:59:49 +00001167void DwarfDebug::endModule() {
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001168 assert(CurFn == 0);
1169 assert(CurMI == 0);
Eric Christopher960ac372012-11-22 00:59:49 +00001170
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001171 if (!FirstCU)
1172 return;
Eric Christopher960ac372012-11-22 00:59:49 +00001173
1174 // End any existing sections.
1175 // TODO: Does this need to happen?
1176 endSections();
1177
1178 // Finalize the debug info for the module.
1179 finalizeModuleInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +00001180
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001181 emitDebugStr();
Eric Christopher9cd26af2013-09-20 23:22:52 +00001182
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001183 // Emit all the DIEs into a debug info section.
1184 emitDebugInfo();
Eric Christopher4c9b1192012-11-27 00:41:54 +00001185
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001186 // Corresponding abbreviations into a abbrev section.
1187 emitAbbreviations();
Eric Christopher95198f502012-11-27 22:43:42 +00001188
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001189 // Emit info into a debug loc section.
1190 emitDebugLoc();
Eric Christopher95198f502012-11-27 22:43:42 +00001191
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001192 // Emit info into a debug aranges section.
1193 emitDebugARanges();
Eric Christopher95198f502012-11-27 22:43:42 +00001194
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001195 // Emit info into a debug ranges section.
1196 emitDebugRanges();
Eric Christopher95198f502012-11-27 22:43:42 +00001197
Eric Christopher9a8f5ed2013-11-19 09:04:50 +00001198 if (useSplitDwarf()) {
1199 emitDebugStrDWO();
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001200 emitDebugInfoDWO();
Eric Christopher3c5a1912012-12-19 22:02:53 +00001201 emitDebugAbbrevDWO();
Eric Christopher962c9082013-01-15 23:56:56 +00001202 // Emit DWO addresses.
1203 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
Eric Christopher95198f502012-11-27 22:43:42 +00001204 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001205
Eric Christophera876b822012-08-23 07:32:06 +00001206 // Emit info into the dwarf accelerator table sections.
Eric Christopher20b76a72012-08-23 22:36:40 +00001207 if (useDwarfAccelTables()) {
Eric Christopher4996c702011-11-07 09:24:32 +00001208 emitAccelNames();
1209 emitAccelObjC();
1210 emitAccelNamespaces();
1211 emitAccelTypes();
1212 }
Eric Christopher6a841382012-11-19 22:42:10 +00001213
Eric Christopher4b358182013-08-30 00:40:17 +00001214 // Emit the pubnames and pubtypes sections if requested.
1215 if (HasDwarfPubSections) {
David Blaikie70a33202013-09-19 17:33:35 +00001216 emitDebugPubNames(GenerateGnuPubSections);
1217 emitDebugPubTypes(GenerateGnuPubSections);
Eric Christopher4b358182013-08-30 00:40:17 +00001218 }
Devang Patel04d2f2d2009-11-24 01:14:22 +00001219
Devang Pateld0701282010-08-02 17:32:15 +00001220 // clean up.
Devang Pateleb1bb4e2011-08-16 22:09:43 +00001221 SPMap.clear();
Eric Christopher8afd7b62012-12-10 19:51:18 +00001222
Eric Christopher9c2ecd92012-11-30 23:59:06 +00001223 // Reset these for the next Module if we have one.
1224 FirstCU = NULL;
Bill Wendling2b128d72009-05-20 23:19:06 +00001225}
1226
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001227// Find abstract variable, if any, associated with Var.
Devang Patelbb23a4a2011-08-10 21:50:54 +00001228DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
Chris Lattner915c5f92010-04-02 19:42:39 +00001229 DebugLoc ScopeLoc) {
Devang Patelbb23a4a2011-08-10 21:50:54 +00001230 LLVMContext &Ctx = DV->getContext();
1231 // More then one inlined variable corresponds to one abstract variable.
1232 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001233 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001234 if (AbsDbgVariable)
1235 return AbsDbgVariable;
1236
Devang Patel7e623022011-08-10 20:55:27 +00001237 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001238 if (!Scope)
1239 return NULL;
1240
Manman Renb3388602013-10-05 01:43:03 +00001241 AbsDbgVariable = new DbgVariable(Var, NULL, this);
Devang Patel7e623022011-08-10 20:55:27 +00001242 addScopeVariable(Scope, AbsDbgVariable);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001243 AbstractVariables[Var] = AbsDbgVariable;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001244 return AbsDbgVariable;
1245}
1246
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001247// If Var is a current function argument then add it to CurrentFnArguments list.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001248bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
Devang Patel7e623022011-08-10 20:55:27 +00001249 if (!LScopes.isCurrentFunctionScope(Scope))
Devang Patel6c622ef2011-03-01 22:58:55 +00001250 return false;
1251 DIVariable DV = Var->getVariable();
1252 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1253 return false;
1254 unsigned ArgNo = DV.getArgNumber();
Eric Christopher6a841382012-11-19 22:42:10 +00001255 if (ArgNo == 0)
Devang Patel6c622ef2011-03-01 22:58:55 +00001256 return false;
1257
Devang Patel4ab660b2011-03-03 20:02:02 +00001258 size_t Size = CurrentFnArguments.size();
1259 if (Size == 0)
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001260 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
Devang Patel63b3e762011-03-03 21:49:41 +00001261 // llvm::Function argument size is not good indicator of how many
Devang Patel34a7ab42011-03-03 20:08:10 +00001262 // arguments does the function have at source level.
1263 if (ArgNo > Size)
Devang Patel4ab660b2011-03-03 20:02:02 +00001264 CurrentFnArguments.resize(ArgNo * 2);
Devang Patel6c622ef2011-03-01 22:58:55 +00001265 CurrentFnArguments[ArgNo - 1] = Var;
1266 return true;
1267}
1268
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001269// Collect variable information from side table maintained by MMI.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001270void DwarfDebug::collectVariableInfoFromMMITable(
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001271 SmallPtrSet<const MDNode *, 16> &Processed) {
Devang Patel475d32a2009-10-06 01:26:37 +00001272 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1273 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001274 VE = VMap.end();
1275 VI != VE; ++VI) {
Devang Patel32cc43c2010-05-07 20:54:48 +00001276 const MDNode *Var = VI->first;
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001277 if (!Var)
1278 continue;
Devang Patele0a94bf2010-05-14 21:01:35 +00001279 Processed.insert(Var);
Chris Lattner915c5f92010-04-02 19:42:39 +00001280 DIVariable DV(Var);
1281 const std::pair<unsigned, DebugLoc> &VP = VI->second;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001282
Devang Patel7e623022011-08-10 20:55:27 +00001283 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001284
Devang Patelcdb7d442009-11-10 23:20:04 +00001285 // If variable scope is not found then skip this variable.
Chris Lattner915c5f92010-04-02 19:42:39 +00001286 if (Scope == 0)
Devang Patelcdb7d442009-11-10 23:20:04 +00001287 continue;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001288
Devang Patele1c53f22010-05-20 16:36:41 +00001289 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
Manman Renb3388602013-10-05 01:43:03 +00001290 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
Devang Patel3e4a9652011-08-15 21:24:36 +00001291 RegVar->setFrameIndex(VP.first);
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001292 if (!addCurrentFnArgument(RegVar, Scope))
Devang Patel7e623022011-08-10 20:55:27 +00001293 addScopeVariable(Scope, RegVar);
Devang Patel99819b52011-08-15 19:01:20 +00001294 if (AbsDbgVariable)
Devang Patel3e4a9652011-08-15 21:24:36 +00001295 AbsDbgVariable->setFrameIndex(VP.first);
Devang Patel475d32a2009-10-06 01:26:37 +00001296 }
Devang Patel490c8ab2010-05-20 19:57:06 +00001297}
Devang Patela3e9c9c2010-03-15 18:33:46 +00001298
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001299// Return true if debug value, encoded by DBG_VALUE instruction, is in a
1300// defined reg.
Devang Patel9fc11702010-05-25 23:40:22 +00001301static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
Nick Lewycky654f5ce2011-10-26 22:55:33 +00001302 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001303 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1304 MI->getOperand(0).getReg() &&
Adrian Prantl418d1d12013-07-09 20:28:37 +00001305 (MI->getOperand(1).isImm() ||
1306 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
Devang Patel9fc11702010-05-25 23:40:22 +00001307}
1308
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001309// Get .debug_loc entry for the instruction range starting at MI.
Eric Christopher6a841382012-11-19 22:42:10 +00001310static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1311 const MCSymbol *FLabel,
Devang Patel2442a892011-07-08 17:09:57 +00001312 const MCSymbol *SLabel,
1313 const MachineInstr *MI) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001314 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
Devang Patel2442a892011-07-08 17:09:57 +00001315
David Blaikie0252265b2013-06-16 20:34:15 +00001316 assert(MI->getNumOperands() == 3);
Adrian Prantl418d1d12013-07-09 20:28:37 +00001317 if (MI->getOperand(0).isReg()) {
Devang Patel2442a892011-07-08 17:09:57 +00001318 MachineLocation MLoc;
Adrian Prantl418d1d12013-07-09 20:28:37 +00001319 // If the second operand is an immediate, this is a
1320 // register-indirect address.
1321 if (!MI->getOperand(1).isImm())
Adrian Prantld4c0dd42013-04-26 21:57:17 +00001322 MLoc.set(MI->getOperand(0).getReg());
1323 else
1324 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
Devang Patel2442a892011-07-08 17:09:57 +00001325 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1326 }
1327 if (MI->getOperand(0).isImm())
1328 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1329 if (MI->getOperand(0).isFPImm())
1330 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1331 if (MI->getOperand(0).isCImm())
1332 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1333
Craig Topperee4dab52012-02-05 08:31:47 +00001334 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
Devang Patel2442a892011-07-08 17:09:57 +00001335}
1336
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001337// Find variables for each lexical scope.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001338void
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001339DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001340
Eric Christopher270a12c2013-07-03 21:37:03 +00001341 // Grab the variable info that was squirreled away in the MMI side-table.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001342 collectVariableInfoFromMMITable(Processed);
Devang Patel490c8ab2010-05-20 19:57:06 +00001343
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001344 for (SmallVectorImpl<const MDNode *>::const_iterator
1345 UVI = UserVariables.begin(),
1346 UVE = UserVariables.end();
1347 UVI != UVE; ++UVI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001348 const MDNode *Var = *UVI;
1349 if (Processed.count(Var))
Devang Patel490c8ab2010-05-20 19:57:06 +00001350 continue;
1351
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001352 // History contains relevant DBG_VALUE instructions for Var and instructions
1353 // clobbering it.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001354 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001355 if (History.empty())
1356 continue;
1357 const MachineInstr *MInsn = History.front();
Devang Patel9fc11702010-05-25 23:40:22 +00001358
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001359 DIVariable DV(Var);
Devang Patel7e623022011-08-10 20:55:27 +00001360 LexicalScope *Scope = NULL;
Devang Patel7a9dedf2010-05-27 20:25:04 +00001361 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001362 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
Devang Patel7e623022011-08-10 20:55:27 +00001363 Scope = LScopes.getCurrentFunctionScope();
David Blaikiedc69ebb2013-03-11 23:39:23 +00001364 else if (MDNode *IA = DV.getInlinedAt())
1365 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1366 else
1367 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
Devang Patel490c8ab2010-05-20 19:57:06 +00001368 // If variable scope is not found then skip this variable.
Devang Patelfbd6c452010-05-21 00:10:20 +00001369 if (!Scope)
Devang Patel490c8ab2010-05-20 19:57:06 +00001370 continue;
1371
1372 Processed.insert(DV);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001373 assert(MInsn->isDebugValue() && "History must begin with debug value");
Devang Patel99819b52011-08-15 19:01:20 +00001374 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
Manman Renb3388602013-10-05 01:43:03 +00001375 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001376 if (!addCurrentFnArgument(RegVar, Scope))
Devang Patel7e623022011-08-10 20:55:27 +00001377 addScopeVariable(Scope, RegVar);
Devang Patel99819b52011-08-15 19:01:20 +00001378 if (AbsVar)
Devang Patel3e4a9652011-08-15 21:24:36 +00001379 AbsVar->setMInsn(MInsn);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001380
Eric Christophercc10d202012-10-08 20:48:54 +00001381 // Simplify ranges that are fully coalesced.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001382 if (History.size() <= 1 ||
1383 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
Devang Patel3e4a9652011-08-15 21:24:36 +00001384 RegVar->setMInsn(MInsn);
Devang Patel9fc11702010-05-25 23:40:22 +00001385 continue;
1386 }
1387
Eric Christopher59cc0712013-01-28 17:33:26 +00001388 // Handle multiple DBG_VALUE instructions describing one variable.
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001389 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001390
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001391 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1392 HI = History.begin(),
1393 HE = History.end();
1394 HI != HE; ++HI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001395 const MachineInstr *Begin = *HI;
1396 assert(Begin->isDebugValue() && "Invalid History entry");
Jakob Stoklund Olesen9c057ee2011-03-22 00:21:41 +00001397
Devang Patele7181b52011-06-01 23:00:17 +00001398 // Check if DBG_VALUE is truncating a range.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001399 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1400 !Begin->getOperand(0).getReg())
Devang Patele7181b52011-06-01 23:00:17 +00001401 continue;
1402
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001403 // Compute the range for a register location.
1404 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1405 const MCSymbol *SLabel = 0;
1406
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001407 if (HI + 1 == HE)
1408 // If Begin is the last instruction in History then its value is valid
Chris Lattner0ab5e2c2011-04-15 05:18:47 +00001409 // until the end of the function.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001410 SLabel = FunctionEndSym;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001411 else {
1412 const MachineInstr *End = HI[1];
Eric Christopher6a841382012-11-19 22:42:10 +00001413 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001414 << "\t" << *Begin << "\t" << *End << "\n");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001415 if (End->isDebugValue())
1416 SLabel = getLabelBeforeInsn(End);
1417 else {
1418 // End is a normal instruction clobbering the range.
1419 SLabel = getLabelAfterInsn(End);
1420 assert(SLabel && "Forgot label after clobber instruction");
1421 ++HI;
1422 }
1423 }
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001424
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001425 // The value is valid until the next DBG_VALUE or clobber.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001426 DotDebugLocEntries.push_back(
1427 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
Devang Patel9fc11702010-05-25 23:40:22 +00001428 }
1429 DotDebugLocEntries.push_back(DotDebugLocEntry());
Devang Patela3e9c9c2010-03-15 18:33:46 +00001430 }
Devang Patele0a94bf2010-05-14 21:01:35 +00001431
1432 // Collect info for variables that were optimized out.
Devang Patel59e27c52011-08-19 23:28:12 +00001433 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1434 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1435 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1436 DIVariable DV(Variables.getElement(i));
Manman Ren7504ed42013-07-08 18:33:29 +00001437 if (!DV || !DV.isVariable() || !Processed.insert(DV))
Devang Patel59e27c52011-08-19 23:28:12 +00001438 continue;
1439 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
Manman Renb3388602013-10-05 01:43:03 +00001440 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
Devang Patele0a94bf2010-05-14 21:01:35 +00001441 }
Devang Patel9fc11702010-05-25 23:40:22 +00001442}
Devang Patele0a94bf2010-05-14 21:01:35 +00001443
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001444// Return Label preceding the instruction.
Eric Christopher962c9082013-01-15 23:56:56 +00001445MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001446 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1447 assert(Label && "Didn't insert label before instruction");
1448 return Label;
Devang Patel9fc11702010-05-25 23:40:22 +00001449}
1450
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001451// Return Label immediately following the instruction.
Eric Christopher962c9082013-01-15 23:56:56 +00001452MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001453 return LabelsAfterInsn.lookup(MI);
Devang Patel475d32a2009-10-06 01:26:37 +00001454}
1455
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001456// Process beginning of an instruction.
Devang Patelb5694e72010-10-26 17:49:02 +00001457void DwarfDebug::beginInstruction(const MachineInstr *MI) {
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001458 assert(CurMI == 0);
1459 CurMI = MI;
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001460 // Check if source location changes, but ignore DBG_VALUE locations.
1461 if (!MI->isDebugValue()) {
1462 DebugLoc DL = MI->getDebugLoc();
1463 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
Eric Christopheraec8a822012-04-05 20:39:05 +00001464 unsigned Flags = 0;
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001465 PrevInstLoc = DL;
Devang Patel34a66202011-05-11 19:22:19 +00001466 if (DL == PrologEndLoc) {
1467 Flags |= DWARF2_FLAG_PROLOGUE_END;
1468 PrologEndLoc = DebugLoc();
1469 }
Eric Christopheraec8a822012-04-05 20:39:05 +00001470 if (PrologEndLoc.isUnknown())
1471 Flags |= DWARF2_FLAG_IS_STMT;
1472
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001473 if (!DL.isUnknown()) {
1474 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
Devang Patel34a66202011-05-11 19:22:19 +00001475 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001476 } else
Devang Patel34a66202011-05-11 19:22:19 +00001477 recordSourceLine(0, 0, 0, 0);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001478 }
Devang Patel9fc11702010-05-25 23:40:22 +00001479 }
Devang Patel23b2ae62010-03-29 22:59:58 +00001480
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001481 // Insert labels where requested.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001482 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1483 LabelsBeforeInsn.find(MI);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001484
1485 // No label needed.
1486 if (I == LabelsBeforeInsn.end())
1487 return;
1488
1489 // Label already assigned.
1490 if (I->second)
Devang Patel002d54d2010-05-26 19:37:24 +00001491 return;
Devang Patelbd477be2010-03-29 17:20:31 +00001492
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001493 if (!PrevLabel) {
Devang Patelacc32a52010-05-26 21:23:46 +00001494 PrevLabel = MMI->getContext().CreateTempSymbol();
1495 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel002d54d2010-05-26 19:37:24 +00001496 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001497 I->second = PrevLabel;
Devang Patel8db360d2009-10-06 01:50:42 +00001498}
1499
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001500// Process end of an instruction.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001501void DwarfDebug::endInstruction() {
1502 assert(CurMI != 0);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001503 // Don't create a new label after DBG_VALUE instructions.
1504 // They don't generate code.
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001505 if (!CurMI->isDebugValue())
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001506 PrevLabel = 0;
1507
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001508 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001509 LabelsAfterInsn.find(CurMI);
1510 CurMI = 0;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001511
1512 // No label needed.
1513 if (I == LabelsAfterInsn.end())
1514 return;
1515
1516 // Label already assigned.
1517 if (I->second)
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001518 return;
1519
1520 // We need a label after this instruction.
1521 if (!PrevLabel) {
1522 PrevLabel = MMI->getContext().CreateTempSymbol();
1523 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel3ebd8932010-04-08 16:50:29 +00001524 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001525 I->second = PrevLabel;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001526}
1527
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001528// Each LexicalScope has first instruction and last instruction to mark
1529// beginning and end of a scope respectively. Create an inverse map that list
1530// scopes starts (and ends) with an instruction. One instruction may start (or
1531// end) multiple scopes. Ignore scopes that are not reachable.
Devang Patel359b0132010-04-08 18:43:56 +00001532void DwarfDebug::identifyScopeMarkers() {
Devang Patel7e623022011-08-10 20:55:27 +00001533 SmallVector<LexicalScope *, 4> WorkList;
1534 WorkList.push_back(LScopes.getCurrentFunctionScope());
Devang Patel7771b7c2010-01-20 02:05:23 +00001535 while (!WorkList.empty()) {
Devang Patel7e623022011-08-10 20:55:27 +00001536 LexicalScope *S = WorkList.pop_back_val();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001537
Craig Topper977e9cd2013-07-03 04:24:43 +00001538 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001539 if (!Children.empty())
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001540 for (SmallVectorImpl<LexicalScope *>::const_iterator
1541 SI = Children.begin(),
1542 SE = Children.end();
1543 SI != SE; ++SI)
Devang Patel7771b7c2010-01-20 02:05:23 +00001544 WorkList.push_back(*SI);
1545
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001546 if (S->isAbstractScope())
1547 continue;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001548
Craig Topper977e9cd2013-07-03 04:24:43 +00001549 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
Devang Patel6c74a872010-04-27 19:46:33 +00001550 if (Ranges.empty())
1551 continue;
Craig Topperd8e43652013-07-03 04:17:25 +00001552 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001553 RE = Ranges.end();
1554 RI != RE; ++RI) {
Devang Patel7e623022011-08-10 20:55:27 +00001555 assert(RI->first && "InsnRange does not have first instruction!");
1556 assert(RI->second && "InsnRange does not have second instruction!");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001557 requestLabelBeforeInsn(RI->first);
1558 requestLabelAfterInsn(RI->second);
Devang Patel6c74a872010-04-27 19:46:33 +00001559 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001560 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001561}
1562
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001563// Get MDNode for DebugLoc's scope.
Devang Patel589845d2011-05-09 22:14:49 +00001564static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1565 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1566 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1567 return DL.getScope(Ctx);
1568}
1569
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001570// Walk up the scope chain of given debug loc and find line number info
1571// for the function.
Devang Patel34a66202011-05-11 19:22:19 +00001572static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1573 const MDNode *Scope = getScopeNode(DL, Ctx);
1574 DISubprogram SP = getDISubprogram(Scope);
Manman Ren7504ed42013-07-08 18:33:29 +00001575 if (SP.isSubprogram()) {
Eric Christopher34164192012-04-03 00:43:49 +00001576 // Check for number of operands since the compatibility is
1577 // cheap here.
Eric Christopherb81e2b42012-04-03 17:55:42 +00001578 if (SP->getNumOperands() > 19)
Eric Christopher34164192012-04-03 00:43:49 +00001579 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1580 else
1581 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1582 }
1583
Devang Patel34a66202011-05-11 19:22:19 +00001584 return DebugLoc();
1585}
1586
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001587// Gather pre-function debug information. Assumes being called immediately
1588// after the function entry point has been emitted.
Chris Lattner76555b52010-01-26 23:18:02 +00001589void DwarfDebug::beginFunction(const MachineFunction *MF) {
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001590 CurFn = MF;
Eric Christopherfedfa442013-11-01 23:14:17 +00001591
1592 // If there's no debug info for the function we're not going to do anything.
1593 if (!MMI->hasDebugInfo())
1594 return;
1595
1596 // Grab the lexical scopes for the function, if we don't have any of those
1597 // then we're not going to be able to do anything.
Devang Patel7e623022011-08-10 20:55:27 +00001598 LScopes.initialize(*MF);
Eric Christopherfedfa442013-11-01 23:14:17 +00001599 if (LScopes.empty())
1600 return;
1601
1602 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1603
1604 // Make sure that each lexical scope will have a begin/end label.
Devang Patel7e623022011-08-10 20:55:27 +00001605 identifyScopeMarkers();
Devang Patel4598eb62009-10-06 18:37:31 +00001606
Eric Christopher4287a492013-12-09 23:57:44 +00001607 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
Eric Christopherfedfa442013-11-01 23:14:17 +00001608 // belongs to so that we add to the correct per-cu line table in the
1609 // non-asm case.
Manman Ren4e042a62013-02-05 21:52:47 +00001610 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
Eric Christopher4287a492013-12-09 23:57:44 +00001611 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
Manman Ren4e042a62013-02-05 21:52:47 +00001612 assert(TheCU && "Unable to find compile unit!");
Rafael Espindolaac4ad252013-10-05 16:42:21 +00001613 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
Manman Ren9d4c7352013-05-21 00:57:22 +00001614 // Use a single line table if we are using .loc and generating assembly.
1615 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1616 else
1617 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
Manman Ren4e042a62013-02-05 21:52:47 +00001618
Eric Christopherfedfa442013-11-01 23:14:17 +00001619 // Emit a label for the function so that we have a beginning address.
1620 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
Bill Wendling2b128d72009-05-20 23:19:06 +00001621 // Assumes in correct section after the entry point.
Devang Patel6c74a872010-04-27 19:46:33 +00001622 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
Bill Wendling2b128d72009-05-20 23:19:06 +00001623
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001624 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001625 // LiveUserVar - Map physreg numbers to the MDNode they contain.
Eric Christopherfedfa442013-11-01 23:14:17 +00001626 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001627
Eric Christopherfedfa442013-11-01 23:14:17 +00001628 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1629 ++I) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001630 bool AtBlockEntry = true;
Devang Patel002d54d2010-05-26 19:37:24 +00001631 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1632 II != IE; ++II) {
1633 const MachineInstr *MI = II;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001634
Devang Patel002d54d2010-05-26 19:37:24 +00001635 if (MI->isDebugValue()) {
Nick Lewycky654f5ce2011-10-26 22:55:33 +00001636 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001637
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001638 // Keep track of user variables.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001639 const MDNode *Var =
Eric Christopherfedfa442013-11-01 23:14:17 +00001640 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001641
1642 // Variable is in a register, we need to check for clobbers.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001643 if (isDbgValueInDefinedReg(MI))
1644 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1645
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001646 // Check the history of this variable.
Eric Christopherfedfa442013-11-01 23:14:17 +00001647 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001648 if (History.empty()) {
1649 UserVariables.push_back(Var);
1650 // The first mention of a function argument gets the FunctionBeginSym
1651 // label, so arguments are visible when breaking at function entry.
1652 DIVariable DV(Var);
Manman Ren7504ed42013-07-08 18:33:29 +00001653 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
David Blaikie5af2aca2013-11-18 23:57:26 +00001654 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001655 LabelsBeforeInsn[MI] = FunctionBeginSym;
1656 } else {
1657 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1658 const MachineInstr *Prev = History.back();
1659 if (Prev->isDebugValue()) {
1660 // Coalesce identical entries at the end of History.
1661 if (History.size() >= 2 &&
Devang Patelb7a328e2011-07-07 00:14:27 +00001662 Prev->isIdenticalTo(History[History.size() - 2])) {
Eric Christopher85a495e2012-10-08 20:48:49 +00001663 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
Eric Christopherfedfa442013-11-01 23:14:17 +00001664 << "\t" << *Prev << "\t"
1665 << *History[History.size() - 2] << "\n");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001666 History.pop_back();
Devang Patelb7a328e2011-07-07 00:14:27 +00001667 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001668
1669 // Terminate old register assignments that don't reach MI;
1670 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1671 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1672 isDbgValueInDefinedReg(Prev)) {
1673 // Previous register assignment needs to terminate at the end of
1674 // its basic block.
1675 MachineBasicBlock::const_iterator LastMI =
Eric Christopherfedfa442013-11-01 23:14:17 +00001676 PrevMBB->getLastNonDebugInstr();
Devang Patelb7a328e2011-07-07 00:14:27 +00001677 if (LastMI == PrevMBB->end()) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001678 // Drop DBG_VALUE for empty range.
Eric Christopher85a495e2012-10-08 20:48:49 +00001679 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
Eric Christopherfedfa442013-11-01 23:14:17 +00001680 << "\t" << *Prev << "\n");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001681 History.pop_back();
David Blaikieea2605d2013-06-20 00:25:24 +00001682 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001683 // Terminate after LastMI.
1684 History.push_back(LastMI);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001685 }
1686 }
1687 }
1688 History.push_back(MI);
Devang Patel002d54d2010-05-26 19:37:24 +00001689 } else {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001690 // Not a DBG_VALUE instruction.
1691 if (!MI->isLabel())
1692 AtBlockEntry = false;
1693
Eric Christopher133195782012-10-04 20:46:14 +00001694 // First known non-DBG_VALUE and non-frame setup location marks
1695 // the beginning of the function body.
1696 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1697 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
Devang Patel34a66202011-05-11 19:22:19 +00001698 PrologEndLoc = MI->getDebugLoc();
1699
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001700 // Check if the instruction clobbers any registers with debug vars.
1701 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
Eric Christopherfedfa442013-11-01 23:14:17 +00001702 MOE = MI->operands_end();
1703 MOI != MOE; ++MOI) {
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001704 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1705 continue;
Eric Christopherfedfa442013-11-01 23:14:17 +00001706 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1707 ++AI) {
Jakob Stoklund Olesen54038d72012-06-01 23:28:30 +00001708 unsigned Reg = *AI;
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001709 const MDNode *Var = LiveUserVar[Reg];
1710 if (!Var)
1711 continue;
1712 // Reg is now clobbered.
1713 LiveUserVar[Reg] = 0;
1714
1715 // Was MD last defined by a DBG_VALUE referring to Reg?
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001716 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1717 if (HistI == DbgValues.end())
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001718 continue;
Eric Christopherfedfa442013-11-01 23:14:17 +00001719 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001720 if (History.empty())
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001721 continue;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001722 const MachineInstr *Prev = History.back();
1723 // Sanity-check: Register assignments are terminated at the end of
1724 // their block.
1725 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1726 continue;
1727 // Is the variable still in Reg?
1728 if (!isDbgValueInDefinedReg(Prev) ||
1729 Prev->getOperand(0).getReg() != Reg)
1730 continue;
1731 // Var is clobbered. Make sure the next instruction gets a label.
1732 History.push_back(MI);
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001733 }
1734 }
Devang Patel002d54d2010-05-26 19:37:24 +00001735 }
Devang Patel002d54d2010-05-26 19:37:24 +00001736 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001737 }
1738
1739 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1740 I != E; ++I) {
Eric Christopherfedfa442013-11-01 23:14:17 +00001741 SmallVectorImpl<const MachineInstr *> &History = I->second;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001742 if (History.empty())
1743 continue;
1744
1745 // Make sure the final register assignments are terminated.
1746 const MachineInstr *Prev = History.back();
1747 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1748 const MachineBasicBlock *PrevMBB = Prev->getParent();
Eric Christopher6a841382012-11-19 22:42:10 +00001749 MachineBasicBlock::const_iterator LastMI =
Eric Christopherfedfa442013-11-01 23:14:17 +00001750 PrevMBB->getLastNonDebugInstr();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001751 if (LastMI == PrevMBB->end())
1752 // Drop DBG_VALUE for empty range.
1753 History.pop_back();
David Blaikieea2605d2013-06-20 00:25:24 +00001754 else if (PrevMBB != &PrevMBB->getParent()->back()) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001755 // Terminate after LastMI.
1756 History.push_back(LastMI);
1757 }
1758 }
1759 // Request labels for the full history.
1760 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1761 const MachineInstr *MI = History[i];
1762 if (MI->isDebugValue())
1763 requestLabelBeforeInsn(MI);
1764 else
1765 requestLabelAfterInsn(MI);
1766 }
1767 }
Devang Patel002d54d2010-05-26 19:37:24 +00001768
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001769 PrevInstLoc = DebugLoc();
Devang Patel002d54d2010-05-26 19:37:24 +00001770 PrevLabel = FunctionBeginSym;
Devang Patel34a66202011-05-11 19:22:19 +00001771
1772 // Record beginning of function.
1773 if (!PrologEndLoc.isUnknown()) {
Eric Christopherfedfa442013-11-01 23:14:17 +00001774 DebugLoc FnStartDL =
1775 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1776 recordSourceLine(
1777 FnStartDL.getLine(), FnStartDL.getCol(),
1778 FnStartDL.getScope(MF->getFunction()->getContext()),
1779 // We'd like to list the prologue as "not statements" but GDB behaves
1780 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1781 DWARF2_FLAG_IS_STMT);
Devang Patel34a66202011-05-11 19:22:19 +00001782 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001783}
1784
Devang Patel7e623022011-08-10 20:55:27 +00001785void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
David Blaikie6f1a8062013-06-05 05:39:59 +00001786 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1787 DIVariable DV = Var->getVariable();
David Blaikie36d5d2f2013-06-06 21:04:51 +00001788 // Variables with positive arg numbers are parameters.
1789 if (unsigned ArgNum = DV.getArgNumber()) {
1790 // Keep all parameters in order at the start of the variable list to ensure
1791 // function types are correct (no out-of-order parameters)
1792 //
1793 // This could be improved by only doing it for optimized builds (unoptimized
1794 // builds have the right order to begin with), searching from the back (this
1795 // would catch the unoptimized case quickly), or doing a binary search
1796 // rather than linear search.
1797 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1798 while (I != Vars.end()) {
1799 unsigned CurNum = (*I)->getVariable().getArgNumber();
1800 // A local (non-parameter) variable has been found, insert immediately
1801 // before it.
1802 if (CurNum == 0)
1803 break;
1804 // A later indexed parameter has been found, insert immediately before it.
David Blaikieb272a752013-06-06 22:28:26 +00001805 if (CurNum > ArgNum)
David Blaikie36d5d2f2013-06-06 21:04:51 +00001806 break;
David Blaikieb272a752013-06-06 22:28:26 +00001807 ++I;
David Blaikie6f1a8062013-06-05 05:39:59 +00001808 }
David Blaikie36d5d2f2013-06-06 21:04:51 +00001809 Vars.insert(I, Var);
1810 return;
David Blaikie6f1a8062013-06-05 05:39:59 +00001811 }
1812
1813 Vars.push_back(Var);
Devang Patel7e623022011-08-10 20:55:27 +00001814}
1815
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001816// Gather and emit post-function debug information.
NAKAMURA Takumib9271612013-12-03 13:15:54 +00001817void DwarfDebug::endFunction(const MachineFunction *MF) {
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001818 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1819 // though the beginFunction may not be called at all.
1820 // We should handle both cases.
1821 if (CurFn == 0)
1822 CurFn = MF;
1823 else
1824 assert(CurFn == MF);
1825 assert(CurFn != 0);
1826
1827 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1828 CurFn = 0;
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001829 return;
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001830 }
Devang Patel2904aa92009-11-12 19:02:56 +00001831
Devang Patel7e623022011-08-10 20:55:27 +00001832 // Define end label for subprogram.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001833 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
Devang Patel7e623022011-08-10 20:55:27 +00001834 // Assumes in correct section after the entry point.
1835 Asm->OutStreamer.EmitLabel(FunctionEndSym);
Eric Christopher4287a492013-12-09 23:57:44 +00001836 // Set DwarfDwarfCompileUnitID in MCContext to default value.
Manman Ren4e042a62013-02-05 21:52:47 +00001837 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
Eric Christopher6a841382012-11-19 22:42:10 +00001838
Devang Patel7e623022011-08-10 20:55:27 +00001839 SmallPtrSet<const MDNode *, 16> ProcessedVars;
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001840 collectVariableInfo(ProcessedVars);
Eric Christopher6a841382012-11-19 22:42:10 +00001841
Devang Patel3acc70e2011-08-15 22:04:40 +00001842 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
Eric Christopher4287a492013-12-09 23:57:44 +00001843 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
Nick Lewycky654f5ce2011-10-26 22:55:33 +00001844 assert(TheCU && "Unable to find compile unit!");
Devang Patel3acc70e2011-08-15 22:04:40 +00001845
Devang Patel7e623022011-08-10 20:55:27 +00001846 // Construct abstract scopes.
Devang Patel44403472011-08-12 18:10:19 +00001847 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1848 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1849 LexicalScope *AScope = AList[i];
1850 DISubprogram SP(AScope->getScopeNode());
Manman Ren7504ed42013-07-08 18:33:29 +00001851 if (SP.isSubprogram()) {
Devang Patel7e623022011-08-10 20:55:27 +00001852 // Collect info for variables that were optimized out.
Devang Patel59e27c52011-08-19 23:28:12 +00001853 DIArray Variables = SP.getVariables();
1854 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1855 DIVariable DV(Variables.getElement(i));
Manman Ren7504ed42013-07-08 18:33:29 +00001856 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
Devang Patel59e27c52011-08-19 23:28:12 +00001857 continue;
Alexey Samsonov39602782012-07-06 08:45:08 +00001858 // Check that DbgVariable for DV wasn't created earlier, when
1859 // findAbstractVariable() was called for inlined instance of DV.
1860 LLVMContext &Ctx = DV->getContext();
1861 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1862 if (AbstractVariables.lookup(CleanDV))
1863 continue;
Devang Patel59e27c52011-08-19 23:28:12 +00001864 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
Manman Renb3388602013-10-05 01:43:03 +00001865 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
Devang Patel5c0f85c2010-06-25 22:07:34 +00001866 }
1867 }
Devang Patel44403472011-08-12 18:10:19 +00001868 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
Manman Ren4213c392013-05-29 17:16:59 +00001869 constructScopeDIE(TheCU, AScope);
Bill Wendling2b128d72009-05-20 23:19:06 +00001870 }
Eric Christopher6a841382012-11-19 22:42:10 +00001871
Devang Patel3acc70e2011-08-15 22:04:40 +00001872 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
Eric Christopher6a841382012-11-19 22:42:10 +00001873
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001874 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
Eric Christopherbb69a272012-08-24 01:14:27 +00001875 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
Devang Patel3acc70e2011-08-15 22:04:40 +00001876
Bill Wendling2b128d72009-05-20 23:19:06 +00001877 // Clear debug info
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001878 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1879 E = ScopeVariables.end();
1880 I != E; ++I)
Devang Patel7e623022011-08-10 20:55:27 +00001881 DeleteContainerPointers(I->second);
1882 ScopeVariables.clear();
Devang Patelad45d912011-04-22 18:09:57 +00001883 DeleteContainerPointers(CurrentFnArguments);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001884 UserVariables.clear();
1885 DbgValues.clear();
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00001886 AbstractVariables.clear();
Devang Patel6c74a872010-04-27 19:46:33 +00001887 LabelsBeforeInsn.clear();
1888 LabelsAfterInsn.clear();
Devang Patel12563b32010-04-16 23:33:45 +00001889 PrevLabel = NULL;
Timur Iskhodzhanov1cd14442013-12-03 15:10:23 +00001890 CurFn = 0;
Bill Wendling2b128d72009-05-20 23:19:06 +00001891}
1892
Eric Christopheracdcbdb2012-11-27 22:43:45 +00001893// Register a source line with debug info. Returns the unique label that was
1894// emitted and which provides correspondence to the source line list.
Devang Patel34a66202011-05-11 19:22:19 +00001895void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1896 unsigned Flags) {
Devang Patel2d9caf92009-11-25 17:36:49 +00001897 StringRef Fn;
Devang Patele01b75c2011-03-24 20:30:50 +00001898 StringRef Dir;
Dan Gohman50849c62010-05-05 23:41:32 +00001899 unsigned Src = 1;
1900 if (S) {
1901 DIDescriptor Scope(S);
Devang Patel2089d162009-10-05 18:03:19 +00001902
Dan Gohman50849c62010-05-05 23:41:32 +00001903 if (Scope.isCompileUnit()) {
1904 DICompileUnit CU(S);
Dan Gohman50849c62010-05-05 23:41:32 +00001905 Fn = CU.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001906 Dir = CU.getDirectory();
Devang Patelc4b69052010-10-28 17:30:52 +00001907 } else if (Scope.isFile()) {
1908 DIFile F(S);
Devang Patelc4b69052010-10-28 17:30:52 +00001909 Fn = F.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001910 Dir = F.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00001911 } else if (Scope.isSubprogram()) {
1912 DISubprogram SP(S);
Dan Gohman50849c62010-05-05 23:41:32 +00001913 Fn = SP.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001914 Dir = SP.getDirectory();
Eric Christopher6647b832011-10-11 22:59:11 +00001915 } else if (Scope.isLexicalBlockFile()) {
1916 DILexicalBlockFile DBF(S);
1917 Fn = DBF.getFilename();
1918 Dir = DBF.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00001919 } else if (Scope.isLexicalBlock()) {
1920 DILexicalBlock DB(S);
Dan Gohman50849c62010-05-05 23:41:32 +00001921 Fn = DB.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001922 Dir = DB.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00001923 } else
Craig Topperee4dab52012-02-05 08:31:47 +00001924 llvm_unreachable("Unexpected scope info");
Dan Gohman50849c62010-05-05 23:41:32 +00001925
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001926 Src = getOrCreateSourceID(
1927 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
Dan Gohman50849c62010-05-05 23:41:32 +00001928 }
Nick Lewycky019d2552011-07-29 03:49:23 +00001929 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
Bill Wendling2b128d72009-05-20 23:19:06 +00001930}
1931
Bill Wendling806535f2009-05-20 23:22:40 +00001932//===----------------------------------------------------------------------===//
1933// Emit Methods
1934//===----------------------------------------------------------------------===//
1935
Manman Rence20d462013-10-29 22:57:10 +00001936// Compute the size and offset of a DIE. The offset is relative to start of the
1937// CU. It returns the offset after laying out the DIE.
Eric Christopherf8194852013-12-05 18:06:10 +00001938unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
Bill Wendling480ff322009-05-20 23:21:38 +00001939 // Get the children.
1940 const std::vector<DIE *> &Children = Die->getChildren();
1941
Bill Wendling480ff322009-05-20 23:21:38 +00001942 // Record the abbreviation.
Devang Patel930143b2009-11-21 02:48:08 +00001943 assignAbbrevNumber(Die->getAbbrev());
Bill Wendling480ff322009-05-20 23:21:38 +00001944
1945 // Get the abbreviation for this DIE.
David Blaikieff3ab2c2013-12-05 01:01:41 +00001946 const DIEAbbrev &Abbrev = Die->getAbbrev();
Bill Wendling480ff322009-05-20 23:21:38 +00001947
1948 // Set DIE offset
1949 Die->setOffset(Offset);
1950
1951 // Start the size with the size of abbreviation code.
David Blaikieff3ab2c2013-12-05 01:01:41 +00001952 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
Bill Wendling480ff322009-05-20 23:21:38 +00001953
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001954 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
David Blaikieff3ab2c2013-12-05 01:01:41 +00001955 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
Bill Wendling480ff322009-05-20 23:21:38 +00001956
1957 // Size the DIE attribute values.
1958 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1959 // Size attribute value.
Chris Lattner5a00dea2010-04-05 00:18:22 +00001960 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
Bill Wendling480ff322009-05-20 23:21:38 +00001961
1962 // Size the DIE children if any.
1963 if (!Children.empty()) {
David Blaikieff3ab2c2013-12-05 01:01:41 +00001964 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
Bill Wendling480ff322009-05-20 23:21:38 +00001965 "Children flag not set");
1966
1967 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Eric Christopher1f0cbb82012-11-20 22:14:13 +00001968 Offset = computeSizeAndOffset(Children[j], Offset);
Bill Wendling480ff322009-05-20 23:21:38 +00001969
1970 // End of children marker.
1971 Offset += sizeof(int8_t);
1972 }
1973
1974 Die->setSize(Offset - Die->getOffset());
1975 return Offset;
1976}
1977
Eric Christopherb088d2d2013-10-24 21:05:08 +00001978// Compute the size and offset for each DIE.
Eric Christopherf8194852013-12-05 18:06:10 +00001979void DwarfFile::computeSizeAndOffsets() {
Manman Rence20d462013-10-29 22:57:10 +00001980 // Offset from the first CU in the debug info section is 0 initially.
1981 unsigned SecOffset = 0;
1982
Eric Christopherb088d2d2013-10-24 21:05:08 +00001983 // Iterate over each compile unit and set the size and offsets for each
1984 // DIE within each compile unit. All offsets are CU relative.
Eric Christophera5a79422013-12-09 23:32:48 +00001985 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1986 E = CUs.end();
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001987 I != E; ++I) {
Manman Rence20d462013-10-29 22:57:10 +00001988 (*I)->setDebugInfoOffset(SecOffset);
1989
1990 // CU-relative offset is reset to 0 here.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00001991 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
David Blaikie6b288cf2013-10-30 20:42:41 +00001992 (*I)->getHeaderSize(); // Unit-specific headers
Manman Rence20d462013-10-29 22:57:10 +00001993
1994 // EndOffset here is CU-relative, after laying out
1995 // all of the CU DIE.
David Blaikie2a80e442013-12-02 22:09:48 +00001996 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
Manman Rence20d462013-10-29 22:57:10 +00001997 SecOffset += EndOffset;
Devang Patel1a0df9a2010-05-10 22:49:55 +00001998 }
Bill Wendling480ff322009-05-20 23:21:38 +00001999}
2000
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002001// Emit initial Dwarf sections with a label at the start of each one.
Eric Christopher7b30f2e42012-11-21 00:34:35 +00002002void DwarfDebug::emitSectionLabels() {
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002003 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00002004
Bill Wendling480ff322009-05-20 23:21:38 +00002005 // Dwarf sections base addresses.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002006 DwarfInfoSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002007 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
Eric Christopherd8667202013-12-30 17:22:27 +00002008 if (useSplitDwarf())
2009 DwarfInfoDWOSectionSym =
2010 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002011 DwarfAbbrevSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002012 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
Eric Christopher3c5a1912012-12-19 22:02:53 +00002013 if (useSplitDwarf())
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002014 DwarfAbbrevDWOSectionSym = emitSectionSym(
2015 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
Eric Christopher7b30f2e42012-11-21 00:34:35 +00002016 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002017
Chris Lattner6629ca92010-04-04 22:59:04 +00002018 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
Eric Christopher7b30f2e42012-11-21 00:34:35 +00002019 emitSectionSym(Asm, MacroInfo);
Bill Wendling480ff322009-05-20 23:21:38 +00002020
Eric Christopher74804332013-02-07 21:19:50 +00002021 DwarfLineSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002022 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
Eric Christopher7b30f2e42012-11-21 00:34:35 +00002023 emitSectionSym(Asm, TLOF.getDwarfLocSection());
Eric Christopher261d2342013-09-23 20:55:35 +00002024 if (GenerateGnuPubSections) {
Eric Christopher39eebfa2013-09-30 23:14:16 +00002025 DwarfGnuPubNamesSectionSym =
2026 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2027 DwarfGnuPubTypesSectionSym =
2028 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
Eric Christopher261d2342013-09-23 20:55:35 +00002029 } else if (HasDwarfPubSections) {
2030 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2031 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
Michael Gottesmanc89466f2013-09-04 04:39:38 +00002032 }
Eric Christopherdd1a0122013-09-13 00:35:05 +00002033
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002034 DwarfStrSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002035 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
Eric Christopher55863be2013-04-07 03:43:09 +00002036 if (useSplitDwarf()) {
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002037 DwarfStrDWOSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002038 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
Eric Christopher55863be2013-04-07 03:43:09 +00002039 DwarfAddrSectionSym =
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002040 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
Eric Christopher55863be2013-04-07 03:43:09 +00002041 }
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002042 DwarfDebugRangeSectionSym =
2043 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
Bill Wendling480ff322009-05-20 23:21:38 +00002044
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002045 DwarfDebugLocSectionSym =
2046 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
Bill Wendling480ff322009-05-20 23:21:38 +00002047}
2048
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002049// Recursively emits a debug information entry.
David Blaikieff3ab2c2013-12-05 01:01:41 +00002050void DwarfDebug::emitDIE(DIE *Die) {
Bill Wendling480ff322009-05-20 23:21:38 +00002051 // Get the abbreviation for this DIE.
David Blaikieff3ab2c2013-12-05 01:01:41 +00002052 const DIEAbbrev &Abbrev = Die->getAbbrev();
Bill Wendling480ff322009-05-20 23:21:38 +00002053
Bill Wendling480ff322009-05-20 23:21:38 +00002054 // Emit the code (index) for the abbreviation.
Chris Lattner7bde8c02010-04-04 18:52:31 +00002055 if (Asm->isVerbose())
David Blaikieff3ab2c2013-12-05 01:01:41 +00002056 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2057 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2058 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2059 dwarf::TagString(Abbrev.getTag()));
2060 Asm->EmitULEB128(Abbrev.getNumber());
Bill Wendling480ff322009-05-20 23:21:38 +00002061
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002062 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
David Blaikieff3ab2c2013-12-05 01:01:41 +00002063 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
Bill Wendling480ff322009-05-20 23:21:38 +00002064
2065 // Emit the DIE attribute values.
2066 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
David Blaikief2443192013-10-21 17:28:37 +00002067 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2068 dwarf::Form Form = AbbrevData[i].getForm();
Bill Wendling480ff322009-05-20 23:21:38 +00002069 assert(Form && "Too many attributes for DIE (check abbreviation)");
2070
Chris Lattner7bde8c02010-04-04 18:52:31 +00002071 if (Asm->isVerbose())
Chris Lattner5adf9872010-01-24 18:54:17 +00002072 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002073
Bill Wendling480ff322009-05-20 23:21:38 +00002074 switch (Attr) {
Manman Rence20d462013-10-29 22:57:10 +00002075 case dwarf::DW_AT_abstract_origin:
2076 case dwarf::DW_AT_type:
2077 case dwarf::DW_AT_friend:
2078 case dwarf::DW_AT_specification:
2079 case dwarf::DW_AT_import:
2080 case dwarf::DW_AT_containing_type: {
2081 DIEEntry *E = cast<DIEEntry>(Values[i]);
2082 DIE *Origin = E->getEntry();
2083 unsigned Addr = Origin->getOffset();
2084 if (Form == dwarf::DW_FORM_ref_addr) {
2085 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2086 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2087 // section. Origin->getOffset() returns the offset from start of the
2088 // compile unit.
Eric Christopher4287a492013-12-09 23:57:44 +00002089 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
Manman Rence20d462013-10-29 22:57:10 +00002090 assert(CU && "CUDie should belong to a CU.");
2091 Addr += CU->getDebugInfoOffset();
2092 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
David Blaikie03073f72013-12-06 22:14:48 +00002093 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
Manman Rence20d462013-10-29 22:57:10 +00002094 DIEEntry::getRefAddrSize(Asm));
2095 else
David Blaikie03073f72013-12-06 22:14:48 +00002096 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2097 CU->getSectionSym(),
Manman Ren251a1bd2013-10-29 23:14:15 +00002098 DIEEntry::getRefAddrSize(Asm));
Manman Rence20d462013-10-29 22:57:10 +00002099 } else {
Manman Ren4dbdc902013-10-31 17:54:35 +00002100 // Make sure Origin belong to the same CU.
David Blaikie409dd9c2013-11-19 23:08:21 +00002101 assert(Die->getUnit() == Origin->getUnit() &&
Manman Ren4dbdc902013-10-31 17:54:35 +00002102 "The referenced DIE should belong to the same CU in ref4");
Manman Rence20d462013-10-29 22:57:10 +00002103 Asm->EmitInt32(Addr);
2104 }
2105 break;
2106 }
Devang Patel9fc11702010-05-25 23:40:22 +00002107 case dwarf::DW_AT_location: {
Nick Lewycky33da3362012-06-22 01:25:12 +00002108 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2109 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
Eric Christopherd0b82ae2013-11-16 00:18:40 +00002110 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
Nick Lewycky33da3362012-06-22 01:25:12 +00002111 else
Ulrich Weigand396ba8b2013-07-02 18:46:26 +00002112 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
Nick Lewycky33da3362012-06-22 01:25:12 +00002113 } else {
Devang Patel9fc11702010-05-25 23:40:22 +00002114 Values[i]->EmitValue(Asm, Form);
Nick Lewycky33da3362012-06-22 01:25:12 +00002115 }
Devang Patel9fc11702010-05-25 23:40:22 +00002116 break;
2117 }
Devang Patela1bd5a12010-09-29 19:08:08 +00002118 case dwarf::DW_AT_accessibility: {
2119 if (Asm->isVerbose()) {
2120 DIEInteger *V = cast<DIEInteger>(Values[i]);
2121 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2122 }
2123 Values[i]->EmitValue(Asm, Form);
2124 break;
2125 }
Bill Wendling480ff322009-05-20 23:21:38 +00002126 default:
2127 // Emit an attribute using the defined form.
Chris Lattner3a383cb2010-04-05 00:13:49 +00002128 Values[i]->EmitValue(Asm, Form);
Bill Wendling480ff322009-05-20 23:21:38 +00002129 break;
2130 }
Bill Wendling480ff322009-05-20 23:21:38 +00002131 }
2132
2133 // Emit the DIE children if any.
David Blaikieff3ab2c2013-12-05 01:01:41 +00002134 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
Bill Wendling480ff322009-05-20 23:21:38 +00002135 const std::vector<DIE *> &Children = Die->getChildren();
2136
2137 for (unsigned j = 0, M = Children.size(); j < M; ++j)
David Blaikieff3ab2c2013-12-05 01:01:41 +00002138 emitDIE(Children[j]);
Bill Wendling480ff322009-05-20 23:21:38 +00002139
David Blaikie155f8812013-12-04 21:51:05 +00002140 Asm->OutStreamer.AddComment("End Of Children Mark");
Chris Lattner566cae92010-03-09 23:52:58 +00002141 Asm->EmitInt8(0);
Bill Wendling480ff322009-05-20 23:21:38 +00002142 }
2143}
2144
Eric Christophera2de8262012-12-15 00:04:07 +00002145// Emit the various dwarf units to the unit section USection with
2146// the abbreviations going into ASection.
David Blaikie03073f72013-12-06 22:14:48 +00002147void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2148 const MCSymbol *ASectionSym) {
Eric Christophera5a79422013-12-09 23:32:48 +00002149 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2150 I != E; ++I) {
2151 DwarfUnit *TheU = *I;
David Blaikie2a80e442013-12-02 22:09:48 +00002152 DIE *Die = TheU->getUnitDie();
David Blaikie03073f72013-12-06 22:14:48 +00002153 const MCSection *USection = TheU->getSection();
2154 Asm->OutStreamer.SwitchSection(USection);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002155
Devang Patel1a0df9a2010-05-10 22:49:55 +00002156 // Emit the compile units header.
David Blaikie7d734602013-12-06 22:33:05 +00002157 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002158
Devang Patel1a0df9a2010-05-10 22:49:55 +00002159 // Emit size of content not including length itself
David Blaikie6b288cf2013-10-30 20:42:41 +00002160 Asm->OutStreamer.AddComment("Length of Unit");
David Blaikie2a80e442013-12-02 22:09:48 +00002161 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002162
David Blaikie2a80e442013-12-02 22:09:48 +00002163 TheU->emitHeader(ASection, ASectionSym);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002164
David Blaikieff3ab2c2013-12-05 01:01:41 +00002165 DD->emitDIE(Die);
David Blaikie7d734602013-12-06 22:33:05 +00002166 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
Devang Patel1a0df9a2010-05-10 22:49:55 +00002167 }
Bill Wendling480ff322009-05-20 23:21:38 +00002168}
2169
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002170// Emit the debug info section.
2171void DwarfDebug::emitDebugInfo() {
Eric Christopherf8194852013-12-05 18:06:10 +00002172 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Eric Christophera2de8262012-12-15 00:04:07 +00002173
David Blaikie03073f72013-12-06 22:14:48 +00002174 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
Eric Christophera2de8262012-12-15 00:04:07 +00002175 DwarfAbbrevSectionSym);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002176}
2177
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002178// Emit the abbreviation section.
Eric Christopher38371952012-11-20 23:30:11 +00002179void DwarfDebug::emitAbbreviations() {
Eric Christopherf8194852013-12-05 18:06:10 +00002180 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
David Blaikie0504cda2013-12-05 07:43:55 +00002181
2182 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
Eric Christopher3c5a1912012-12-19 22:02:53 +00002183}
Bill Wendling480ff322009-05-20 23:21:38 +00002184
Eric Christopherf8194852013-12-05 18:06:10 +00002185void DwarfFile::emitAbbrevs(const MCSection *Section) {
Eric Christopher3c5a1912012-12-19 22:02:53 +00002186 // Check to see if it is worth the effort.
David Blaikie0504cda2013-12-05 07:43:55 +00002187 if (!Abbreviations.empty()) {
Eric Christopher3c5a1912012-12-19 22:02:53 +00002188 // Start the debug abbrev section.
2189 Asm->OutStreamer.SwitchSection(Section);
2190
Bill Wendling480ff322009-05-20 23:21:38 +00002191 // For each abbrevation.
David Blaikie0504cda2013-12-05 07:43:55 +00002192 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
Bill Wendling480ff322009-05-20 23:21:38 +00002193 // Get abbreviation data
David Blaikie0504cda2013-12-05 07:43:55 +00002194 const DIEAbbrev *Abbrev = Abbreviations[i];
Bill Wendling480ff322009-05-20 23:21:38 +00002195
2196 // Emit the abbrevations code (base 1 index.)
Chris Lattner9efd1182010-04-04 19:09:29 +00002197 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
Bill Wendling480ff322009-05-20 23:21:38 +00002198
2199 // Emit the abbreviations data.
Chris Lattner3a383cb2010-04-05 00:13:49 +00002200 Abbrev->Emit(Asm);
Bill Wendling480ff322009-05-20 23:21:38 +00002201 }
2202
2203 // Mark end of abbreviations.
Chris Lattner9efd1182010-04-04 19:09:29 +00002204 Asm->EmitULEB128(0, "EOM(3)");
Bill Wendling480ff322009-05-20 23:21:38 +00002205 }
2206}
2207
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002208// Emit the last address of the section and the end of the line matrix.
Devang Patel930143b2009-11-21 02:48:08 +00002209void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling480ff322009-05-20 23:21:38 +00002210 // Define last address of section.
Chris Lattner566cae92010-03-09 23:52:58 +00002211 Asm->OutStreamer.AddComment("Extended Op");
2212 Asm->EmitInt8(0);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002213
Chris Lattner566cae92010-03-09 23:52:58 +00002214 Asm->OutStreamer.AddComment("Op size");
Chandler Carruth5da3f052012-11-01 09:14:31 +00002215 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
Chris Lattner566cae92010-03-09 23:52:58 +00002216 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2217 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2218
2219 Asm->OutStreamer.AddComment("Section end label");
Chris Lattnerb245dfb2010-03-10 01:17:49 +00002220
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002221 Asm->OutStreamer.EmitSymbolValue(
2222 Asm->GetTempSymbol("section_end", SectionEnd),
2223 Asm->getDataLayout().getPointerSize());
Bill Wendling480ff322009-05-20 23:21:38 +00002224
2225 // Mark end of matrix.
Chris Lattner566cae92010-03-09 23:52:58 +00002226 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2227 Asm->EmitInt8(0);
Chris Lattnerf5c834f2010-01-22 22:09:00 +00002228 Asm->EmitInt8(1);
Chris Lattnerfa823552010-01-22 23:18:42 +00002229 Asm->EmitInt8(1);
Bill Wendling480ff322009-05-20 23:21:38 +00002230}
2231
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002232// Emit visible names into a hashed accelerator table section.
Eric Christopher4996c702011-11-07 09:24:32 +00002233void DwarfDebug::emitAccelNames() {
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002234 DwarfAccelTable AT(
2235 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
Eric Christophera5a79422013-12-09 23:32:48 +00002236 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2237 E = getUnits().end();
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002238 I != E; ++I) {
Eric Christophera5a79422013-12-09 23:32:48 +00002239 DwarfUnit *TheU = *I;
David Blaikie2a80e442013-12-02 22:09:48 +00002240 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
David Blaikie2ea848b2013-11-19 22:51:04 +00002241 for (StringMap<std::vector<const DIE *> >::const_iterator
2242 GI = Names.begin(),
2243 GE = Names.end();
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002244 GI != GE; ++GI) {
Benjamin Kramer63e39eb2013-05-11 18:24:28 +00002245 StringRef Name = GI->getKey();
David Blaikie2ea848b2013-11-19 22:51:04 +00002246 const std::vector<const DIE *> &Entities = GI->second;
2247 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2248 DE = Entities.end();
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002249 DI != DE; ++DI)
David Blaikie2ea848b2013-11-19 22:51:04 +00002250 AT.AddName(Name, *DI);
Eric Christopher4996c702011-11-07 09:24:32 +00002251 }
2252 }
2253
2254 AT.FinalizeTable(Asm, "Names");
2255 Asm->OutStreamer.SwitchSection(
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002256 Asm->getObjFileLowering().getDwarfAccelNamesSection());
Eric Christopher4996c702011-11-07 09:24:32 +00002257 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2258 Asm->OutStreamer.EmitLabel(SectionBegin);
2259
2260 // Emit the full data.
Eric Christophere698f532012-12-20 21:58:36 +00002261 AT.Emit(Asm, SectionBegin, &InfoHolder);
Eric Christopher4996c702011-11-07 09:24:32 +00002262}
2263
Eric Christopher48fef592012-12-20 21:58:40 +00002264// Emit objective C classes and categories into a hashed accelerator table
2265// section.
Eric Christopher4996c702011-11-07 09:24:32 +00002266void DwarfDebug::emitAccelObjC() {
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002267 DwarfAccelTable AT(
2268 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
Eric Christophera5a79422013-12-09 23:32:48 +00002269 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2270 E = getUnits().end();
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002271 I != E; ++I) {
Eric Christophera5a79422013-12-09 23:32:48 +00002272 DwarfUnit *TheU = *I;
David Blaikie2a80e442013-12-02 22:09:48 +00002273 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
David Blaikie2ea848b2013-11-19 22:51:04 +00002274 for (StringMap<std::vector<const DIE *> >::const_iterator
2275 GI = Names.begin(),
2276 GE = Names.end();
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002277 GI != GE; ++GI) {
Benjamin Kramer63e39eb2013-05-11 18:24:28 +00002278 StringRef Name = GI->getKey();
David Blaikie2ea848b2013-11-19 22:51:04 +00002279 const std::vector<const DIE *> &Entities = GI->second;
2280 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2281 DE = Entities.end();
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002282 DI != DE; ++DI)
David Blaikie2ea848b2013-11-19 22:51:04 +00002283 AT.AddName(Name, *DI);
Eric Christopher4996c702011-11-07 09:24:32 +00002284 }
2285 }
2286
2287 AT.FinalizeTable(Asm, "ObjC");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002288 Asm->OutStreamer.SwitchSection(
2289 Asm->getObjFileLowering().getDwarfAccelObjCSection());
Eric Christopher4996c702011-11-07 09:24:32 +00002290 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2291 Asm->OutStreamer.EmitLabel(SectionBegin);
2292
2293 // Emit the full data.
Eric Christophere698f532012-12-20 21:58:36 +00002294 AT.Emit(Asm, SectionBegin, &InfoHolder);
Eric Christopher4996c702011-11-07 09:24:32 +00002295}
2296
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002297// Emit namespace dies into a hashed accelerator table.
Eric Christopher4996c702011-11-07 09:24:32 +00002298void DwarfDebug::emitAccelNamespaces() {
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002299 DwarfAccelTable AT(
2300 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
Eric Christophera5a79422013-12-09 23:32:48 +00002301 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2302 E = getUnits().end();
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002303 I != E; ++I) {
Eric Christophera5a79422013-12-09 23:32:48 +00002304 DwarfUnit *TheU = *I;
David Blaikie2ea848b2013-11-19 22:51:04 +00002305 const StringMap<std::vector<const DIE *> > &Names =
David Blaikie2a80e442013-12-02 22:09:48 +00002306 TheU->getAccelNamespace();
David Blaikie2ea848b2013-11-19 22:51:04 +00002307 for (StringMap<std::vector<const DIE *> >::const_iterator
2308 GI = Names.begin(),
2309 GE = Names.end();
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002310 GI != GE; ++GI) {
Benjamin Kramer63e39eb2013-05-11 18:24:28 +00002311 StringRef Name = GI->getKey();
David Blaikie2ea848b2013-11-19 22:51:04 +00002312 const std::vector<const DIE *> &Entities = GI->second;
2313 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2314 DE = Entities.end();
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002315 DI != DE; ++DI)
David Blaikie2ea848b2013-11-19 22:51:04 +00002316 AT.AddName(Name, *DI);
Eric Christopher4996c702011-11-07 09:24:32 +00002317 }
2318 }
2319
2320 AT.FinalizeTable(Asm, "namespac");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002321 Asm->OutStreamer.SwitchSection(
2322 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
Eric Christopher4996c702011-11-07 09:24:32 +00002323 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2324 Asm->OutStreamer.EmitLabel(SectionBegin);
2325
2326 // Emit the full data.
Eric Christophere698f532012-12-20 21:58:36 +00002327 AT.Emit(Asm, SectionBegin, &InfoHolder);
Eric Christopher4996c702011-11-07 09:24:32 +00002328}
2329
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002330// Emit type dies into a hashed accelerator table.
Eric Christopher4996c702011-11-07 09:24:32 +00002331void DwarfDebug::emitAccelTypes() {
Eric Christopher21bde872012-01-06 04:35:23 +00002332 std::vector<DwarfAccelTable::Atom> Atoms;
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002333 Atoms.push_back(
2334 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2335 Atoms.push_back(
2336 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2337 Atoms.push_back(
2338 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
Eric Christopher21bde872012-01-06 04:35:23 +00002339 DwarfAccelTable AT(Atoms);
Eric Christophera5a79422013-12-09 23:32:48 +00002340 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2341 E = getUnits().end();
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002342 I != E; ++I) {
Eric Christophera5a79422013-12-09 23:32:48 +00002343 DwarfUnit *TheU = *I;
David Blaikie2ea848b2013-11-19 22:51:04 +00002344 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
David Blaikie2a80e442013-12-02 22:09:48 +00002345 TheU->getAccelTypes();
David Blaikie2ea848b2013-11-19 22:51:04 +00002346 for (StringMap<
2347 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002348 GI = Names.begin(),
2349 GE = Names.end();
2350 GI != GE; ++GI) {
Benjamin Kramer63e39eb2013-05-11 18:24:28 +00002351 StringRef Name = GI->getKey();
David Blaikie2ea848b2013-11-19 22:51:04 +00002352 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2353 GI->second;
2354 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002355 DI = Entities.begin(),
2356 DE = Entities.end();
2357 DI != DE; ++DI)
David Blaikie2ea848b2013-11-19 22:51:04 +00002358 AT.AddName(Name, DI->first, DI->second);
Eric Christopher4996c702011-11-07 09:24:32 +00002359 }
2360 }
2361
2362 AT.FinalizeTable(Asm, "types");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002363 Asm->OutStreamer.SwitchSection(
2364 Asm->getObjFileLowering().getDwarfAccelTypesSection());
Eric Christopher4996c702011-11-07 09:24:32 +00002365 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2366 Asm->OutStreamer.EmitLabel(SectionBegin);
2367
2368 // Emit the full data.
Eric Christophere698f532012-12-20 21:58:36 +00002369 AT.Emit(Asm, SectionBegin, &InfoHolder);
Eric Christopher4996c702011-11-07 09:24:32 +00002370}
2371
Eric Christopherdd1a0122013-09-13 00:35:05 +00002372// Public name handling.
2373// The format for the various pubnames:
2374//
2375// dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2376// for the DIE that is named.
2377//
2378// gnu pubnames - offset/index value/name tuples where the offset is the offset
2379// into the CU and the index value is computed according to the type of value
2380// for the DIE that is named.
2381//
2382// For type units the offset is the offset of the skeleton DIE. For split dwarf
2383// it's the offset within the debug_info/debug_types dwo section, however, the
2384// reference in the pubname header doesn't change.
2385
2386/// computeIndexValue - Compute the gdb index value for the DIE and CU.
Eric Christophera5a79422013-12-09 23:32:48 +00002387static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
Eric Christopher0fe676a2013-11-21 00:48:22 +00002388 const DIE *Die) {
Eric Christopherd2b497b2013-10-16 01:37:49 +00002389 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2390
2391 // We could have a specification DIE that has our most of our knowledge,
2392 // look for that now.
2393 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2394 if (SpecVal) {
2395 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2396 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2397 Linkage = dwarf::GIEL_EXTERNAL;
2398 } else if (Die->findAttribute(dwarf::DW_AT_external))
2399 Linkage = dwarf::GIEL_EXTERNAL;
Eric Christopherdd1a0122013-09-13 00:35:05 +00002400
2401 switch (Die->getTag()) {
2402 case dwarf::DW_TAG_class_type:
2403 case dwarf::DW_TAG_structure_type:
2404 case dwarf::DW_TAG_union_type:
2405 case dwarf::DW_TAG_enumeration_type:
Eric Christopher261d2342013-09-23 20:55:35 +00002406 return dwarf::PubIndexEntryDescriptor(
2407 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2408 ? dwarf::GIEL_STATIC
2409 : dwarf::GIEL_EXTERNAL);
Eric Christopherdd1a0122013-09-13 00:35:05 +00002410 case dwarf::DW_TAG_typedef:
2411 case dwarf::DW_TAG_base_type:
2412 case dwarf::DW_TAG_subrange_type:
David Blaikie8dec4072013-09-19 20:40:26 +00002413 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
Eric Christopherdd1a0122013-09-13 00:35:05 +00002414 case dwarf::DW_TAG_namespace:
David Blaikie8dec4072013-09-19 20:40:26 +00002415 return dwarf::GIEK_TYPE;
Eric Christopherdd1a0122013-09-13 00:35:05 +00002416 case dwarf::DW_TAG_subprogram:
Eric Christopherccac5c42013-09-23 22:59:14 +00002417 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
Eric Christopherdd1a0122013-09-13 00:35:05 +00002418 case dwarf::DW_TAG_constant:
2419 case dwarf::DW_TAG_variable:
Eric Christopherccac5c42013-09-23 22:59:14 +00002420 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
Eric Christopherdd1a0122013-09-13 00:35:05 +00002421 case dwarf::DW_TAG_enumerator:
David Blaikie8dec4072013-09-19 20:40:26 +00002422 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2423 dwarf::GIEL_STATIC);
Eric Christopherdd1a0122013-09-13 00:35:05 +00002424 default:
David Blaikie8dec4072013-09-19 20:40:26 +00002425 return dwarf::GIEK_NONE;
Eric Christopherdd1a0122013-09-13 00:35:05 +00002426 }
Eric Christopherdd1a0122013-09-13 00:35:05 +00002427}
2428
Eric Christopher5f93bb92013-09-09 20:03:17 +00002429/// emitDebugPubNames - Emit visible names into a debug pubnames section.
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002430///
Eric Christopherdd1a0122013-09-13 00:35:05 +00002431void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
Eric Christopherdd1a0122013-09-13 00:35:05 +00002432 const MCSection *PSec =
2433 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2434 : Asm->getObjFileLowering().getDwarfPubNamesSection();
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002435
David Blaikie4f623202013-12-06 19:38:49 +00002436 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Eric Christophera5a79422013-12-09 23:32:48 +00002437 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
David Blaikie4f623202013-12-06 19:38:49 +00002438 for (unsigned i = 0; i != Units.size(); ++i) {
Eric Christophera5a79422013-12-09 23:32:48 +00002439 DwarfUnit *TheU = Units[i];
David Blaikie2a80e442013-12-02 22:09:48 +00002440 unsigned ID = TheU->getUniqueID();
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002441
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002442 // Start the dwarf pubnames section.
Eric Christopher13b99d22013-09-10 21:49:37 +00002443 Asm->OutStreamer.SwitchSection(PSec);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002444
Eric Christopher39eebfa2013-09-30 23:14:16 +00002445 // Emit a label so we can reference the beginning of this pubname section.
2446 if (GnuStyle)
David Blaikieb7a1c4d2013-12-04 17:55:41 +00002447 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
Eric Christopher39eebfa2013-09-30 23:14:16 +00002448
Eric Christopherdd1a0122013-09-13 00:35:05 +00002449 // Emit the header.
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002450 Asm->OutStreamer.AddComment("Length of Public Names Info");
David Blaikieb7a1c4d2013-12-04 17:55:41 +00002451 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2452 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2453 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002454
David Blaikieb7a1c4d2013-12-04 17:55:41 +00002455 Asm->OutStreamer.EmitLabel(BeginLabel);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002456
2457 Asm->OutStreamer.AddComment("DWARF Version");
David Majnemered89b5c2013-08-21 06:13:34 +00002458 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002459
2460 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
David Blaikie7d734602013-12-06 22:33:05 +00002461 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002462
2463 Asm->OutStreamer.AddComment("Compilation Unit Length");
David Blaikie7d734602013-12-06 22:33:05 +00002464 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002465
Eric Christopherdd1a0122013-09-13 00:35:05 +00002466 // Emit the pubnames for this compilation unit.
David Blaikie4f623202013-12-06 19:38:49 +00002467 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
Eric Christopher0fe676a2013-11-21 00:48:22 +00002468 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2469 GE = Globals.end();
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002470 GI != GE; ++GI) {
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002471 const char *Name = GI->getKeyData();
Eric Christopher0fe676a2013-11-21 00:48:22 +00002472 const DIE *Entity = GI->second;
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002473
2474 Asm->OutStreamer.AddComment("DIE offset");
2475 Asm->EmitInt32(Entity->getOffset());
2476
Eric Christopherdd1a0122013-09-13 00:35:05 +00002477 if (GnuStyle) {
David Blaikie2a80e442013-12-02 22:09:48 +00002478 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
David Blaikied0a869d2013-09-19 22:19:37 +00002479 Asm->OutStreamer.AddComment(
David Blaikieefd0bcb2013-09-20 00:33:15 +00002480 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
David Blaikie404d3042013-09-19 23:01:29 +00002481 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
David Blaikied0a869d2013-09-19 22:19:37 +00002482 Asm->EmitInt8(Desc.toBits());
Eric Christopherdd1a0122013-09-13 00:35:05 +00002483 }
2484
David Blaikie155f8812013-12-04 21:51:05 +00002485 Asm->OutStreamer.AddComment("External Name");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002486 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002487 }
2488
2489 Asm->OutStreamer.AddComment("End Mark");
2490 Asm->EmitInt32(0);
David Blaikieb7a1c4d2013-12-04 17:55:41 +00002491 Asm->OutStreamer.EmitLabel(EndLabel);
Krzysztof Parzyszek228daa62013-02-12 18:00:14 +00002492 }
2493}
2494
Eric Christopherdd1a0122013-09-13 00:35:05 +00002495void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
Eric Christopher261d2342013-09-23 20:55:35 +00002496 const MCSection *PSec =
2497 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2498 : Asm->getObjFileLowering().getDwarfPubTypesSection();
Eric Christopher8b3737f2013-09-13 00:34:58 +00002499
David Blaikie4f623202013-12-06 19:38:49 +00002500 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Eric Christophera5a79422013-12-09 23:32:48 +00002501 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
David Blaikie4f623202013-12-06 19:38:49 +00002502 for (unsigned i = 0; i != Units.size(); ++i) {
Eric Christophera5a79422013-12-09 23:32:48 +00002503 DwarfUnit *TheU = Units[i];
David Blaikieb7a1c4d2013-12-04 17:55:41 +00002504 unsigned ID = TheU->getUniqueID();
2505
Eric Christopher6abc9c52011-11-07 09:18:35 +00002506 // Start the dwarf pubtypes section.
Eric Christopher8b3737f2013-09-13 00:34:58 +00002507 Asm->OutStreamer.SwitchSection(PSec);
Eric Christopher39eebfa2013-09-30 23:14:16 +00002508
2509 // Emit a label so we can reference the beginning of this pubtype section.
2510 if (GnuStyle)
David Blaikieb7a1c4d2013-12-04 17:55:41 +00002511 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
Eric Christopher39eebfa2013-09-30 23:14:16 +00002512
2513 // Emit the header.
Devang Patel1a0df9a2010-05-10 22:49:55 +00002514 Asm->OutStreamer.AddComment("Length of Public Types Info");
David Blaikieb7a1c4d2013-12-04 17:55:41 +00002515 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2516 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2517 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002518
David Blaikieb7a1c4d2013-12-04 17:55:41 +00002519 Asm->OutStreamer.EmitLabel(BeginLabel);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002520
David Blaikie155f8812013-12-04 21:51:05 +00002521 Asm->OutStreamer.AddComment("DWARF Version");
David Majnemered89b5c2013-08-21 06:13:34 +00002522 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002523
Devang Patel1a0df9a2010-05-10 22:49:55 +00002524 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
David Blaikie7d734602013-12-06 22:33:05 +00002525 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002526
Devang Patel1a0df9a2010-05-10 22:49:55 +00002527 Asm->OutStreamer.AddComment("Compilation Unit Length");
David Blaikie7d734602013-12-06 22:33:05 +00002528 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002529
Eric Christopher39eebfa2013-09-30 23:14:16 +00002530 // Emit the pubtypes.
David Blaikie4f623202013-12-06 19:38:49 +00002531 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
Eric Christopher0fe676a2013-11-21 00:48:22 +00002532 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2533 GE = Globals.end();
Eric Christopher8b3737f2013-09-13 00:34:58 +00002534 GI != GE; ++GI) {
Devang Patel1a0df9a2010-05-10 22:49:55 +00002535 const char *Name = GI->getKeyData();
Eric Christopher0fe676a2013-11-21 00:48:22 +00002536 const DIE *Entity = GI->second;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002537
David Blaikie155f8812013-12-04 21:51:05 +00002538 Asm->OutStreamer.AddComment("DIE offset");
Devang Patel1a0df9a2010-05-10 22:49:55 +00002539 Asm->EmitInt32(Entity->getOffset());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002540
Eric Christopherdd1a0122013-09-13 00:35:05 +00002541 if (GnuStyle) {
David Blaikie2a80e442013-12-02 22:09:48 +00002542 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
David Blaikied0a869d2013-09-19 22:19:37 +00002543 Asm->OutStreamer.AddComment(
David Blaikieefd0bcb2013-09-20 00:33:15 +00002544 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
David Blaikie404d3042013-09-19 23:01:29 +00002545 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
David Blaikied0a869d2013-09-19 22:19:37 +00002546 Asm->EmitInt8(Desc.toBits());
Eric Christopherdd1a0122013-09-13 00:35:05 +00002547 }
2548
David Blaikie155f8812013-12-04 21:51:05 +00002549 Asm->OutStreamer.AddComment("External Name");
Eric Christopher8b3737f2013-09-13 00:34:58 +00002550
Benjamin Kramer966ed1b2011-11-09 18:16:11 +00002551 // Emit the name with a terminating null byte.
Eric Christopher8b3737f2013-09-13 00:34:58 +00002552 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
Devang Patel1a0df9a2010-05-10 22:49:55 +00002553 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002554
Devang Patel1a0df9a2010-05-10 22:49:55 +00002555 Asm->OutStreamer.AddComment("End Mark");
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002556 Asm->EmitInt32(0);
David Blaikieb7a1c4d2013-12-04 17:55:41 +00002557 Asm->OutStreamer.EmitLabel(EndLabel);
Devang Patel04d2f2d2009-11-24 01:14:22 +00002558 }
Devang Patel04d2f2d2009-11-24 01:14:22 +00002559}
2560
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002561// Emit strings into a string section.
Eric Christopherf8194852013-12-05 18:06:10 +00002562void DwarfFile::emitStrings(const MCSection *StrSection,
Eric Christophera5a79422013-12-09 23:32:48 +00002563 const MCSection *OffsetSection = NULL,
2564 const MCSymbol *StrSecSym = NULL) {
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002565
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002566 if (StringPool.empty())
2567 return;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002568
Chris Lattner3d72a672010-03-09 23:38:23 +00002569 // Start the dwarf str section.
Eric Christopher2cbd5762013-01-07 19:32:41 +00002570 Asm->OutStreamer.SwitchSection(StrSection);
Bill Wendling480ff322009-05-20 23:21:38 +00002571
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002572 // Get all of the string pool entries and put them in an array by their ID so
2573 // we can sort them.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002574 SmallVector<
2575 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2576 64> Entries;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002577
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002578 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2579 I = StringPool.begin(),
2580 E = StringPool.end();
Eric Christopher48fef592012-12-20 21:58:40 +00002581 I != E; ++I)
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002582 Entries.push_back(std::make_pair(I->second.second, &*I));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002583
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002584 array_pod_sort(Entries.begin(), Entries.end());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002585
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002586 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
Chris Lattner3d72a672010-03-09 23:38:23 +00002587 // Emit a label for reference from debug information entries.
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002588 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002589
Benjamin Kramer966ed1b2011-11-09 18:16:11 +00002590 // Emit the string itself with a terminating null byte.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002591 Asm->OutStreamer.EmitBytes(
2592 StringRef(Entries[i].second->getKeyData(),
2593 Entries[i].second->getKeyLength() + 1));
Bill Wendling480ff322009-05-20 23:21:38 +00002594 }
Eric Christopher2cbd5762013-01-07 19:32:41 +00002595
2596 // If we've got an offset section go ahead and emit that now as well.
2597 if (OffsetSection) {
2598 Asm->OutStreamer.SwitchSection(OffsetSection);
2599 unsigned offset = 0;
Eric Christopher962c9082013-01-15 23:56:56 +00002600 unsigned size = 4; // FIXME: DWARF64 is 8.
Eric Christopher2cbd5762013-01-07 19:32:41 +00002601 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
Eric Christopherbf7bc492013-01-09 03:52:05 +00002602 Asm->OutStreamer.EmitIntValue(offset, size);
Eric Christopher2cbd5762013-01-07 19:32:41 +00002603 offset += Entries[i].second->getKeyLength() + 1;
2604 }
2605 }
Bill Wendling480ff322009-05-20 23:21:38 +00002606}
2607
Eric Christopher65132a82013-11-19 09:11:26 +00002608// Emit addresses into the section given.
Eric Christopherf8194852013-12-05 18:06:10 +00002609void DwarfFile::emitAddresses(const MCSection *AddrSection) {
Eric Christopher962c9082013-01-15 23:56:56 +00002610
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002611 if (AddressPool.empty())
2612 return;
Eric Christopher962c9082013-01-15 23:56:56 +00002613
2614 // Start the dwarf addr section.
2615 Asm->OutStreamer.SwitchSection(AddrSection);
2616
David Blaikiece1960f2013-07-08 17:51:28 +00002617 // Order the address pool entries by ID
David Blaikieac569a62013-07-08 17:33:10 +00002618 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
Eric Christopher962c9082013-01-15 23:56:56 +00002619
David Blaikiece1960f2013-07-08 17:51:28 +00002620 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2621 E = AddressPool.end();
Eric Christopher962c9082013-01-15 23:56:56 +00002622 I != E; ++I)
David Blaikieac569a62013-07-08 17:33:10 +00002623 Entries[I->second] = I->first;
Eric Christopher962c9082013-01-15 23:56:56 +00002624
2625 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
Ulrich Weigand8b3d2262013-07-02 18:46:46 +00002626 // Emit an expression for reference from debug information entries.
David Blaikieac569a62013-07-08 17:33:10 +00002627 if (const MCExpr *Expr = Entries[i])
Ulrich Weigand8b3d2262013-07-02 18:46:46 +00002628 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
Eric Christopher962c9082013-01-15 23:56:56 +00002629 else
2630 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2631 }
Eric Christopher962c9082013-01-15 23:56:56 +00002632}
2633
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002634// Emit visible names into a debug str section.
2635void DwarfDebug::emitDebugStr() {
Eric Christopherf8194852013-12-05 18:06:10 +00002636 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Eric Christopher3bf29fd2012-12-27 02:14:01 +00002637 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2638}
2639
Eric Christopher9046f942013-07-02 21:36:07 +00002640// Emit locations into the debug loc section.
Devang Patel930143b2009-11-21 02:48:08 +00002641void DwarfDebug::emitDebugLoc() {
Devang Patel6b9a9fe2010-05-26 23:55:23 +00002642 if (DotDebugLocEntries.empty())
2643 return;
2644
Eric Christopher4887c8f2013-03-29 23:34:06 +00002645 for (SmallVectorImpl<DotDebugLocEntry>::iterator
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002646 I = DotDebugLocEntries.begin(),
2647 E = DotDebugLocEntries.end();
Devang Patel116a9d72011-02-04 22:57:18 +00002648 I != E; ++I) {
2649 DotDebugLocEntry &Entry = *I;
2650 if (I + 1 != DotDebugLocEntries.end())
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002651 Entry.Merge(I + 1);
Devang Patel116a9d72011-02-04 22:57:18 +00002652 }
2653
Daniel Dunbarfd95b012011-03-16 22:16:39 +00002654 // Start the dwarf loc section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002655 Asm->OutStreamer.SwitchSection(
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002656 Asm->getObjFileLowering().getDwarfLocSection());
Chandler Carruth5da3f052012-11-01 09:14:31 +00002657 unsigned char Size = Asm->getDataLayout().getPointerSize();
Devang Patel6b9a9fe2010-05-26 23:55:23 +00002658 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2659 unsigned index = 1;
Eric Christopher4887c8f2013-03-29 23:34:06 +00002660 for (SmallVectorImpl<DotDebugLocEntry>::iterator
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002661 I = DotDebugLocEntries.begin(),
2662 E = DotDebugLocEntries.end();
Devang Patel30265c42010-07-07 20:12:52 +00002663 I != E; ++I, ++index) {
Devang Patel116a9d72011-02-04 22:57:18 +00002664 DotDebugLocEntry &Entry = *I;
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002665 if (Entry.isMerged())
2666 continue;
Devang Patel9fc11702010-05-25 23:40:22 +00002667 if (Entry.isEmpty()) {
Eric Christopherce0cfce2013-01-09 01:35:34 +00002668 Asm->OutStreamer.EmitIntValue(0, Size);
2669 Asm->OutStreamer.EmitIntValue(0, Size);
Devang Patel6b9a9fe2010-05-26 23:55:23 +00002670 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
Devang Patel9fc11702010-05-25 23:40:22 +00002671 } else {
Eric Christopher25f06422013-07-03 22:40:18 +00002672 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2673 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2674 DIVariable DV(Entry.getVariable());
Rafael Espindolad23bfb82011-05-27 22:05:41 +00002675 Asm->OutStreamer.AddComment("Loc expr size");
2676 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2677 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2678 Asm->EmitLabelDifference(end, begin, 2);
2679 Asm->OutStreamer.EmitLabel(begin);
Devang Pateled9fd452011-07-08 16:49:43 +00002680 if (Entry.isInt()) {
Devang Patel324f8432011-06-01 22:03:25 +00002681 DIBasicType BTy(DV.getType());
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002682 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2683 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
Devang Patel324f8432011-06-01 22:03:25 +00002684 Asm->OutStreamer.AddComment("DW_OP_consts");
2685 Asm->EmitInt8(dwarf::DW_OP_consts);
Devang Pateled9fd452011-07-08 16:49:43 +00002686 Asm->EmitSLEB128(Entry.getInt());
Devang Patel324f8432011-06-01 22:03:25 +00002687 } else {
2688 Asm->OutStreamer.AddComment("DW_OP_constu");
2689 Asm->EmitInt8(dwarf::DW_OP_constu);
Devang Pateled9fd452011-07-08 16:49:43 +00002690 Asm->EmitULEB128(Entry.getInt());
Devang Patel324f8432011-06-01 22:03:25 +00002691 }
Devang Pateled9fd452011-07-08 16:49:43 +00002692 } else if (Entry.isLocation()) {
Eric Christopher614a89f2013-07-03 22:40:21 +00002693 MachineLocation Loc = Entry.getLoc();
Eric Christopher6a841382012-11-19 22:42:10 +00002694 if (!DV.hasComplexAddress())
Devang Pateled9fd452011-07-08 16:49:43 +00002695 // Regular entry.
Eric Christopher614a89f2013-07-03 22:40:21 +00002696 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
Devang Pateled9fd452011-07-08 16:49:43 +00002697 else {
2698 // Complex address entry.
2699 unsigned N = DV.getNumAddrElements();
2700 unsigned i = 0;
2701 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
Eric Christopher614a89f2013-07-03 22:40:21 +00002702 if (Loc.getOffset()) {
Devang Pateled9fd452011-07-08 16:49:43 +00002703 i = 2;
Eric Christopher614a89f2013-07-03 22:40:21 +00002704 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
Devang Pateled9fd452011-07-08 16:49:43 +00002705 Asm->OutStreamer.AddComment("DW_OP_deref");
2706 Asm->EmitInt8(dwarf::DW_OP_deref);
2707 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2708 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2709 Asm->EmitSLEB128(DV.getAddrElement(1));
2710 } else {
2711 // If first address element is OpPlus then emit
2712 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
Eric Christopher614a89f2013-07-03 22:40:21 +00002713 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2714 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
Devang Pateled9fd452011-07-08 16:49:43 +00002715 i = 2;
2716 }
2717 } else {
Eric Christopher614a89f2013-07-03 22:40:21 +00002718 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
Devang Pateled9fd452011-07-08 16:49:43 +00002719 }
Eric Christopher6a841382012-11-19 22:42:10 +00002720
Devang Pateled9fd452011-07-08 16:49:43 +00002721 // Emit remaining complex address elements.
2722 for (; i < N; ++i) {
2723 uint64_t Element = DV.getAddrElement(i);
2724 if (Element == DIBuilder::OpPlus) {
2725 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2726 Asm->EmitULEB128(DV.getAddrElement(++i));
Eric Christopher4d250522012-05-08 18:56:00 +00002727 } else if (Element == DIBuilder::OpDeref) {
Eric Christopher614a89f2013-07-03 22:40:21 +00002728 if (!Loc.isReg())
Eric Christopher4d250522012-05-08 18:56:00 +00002729 Asm->EmitInt8(dwarf::DW_OP_deref);
2730 } else
2731 llvm_unreachable("unknown Opcode found in complex address");
Devang Pateled9fd452011-07-08 16:49:43 +00002732 }
Devang Patel3e021532011-04-28 02:22:40 +00002733 }
Devang Patel3e021532011-04-28 02:22:40 +00002734 }
Devang Pateled9fd452011-07-08 16:49:43 +00002735 // else ... ignore constant fp. There is not any good way to
2736 // to represent them here in dwarf.
Rafael Espindolad23bfb82011-05-27 22:05:41 +00002737 Asm->OutStreamer.EmitLabel(end);
Devang Patel9fc11702010-05-25 23:40:22 +00002738 }
2739 }
Bill Wendling480ff322009-05-20 23:21:38 +00002740}
2741
Richard Mitton21101b32013-09-19 23:21:01 +00002742struct SymbolCUSorter {
2743 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2744 const MCStreamer &Streamer;
2745
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002746 bool operator()(const SymbolCU &A, const SymbolCU &B) {
Richard Mitton21101b32013-09-19 23:21:01 +00002747 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2748 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2749
2750 // Symbols with no order assigned should be placed at the end.
2751 // (e.g. section end labels)
2752 if (IA == 0)
2753 IA = (unsigned)(-1);
2754 if (IB == 0)
2755 IB = (unsigned)(-1);
2756 return IA < IB;
2757 }
2758};
2759
Eric Christophera5a79422013-12-09 23:32:48 +00002760static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002761 return (A->getUniqueID() < B->getUniqueID());
Richard Mitton21101b32013-09-19 23:21:01 +00002762}
2763
2764struct ArangeSpan {
2765 const MCSymbol *Start, *End;
2766};
2767
2768// Emit a debug aranges section, containing a CU lookup for any
2769// address we can tie back to a CU.
Eric Christopher7b30f2e42012-11-21 00:34:35 +00002770void DwarfDebug::emitDebugARanges() {
Bill Wendling480ff322009-05-20 23:21:38 +00002771 // Start the dwarf aranges section.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002772 Asm->OutStreamer.SwitchSection(
2773 Asm->getObjFileLowering().getDwarfARangesSection());
Richard Mitton21101b32013-09-19 23:21:01 +00002774
Eric Christopher4287a492013-12-09 23:57:44 +00002775 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
Richard Mitton21101b32013-09-19 23:21:01 +00002776
2777 SpansType Spans;
2778
2779 // Build a list of sections used.
2780 std::vector<const MCSection *> Sections;
2781 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2782 it++) {
2783 const MCSection *Section = it->first;
2784 Sections.push_back(Section);
2785 }
2786
2787 // Sort the sections into order.
2788 // This is only done to ensure consistent output order across different runs.
2789 std::sort(Sections.begin(), Sections.end(), SectionSort);
2790
2791 // Build a set of address spans, sorted by CU.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002792 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
Richard Mitton21101b32013-09-19 23:21:01 +00002793 const MCSection *Section = Sections[SecIdx];
2794 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2795 if (List.size() < 2)
2796 continue;
2797
2798 // Sort the symbols by offset within the section.
2799 SymbolCUSorter sorter(Asm->OutStreamer);
2800 std::sort(List.begin(), List.end(), sorter);
2801
2802 // If we have no section (e.g. common), just write out
2803 // individual spans for each symbol.
2804 if (Section == NULL) {
2805 for (size_t n = 0; n < List.size(); n++) {
2806 const SymbolCU &Cur = List[n];
2807
2808 ArangeSpan Span;
2809 Span.Start = Cur.Sym;
2810 Span.End = NULL;
2811 if (Cur.CU)
2812 Spans[Cur.CU].push_back(Span);
2813 }
2814 } else {
2815 // Build spans between each label.
2816 const MCSymbol *StartSym = List[0].Sym;
2817 for (size_t n = 1; n < List.size(); n++) {
2818 const SymbolCU &Prev = List[n - 1];
2819 const SymbolCU &Cur = List[n];
2820
2821 // Try and build the longest span we can within the same CU.
2822 if (Cur.CU != Prev.CU) {
2823 ArangeSpan Span;
2824 Span.Start = StartSym;
2825 Span.End = Cur.Sym;
2826 Spans[Prev.CU].push_back(Span);
2827 StartSym = Cur.Sym;
2828 }
2829 }
2830 }
2831 }
2832
Richard Mitton21101b32013-09-19 23:21:01 +00002833 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2834
2835 // Build a list of CUs used.
Eric Christopher4287a492013-12-09 23:57:44 +00002836 std::vector<DwarfCompileUnit *> CUs;
Richard Mitton21101b32013-09-19 23:21:01 +00002837 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
Eric Christopher4287a492013-12-09 23:57:44 +00002838 DwarfCompileUnit *CU = it->first;
Richard Mitton21101b32013-09-19 23:21:01 +00002839 CUs.push_back(CU);
2840 }
2841
2842 // Sort the CU list (again, to ensure consistent output order).
2843 std::sort(CUs.begin(), CUs.end(), CUSort);
2844
2845 // Emit an arange table for each CU we used.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002846 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
Eric Christopher4287a492013-12-09 23:57:44 +00002847 DwarfCompileUnit *CU = CUs[CUIdx];
Richard Mitton21101b32013-09-19 23:21:01 +00002848 std::vector<ArangeSpan> &List = Spans[CU];
2849
2850 // Emit size of content not including length itself.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002851 unsigned ContentSize =
2852 sizeof(int16_t) + // DWARF ARange version number
2853 sizeof(int32_t) + // Offset of CU in the .debug_info section
2854 sizeof(int8_t) + // Pointer Size (in bytes)
2855 sizeof(int8_t); // Segment Size (in bytes)
Richard Mitton21101b32013-09-19 23:21:01 +00002856
2857 unsigned TupleSize = PtrSize * 2;
2858
2859 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2860 unsigned Padding = 0;
2861 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2862 Padding++;
2863
2864 ContentSize += Padding;
2865 ContentSize += (List.size() + 1) * TupleSize;
2866
2867 // For each compile unit, write the list of spans it covers.
2868 Asm->OutStreamer.AddComment("Length of ARange Set");
2869 Asm->EmitInt32(ContentSize);
2870 Asm->OutStreamer.AddComment("DWARF Arange version number");
2871 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2872 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
Eric Christopherd8667202013-12-30 17:22:27 +00002873 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
Richard Mitton21101b32013-09-19 23:21:01 +00002874 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2875 Asm->EmitInt8(PtrSize);
2876 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2877 Asm->EmitInt8(0);
2878
2879 for (unsigned n = 0; n < Padding; n++)
2880 Asm->EmitInt8(0xff);
2881
2882 for (unsigned n = 0; n < List.size(); n++) {
2883 const ArangeSpan &Span = List[n];
2884 Asm->EmitLabelReference(Span.Start, PtrSize);
2885
2886 // Calculate the size as being from the span start to it's end.
Richard Mitton089ed892013-09-23 17:56:20 +00002887 if (Span.End) {
Richard Mitton21101b32013-09-19 23:21:01 +00002888 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
Richard Mitton089ed892013-09-23 17:56:20 +00002889 } else {
2890 // For symbols without an end marker (e.g. common), we
2891 // write a single arange entry containing just that one symbol.
2892 uint64_t Size = SymSize[Span.Start];
2893 if (Size == 0)
2894 Size = 1;
2895
2896 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2897 }
Richard Mitton21101b32013-09-19 23:21:01 +00002898 }
2899
2900 Asm->OutStreamer.AddComment("ARange terminator");
2901 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2902 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2903 }
Bill Wendling480ff322009-05-20 23:21:38 +00002904}
2905
Eric Christopheracdcbdb2012-11-27 22:43:45 +00002906// Emit visible names into a debug ranges section.
Devang Patel930143b2009-11-21 02:48:08 +00002907void DwarfDebug::emitDebugRanges() {
Bill Wendling480ff322009-05-20 23:21:38 +00002908 // Start the dwarf ranges section.
Eric Christopherb4bef6d2013-11-19 09:04:36 +00002909 Asm->OutStreamer.SwitchSection(
2910 Asm->getObjFileLowering().getDwarfRangesSection());
Eric Christopher4751d702013-11-23 00:05:29 +00002911
Eric Christopher0f63d062013-12-03 00:45:45 +00002912 // Size for our labels.
2913 unsigned char Size = Asm->getDataLayout().getPointerSize();
2914
2915 // Grab the specific ranges for the compile units in the module.
Eric Christopher4287a492013-12-09 23:57:44 +00002916 for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
2917 E = CUMap.end();
Eric Christopher0f63d062013-12-03 00:45:45 +00002918 I != E; ++I) {
Eric Christopher4287a492013-12-09 23:57:44 +00002919 DwarfCompileUnit *TheCU = I->second;
Eric Christopher0f63d062013-12-03 00:45:45 +00002920
2921 // Emit a symbol so we can find the beginning of our ranges.
David Blaikie1ab7c2d2013-12-09 17:51:30 +00002922 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
Eric Christopher0f63d062013-12-03 00:45:45 +00002923
2924 // Iterate over the misc ranges for the compile units in the module.
Eric Christopher270ba4a2013-12-04 19:06:58 +00002925 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
Eric Christophera5a79422013-12-09 23:32:48 +00002926 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2927 E = RangeLists.end();
Eric Christopher0f63d062013-12-03 00:45:45 +00002928 I != E; ++I) {
Eric Christopher270ba4a2013-12-04 19:06:58 +00002929 const RangeSpanList &List = *I;
Eric Christopher0f63d062013-12-03 00:45:45 +00002930
Eric Christopherf8790642013-12-04 22:04:50 +00002931 // Emit our symbol so we can find the beginning of the range.
2932 Asm->OutStreamer.EmitLabel(List.getSym());
Eric Christopher0f63d062013-12-03 00:45:45 +00002933
2934 for (SmallVectorImpl<RangeSpan>::const_iterator
Eric Christopher270ba4a2013-12-04 19:06:58 +00002935 RI = List.getRanges().begin(),
2936 RE = List.getRanges().end();
2937 RI != RE; ++RI) {
2938 const RangeSpan &Range = *RI;
Eric Christopher0f63d062013-12-03 00:45:45 +00002939 const MCSymbol *Begin = Range.getStart();
2940 const MCSymbol *End = Range.getEnd();
Eric Christopher565ab112013-12-20 04:34:22 +00002941 assert(Begin && "Range without a begin symbol?");
2942 assert(End && "Range without an end symbol?");
2943 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2944 Asm->OutStreamer.EmitSymbolValue(End, Size);
Eric Christopher0f63d062013-12-03 00:45:45 +00002945 }
2946
2947 // And terminate the list with two 0 values.
Eric Christopherce0cfce2013-01-09 01:35:34 +00002948 Asm->OutStreamer.EmitIntValue(0, Size);
Eric Christopher0f63d062013-12-03 00:45:45 +00002949 Asm->OutStreamer.EmitIntValue(0, Size);
2950 }
Eric Christopher46e23432013-12-20 04:16:18 +00002951
2952 // Now emit a range for the CU itself.
2953 if (DwarfCURanges) {
2954 Asm->OutStreamer.EmitLabel(
2955 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2956 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2957 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2958 RangeSpan Range = Ranges[i];
Eric Christopher46e23432013-12-20 04:16:18 +00002959 const MCSymbol *Begin = Range.getStart();
2960 const MCSymbol *End = Range.getEnd();
Eric Christopher565ab112013-12-20 04:34:22 +00002961 assert(Begin && "Range without a begin symbol?");
2962 assert(End && "Range without an end symbol?");
2963 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2964 Asm->OutStreamer.EmitSymbolValue(End, Size);
Eric Christopher46e23432013-12-20 04:16:18 +00002965 }
2966 // And terminate the list with two 0 values.
2967 Asm->OutStreamer.EmitIntValue(0, Size);
2968 Asm->OutStreamer.EmitIntValue(0, Size);
2969 }
Devang Patel12563b32010-04-16 23:33:45 +00002970 }
Bill Wendling480ff322009-05-20 23:21:38 +00002971}
2972
Eric Christopherd692c1d2012-12-11 19:42:09 +00002973// DWARF5 Experimental Separate Dwarf emitters.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002974
2975// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2976// DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
Eric Christopher9a08f9e2013-10-01 00:43:36 +00002977// DW_AT_ranges_base, DW_AT_addr_base.
Eric Christopher5090d572013-12-10 00:40:03 +00002978// TODO: Implement DW_AT_ranges_base.
Eric Christopher4287a492013-12-09 23:57:44 +00002979DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002980
2981 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Eric Christopher4287a492013-12-09 23:57:44 +00002982 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2983 CU->getUniqueID(), Die, CU->getNode(), Asm, this, &SkeletonHolder);
David Blaikie1ab7c2d2013-12-09 17:51:30 +00002984 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2985 DwarfInfoSectionSym);
Eric Christopher4c7765f2013-01-17 03:00:04 +00002986
Eric Christopherdae389b2013-02-22 23:50:08 +00002987 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
David Blaikieb01f13e2013-11-15 23:54:45 +00002988 CU->getNode().getSplitDebugFilename());
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002989
Eric Christopher44c6aa62013-04-22 07:51:08 +00002990 // Relocate to the beginning of the addr_base section, else 0 for the
2991 // beginning of the one for this compile unit.
Eric Christopher55863be2013-04-07 03:43:09 +00002992 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
Eric Christopher33ff6972013-11-21 23:46:41 +00002993 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
2994 DwarfAddrSectionSym);
Eric Christopher55863be2013-04-07 03:43:09 +00002995 else
Eric Christopher33ff6972013-11-21 23:46:41 +00002996 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002997
Eric Christopher9c2ecd92012-11-30 23:59:06 +00002998 // DW_AT_stmt_list is a offset of line number information for this
2999 // compile unit in debug_line section.
Eric Christopher55863be2013-04-07 03:43:09 +00003000 // FIXME: Should handle multiple compile units.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00003001 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
Eric Christophera5a79422013-12-09 23:32:48 +00003002 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00003003 else
Eric Christopher33ff6972013-11-21 23:46:41 +00003004 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00003005
3006 if (!CompilationDir.empty())
Eric Christopher2cbd5762013-01-07 19:32:41 +00003007 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
Eric Christopher9c2ecd92012-11-30 23:59:06 +00003008
David Blaikie3c842622013-12-04 21:31:26 +00003009 addGnuPubAttributes(NewCU, Die);
Eric Christopherdd1a0122013-09-13 00:35:05 +00003010
Eric Christopherc8a310e2012-12-10 23:34:43 +00003011 SkeletonHolder.addUnit(NewCU);
3012
Eric Christopher9c2ecd92012-11-30 23:59:06 +00003013 return NewCU;
3014}
3015
Eric Christopherd692c1d2012-12-11 19:42:09 +00003016// Emit the .debug_info.dwo section for separated dwarf. This contains the
3017// compile units that would normally be in debug_info.
Eric Christopher9c2ecd92012-11-30 23:59:06 +00003018void DwarfDebug::emitDebugInfoDWO() {
Eric Christophercdf218d2012-12-10 19:51:21 +00003019 assert(useSplitDwarf() && "No split dwarf debug info?");
David Blaikie03073f72013-12-06 22:14:48 +00003020 InfoHolder.emitUnits(this,
Eric Christopher3c5a1912012-12-19 22:02:53 +00003021 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3022 DwarfAbbrevDWOSectionSym);
3023}
3024
3025// Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3026// abbreviations for the .debug_info.dwo section.
3027void DwarfDebug::emitDebugAbbrevDWO() {
3028 assert(useSplitDwarf() && "No split dwarf?");
David Blaikie0504cda2013-12-05 07:43:55 +00003029 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
Eric Christopher9c2ecd92012-11-30 23:59:06 +00003030}
Eric Christopher3bf29fd2012-12-27 02:14:01 +00003031
3032// Emit the .debug_str.dwo section for separated dwarf. This contains the
3033// string section and is identical in format to traditional .debug_str
3034// sections.
3035void DwarfDebug::emitDebugStrDWO() {
3036 assert(useSplitDwarf() && "No split dwarf?");
Eric Christopherb4bef6d2013-11-19 09:04:36 +00003037 const MCSection *OffSec =
3038 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
Eric Christopher2cbd5762013-01-07 19:32:41 +00003039 const MCSymbol *StrSym = DwarfStrSectionSym;
3040 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3041 OffSec, StrSym);
Eric Christopher3bf29fd2012-12-27 02:14:01 +00003042}
David Blaikie409dd9c2013-11-19 23:08:21 +00003043
Eric Christopher4287a492013-12-09 23:57:44 +00003044void DwarfDebug::addDwarfTypeUnitType(uint16_t Language, DIE *RefDie,
3045 DICompositeType CTy) {
David Blaikie47f615e2013-12-17 23:32:35 +00003046 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3047 if (!TU) {
David Blaikie409dd9c2013-11-19 23:08:21 +00003048 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
Eric Christopher4287a492013-12-09 23:57:44 +00003049 DwarfTypeUnit *NewTU =
3050 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, Language, Asm,
3051 this, &InfoHolder);
David Blaikie47f615e2013-12-17 23:32:35 +00003052 TU = NewTU;
David Blaikie2666e242013-12-06 19:38:46 +00003053 InfoHolder.addUnit(NewTU);
3054
David Blaikie319a05f2013-12-02 19:33:10 +00003055 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
David Blaikie3c1d3322013-12-02 18:44:29 +00003056 Language);
David Blaikie409dd9c2013-11-19 23:08:21 +00003057
David Blaikie319a05f2013-12-02 19:33:10 +00003058 DIE *Die = NewTU->createTypeDIE(CTy);
David Blaikie409dd9c2013-11-19 23:08:21 +00003059
David Blaikie319a05f2013-12-02 19:33:10 +00003060 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3061 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
David Blaikie409dd9c2013-11-19 23:08:21 +00003062 dwarf::DW_FORM_data8,
3063 DIEHash().computeDIEODRSignature(*Die));
3064 // FIXME: This won't handle circularly referential structures, as the DIE
3065 // may have references to other DIEs still under construction and missing
3066 // their signature. Hashing should walk through the signatures to their
3067 // referenced type, or possibly walk the precomputed hashes of related types
3068 // at the end.
3069 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
David Blaikiebc563272013-12-13 21:33:40 +00003070 NewTU->setTypeSignature(Signature);
3071 NewTU->setType(Die);
David Blaikie409dd9c2013-11-19 23:08:21 +00003072
David Blaikie03073f72013-12-06 22:14:48 +00003073 NewTU->initSection(
David Blaikiebc563272013-12-13 21:33:40 +00003074 useSplitDwarf()
3075 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3076 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
David Blaikie409dd9c2013-11-19 23:08:21 +00003077 }
3078
David Blaikie47f615e2013-12-17 23:32:35 +00003079 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);
David Blaikie409dd9c2013-11-19 23:08:21 +00003080}