blob: be7d18a926f013415a1f1e4377e2026e2b772580 [file] [log] [blame]
Bill Wendling2f921f82009-05-15 09:23:25 +00001//===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains support for writing dwarf debug info into asm files.
11//
12//===----------------------------------------------------------------------===//
Chris Lattnerb14490d2010-03-09 00:39:24 +000013
Devang Patel80ae3492009-08-28 23:24:31 +000014#define DEBUG_TYPE "dwarfdebug"
Bill Wendling2f921f82009-05-15 09:23:25 +000015#include "DwarfDebug.h"
Chris Lattner3f3fb972010-04-05 05:24:55 +000016#include "DIE.h"
Eric Christopher4996c702011-11-07 09:24:32 +000017#include "DwarfAccelTable.h"
Devang Patel5eb43192011-04-12 17:40:32 +000018#include "DwarfCompileUnit.h"
Bill Wendling30346342010-04-05 22:59:21 +000019#include "llvm/Constants.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000020#include "llvm/Module.h"
Devang Patel2d9e5322011-01-20 00:02:16 +000021#include "llvm/Instructions.h"
David Greene829b3e82009-08-19 21:52:55 +000022#include "llvm/CodeGen/MachineFunction.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000023#include "llvm/CodeGen/MachineModuleInfo.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000024#include "llvm/MC/MCAsmInfo.h"
Chris Lattner4d2c0f92009-07-31 18:48:30 +000025#include "llvm/MC/MCSection.h"
Chris Lattner4b7dadb2009-08-19 05:49:37 +000026#include "llvm/MC/MCStreamer.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000027#include "llvm/MC/MCSymbol.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000028#include "llvm/Target/TargetData.h"
Anton Korobeynikov2f931282011-01-10 12:39:04 +000029#include "llvm/Target/TargetFrameLowering.h"
Chris Lattner5e693ed2009-07-28 03:13:23 +000030#include "llvm/Target/TargetLoweringObjectFile.h"
Chris Lattner21dc46e2010-04-04 18:06:11 +000031#include "llvm/Target/TargetMachine.h"
Chris Lattner5e693ed2009-07-28 03:13:23 +000032#include "llvm/Target/TargetRegisterInfo.h"
Devang Patel61880932010-04-19 19:14:02 +000033#include "llvm/Target/TargetOptions.h"
Chris Lattner3f3fb972010-04-05 05:24:55 +000034#include "llvm/Analysis/DebugInfo.h"
Devang Patela5d93242011-02-24 18:49:30 +000035#include "llvm/Analysis/DIBuilder.h"
Devang Patela86114b2010-10-25 20:45:32 +000036#include "llvm/ADT/Statistic.h"
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +000037#include "llvm/ADT/STLExtras.h"
Chris Lattner06fa1762009-08-24 03:52:50 +000038#include "llvm/ADT/StringExtras.h"
Devang Patel6c74a872010-04-27 19:46:33 +000039#include "llvm/Support/CommandLine.h"
Daniel Dunbarcdf01b52009-10-13 06:47:08 +000040#include "llvm/Support/Debug.h"
41#include "llvm/Support/ErrorHandling.h"
Devang Patel1973df22010-01-26 21:39:14 +000042#include "llvm/Support/ValueHandle.h"
Chris Lattnerf5c834f2010-01-22 22:09:00 +000043#include "llvm/Support/FormattedStream.h"
Chris Lattner4d2c0f92009-07-31 18:48:30 +000044#include "llvm/Support/Timer.h"
Michael J. Spencer447762d2010-11-29 18:16:10 +000045#include "llvm/Support/Path.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000046using namespace llvm;
47
Jim Grosbacha8683bb2010-07-21 21:21:52 +000048static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
Devang Patel30265c42010-07-07 20:12:52 +000049 cl::Hidden,
Devang Patel6c74a872010-04-27 19:46:33 +000050 cl::desc("Disable debug info printing"));
51
Dan Gohman7421ae42010-05-07 01:08:53 +000052static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
Chris Lattner0ab5e2c2011-04-15 05:18:47 +000053 cl::desc("Make an absence of debug location information explicit."),
Dan Gohman7421ae42010-05-07 01:08:53 +000054 cl::init(false));
55
Eric Christopher4996c702011-11-07 09:24:32 +000056static cl::opt<bool> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
57 cl::desc("Output prototype dwarf accelerator tables."),
58 cl::init(false));
59
Bill Wendlingfcc14142010-04-07 09:28:04 +000060namespace {
61 const char *DWARFGroupName = "DWARF Emission";
62 const char *DbgTimerName = "DWARF Debug Writer";
63} // end anonymous namespace
64
Bill Wendling2f921f82009-05-15 09:23:25 +000065//===----------------------------------------------------------------------===//
66
67/// Configuration values for initial hash set sizes (log2).
68///
Bill Wendling2f921f82009-05-15 09:23:25 +000069static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
Bill Wendling2f921f82009-05-15 09:23:25 +000070
71namespace llvm {
72
Nick Lewycky019d2552011-07-29 03:49:23 +000073DIType DbgVariable::getType() const {
Devang Patelf20c4f72011-04-12 22:53:02 +000074 DIType Ty = Var.getType();
75 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
76 // addresses instead.
77 if (Var.isBlockByrefVariable()) {
78 /* Byref variables, in Blocks, are declared by the programmer as
79 "SomeType VarName;", but the compiler creates a
80 __Block_byref_x_VarName struct, and gives the variable VarName
81 either the struct, or a pointer to the struct, as its type. This
82 is necessary for various behind-the-scenes things the compiler
83 needs to do with by-reference variables in blocks.
84
85 However, as far as the original *programmer* is concerned, the
86 variable should still have type 'SomeType', as originally declared.
87
88 The following function dives into the __Block_byref_x_VarName
89 struct to find the original type of the variable. This will be
90 passed back to the code generating the type for the Debug
91 Information Entry for the variable 'VarName'. 'VarName' will then
92 have the original type 'SomeType' in its debug information.
93
94 The original type 'SomeType' will be the type of the field named
95 'VarName' inside the __Block_byref_x_VarName struct.
96
97 NOTE: In order for this to not completely fail on the debugger
98 side, the Debug Information Entry for the variable VarName needs to
99 have a DW_AT_location that tells the debugger how to unwind through
100 the pointers and __Block_byref_x_VarName struct to find the actual
101 value of the variable. The function addBlockByrefType does this. */
102 DIType subType = Ty;
103 unsigned tag = Ty.getTag();
104
105 if (tag == dwarf::DW_TAG_pointer_type) {
106 DIDerivedType DTy = DIDerivedType(Ty);
107 subType = DTy.getTypeDerivedFrom();
108 }
109
110 DICompositeType blockStruct = DICompositeType(subType);
111 DIArray Elements = blockStruct.getTypeArray();
112
113 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
114 DIDescriptor Element = Elements.getElement(i);
115 DIDerivedType DT = DIDerivedType(Element);
116 if (getName() == DT.getName())
117 return (DT.getTypeDerivedFrom());
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000118 }
119 return Ty;
120 }
Devang Patelf20c4f72011-04-12 22:53:02 +0000121 return Ty;
122}
Bill Wendling2f921f82009-05-15 09:23:25 +0000123
Chris Lattnerf5d06362010-04-05 04:09:20 +0000124} // end llvm namespace
Bill Wendling2f921f82009-05-15 09:23:25 +0000125
Chris Lattnerf0d6bd32010-04-05 05:11:15 +0000126DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
Devang Patel1a0df9a2010-05-10 22:49:55 +0000127 : Asm(A), MMI(Asm->MMI), FirstCU(0),
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000128 AbbreviationsSet(InitAbbreviationsSetSize),
Devang Patel7e623022011-08-10 20:55:27 +0000129 PrevLabel(NULL) {
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000130 NextStringPoolNumber = 0;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000131
Rafael Espindolaa7160962011-05-06 14:56:22 +0000132 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
Chris Lattnere58b5472010-04-04 23:10:38 +0000133 DwarfStrSectionSym = TextSectionSym = 0;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000134 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
Devang Patel9fc11702010-05-25 23:40:22 +0000135 FunctionBeginSym = FunctionEndSym = 0;
Dan Gohman6e681a52010-06-18 15:56:31 +0000136 {
137 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
138 beginModule(M);
Torok Edwinf8dba242010-04-07 10:44:46 +0000139 }
Bill Wendling2f921f82009-05-15 09:23:25 +0000140}
141DwarfDebug::~DwarfDebug() {
Bill Wendling2f921f82009-05-15 09:23:25 +0000142}
143
Eric Christophera7b61892011-11-07 09:18:38 +0000144/// EmitSectionSym - Switch to the specified MCSection and emit an assembler
145/// temporary label to it if SymbolStem is specified.
146static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
147 const char *SymbolStem = 0) {
148 Asm->OutStreamer.SwitchSection(Section);
149 if (!SymbolStem) return 0;
150
151 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
152 Asm->OutStreamer.EmitLabel(TmpSym);
153 return TmpSym;
154}
155
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000156MCSymbol *DwarfDebug::getStringPool() {
157 return Asm->GetTempSymbol("section_str");
158}
159
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000160MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
161 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
162 if (Entry.first) return Entry.first;
163
164 Entry.second = NextStringPoolNumber++;
Chris Lattnera179b522010-04-04 19:25:43 +0000165 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000166}
167
Devang Patel930143b2009-11-21 02:48:08 +0000168/// assignAbbrevNumber - Define a unique number for the abbreviation.
Bill Wendling2f921f82009-05-15 09:23:25 +0000169///
Devang Patel930143b2009-11-21 02:48:08 +0000170void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
Bill Wendling2f921f82009-05-15 09:23:25 +0000171 // Profile the node so that we can make it unique.
172 FoldingSetNodeID ID;
173 Abbrev.Profile(ID);
174
175 // Check the set for priors.
176 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
177
178 // If it's newly added.
179 if (InSet == &Abbrev) {
180 // Add to abbreviation list.
181 Abbreviations.push_back(&Abbrev);
182
183 // Assign the vector position + 1 as its number.
184 Abbrev.setNumber(Abbreviations.size());
185 } else {
186 // Assign existing abbreviation number.
187 Abbrev.setNumber(InSet->getNumber());
188 }
189}
190
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000191/// getRealLinkageName - If special LLVM prefix that is used to inform the asm
Devang Patel43ef34d2010-01-05 01:46:14 +0000192/// printer to not emit usual symbol prefix before the symbol name is used then
193/// return linkage name after skipping this special LLVM prefix.
194static StringRef getRealLinkageName(StringRef LinkageName) {
195 char One = '\1';
196 if (LinkageName.startswith(StringRef(&One, 1)))
197 return LinkageName.substr(1);
198 return LinkageName;
199}
200
Jim Grosbach042483e2009-11-21 23:12:12 +0000201/// updateSubprogramScopeDIE - Find DIE for the given subprogram and
Devang Patel930143b2009-11-21 02:48:08 +0000202/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
203/// If there are global variables in this scope then create and insert
204/// DIEs for these variables.
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000205DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
206 const MDNode *SPNode) {
Devang Patel1a0df9a2010-05-10 22:49:55 +0000207 DIE *SPDie = SPCU->getDIE(SPNode);
Devang Patela37a95e2010-07-07 22:20:57 +0000208
Chris Lattner3a383cb2010-04-05 00:13:49 +0000209 assert(SPDie && "Unable to find subprogram DIE!");
210 DISubprogram SP(SPNode);
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000211
Devang Patel1d6bbd42011-04-22 23:10:17 +0000212 DISubprogram SPDecl = SP.getFunctionDeclaration();
Rafael Espindola6cf4e832011-11-04 19:00:29 +0000213 if (!SPDecl.isSubprogram()) {
Devang Patel1d6bbd42011-04-22 23:10:17 +0000214 // There is not any need to generate specification DIE for a function
215 // defined at compile unit level. If a function is defined inside another
216 // function then gdb prefers the definition at top level and but does not
217 // expect specification DIE in parent function. So avoid creating
218 // specification DIE for a function defined inside a function.
219 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
220 !SP.getContext().isFile() &&
221 !isSubprogramContext(SP.getContext())) {
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000222 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Devang Patel1d6bbd42011-04-22 23:10:17 +0000223
224 // Add arguments.
225 DICompositeType SPTy = SP.getType();
226 DIArray Args = SPTy.getTypeArray();
227 unsigned SPTag = SPTy.getTag();
228 if (SPTag == dwarf::DW_TAG_subroutine_type)
229 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
230 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
231 DIType ATy = DIType(DIType(Args.getElement(i)));
232 SPCU->addType(Arg, ATy);
233 if (ATy.isArtificial())
234 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
235 SPDie->addChild(Arg);
236 }
237 DIE *SPDeclDie = SPDie;
238 SPDie = new DIE(dwarf::DW_TAG_subprogram);
239 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
240 SPDeclDie);
241 SPCU->addDie(SPDie);
242 }
Chris Lattner3a383cb2010-04-05 00:13:49 +0000243 }
Devang Patela37a95e2010-07-07 22:20:57 +0000244 // Pick up abstract subprogram DIE.
245 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
246 SPDie = new DIE(dwarf::DW_TAG_subprogram);
Devang Patelf20c4f72011-04-12 22:53:02 +0000247 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
248 dwarf::DW_FORM_ref4, AbsSPDIE);
Devang Patela37a95e2010-07-07 22:20:57 +0000249 SPCU->addDie(SPDie);
250 }
251
Devang Patelf20c4f72011-04-12 22:53:02 +0000252 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
253 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
254 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
255 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
Chris Lattner3a383cb2010-04-05 00:13:49 +0000256 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
257 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
Devang Patelf20c4f72011-04-12 22:53:02 +0000258 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
Devang Patel6efc8e52010-02-06 01:02:37 +0000259
Chris Lattner3a383cb2010-04-05 00:13:49 +0000260 return SPDie;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000261}
262
Jim Grosbach042483e2009-11-21 23:12:12 +0000263/// constructLexicalScope - Construct new DW_TAG_lexical_block
Devang Patel930143b2009-11-21 02:48:08 +0000264/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000265DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
266 LexicalScope *Scope) {
Devang Patel6c74a872010-04-27 19:46:33 +0000267 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
268 if (Scope->isAbstractScope())
269 return ScopeDIE;
270
Devang Patel7e623022011-08-10 20:55:27 +0000271 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
Devang Patel6c74a872010-04-27 19:46:33 +0000272 if (Ranges.empty())
273 return 0;
274
Devang Patel7e623022011-08-10 20:55:27 +0000275 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
Devang Patel6c74a872010-04-27 19:46:33 +0000276 if (Ranges.size() > 1) {
277 // .debug_range section has not been laid out yet. Emit offset in
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000278 // .debug_range as a uint, size 4, for now. emitDIE will handle
Devang Patel6c74a872010-04-27 19:46:33 +0000279 // DW_AT_ranges appropriately.
Devang Patelf20c4f72011-04-12 22:53:02 +0000280 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
Devang Patel784077e2011-08-10 23:58:09 +0000281 DebugRangeSymbols.size()
282 * Asm->getTargetData().getPointerSize());
Devang Patel7e623022011-08-10 20:55:27 +0000283 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
Devang Patel6c74a872010-04-27 19:46:33 +0000284 RE = Ranges.end(); RI != RE; ++RI) {
Devang Patel9fc11702010-05-25 23:40:22 +0000285 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
286 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
Devang Patel6c74a872010-04-27 19:46:33 +0000287 }
288 DebugRangeSymbols.push_back(NULL);
289 DebugRangeSymbols.push_back(NULL);
290 return ScopeDIE;
291 }
292
Devang Patel9fc11702010-05-25 23:40:22 +0000293 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
294 const MCSymbol *End = getLabelAfterInsn(RI->second);
Devang Patel6c74a872010-04-27 19:46:33 +0000295
Devang Patel9fc11702010-05-25 23:40:22 +0000296 if (End == 0) return 0;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000297
Chris Lattnere13c3722010-03-09 01:58:53 +0000298 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
299 assert(End->isDefined() && "Invalid end label for an inlined scope!");
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000300
Devang Patelf20c4f72011-04-12 22:53:02 +0000301 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
302 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000303
304 return ScopeDIE;
305}
306
Devang Patel930143b2009-11-21 02:48:08 +0000307/// constructInlinedScopeDIE - This scope represents inlined body of
308/// a function. Construct DIE to represent this concrete inlined copy
309/// of the function.
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000310DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
311 LexicalScope *Scope) {
Devang Patel7e623022011-08-10 20:55:27 +0000312 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000313 assert(Ranges.empty() == false &&
314 "LexicalScope does not have instruction markers!");
Devang Patel6c74a872010-04-27 19:46:33 +0000315
Devang Patelf098ce22011-07-27 00:34:13 +0000316 if (!Scope->getScopeNode())
317 return NULL;
318 DIScope DS(Scope->getScopeNode());
319 DISubprogram InlinedSP = getDISubprogram(DS);
Devang Patelf098ce22011-07-27 00:34:13 +0000320 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
321 if (!OriginDIE) {
322 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
323 return NULL;
324 }
325
Devang Patel7e623022011-08-10 20:55:27 +0000326 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
Devang Patel9fc11702010-05-25 23:40:22 +0000327 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
328 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
Devang Patel6c74a872010-04-27 19:46:33 +0000329
Devang Patel4c6bd662010-07-08 22:39:20 +0000330 if (StartLabel == 0 || EndLabel == 0) {
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000331 assert(0 && "Unexpected Start and End labels for a inlined scope!");
Devang Patel6c74a872010-04-27 19:46:33 +0000332 return 0;
333 }
Chris Lattnere13c3722010-03-09 01:58:53 +0000334 assert(StartLabel->isDefined() &&
Chris Lattnerc3b70f62010-03-09 01:51:43 +0000335 "Invalid starting label for an inlined scope!");
Chris Lattnere13c3722010-03-09 01:58:53 +0000336 assert(EndLabel->isDefined() &&
Chris Lattnerc3b70f62010-03-09 01:51:43 +0000337 "Invalid end label for an inlined scope!");
Devang Patel6c74a872010-04-27 19:46:33 +0000338
Devang Patel73bc1722011-05-05 17:54:26 +0000339 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
Devang Patelf20c4f72011-04-12 22:53:02 +0000340 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
341 dwarf::DW_FORM_ref4, OriginDIE);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000342
Devang Patelf098ce22011-07-27 00:34:13 +0000343 if (Ranges.size() > 1) {
344 // .debug_range section has not been laid out yet. Emit offset in
345 // .debug_range as a uint, size 4, for now. emitDIE will handle
346 // DW_AT_ranges appropriately.
347 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
Devang Patel784077e2011-08-10 23:58:09 +0000348 DebugRangeSymbols.size()
349 * Asm->getTargetData().getPointerSize());
Devang Patel7e623022011-08-10 20:55:27 +0000350 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
Devang Patelf098ce22011-07-27 00:34:13 +0000351 RE = Ranges.end(); RI != RE; ++RI) {
352 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
353 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
354 }
355 DebugRangeSymbols.push_back(NULL);
356 DebugRangeSymbols.push_back(NULL);
357 } else {
Devang Patel784077e2011-08-10 23:58:09 +0000358 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
359 StartLabel);
360 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
361 EndLabel);
Devang Patelf098ce22011-07-27 00:34:13 +0000362 }
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000363
364 InlinedSubprogramDIEs.insert(OriginDIE);
365
366 // Track the start label for this inlined function.
Devang Patelf098ce22011-07-27 00:34:13 +0000367 //.debug_inlined section specification does not clearly state how
368 // to emit inlined scope that is split into multiple instruction ranges.
369 // For now, use first instruction range and emit low_pc/high_pc pair and
370 // corresponding .debug_inlined section entry for this pair.
Devang Patel32cc43c2010-05-07 20:54:48 +0000371 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000372 I = InlineInfo.find(InlinedSP);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000373
374 if (I == InlineInfo.end()) {
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000375 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000376 InlinedSPNodes.push_back(InlinedSP);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000377 } else
Chris Lattner085b6522010-03-09 00:31:02 +0000378 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000379
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000380 DILocation DL(Scope->getInlinedAt());
Devang Patelf20c4f72011-04-12 22:53:02 +0000381 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
382 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000383
384 return ScopeDIE;
385}
386
Devang Patel930143b2009-11-21 02:48:08 +0000387/// constructScopeDIE - Construct a DIE for this scope.
Devang Patel3acc70e2011-08-15 22:04:40 +0000388DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
Devang Patel3b548aa2010-03-08 20:52:55 +0000389 if (!Scope || !Scope->getScopeNode())
390 return NULL;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000391
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000392 SmallVector<DIE *, 8> Children;
Devang Patel6c622ef2011-03-01 22:58:55 +0000393
394 // Collect arguments for current function.
Devang Patel7e623022011-08-10 20:55:27 +0000395 if (LScopes.isCurrentFunctionScope(Scope))
Devang Patel6c622ef2011-03-01 22:58:55 +0000396 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
397 if (DbgVariable *ArgDV = CurrentFnArguments[i])
Devang Patel3acc70e2011-08-15 22:04:40 +0000398 if (DIE *Arg =
399 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
Devang Patel6c622ef2011-03-01 22:58:55 +0000400 Children.push_back(Arg);
401
Eric Christopherf84354b2011-10-03 15:49:16 +0000402 // Collect lexical scope children first.
Devang Patel7e623022011-08-10 20:55:27 +0000403 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000404 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
Devang Patel3acc70e2011-08-15 22:04:40 +0000405 if (DIE *Variable =
406 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000407 Children.push_back(Variable);
Devang Patel7e623022011-08-10 20:55:27 +0000408 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000409 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
Devang Patel3acc70e2011-08-15 22:04:40 +0000410 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000411 Children.push_back(Nested);
Devang Patel3b548aa2010-03-08 20:52:55 +0000412 DIScope DS(Scope->getScopeNode());
413 DIE *ScopeDIE = NULL;
414 if (Scope->getInlinedAt())
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000415 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
Devang Patel3b548aa2010-03-08 20:52:55 +0000416 else if (DS.isSubprogram()) {
Devang Pateld10b2af2010-06-28 20:53:04 +0000417 ProcessedSPNodes.insert(DS);
Devang Patela37a95e2010-07-07 22:20:57 +0000418 if (Scope->isAbstractScope()) {
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000419 ScopeDIE = TheCU->getDIE(DS);
Devang Patela37a95e2010-07-07 22:20:57 +0000420 // Note down abstract DIE.
421 if (ScopeDIE)
422 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
423 }
Devang Patel3b548aa2010-03-08 20:52:55 +0000424 else
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000425 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
Devang Patel3b548aa2010-03-08 20:52:55 +0000426 }
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000427 else {
428 // There is no need to emit empty lexical block DIE.
429 if (Children.empty())
430 return NULL;
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000431 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000432 }
433
Devang Patel23b2ae62010-03-29 22:59:58 +0000434 if (!ScopeDIE) return NULL;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000435
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000436 // Add children
437 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
438 E = Children.end(); I != E; ++I)
439 ScopeDIE->addChild(*I);
Devang Patel04d2f2d2009-11-24 01:14:22 +0000440
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000441 if (DS.isSubprogram())
Devang Pateld2dfc5e2011-08-15 22:24:32 +0000442 TheCU->addPubTypes(DISubprogram(DS));
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000443
Eric Christopher08a558e2011-11-08 21:56:23 +0000444 if (DS.isSubprogram() && !Scope->isAbstractScope()) {
445 DISubprogram SP = DISubprogram(DS);
446 TheCU->addAccelName(SP.getName(), ScopeDIE);
447
448 // If the linkage name is different than the name, go ahead and output
449 // that as well into the name table.
450 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
451 TheCU->addAccelName(SP.getLinkageName(), ScopeDIE);
452 }
Eric Christopher4996c702011-11-07 09:24:32 +0000453
Devang Patel04d2f2d2009-11-24 01:14:22 +0000454 return ScopeDIE;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000455}
456
Bill Wendling2b128d72009-05-20 23:19:06 +0000457/// GetOrCreateSourceID - Look up the source id with the given directory and
458/// source file names. If none currently exists, create a new id and insert it
459/// in the SourceIds map. This can update DirectoryNames and SourceFileNames
460/// maps as well.
Devang Patele01b75c2011-03-24 20:30:50 +0000461unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
462 StringRef DirName) {
Devang Patel871d0b12010-09-16 20:57:49 +0000463 // If FE did not provide a file name, then assume stdin.
464 if (FileName.empty())
Devang Patele01b75c2011-03-24 20:30:50 +0000465 return GetOrCreateSourceID("<stdin>", StringRef());
466
Nick Lewyckyd1ee7f82011-11-02 20:55:33 +0000467 // TODO: this might not belong here. See if we can factor this better.
468 if (DirName == CompilationDir)
469 DirName = "";
470
Nick Lewycky40f8f2f2011-10-17 23:05:28 +0000471 unsigned SrcId = SourceIdMap.size()+1;
472 std::pair<std::string, std::string> SourceName =
473 std::make_pair(FileName, DirName);
474 std::pair<std::pair<std::string, std::string>, unsigned> Entry =
475 make_pair(SourceName, SrcId);
Devang Patel871d0b12010-09-16 20:57:49 +0000476
Nick Lewycky40f8f2f2011-10-17 23:05:28 +0000477 std::map<std::pair<std::string, std::string>, unsigned>::iterator I;
478 bool NewlyInserted;
479 tie(I, NewlyInserted) = SourceIdMap.insert(Entry);
480 if (!NewlyInserted)
481 return I->second;
Bill Wendling2b128d72009-05-20 23:19:06 +0000482
Rafael Espindola67c6ab82010-11-18 02:04:25 +0000483 // Print out a .file directive to specify files for .loc directives.
Nick Lewycky40f8f2f2011-10-17 23:05:28 +0000484 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.first.second,
485 Entry.first.first);
Bill Wendling2b128d72009-05-20 23:19:06 +0000486
487 return SrcId;
488}
489
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000490/// constructCompileUnit - Create new CompileUnit for the given
Devang Patel1a0df9a2010-05-10 22:49:55 +0000491/// metadata node with tag DW_TAG_compile_unit.
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000492CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
Devang Patel80ae3492009-08-28 23:24:31 +0000493 DICompileUnit DIUnit(N);
Devang Patel2d9caf92009-11-25 17:36:49 +0000494 StringRef FN = DIUnit.getFilename();
Nick Lewyckyd1ee7f82011-11-02 20:55:33 +0000495 CompilationDir = DIUnit.getDirectory();
496 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
Bill Wendling2b128d72009-05-20 23:19:06 +0000497
498 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Devang Patelf20c4f72011-04-12 22:53:02 +0000499 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000500 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
Devang Patelf20c4f72011-04-12 22:53:02 +0000501 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
502 DIUnit.getLanguage());
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000503 NewCU->addString(Die, dwarf::DW_AT_name, FN);
Devang Patelbd798ce2010-04-26 22:54:28 +0000504 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
505 // simplifies debug range entries.
Devang Patelf20c4f72011-04-12 22:53:02 +0000506 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
Devang Pateld22ed622010-03-22 23:11:36 +0000507 // DW_AT_stmt_list is a offset of line number information for this
Devang Patel4a213872010-08-24 00:06:12 +0000508 // compile unit in debug_line section.
Nick Lewycky479a8fe2011-10-17 23:27:36 +0000509 if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
Rafael Espindolaa7558912011-05-04 17:44:06 +0000510 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
Devang Patelf20c4f72011-04-12 22:53:02 +0000511 Asm->GetTempSymbol("section_line"));
Devang Patelea636392010-08-31 23:50:19 +0000512 else
Devang Patelf20c4f72011-04-12 22:53:02 +0000513 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
Bill Wendling2b128d72009-05-20 23:19:06 +0000514
Nick Lewyckyd1ee7f82011-11-02 20:55:33 +0000515 if (!CompilationDir.empty())
516 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
Bill Wendling2b128d72009-05-20 23:19:06 +0000517 if (DIUnit.isOptimized())
Devang Patelf20c4f72011-04-12 22:53:02 +0000518 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
Bill Wendling2b128d72009-05-20 23:19:06 +0000519
Devang Patel2d9caf92009-11-25 17:36:49 +0000520 StringRef Flags = DIUnit.getFlags();
521 if (!Flags.empty())
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +0000522 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
Devang Patelf20c4f72011-04-12 22:53:02 +0000523
Nick Lewycky479a8fe2011-10-17 23:27:36 +0000524 if (unsigned RVer = DIUnit.getRunTimeVersion())
Devang Patelf20c4f72011-04-12 22:53:02 +0000525 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
Bill Wendling2b128d72009-05-20 23:19:06 +0000526 dwarf::DW_FORM_data1, RVer);
527
Devang Patel1a0df9a2010-05-10 22:49:55 +0000528 if (!FirstCU)
529 FirstCU = NewCU;
530 CUMap.insert(std::make_pair(N, NewCU));
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000531 return NewCU;
Devang Patel1a0df9a2010-05-10 22:49:55 +0000532}
533
Eric Christopher4996c702011-11-07 09:24:32 +0000534static bool isObjCClass(StringRef Name) {
Eric Christopher988ac002011-11-07 18:53:23 +0000535 return Name.startswith("+") || Name.startswith("-");
Eric Christopher4996c702011-11-07 09:24:32 +0000536}
537
538static bool hasObjCCategory(StringRef Name) {
Eric Christopher988ac002011-11-07 18:53:23 +0000539 if (!isObjCClass(Name)) return false;
Eric Christopher4996c702011-11-07 09:24:32 +0000540
541 size_t pos = Name.find(')');
542 if (pos != std::string::npos) {
543 if (Name[pos+1] != ' ') return false;
544 return true;
545 }
Eric Christopher4996c702011-11-07 09:24:32 +0000546 return false;
547}
548
549static void getObjCClassCategory(StringRef In, StringRef &Class,
550 StringRef &Category) {
551 if (!hasObjCCategory(In)) {
552 Class = In.slice(In.find('[') + 1, In.find(' '));
553 Category = "";
554 return;
555 }
556
557 Class = In.slice(In.find('[') + 1, In.find('('));
558 Category = In.slice(In.find('[') + 1, In.find(' '));
559 return;
560}
561
Eric Christopher970771c2011-11-08 19:16:01 +0000562static StringRef getObjCMethodName(StringRef In) {
563 return In.slice(In.find(' ') + 1, In.find(']'));
564}
565
Devang Patel1a0df9a2010-05-10 22:49:55 +0000566/// construct SubprogramDIE - Construct subprogram DIE.
Devang Patel1f4f98d2011-08-15 23:36:40 +0000567void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
568 const MDNode *N) {
Rafael Espindola6cf4e832011-11-04 19:00:29 +0000569 CompileUnit *&CURef = SPMap[N];
570 if (CURef)
571 return;
572 CURef = TheCU;
573
Devang Patel80ae3492009-08-28 23:24:31 +0000574 DISubprogram SP(N);
Bill Wendling2b128d72009-05-20 23:19:06 +0000575 if (!SP.isDefinition())
576 // This is a method declaration which will be handled while constructing
577 // class type.
Devang Patel0751a282009-06-26 01:49:18 +0000578 return;
Bill Wendling2b128d72009-05-20 23:19:06 +0000579
Rafael Espindola6cf4e832011-11-04 19:00:29 +0000580 DISubprogram SPDecl = SP.getFunctionDeclaration();
581 DIE *DeclDie = NULL;
582 if (SPDecl.isSubprogram()) {
583 DeclDie = TheCU->getOrCreateSubprogramDIE(SPDecl);
584 }
585
Devang Patel89543712011-08-15 17:24:54 +0000586 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
Stuart Hastings4bd3dd92010-04-06 21:38:29 +0000587
Rafael Espindola6cf4e832011-11-04 19:00:29 +0000588 if (DeclDie) {
589 // Refer function declaration directly.
590 TheCU->addDIEEntry(SubprogramDie, dwarf::DW_AT_specification,
591 dwarf::DW_FORM_ref4, DeclDie);
592 }
593
Stuart Hastings4bd3dd92010-04-06 21:38:29 +0000594 // Add to map.
Devang Patel1a0df9a2010-05-10 22:49:55 +0000595 TheCU->insertDIE(N, SubprogramDie);
Bill Wendling2b128d72009-05-20 23:19:06 +0000596
597 // Add to context owner.
Devang Patelf20c4f72011-04-12 22:53:02 +0000598 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
Devang Patel512001a2009-12-08 23:21:45 +0000599
Eric Christopher4996c702011-11-07 09:24:32 +0000600 // Add to Accel Names
601 TheCU->addAccelName(SP.getName(), SubprogramDie);
602
Eric Christopher08a558e2011-11-08 21:56:23 +0000603 // If the linkage name is different than the name, go ahead and output
604 // that as well into the name table.
605 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
606 TheCU->addAccelName(SP.getLinkageName(), SubprogramDie);
607
Eric Christopher4996c702011-11-07 09:24:32 +0000608 // If this is an Objective-C selector name add it to the ObjC accelerator too.
609 if (isObjCClass(SP.getName())) {
610 StringRef Class, Category;
611 getObjCClassCategory(SP.getName(), Class, Category);
612 TheCU->addAccelObjC(Class, SubprogramDie);
613 if (Category != "")
614 TheCU->addAccelObjC(Category, SubprogramDie);
Eric Christopher970771c2011-11-08 19:16:01 +0000615 // Also add the base method name to the name table.
616 TheCU->addAccelName(getObjCMethodName(SP.getName()), SubprogramDie);
Eric Christopher4996c702011-11-07 09:24:32 +0000617 }
618
Devang Patel0751a282009-06-26 01:49:18 +0000619 return;
Bill Wendling2b128d72009-05-20 23:19:06 +0000620}
621
Devang Patel07bb9ee2011-08-15 23:47:24 +0000622/// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
623/// as llvm.dbg.enum and llvm.dbg.ty
624void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000625 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
626 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
627 const MDNode *N = NMD->getOperand(i);
628 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
629 constructSubprogramDIE(CU, N);
630 }
631
632 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
633 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
634 const MDNode *N = NMD->getOperand(i);
635 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
Devang Patel0ecbcbd2011-08-18 23:17:55 +0000636 CU->createGlobalVariableDIE(N);
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000637 }
638
Devang Patel07bb9ee2011-08-15 23:47:24 +0000639 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
640 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
641 DIType Ty(NMD->getOperand(i));
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000642 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
643 CU->getOrCreateTypeDIE(Ty);
Devang Patel07bb9ee2011-08-15 23:47:24 +0000644 }
645
646 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
647 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
648 DIType Ty(NMD->getOperand(i));
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000649 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
650 CU->getOrCreateTypeDIE(Ty);
Devang Patel07bb9ee2011-08-15 23:47:24 +0000651 }
652}
653
654/// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
655/// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
656bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
657 DebugInfoFinder DbgFinder;
658 DbgFinder.processModule(*M);
659
660 bool HasDebugInfo = false;
661 // Scan all the compile-units to see if there are any marked as the main
662 // unit. If not, we do not generate debug info.
663 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
664 E = DbgFinder.compile_unit_end(); I != E; ++I) {
665 if (DICompileUnit(*I).isMain()) {
666 HasDebugInfo = true;
667 break;
668 }
669 }
670 if (!HasDebugInfo) return false;
671
672 // Create all the compile unit DIEs.
673 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
674 E = DbgFinder.compile_unit_end(); I != E; ++I)
675 constructCompileUnit(*I);
676
677 // Create DIEs for each global variable.
678 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
679 E = DbgFinder.global_variable_end(); I != E; ++I) {
680 const MDNode *N = *I;
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000681 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
Devang Patel0ecbcbd2011-08-18 23:17:55 +0000682 CU->createGlobalVariableDIE(N);
Devang Patel07bb9ee2011-08-15 23:47:24 +0000683 }
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000684
Devang Patel07bb9ee2011-08-15 23:47:24 +0000685 // Create DIEs for each subprogram.
686 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
687 E = DbgFinder.subprogram_end(); I != E; ++I) {
688 const MDNode *N = *I;
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000689 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
690 constructSubprogramDIE(CU, N);
Devang Patel07bb9ee2011-08-15 23:47:24 +0000691 }
692
693 return HasDebugInfo;
694}
695
Devang Patel930143b2009-11-21 02:48:08 +0000696/// beginModule - Emit all Dwarf sections that should come prior to the
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000697/// content. Create global DIEs and emit initial debug info sections.
Nick Lewycky019d2552011-07-29 03:49:23 +0000698/// This is invoked by the target AsmPrinter.
Chris Lattner11980022010-04-04 07:48:20 +0000699void DwarfDebug::beginModule(Module *M) {
Devang Patel6c74a872010-04-27 19:46:33 +0000700 if (DisableDebugInfoPrinting)
701 return;
702
Nick Lewycky019d2552011-07-29 03:49:23 +0000703 // If module has named metadata anchors then use them, otherwise scan the
704 // module using debug info finder to collect debug info.
Devang Patele02e5852011-05-03 16:45:22 +0000705 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
706 if (CU_Nodes) {
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000707 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
708 DICompileUnit CUNode(CU_Nodes->getOperand(i));
709 CompileUnit *CU = constructCompileUnit(CUNode);
710 DIArray GVs = CUNode.getGlobalVariables();
711 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
Devang Patel0ecbcbd2011-08-18 23:17:55 +0000712 CU->createGlobalVariableDIE(GVs.getElement(i));
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000713 DIArray SPs = CUNode.getSubprograms();
714 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
715 constructSubprogramDIE(CU, SPs.getElement(i));
716 DIArray EnumTypes = CUNode.getEnumTypes();
717 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
718 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
719 DIArray RetainedTypes = CUNode.getRetainedTypes();
720 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
721 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
722 }
Devang Patel07bb9ee2011-08-15 23:47:24 +0000723 } else if (!collectLegacyDebugInfo(M))
724 return;
Devang Patele02e5852011-05-03 16:45:22 +0000725
Devang Patel07bb9ee2011-08-15 23:47:24 +0000726 collectInfoFromNamedMDNodes(M);
Devang Patele02e5852011-05-03 16:45:22 +0000727
Chris Lattner7cfa70e2010-04-05 02:19:28 +0000728 // Tell MMI that we have debug info.
729 MMI->setDebugInfoAvailability(true);
Devang Patele02e5852011-05-03 16:45:22 +0000730
Chris Lattnerd442aa32010-04-04 23:17:54 +0000731 // Emit initial sections.
Chris Lattner7cfa70e2010-04-05 02:19:28 +0000732 EmitSectionLabels();
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000733
Bill Wendling2b128d72009-05-20 23:19:06 +0000734 // Prime section data.
Chris Lattner5e693ed2009-07-28 03:13:23 +0000735 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
Bill Wendling2b128d72009-05-20 23:19:06 +0000736}
737
Devang Patel930143b2009-11-21 02:48:08 +0000738/// endModule - Emit all Dwarf sections that should come after the content.
Bill Wendling2b128d72009-05-20 23:19:06 +0000739///
Devang Patel930143b2009-11-21 02:48:08 +0000740void DwarfDebug::endModule() {
Devang Patel1a0df9a2010-05-10 22:49:55 +0000741 if (!FirstCU) return;
Devang Patelf3b2db62010-06-28 18:25:03 +0000742 const Module *M = MMI->getModule();
Devang Patel7e623022011-08-10 20:55:27 +0000743 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
Devang Patelf3b2db62010-06-28 18:25:03 +0000744
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000745 // Collect info for variables that were optimized out.
746 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
747 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
748 DICompileUnit TheCU(CU_Nodes->getOperand(i));
749 DIArray Subprograms = TheCU.getSubprograms();
750 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
751 DISubprogram SP(Subprograms.getElement(i));
752 if (ProcessedSPNodes.count(SP) != 0) continue;
753 if (!SP.Verify()) continue;
754 if (!SP.isDefinition()) continue;
Devang Patel59e27c52011-08-19 23:28:12 +0000755 DIArray Variables = SP.getVariables();
756 if (Variables.getNumElements() == 0) continue;
757
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000758 LexicalScope *Scope =
759 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
760 DeadFnScopeMap[SP] = Scope;
761
762 // Construct subprogram DIE and add variables DIEs.
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000763 CompileUnit *SPCU = CUMap.lookup(TheCU);
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000764 assert(SPCU && "Unable to find Compile Unit!");
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000765 constructSubprogramDIE(SPCU, SP);
766 DIE *ScopeDIE = SPCU->getDIE(SP);
Devang Patel59e27c52011-08-19 23:28:12 +0000767 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
768 DIVariable DV(Variables.getElement(vi));
769 if (!DV.Verify()) continue;
770 DbgVariable *NewVar = new DbgVariable(DV, NULL);
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000771 if (DIE *VariableDIE =
Devang Patel59e27c52011-08-19 23:28:12 +0000772 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000773 ScopeDIE->addChild(VariableDIE);
774 }
Devang Patelf3b2db62010-06-28 18:25:03 +0000775 }
776 }
777 }
Bill Wendling2b128d72009-05-20 23:19:06 +0000778
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000779 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
780 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
781 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
782 DIE *ISP = *AI;
Devang Patelf20c4f72011-04-12 22:53:02 +0000783 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000784 }
785
Devang Patel89543712011-08-15 17:24:54 +0000786 // Emit DW_AT_containing_type attribute to connect types with their
787 // vtable holding type.
788 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
789 CUE = CUMap.end(); CUI != CUE; ++CUI) {
790 CompileUnit *TheCU = CUI->second;
791 TheCU->constructContainingTypeDIEs();
Devang Pateleb57c592009-12-03 19:11:07 +0000792 }
793
Bill Wendling2b128d72009-05-20 23:19:06 +0000794 // Standard sections final addresses.
Chris Lattner4b7dadb2009-08-19 05:49:37 +0000795 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
Chris Lattnera179b522010-04-04 19:25:43 +0000796 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
Chris Lattner4b7dadb2009-08-19 05:49:37 +0000797 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
Chris Lattnera179b522010-04-04 19:25:43 +0000798 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
Bill Wendling2b128d72009-05-20 23:19:06 +0000799
800 // End text sections.
801 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
Chris Lattner4b7dadb2009-08-19 05:49:37 +0000802 Asm->OutStreamer.SwitchSection(SectionMap[i]);
Chris Lattnera179b522010-04-04 19:25:43 +0000803 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
Bill Wendling2b128d72009-05-20 23:19:06 +0000804 }
805
Bill Wendling2b128d72009-05-20 23:19:06 +0000806 // Compute DIE offsets and sizes.
Devang Patel930143b2009-11-21 02:48:08 +0000807 computeSizeAndOffsets();
Bill Wendling2b128d72009-05-20 23:19:06 +0000808
809 // Emit all the DIEs into a debug info section
Devang Patel930143b2009-11-21 02:48:08 +0000810 emitDebugInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +0000811
812 // Corresponding abbreviations into a abbrev section.
Devang Patel930143b2009-11-21 02:48:08 +0000813 emitAbbreviations();
Bill Wendling2b128d72009-05-20 23:19:06 +0000814
Eric Christopher4996c702011-11-07 09:24:32 +0000815 // Emit info into a dwarf accelerator table sections.
816 if (DwarfAccelTables) {
817 emitAccelNames();
818 emitAccelObjC();
819 emitAccelNamespaces();
820 emitAccelTypes();
821 }
822
Devang Patel04d2f2d2009-11-24 01:14:22 +0000823 // Emit info into a debug pubtypes section.
824 emitDebugPubTypes();
825
Bill Wendling2b128d72009-05-20 23:19:06 +0000826 // Emit info into a debug loc section.
Devang Patel930143b2009-11-21 02:48:08 +0000827 emitDebugLoc();
Bill Wendling2b128d72009-05-20 23:19:06 +0000828
829 // Emit info into a debug aranges section.
830 EmitDebugARanges();
831
832 // Emit info into a debug ranges section.
Devang Patel930143b2009-11-21 02:48:08 +0000833 emitDebugRanges();
Bill Wendling2b128d72009-05-20 23:19:06 +0000834
835 // Emit info into a debug macinfo section.
Devang Patel930143b2009-11-21 02:48:08 +0000836 emitDebugMacInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +0000837
838 // Emit inline info.
Devang Patel930143b2009-11-21 02:48:08 +0000839 emitDebugInlineInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +0000840
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000841 // Emit info into a debug str section.
842 emitDebugStr();
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000843
Devang Pateld0701282010-08-02 17:32:15 +0000844 // clean up.
845 DeleteContainerSeconds(DeadFnScopeMap);
Devang Pateleb1bb4e2011-08-16 22:09:43 +0000846 SPMap.clear();
Devang Patel1a0df9a2010-05-10 22:49:55 +0000847 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
848 E = CUMap.end(); I != E; ++I)
849 delete I->second;
850 FirstCU = NULL; // Reset for the next Module, if any.
Bill Wendling2b128d72009-05-20 23:19:06 +0000851}
852
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000853/// findAbstractVariable - Find abstract variable, if any, associated with Var.
Devang Patelbb23a4a2011-08-10 21:50:54 +0000854DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
Chris Lattner915c5f92010-04-02 19:42:39 +0000855 DebugLoc ScopeLoc) {
Devang Patelbb23a4a2011-08-10 21:50:54 +0000856 LLVMContext &Ctx = DV->getContext();
857 // More then one inlined variable corresponds to one abstract variable.
858 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000859 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000860 if (AbsDbgVariable)
861 return AbsDbgVariable;
862
Devang Patel7e623022011-08-10 20:55:27 +0000863 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000864 if (!Scope)
865 return NULL;
866
Devang Patel99819b52011-08-15 19:01:20 +0000867 AbsDbgVariable = new DbgVariable(Var, NULL);
Devang Patel7e623022011-08-10 20:55:27 +0000868 addScopeVariable(Scope, AbsDbgVariable);
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000869 AbstractVariables[Var] = AbsDbgVariable;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000870 return AbsDbgVariable;
871}
872
Nick Lewycky019d2552011-07-29 03:49:23 +0000873/// addCurrentFnArgument - If Var is a current function argument then add
874/// it to CurrentFnArguments list.
Devang Patel6c622ef2011-03-01 22:58:55 +0000875bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
Devang Patel7e623022011-08-10 20:55:27 +0000876 DbgVariable *Var, LexicalScope *Scope) {
877 if (!LScopes.isCurrentFunctionScope(Scope))
Devang Patel6c622ef2011-03-01 22:58:55 +0000878 return false;
879 DIVariable DV = Var->getVariable();
880 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
881 return false;
882 unsigned ArgNo = DV.getArgNumber();
883 if (ArgNo == 0)
884 return false;
885
Devang Patel4ab660b2011-03-03 20:02:02 +0000886 size_t Size = CurrentFnArguments.size();
887 if (Size == 0)
Devang Patel6c622ef2011-03-01 22:58:55 +0000888 CurrentFnArguments.resize(MF->getFunction()->arg_size());
Devang Patel63b3e762011-03-03 21:49:41 +0000889 // llvm::Function argument size is not good indicator of how many
Devang Patel34a7ab42011-03-03 20:08:10 +0000890 // arguments does the function have at source level.
891 if (ArgNo > Size)
Devang Patel4ab660b2011-03-03 20:02:02 +0000892 CurrentFnArguments.resize(ArgNo * 2);
Devang Patel6c622ef2011-03-01 22:58:55 +0000893 CurrentFnArguments[ArgNo - 1] = Var;
894 return true;
895}
896
Devang Patel490c8ab2010-05-20 19:57:06 +0000897/// collectVariableInfoFromMMITable - Collect variable information from
898/// side table maintained by MMI.
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000899void
Nick Lewycky019d2552011-07-29 03:49:23 +0000900DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
Devang Patel490c8ab2010-05-20 19:57:06 +0000901 SmallPtrSet<const MDNode *, 16> &Processed) {
Devang Patel475d32a2009-10-06 01:26:37 +0000902 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
903 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
904 VE = VMap.end(); VI != VE; ++VI) {
Devang Patel32cc43c2010-05-07 20:54:48 +0000905 const MDNode *Var = VI->first;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000906 if (!Var) continue;
Devang Patele0a94bf2010-05-14 21:01:35 +0000907 Processed.insert(Var);
Chris Lattner915c5f92010-04-02 19:42:39 +0000908 DIVariable DV(Var);
909 const std::pair<unsigned, DebugLoc> &VP = VI->second;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000910
Devang Patel7e623022011-08-10 20:55:27 +0000911 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000912
Devang Patelcdb7d442009-11-10 23:20:04 +0000913 // If variable scope is not found then skip this variable.
Chris Lattner915c5f92010-04-02 19:42:39 +0000914 if (Scope == 0)
Devang Patelcdb7d442009-11-10 23:20:04 +0000915 continue;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000916
Devang Patele1c53f22010-05-20 16:36:41 +0000917 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
Devang Patel99819b52011-08-15 19:01:20 +0000918 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
Devang Patel3e4a9652011-08-15 21:24:36 +0000919 RegVar->setFrameIndex(VP.first);
Devang Patel6c622ef2011-03-01 22:58:55 +0000920 if (!addCurrentFnArgument(MF, RegVar, Scope))
Devang Patel7e623022011-08-10 20:55:27 +0000921 addScopeVariable(Scope, RegVar);
Devang Patel99819b52011-08-15 19:01:20 +0000922 if (AbsDbgVariable)
Devang Patel3e4a9652011-08-15 21:24:36 +0000923 AbsDbgVariable->setFrameIndex(VP.first);
Devang Patel475d32a2009-10-06 01:26:37 +0000924 }
Devang Patel490c8ab2010-05-20 19:57:06 +0000925}
Devang Patela3e9c9c2010-03-15 18:33:46 +0000926
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000927/// isDbgValueInDefinedReg - Return true if debug value, encoded by
Devang Patel9fc11702010-05-25 23:40:22 +0000928/// DBG_VALUE instruction, is in a defined reg.
929static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000930 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +0000931 return MI->getNumOperands() == 3 &&
932 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
933 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
Devang Patel9fc11702010-05-25 23:40:22 +0000934}
935
Nick Lewycky019d2552011-07-29 03:49:23 +0000936/// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
Devang Patel2442a892011-07-08 17:09:57 +0000937/// at MI.
938static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
939 const MCSymbol *FLabel,
940 const MCSymbol *SLabel,
941 const MachineInstr *MI) {
942 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
943
944 if (MI->getNumOperands() != 3) {
945 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
946 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
947 }
948 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
949 MachineLocation MLoc;
950 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
951 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
952 }
953 if (MI->getOperand(0).isImm())
954 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
955 if (MI->getOperand(0).isFPImm())
956 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
957 if (MI->getOperand(0).isCImm())
958 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
959
Nick Lewycky654f5ce2011-10-26 22:55:33 +0000960 assert(0 && "Unexpected 3 operand DBG_VALUE instruction!");
Devang Patel2442a892011-07-08 17:09:57 +0000961 return DotDebugLocEntry();
962}
963
Devang Patel7e623022011-08-10 20:55:27 +0000964/// collectVariableInfo - Find variables for each lexical scope.
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000965void
Devang Patel5c0f85c2010-06-25 22:07:34 +0000966DwarfDebug::collectVariableInfo(const MachineFunction *MF,
967 SmallPtrSet<const MDNode *, 16> &Processed) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000968
Devang Patel490c8ab2010-05-20 19:57:06 +0000969 /// collection info from MMI table.
970 collectVariableInfoFromMMITable(MF, Processed);
971
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +0000972 for (SmallVectorImpl<const MDNode*>::const_iterator
973 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
974 ++UVI) {
975 const MDNode *Var = *UVI;
976 if (Processed.count(Var))
Devang Patel490c8ab2010-05-20 19:57:06 +0000977 continue;
978
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +0000979 // History contains relevant DBG_VALUE instructions for Var and instructions
980 // clobbering it.
981 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
982 if (History.empty())
983 continue;
984 const MachineInstr *MInsn = History.front();
Devang Patel9fc11702010-05-25 23:40:22 +0000985
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +0000986 DIVariable DV(Var);
Devang Patel7e623022011-08-10 20:55:27 +0000987 LexicalScope *Scope = NULL;
Devang Patel7a9dedf2010-05-27 20:25:04 +0000988 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
989 DISubprogram(DV.getContext()).describes(MF->getFunction()))
Devang Patel7e623022011-08-10 20:55:27 +0000990 Scope = LScopes.getCurrentFunctionScope();
Devang Patel8fb9fd62011-07-20 22:18:50 +0000991 else {
992 if (DV.getVersion() <= LLVMDebugVersion9)
Devang Patel7e623022011-08-10 20:55:27 +0000993 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
Devang Patel8fb9fd62011-07-20 22:18:50 +0000994 else {
995 if (MDNode *IA = DV.getInlinedAt())
Devang Patel7e623022011-08-10 20:55:27 +0000996 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
Devang Patel8fb9fd62011-07-20 22:18:50 +0000997 else
Devang Patel7e623022011-08-10 20:55:27 +0000998 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
Devang Patel8fb9fd62011-07-20 22:18:50 +0000999 }
1000 }
Devang Patel490c8ab2010-05-20 19:57:06 +00001001 // If variable scope is not found then skip this variable.
Devang Patelfbd6c452010-05-21 00:10:20 +00001002 if (!Scope)
Devang Patel490c8ab2010-05-20 19:57:06 +00001003 continue;
1004
1005 Processed.insert(DV);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001006 assert(MInsn->isDebugValue() && "History must begin with debug value");
Devang Patel99819b52011-08-15 19:01:20 +00001007 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1008 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
Devang Patel6c622ef2011-03-01 22:58:55 +00001009 if (!addCurrentFnArgument(MF, RegVar, Scope))
Devang Patel7e623022011-08-10 20:55:27 +00001010 addScopeVariable(Scope, RegVar);
Devang Patel99819b52011-08-15 19:01:20 +00001011 if (AbsVar)
Devang Patel3e4a9652011-08-15 21:24:36 +00001012 AbsVar->setMInsn(MInsn);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001013
1014 // Simple ranges that are fully coalesced.
1015 if (History.size() <= 1 || (History.size() == 2 &&
1016 MInsn->isIdenticalTo(History.back()))) {
Devang Patel3e4a9652011-08-15 21:24:36 +00001017 RegVar->setMInsn(MInsn);
Devang Patel9fc11702010-05-25 23:40:22 +00001018 continue;
1019 }
1020
1021 // handle multiple DBG_VALUE instructions describing one variable.
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001022 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001023
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001024 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1025 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1026 const MachineInstr *Begin = *HI;
1027 assert(Begin->isDebugValue() && "Invalid History entry");
Jakob Stoklund Olesen9c057ee2011-03-22 00:21:41 +00001028
Devang Patele7181b52011-06-01 23:00:17 +00001029 // Check if DBG_VALUE is truncating a range.
1030 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1031 && !Begin->getOperand(0).getReg())
1032 continue;
1033
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001034 // Compute the range for a register location.
1035 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1036 const MCSymbol *SLabel = 0;
1037
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001038 if (HI + 1 == HE)
1039 // If Begin is the last instruction in History then its value is valid
Chris Lattner0ab5e2c2011-04-15 05:18:47 +00001040 // until the end of the function.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001041 SLabel = FunctionEndSym;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001042 else {
1043 const MachineInstr *End = HI[1];
Devang Patel53b050a2011-07-07 21:44:42 +00001044 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1045 << "\t" << *Begin << "\t" << *End << "\n");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001046 if (End->isDebugValue())
1047 SLabel = getLabelBeforeInsn(End);
1048 else {
1049 // End is a normal instruction clobbering the range.
1050 SLabel = getLabelAfterInsn(End);
1051 assert(SLabel && "Forgot label after clobber instruction");
1052 ++HI;
1053 }
1054 }
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001055
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001056 // The value is valid until the next DBG_VALUE or clobber.
Devang Patel2442a892011-07-08 17:09:57 +00001057 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
Devang Patel9fc11702010-05-25 23:40:22 +00001058 }
1059 DotDebugLocEntries.push_back(DotDebugLocEntry());
Devang Patela3e9c9c2010-03-15 18:33:46 +00001060 }
Devang Patele0a94bf2010-05-14 21:01:35 +00001061
1062 // Collect info for variables that were optimized out.
Devang Patel59e27c52011-08-19 23:28:12 +00001063 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1064 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1065 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1066 DIVariable DV(Variables.getElement(i));
1067 if (!DV || !DV.Verify() || !Processed.insert(DV))
1068 continue;
1069 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1070 addScopeVariable(Scope, new DbgVariable(DV, NULL));
Devang Patele0a94bf2010-05-14 21:01:35 +00001071 }
Devang Patel9fc11702010-05-25 23:40:22 +00001072}
Devang Patele0a94bf2010-05-14 21:01:35 +00001073
Devang Patel9fc11702010-05-25 23:40:22 +00001074/// getLabelBeforeInsn - Return Label preceding the instruction.
1075const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001076 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1077 assert(Label && "Didn't insert label before instruction");
1078 return Label;
Devang Patel9fc11702010-05-25 23:40:22 +00001079}
1080
1081/// getLabelAfterInsn - Return Label immediately following the instruction.
1082const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001083 return LabelsAfterInsn.lookup(MI);
Devang Patel475d32a2009-10-06 01:26:37 +00001084}
1085
Devang Patelb5694e72010-10-26 17:49:02 +00001086/// beginInstruction - Process beginning of an instruction.
1087void DwarfDebug::beginInstruction(const MachineInstr *MI) {
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001088 // Check if source location changes, but ignore DBG_VALUE locations.
1089 if (!MI->isDebugValue()) {
1090 DebugLoc DL = MI->getDebugLoc();
1091 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
Devang Patel34a66202011-05-11 19:22:19 +00001092 unsigned Flags = DWARF2_FLAG_IS_STMT;
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001093 PrevInstLoc = DL;
Devang Patel34a66202011-05-11 19:22:19 +00001094 if (DL == PrologEndLoc) {
1095 Flags |= DWARF2_FLAG_PROLOGUE_END;
1096 PrologEndLoc = DebugLoc();
1097 }
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001098 if (!DL.isUnknown()) {
1099 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
Devang Patel34a66202011-05-11 19:22:19 +00001100 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001101 } else
Devang Patel34a66202011-05-11 19:22:19 +00001102 recordSourceLine(0, 0, 0, 0);
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001103 }
Devang Patel9fc11702010-05-25 23:40:22 +00001104 }
Devang Patel23b2ae62010-03-29 22:59:58 +00001105
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001106 // Insert labels where requested.
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001107 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1108 LabelsBeforeInsn.find(MI);
1109
1110 // No label needed.
1111 if (I == LabelsBeforeInsn.end())
1112 return;
1113
1114 // Label already assigned.
1115 if (I->second)
Devang Patel002d54d2010-05-26 19:37:24 +00001116 return;
Devang Patelbd477be2010-03-29 17:20:31 +00001117
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001118 if (!PrevLabel) {
Devang Patelacc32a52010-05-26 21:23:46 +00001119 PrevLabel = MMI->getContext().CreateTempSymbol();
1120 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel002d54d2010-05-26 19:37:24 +00001121 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001122 I->second = PrevLabel;
Devang Patel8db360d2009-10-06 01:50:42 +00001123}
1124
Devang Patelb5694e72010-10-26 17:49:02 +00001125/// endInstruction - Process end of an instruction.
1126void DwarfDebug::endInstruction(const MachineInstr *MI) {
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001127 // Don't create a new label after DBG_VALUE instructions.
1128 // They don't generate code.
1129 if (!MI->isDebugValue())
1130 PrevLabel = 0;
1131
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001132 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1133 LabelsAfterInsn.find(MI);
1134
1135 // No label needed.
1136 if (I == LabelsAfterInsn.end())
1137 return;
1138
1139 // Label already assigned.
1140 if (I->second)
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001141 return;
1142
1143 // We need a label after this instruction.
1144 if (!PrevLabel) {
1145 PrevLabel = MMI->getContext().CreateTempSymbol();
1146 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel3ebd8932010-04-08 16:50:29 +00001147 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001148 I->second = PrevLabel;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001149}
1150
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001151/// identifyScopeMarkers() -
Devang Patel784077e2011-08-10 23:58:09 +00001152/// Each LexicalScope has first instruction and last instruction to mark
1153/// beginning and end of a scope respectively. Create an inverse map that list
1154/// scopes starts (and ends) with an instruction. One instruction may start (or
1155/// end) multiple scopes. Ignore scopes that are not reachable.
Devang Patel359b0132010-04-08 18:43:56 +00001156void DwarfDebug::identifyScopeMarkers() {
Devang Patel7e623022011-08-10 20:55:27 +00001157 SmallVector<LexicalScope *, 4> WorkList;
1158 WorkList.push_back(LScopes.getCurrentFunctionScope());
Devang Patel7771b7c2010-01-20 02:05:23 +00001159 while (!WorkList.empty()) {
Devang Patel7e623022011-08-10 20:55:27 +00001160 LexicalScope *S = WorkList.pop_back_val();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001161
Devang Patel7e623022011-08-10 20:55:27 +00001162 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001163 if (!Children.empty())
Devang Patel7e623022011-08-10 20:55:27 +00001164 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
Devang Patel7771b7c2010-01-20 02:05:23 +00001165 SE = Children.end(); SI != SE; ++SI)
1166 WorkList.push_back(*SI);
1167
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001168 if (S->isAbstractScope())
1169 continue;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001170
Devang Patel7e623022011-08-10 20:55:27 +00001171 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
Devang Patel6c74a872010-04-27 19:46:33 +00001172 if (Ranges.empty())
1173 continue;
Devang Patel7e623022011-08-10 20:55:27 +00001174 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
Devang Patel6c74a872010-04-27 19:46:33 +00001175 RE = Ranges.end(); RI != RE; ++RI) {
Devang Patel7e623022011-08-10 20:55:27 +00001176 assert(RI->first && "InsnRange does not have first instruction!");
1177 assert(RI->second && "InsnRange does not have second instruction!");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001178 requestLabelBeforeInsn(RI->first);
1179 requestLabelAfterInsn(RI->second);
Devang Patel6c74a872010-04-27 19:46:33 +00001180 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001181 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001182}
1183
Devang Patel589845d2011-05-09 22:14:49 +00001184/// getScopeNode - Get MDNode for DebugLoc's scope.
1185static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1186 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1187 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1188 return DL.getScope(Ctx);
1189}
1190
Devang Patel34a66202011-05-11 19:22:19 +00001191/// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1192/// line number info for the function.
1193static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1194 const MDNode *Scope = getScopeNode(DL, Ctx);
1195 DISubprogram SP = getDISubprogram(Scope);
1196 if (SP.Verify())
1197 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1198 return DebugLoc();
1199}
1200
Devang Patel930143b2009-11-21 02:48:08 +00001201/// beginFunction - Gather pre-function debug information. Assumes being
Bill Wendling2b128d72009-05-20 23:19:06 +00001202/// emitted immediately after the function entry point.
Chris Lattner76555b52010-01-26 23:18:02 +00001203void DwarfDebug::beginFunction(const MachineFunction *MF) {
Chris Lattner196dbdc2010-04-05 03:52:55 +00001204 if (!MMI->hasDebugInfo()) return;
Devang Patel7e623022011-08-10 20:55:27 +00001205 LScopes.initialize(*MF);
1206 if (LScopes.empty()) return;
1207 identifyScopeMarkers();
Devang Patel4598eb62009-10-06 18:37:31 +00001208
Devang Patel6c74a872010-04-27 19:46:33 +00001209 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1210 Asm->getFunctionNumber());
Bill Wendling2b128d72009-05-20 23:19:06 +00001211 // Assumes in correct section after the entry point.
Devang Patel6c74a872010-04-27 19:46:33 +00001212 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
Bill Wendling2b128d72009-05-20 23:19:06 +00001213
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001214 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1215
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001216 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001217 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1218 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1219
Devang Patel002d54d2010-05-26 19:37:24 +00001220 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001221 I != E; ++I) {
1222 bool AtBlockEntry = true;
Devang Patel002d54d2010-05-26 19:37:24 +00001223 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1224 II != IE; ++II) {
1225 const MachineInstr *MI = II;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001226
Devang Patel002d54d2010-05-26 19:37:24 +00001227 if (MI->isDebugValue()) {
Nick Lewycky654f5ce2011-10-26 22:55:33 +00001228 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001229
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001230 // Keep track of user variables.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001231 const MDNode *Var =
1232 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001233
1234 // Variable is in a register, we need to check for clobbers.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001235 if (isDbgValueInDefinedReg(MI))
1236 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1237
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001238 // Check the history of this variable.
1239 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1240 if (History.empty()) {
1241 UserVariables.push_back(Var);
1242 // The first mention of a function argument gets the FunctionBeginSym
1243 // label, so arguments are visible when breaking at function entry.
1244 DIVariable DV(Var);
1245 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1246 DISubprogram(getDISubprogram(DV.getContext()))
1247 .describes(MF->getFunction()))
1248 LabelsBeforeInsn[MI] = FunctionBeginSym;
1249 } else {
1250 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1251 const MachineInstr *Prev = History.back();
1252 if (Prev->isDebugValue()) {
1253 // Coalesce identical entries at the end of History.
1254 if (History.size() >= 2 &&
Devang Patelb7a328e2011-07-07 00:14:27 +00001255 Prev->isIdenticalTo(History[History.size() - 2])) {
1256 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1257 << "\t" << *Prev
1258 << "\t" << *History[History.size() - 2] << "\n");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001259 History.pop_back();
Devang Patelb7a328e2011-07-07 00:14:27 +00001260 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001261
1262 // Terminate old register assignments that don't reach MI;
1263 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1264 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1265 isDbgValueInDefinedReg(Prev)) {
1266 // Previous register assignment needs to terminate at the end of
1267 // its basic block.
1268 MachineBasicBlock::const_iterator LastMI =
1269 PrevMBB->getLastNonDebugInstr();
Devang Patelb7a328e2011-07-07 00:14:27 +00001270 if (LastMI == PrevMBB->end()) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001271 // Drop DBG_VALUE for empty range.
Devang Patelb7a328e2011-07-07 00:14:27 +00001272 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1273 << "\t" << *Prev << "\n");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001274 History.pop_back();
Devang Patelb7a328e2011-07-07 00:14:27 +00001275 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001276 else {
1277 // Terminate after LastMI.
1278 History.push_back(LastMI);
1279 }
1280 }
1281 }
1282 }
1283 History.push_back(MI);
Devang Patel002d54d2010-05-26 19:37:24 +00001284 } else {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001285 // Not a DBG_VALUE instruction.
1286 if (!MI->isLabel())
1287 AtBlockEntry = false;
1288
Devang Patel34a66202011-05-11 19:22:19 +00001289 // First known non DBG_VALUE location marks beginning of function
1290 // body.
1291 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1292 PrologEndLoc = MI->getDebugLoc();
1293
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001294 // Check if the instruction clobbers any registers with debug vars.
1295 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1296 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1297 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1298 continue;
1299 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1300 unsigned Reg = *AI; ++AI) {
1301 const MDNode *Var = LiveUserVar[Reg];
1302 if (!Var)
1303 continue;
1304 // Reg is now clobbered.
1305 LiveUserVar[Reg] = 0;
1306
1307 // Was MD last defined by a DBG_VALUE referring to Reg?
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001308 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1309 if (HistI == DbgValues.end())
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001310 continue;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001311 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1312 if (History.empty())
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001313 continue;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001314 const MachineInstr *Prev = History.back();
1315 // Sanity-check: Register assignments are terminated at the end of
1316 // their block.
1317 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1318 continue;
1319 // Is the variable still in Reg?
1320 if (!isDbgValueInDefinedReg(Prev) ||
1321 Prev->getOperand(0).getReg() != Reg)
1322 continue;
1323 // Var is clobbered. Make sure the next instruction gets a label.
1324 History.push_back(MI);
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001325 }
1326 }
Devang Patel002d54d2010-05-26 19:37:24 +00001327 }
Devang Patel002d54d2010-05-26 19:37:24 +00001328 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001329 }
1330
1331 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1332 I != E; ++I) {
1333 SmallVectorImpl<const MachineInstr*> &History = I->second;
1334 if (History.empty())
1335 continue;
1336
1337 // Make sure the final register assignments are terminated.
1338 const MachineInstr *Prev = History.back();
1339 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1340 const MachineBasicBlock *PrevMBB = Prev->getParent();
Devang Patel784077e2011-08-10 23:58:09 +00001341 MachineBasicBlock::const_iterator LastMI =
1342 PrevMBB->getLastNonDebugInstr();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001343 if (LastMI == PrevMBB->end())
1344 // Drop DBG_VALUE for empty range.
1345 History.pop_back();
1346 else {
1347 // Terminate after LastMI.
1348 History.push_back(LastMI);
1349 }
1350 }
1351 // Request labels for the full history.
1352 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1353 const MachineInstr *MI = History[i];
1354 if (MI->isDebugValue())
1355 requestLabelBeforeInsn(MI);
1356 else
1357 requestLabelAfterInsn(MI);
1358 }
1359 }
Devang Patel002d54d2010-05-26 19:37:24 +00001360
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001361 PrevInstLoc = DebugLoc();
Devang Patel002d54d2010-05-26 19:37:24 +00001362 PrevLabel = FunctionBeginSym;
Devang Patel34a66202011-05-11 19:22:19 +00001363
1364 // Record beginning of function.
1365 if (!PrologEndLoc.isUnknown()) {
1366 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1367 MF->getFunction()->getContext());
1368 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1369 FnStartDL.getScope(MF->getFunction()->getContext()),
1370 DWARF2_FLAG_IS_STMT);
1371 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001372}
1373
Devang Patel7e623022011-08-10 20:55:27 +00001374void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1375// SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1376 ScopeVariables[LS].push_back(Var);
1377// Vars.push_back(Var);
1378}
1379
Devang Patel930143b2009-11-21 02:48:08 +00001380/// endFunction - Gather and emit post-function debug information.
Bill Wendling2b128d72009-05-20 23:19:06 +00001381///
Chris Lattner76555b52010-01-26 23:18:02 +00001382void DwarfDebug::endFunction(const MachineFunction *MF) {
Devang Patel7e623022011-08-10 20:55:27 +00001383 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
Devang Patel2904aa92009-11-12 19:02:56 +00001384
Devang Patel7e623022011-08-10 20:55:27 +00001385 // Define end label for subprogram.
1386 FunctionEndSym = Asm->GetTempSymbol("func_end",
1387 Asm->getFunctionNumber());
1388 // Assumes in correct section after the entry point.
1389 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1390
1391 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1392 collectVariableInfo(MF, ProcessedVars);
1393
Devang Patel3acc70e2011-08-15 22:04:40 +00001394 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
Devang Pateleb1bb4e2011-08-16 22:09:43 +00001395 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
Nick Lewycky654f5ce2011-10-26 22:55:33 +00001396 assert(TheCU && "Unable to find compile unit!");
Devang Patel3acc70e2011-08-15 22:04:40 +00001397
Devang Patel7e623022011-08-10 20:55:27 +00001398 // Construct abstract scopes.
Devang Patel44403472011-08-12 18:10:19 +00001399 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1400 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1401 LexicalScope *AScope = AList[i];
1402 DISubprogram SP(AScope->getScopeNode());
Devang Patel7e623022011-08-10 20:55:27 +00001403 if (SP.Verify()) {
1404 // Collect info for variables that were optimized out.
Devang Patel59e27c52011-08-19 23:28:12 +00001405 DIArray Variables = SP.getVariables();
1406 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1407 DIVariable DV(Variables.getElement(i));
1408 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1409 continue;
1410 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1411 addScopeVariable(Scope, new DbgVariable(DV, NULL));
Devang Patel5c0f85c2010-06-25 22:07:34 +00001412 }
1413 }
Devang Patel44403472011-08-12 18:10:19 +00001414 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
Devang Patel3acc70e2011-08-15 22:04:40 +00001415 constructScopeDIE(TheCU, AScope);
Bill Wendling2b128d72009-05-20 23:19:06 +00001416 }
Devang Patel7e623022011-08-10 20:55:27 +00001417
Devang Patel3acc70e2011-08-15 22:04:40 +00001418 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
Devang Patel7e623022011-08-10 20:55:27 +00001419
Devang Patel3acc70e2011-08-15 22:04:40 +00001420 if (!DisableFramePointerElim(*MF))
Devang Patel784077e2011-08-10 23:58:09 +00001421 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1422 dwarf::DW_FORM_flag, 1);
Devang Patel3acc70e2011-08-15 22:04:40 +00001423
Devang Patel7e623022011-08-10 20:55:27 +00001424 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1425 MMI->getFrameMoves()));
Bill Wendling2b128d72009-05-20 23:19:06 +00001426
Bill Wendling2b128d72009-05-20 23:19:06 +00001427 // Clear debug info
Devang Patel7e623022011-08-10 20:55:27 +00001428 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1429 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1430 DeleteContainerPointers(I->second);
1431 ScopeVariables.clear();
Devang Patelad45d912011-04-22 18:09:57 +00001432 DeleteContainerPointers(CurrentFnArguments);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001433 UserVariables.clear();
1434 DbgValues.clear();
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00001435 AbstractVariables.clear();
Devang Patel6c74a872010-04-27 19:46:33 +00001436 LabelsBeforeInsn.clear();
1437 LabelsAfterInsn.clear();
Devang Patel12563b32010-04-16 23:33:45 +00001438 PrevLabel = NULL;
Bill Wendling2b128d72009-05-20 23:19:06 +00001439}
1440
Chris Lattnerba35a672010-03-09 04:54:43 +00001441/// recordSourceLine - Register a source line with debug info. Returns the
1442/// unique label that was emitted and which provides correspondence to
1443/// the source line list.
Devang Patel34a66202011-05-11 19:22:19 +00001444void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1445 unsigned Flags) {
Devang Patel2d9caf92009-11-25 17:36:49 +00001446 StringRef Fn;
Devang Patele01b75c2011-03-24 20:30:50 +00001447 StringRef Dir;
Dan Gohman50849c62010-05-05 23:41:32 +00001448 unsigned Src = 1;
1449 if (S) {
1450 DIDescriptor Scope(S);
Devang Patel2089d162009-10-05 18:03:19 +00001451
Dan Gohman50849c62010-05-05 23:41:32 +00001452 if (Scope.isCompileUnit()) {
1453 DICompileUnit CU(S);
Dan Gohman50849c62010-05-05 23:41:32 +00001454 Fn = CU.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001455 Dir = CU.getDirectory();
Devang Patelc4b69052010-10-28 17:30:52 +00001456 } else if (Scope.isFile()) {
1457 DIFile F(S);
Devang Patelc4b69052010-10-28 17:30:52 +00001458 Fn = F.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001459 Dir = F.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00001460 } else if (Scope.isSubprogram()) {
1461 DISubprogram SP(S);
Dan Gohman50849c62010-05-05 23:41:32 +00001462 Fn = SP.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001463 Dir = SP.getDirectory();
Eric Christopher6647b832011-10-11 22:59:11 +00001464 } else if (Scope.isLexicalBlockFile()) {
1465 DILexicalBlockFile DBF(S);
1466 Fn = DBF.getFilename();
1467 Dir = DBF.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00001468 } else if (Scope.isLexicalBlock()) {
1469 DILexicalBlock DB(S);
Dan Gohman50849c62010-05-05 23:41:32 +00001470 Fn = DB.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00001471 Dir = DB.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00001472 } else
1473 assert(0 && "Unexpected scope info");
1474
Devang Patele01b75c2011-03-24 20:30:50 +00001475 Src = GetOrCreateSourceID(Fn, Dir);
Dan Gohman50849c62010-05-05 23:41:32 +00001476 }
Nick Lewycky019d2552011-07-29 03:49:23 +00001477 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
Bill Wendling2b128d72009-05-20 23:19:06 +00001478}
1479
Bill Wendling806535f2009-05-20 23:22:40 +00001480//===----------------------------------------------------------------------===//
1481// Emit Methods
1482//===----------------------------------------------------------------------===//
1483
Devang Patel930143b2009-11-21 02:48:08 +00001484/// computeSizeAndOffset - Compute the size and offset of a DIE.
Bill Wendling480ff322009-05-20 23:21:38 +00001485///
Jim Grosbach00e9c612009-11-22 19:20:36 +00001486unsigned
1487DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
Bill Wendling480ff322009-05-20 23:21:38 +00001488 // Get the children.
1489 const std::vector<DIE *> &Children = Die->getChildren();
1490
1491 // If not last sibling and has children then add sibling offset attribute.
Jeffrey Yasskin54ebc982010-03-22 18:47:14 +00001492 if (!Last && !Children.empty())
Benjamin Kramer74729ae2010-03-31 19:34:01 +00001493 Die->addSiblingOffset(DIEValueAllocator);
Bill Wendling480ff322009-05-20 23:21:38 +00001494
1495 // Record the abbreviation.
Devang Patel930143b2009-11-21 02:48:08 +00001496 assignAbbrevNumber(Die->getAbbrev());
Bill Wendling480ff322009-05-20 23:21:38 +00001497
1498 // Get the abbreviation for this DIE.
1499 unsigned AbbrevNumber = Die->getAbbrevNumber();
1500 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1501
1502 // Set DIE offset
1503 Die->setOffset(Offset);
1504
1505 // Start the size with the size of abbreviation code.
Chris Lattner7b26fce2009-08-22 20:48:53 +00001506 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
Bill Wendling480ff322009-05-20 23:21:38 +00001507
1508 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1509 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1510
1511 // Size the DIE attribute values.
1512 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1513 // Size attribute value.
Chris Lattner5a00dea2010-04-05 00:18:22 +00001514 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
Bill Wendling480ff322009-05-20 23:21:38 +00001515
1516 // Size the DIE children if any.
1517 if (!Children.empty()) {
1518 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1519 "Children flag not set");
1520
1521 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel930143b2009-11-21 02:48:08 +00001522 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
Bill Wendling480ff322009-05-20 23:21:38 +00001523
1524 // End of children marker.
1525 Offset += sizeof(int8_t);
1526 }
1527
1528 Die->setSize(Offset - Die->getOffset());
1529 return Offset;
1530}
1531
Devang Patel930143b2009-11-21 02:48:08 +00001532/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
Bill Wendling480ff322009-05-20 23:21:38 +00001533///
Devang Patel930143b2009-11-21 02:48:08 +00001534void DwarfDebug::computeSizeAndOffsets() {
Devang Patel1a0df9a2010-05-10 22:49:55 +00001535 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1536 E = CUMap.end(); I != E; ++I) {
1537 // Compute size of compile unit header.
Devang Patel28dce702011-04-12 23:10:47 +00001538 unsigned Offset =
Devang Patel1a0df9a2010-05-10 22:49:55 +00001539 sizeof(int32_t) + // Length of Compilation Unit Info
1540 sizeof(int16_t) + // DWARF version number
1541 sizeof(int32_t) + // Offset Into Abbrev. Section
1542 sizeof(int8_t); // Pointer Size (in bytes)
1543 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
Devang Patel1a0df9a2010-05-10 22:49:55 +00001544 }
Bill Wendling480ff322009-05-20 23:21:38 +00001545}
1546
Chris Lattner6629ca92010-04-04 22:59:04 +00001547/// EmitSectionLabels - Emit initial Dwarf sections with a label at
1548/// the start of each one.
Chris Lattner46355d82010-04-04 22:33:59 +00001549void DwarfDebug::EmitSectionLabels() {
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001550 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00001551
Bill Wendling480ff322009-05-20 23:21:38 +00001552 // Dwarf sections base addresses.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001553 DwarfInfoSectionSym =
Chris Lattner6629ca92010-04-04 22:59:04 +00001554 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001555 DwarfAbbrevSectionSym =
Chris Lattner6629ca92010-04-04 22:59:04 +00001556 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
Chris Lattner1fbf53b2010-04-04 23:02:02 +00001557 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001558
Chris Lattner6629ca92010-04-04 22:59:04 +00001559 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
Chris Lattner1fbf53b2010-04-04 23:02:02 +00001560 EmitSectionSym(Asm, MacroInfo);
Bill Wendling480ff322009-05-20 23:21:38 +00001561
Devang Patel4a213872010-08-24 00:06:12 +00001562 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
Chris Lattner1fbf53b2010-04-04 23:02:02 +00001563 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
Chris Lattner1fbf53b2010-04-04 23:02:02 +00001564 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001565 DwarfStrSectionSym =
Chris Lattner6629ca92010-04-04 22:59:04 +00001566 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
Devang Patel12563b32010-04-16 23:33:45 +00001567 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1568 "debug_range");
Bill Wendling480ff322009-05-20 23:21:38 +00001569
Devang Patel9fc11702010-05-25 23:40:22 +00001570 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1571 "section_debug_loc");
1572
Chris Lattner6629ca92010-04-04 22:59:04 +00001573 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
Chris Lattnere58b5472010-04-04 23:10:38 +00001574 EmitSectionSym(Asm, TLOF.getDataSection());
Bill Wendling480ff322009-05-20 23:21:38 +00001575}
1576
Nick Lewycky019d2552011-07-29 03:49:23 +00001577/// emitDIE - Recursively emits a debug information entry.
Bill Wendling480ff322009-05-20 23:21:38 +00001578///
Devang Patel930143b2009-11-21 02:48:08 +00001579void DwarfDebug::emitDIE(DIE *Die) {
Bill Wendling480ff322009-05-20 23:21:38 +00001580 // Get the abbreviation for this DIE.
1581 unsigned AbbrevNumber = Die->getAbbrevNumber();
1582 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1583
Bill Wendling480ff322009-05-20 23:21:38 +00001584 // Emit the code (index) for the abbreviation.
Chris Lattner7bde8c02010-04-04 18:52:31 +00001585 if (Asm->isVerbose())
Chris Lattnerfa823552010-01-22 23:18:42 +00001586 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1587 Twine::utohexstr(Die->getOffset()) + ":0x" +
1588 Twine::utohexstr(Die->getSize()) + " " +
1589 dwarf::TagString(Abbrev->getTag()));
Chris Lattner9efd1182010-04-04 19:09:29 +00001590 Asm->EmitULEB128(AbbrevNumber);
Bill Wendling480ff322009-05-20 23:21:38 +00001591
Jeffrey Yasskin54ebc982010-03-22 18:47:14 +00001592 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
Bill Wendling480ff322009-05-20 23:21:38 +00001593 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1594
1595 // Emit the DIE attribute values.
1596 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1597 unsigned Attr = AbbrevData[i].getAttribute();
1598 unsigned Form = AbbrevData[i].getForm();
1599 assert(Form && "Too many attributes for DIE (check abbreviation)");
1600
Chris Lattner7bde8c02010-04-04 18:52:31 +00001601 if (Asm->isVerbose())
Chris Lattner5adf9872010-01-24 18:54:17 +00001602 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001603
Bill Wendling480ff322009-05-20 23:21:38 +00001604 switch (Attr) {
1605 case dwarf::DW_AT_sibling:
Devang Patel930143b2009-11-21 02:48:08 +00001606 Asm->EmitInt32(Die->getSiblingOffset());
Bill Wendling480ff322009-05-20 23:21:38 +00001607 break;
1608 case dwarf::DW_AT_abstract_origin: {
1609 DIEEntry *E = cast<DIEEntry>(Values[i]);
1610 DIE *Origin = E->getEntry();
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001611 unsigned Addr = Origin->getOffset();
Bill Wendling480ff322009-05-20 23:21:38 +00001612 Asm->EmitInt32(Addr);
1613 break;
1614 }
Devang Patel12563b32010-04-16 23:33:45 +00001615 case dwarf::DW_AT_ranges: {
1616 // DW_AT_range Value encodes offset in debug_range section.
1617 DIEInteger *V = cast<DIEInteger>(Values[i]);
Devang Patelda3ef852010-09-02 16:43:44 +00001618
1619 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1620 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1621 V->getValue(),
1622 4);
1623 } else {
1624 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1625 V->getValue(),
1626 DwarfDebugRangeSectionSym,
1627 4);
1628 }
Devang Patel12563b32010-04-16 23:33:45 +00001629 break;
1630 }
Devang Patel9fc11702010-05-25 23:40:22 +00001631 case dwarf::DW_AT_location: {
Devang Pateld8994442011-08-15 21:43:21 +00001632 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
Daniel Dunbarfd95b012011-03-16 22:16:39 +00001633 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
Devang Pateld8994442011-08-15 21:43:21 +00001634 else
Devang Patel9fc11702010-05-25 23:40:22 +00001635 Values[i]->EmitValue(Asm, Form);
1636 break;
1637 }
Devang Patela1bd5a12010-09-29 19:08:08 +00001638 case dwarf::DW_AT_accessibility: {
1639 if (Asm->isVerbose()) {
1640 DIEInteger *V = cast<DIEInteger>(Values[i]);
1641 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1642 }
1643 Values[i]->EmitValue(Asm, Form);
1644 break;
1645 }
Bill Wendling480ff322009-05-20 23:21:38 +00001646 default:
1647 // Emit an attribute using the defined form.
Chris Lattner3a383cb2010-04-05 00:13:49 +00001648 Values[i]->EmitValue(Asm, Form);
Bill Wendling480ff322009-05-20 23:21:38 +00001649 break;
1650 }
Bill Wendling480ff322009-05-20 23:21:38 +00001651 }
1652
1653 // Emit the DIE children if any.
1654 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1655 const std::vector<DIE *> &Children = Die->getChildren();
1656
1657 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel930143b2009-11-21 02:48:08 +00001658 emitDIE(Children[j]);
Bill Wendling480ff322009-05-20 23:21:38 +00001659
Chris Lattner7bde8c02010-04-04 18:52:31 +00001660 if (Asm->isVerbose())
Chris Lattner566cae92010-03-09 23:52:58 +00001661 Asm->OutStreamer.AddComment("End Of Children Mark");
1662 Asm->EmitInt8(0);
Bill Wendling480ff322009-05-20 23:21:38 +00001663 }
1664}
1665
Devang Patel9ccfb642009-12-09 18:24:21 +00001666/// emitDebugInfo - Emit the debug info section.
Bill Wendling480ff322009-05-20 23:21:38 +00001667///
Devang Patel9ccfb642009-12-09 18:24:21 +00001668void DwarfDebug::emitDebugInfo() {
1669 // Start debug info section.
1670 Asm->OutStreamer.SwitchSection(
1671 Asm->getObjFileLowering().getDwarfInfoSection());
Devang Patel1a0df9a2010-05-10 22:49:55 +00001672 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1673 E = CUMap.end(); I != E; ++I) {
1674 CompileUnit *TheCU = I->second;
1675 DIE *Die = TheCU->getCUDie();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001676
Devang Patel1a0df9a2010-05-10 22:49:55 +00001677 // Emit the compile units header.
1678 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1679 TheCU->getID()));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001680
Devang Patel1a0df9a2010-05-10 22:49:55 +00001681 // Emit size of content not including length itself
1682 unsigned ContentSize = Die->getSize() +
1683 sizeof(int16_t) + // DWARF version number
1684 sizeof(int32_t) + // Offset Into Abbrev. Section
Devang Patele141234942011-04-13 19:41:17 +00001685 sizeof(int8_t); // Pointer Size (in bytes)
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001686
Devang Patel1a0df9a2010-05-10 22:49:55 +00001687 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1688 Asm->EmitInt32(ContentSize);
1689 Asm->OutStreamer.AddComment("DWARF version number");
1690 Asm->EmitInt16(dwarf::DWARF_VERSION);
1691 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1692 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1693 DwarfAbbrevSectionSym);
1694 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1695 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001696
Devang Patel1a0df9a2010-05-10 22:49:55 +00001697 emitDIE(Die);
Devang Patel1a0df9a2010-05-10 22:49:55 +00001698 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1699 }
Bill Wendling480ff322009-05-20 23:21:38 +00001700}
1701
Devang Patel930143b2009-11-21 02:48:08 +00001702/// emitAbbreviations - Emit the abbreviation section.
Bill Wendling480ff322009-05-20 23:21:38 +00001703///
Devang Patel930143b2009-11-21 02:48:08 +00001704void DwarfDebug::emitAbbreviations() const {
Bill Wendling480ff322009-05-20 23:21:38 +00001705 // Check to see if it is worth the effort.
1706 if (!Abbreviations.empty()) {
1707 // Start the debug abbrev section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001708 Asm->OutStreamer.SwitchSection(
1709 Asm->getObjFileLowering().getDwarfAbbrevSection());
Bill Wendling480ff322009-05-20 23:21:38 +00001710
Chris Lattnera179b522010-04-04 19:25:43 +00001711 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
Bill Wendling480ff322009-05-20 23:21:38 +00001712
1713 // For each abbrevation.
1714 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1715 // Get abbreviation data
1716 const DIEAbbrev *Abbrev = Abbreviations[i];
1717
1718 // Emit the abbrevations code (base 1 index.)
Chris Lattner9efd1182010-04-04 19:09:29 +00001719 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
Bill Wendling480ff322009-05-20 23:21:38 +00001720
1721 // Emit the abbreviations data.
Chris Lattner3a383cb2010-04-05 00:13:49 +00001722 Abbrev->Emit(Asm);
Bill Wendling480ff322009-05-20 23:21:38 +00001723 }
1724
1725 // Mark end of abbreviations.
Chris Lattner9efd1182010-04-04 19:09:29 +00001726 Asm->EmitULEB128(0, "EOM(3)");
Bill Wendling480ff322009-05-20 23:21:38 +00001727
Chris Lattnera179b522010-04-04 19:25:43 +00001728 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
Bill Wendling480ff322009-05-20 23:21:38 +00001729 }
1730}
1731
Devang Patel930143b2009-11-21 02:48:08 +00001732/// emitEndOfLineMatrix - Emit the last address of the section and the end of
Bill Wendling480ff322009-05-20 23:21:38 +00001733/// the line matrix.
1734///
Devang Patel930143b2009-11-21 02:48:08 +00001735void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling480ff322009-05-20 23:21:38 +00001736 // Define last address of section.
Chris Lattner566cae92010-03-09 23:52:58 +00001737 Asm->OutStreamer.AddComment("Extended Op");
1738 Asm->EmitInt8(0);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001739
Chris Lattner566cae92010-03-09 23:52:58 +00001740 Asm->OutStreamer.AddComment("Op size");
Chris Lattner3a383cb2010-04-05 00:13:49 +00001741 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner566cae92010-03-09 23:52:58 +00001742 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1743 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1744
1745 Asm->OutStreamer.AddComment("Section end label");
Chris Lattnerb245dfb2010-03-10 01:17:49 +00001746
Chris Lattnera179b522010-04-04 19:25:43 +00001747 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
Chris Lattner3a383cb2010-04-05 00:13:49 +00001748 Asm->getTargetData().getPointerSize(),
1749 0/*AddrSpace*/);
Bill Wendling480ff322009-05-20 23:21:38 +00001750
1751 // Mark end of matrix.
Chris Lattner566cae92010-03-09 23:52:58 +00001752 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1753 Asm->EmitInt8(0);
Chris Lattnerf5c834f2010-01-22 22:09:00 +00001754 Asm->EmitInt8(1);
Chris Lattnerfa823552010-01-22 23:18:42 +00001755 Asm->EmitInt8(1);
Bill Wendling480ff322009-05-20 23:21:38 +00001756}
1757
Eric Christopher4996c702011-11-07 09:24:32 +00001758/// emitAccelNames - Emit visible names into a hashed accelerator table
1759/// section.
1760void DwarfDebug::emitAccelNames() {
1761 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1762 dwarf::DW_FORM_data4));
1763 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1764 E = CUMap.end(); I != E; ++I) {
1765 CompileUnit *TheCU = I->second;
1766 const StringMap<DIE*> &Names = TheCU->getAccelNames();
1767 for (StringMap<DIE*>::const_iterator
1768 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1769 const char *Name = GI->getKeyData();
1770 DIE *Entity = GI->second;
1771 AT.AddName(Name, Entity);
1772 }
1773 }
1774
1775 AT.FinalizeTable(Asm, "Names");
1776 Asm->OutStreamer.SwitchSection(
1777 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1778 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1779 Asm->OutStreamer.EmitLabel(SectionBegin);
1780
1781 // Emit the full data.
1782 AT.Emit(Asm, SectionBegin, this);
1783}
1784
1785/// emitAccelObjC - Emit objective C classes and categories into a hashed
1786/// accelerator table section.
1787void DwarfDebug::emitAccelObjC() {
1788 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1789 dwarf::DW_FORM_data4));
1790 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1791 E = CUMap.end(); I != E; ++I) {
1792 CompileUnit *TheCU = I->second;
1793 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1794 for (StringMap<std::vector<DIE*> >::const_iterator
1795 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1796 const char *Name = GI->getKeyData();
1797 std::vector<DIE *> Entities = GI->second;
1798 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1799 DE = Entities.end(); DI != DE; ++DI)
1800 AT.AddName(Name, (*DI));
1801 }
1802 }
1803
1804 AT.FinalizeTable(Asm, "ObjC");
1805 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1806 .getDwarfAccelObjCSection());
1807 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1808 Asm->OutStreamer.EmitLabel(SectionBegin);
1809
1810 // Emit the full data.
1811 AT.Emit(Asm, SectionBegin, this);
1812}
1813
1814/// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1815/// table.
1816void DwarfDebug::emitAccelNamespaces() {
1817 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1818 dwarf::DW_FORM_data4));
1819 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1820 E = CUMap.end(); I != E; ++I) {
1821 CompileUnit *TheCU = I->second;
1822 const StringMap<DIE*> &Names = TheCU->getAccelNamespace();
1823 for (StringMap<DIE*>::const_iterator
1824 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1825 const char *Name = GI->getKeyData();
1826 DIE *Entity = GI->second;
1827 AT.AddName(Name, Entity);
1828 }
1829 }
1830
1831 AT.FinalizeTable(Asm, "namespac");
1832 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1833 .getDwarfAccelNamespaceSection());
1834 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1835 Asm->OutStreamer.EmitLabel(SectionBegin);
1836
1837 // Emit the full data.
1838 AT.Emit(Asm, SectionBegin, this);
1839}
1840
1841/// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1842void DwarfDebug::emitAccelTypes() {
1843 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1844 dwarf::DW_FORM_data4));
1845 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1846 E = CUMap.end(); I != E; ++I) {
1847 CompileUnit *TheCU = I->second;
Eric Christopher5139dad2011-11-07 22:11:16 +00001848 const StringMap<DIE*> &Names = TheCU->getAccelTypes();
Eric Christopher4996c702011-11-07 09:24:32 +00001849 for (StringMap<DIE*>::const_iterator
1850 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1851 const char *Name = GI->getKeyData();
1852 DIE *Entity = GI->second;
1853 AT.AddName(Name, Entity);
1854 }
1855 }
1856
1857 AT.FinalizeTable(Asm, "types");
1858 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1859 .getDwarfAccelTypesSection());
1860 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1861 Asm->OutStreamer.EmitLabel(SectionBegin);
1862
1863 // Emit the full data.
1864 AT.Emit(Asm, SectionBegin, this);
1865}
1866
Devang Patel04d2f2d2009-11-24 01:14:22 +00001867void DwarfDebug::emitDebugPubTypes() {
Devang Patel1a0df9a2010-05-10 22:49:55 +00001868 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1869 E = CUMap.end(); I != E; ++I) {
1870 CompileUnit *TheCU = I->second;
Eric Christopher6abc9c52011-11-07 09:18:35 +00001871 // Start the dwarf pubtypes section.
Devang Patel1a0df9a2010-05-10 22:49:55 +00001872 Asm->OutStreamer.SwitchSection(
1873 Asm->getObjFileLowering().getDwarfPubTypesSection());
1874 Asm->OutStreamer.AddComment("Length of Public Types Info");
1875 Asm->EmitLabelDifference(
1876 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1877 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001878
Devang Patel1a0df9a2010-05-10 22:49:55 +00001879 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1880 TheCU->getID()));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001881
Devang Patel1a0df9a2010-05-10 22:49:55 +00001882 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1883 Asm->EmitInt16(dwarf::DWARF_VERSION);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001884
Devang Patel1a0df9a2010-05-10 22:49:55 +00001885 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1886 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1887 DwarfInfoSectionSym);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001888
Devang Patel1a0df9a2010-05-10 22:49:55 +00001889 Asm->OutStreamer.AddComment("Compilation Unit Length");
1890 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1891 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1892 4);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001893
Devang Patel1a0df9a2010-05-10 22:49:55 +00001894 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1895 for (StringMap<DIE*>::const_iterator
1896 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1897 const char *Name = GI->getKeyData();
Nick Lewycky019d2552011-07-29 03:49:23 +00001898 DIE *Entity = GI->second;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001899
Devang Patel1a0df9a2010-05-10 22:49:55 +00001900 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1901 Asm->EmitInt32(Entity->getOffset());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001902
Devang Patel1a0df9a2010-05-10 22:49:55 +00001903 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1904 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1905 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001906
Devang Patel1a0df9a2010-05-10 22:49:55 +00001907 Asm->OutStreamer.AddComment("End Mark");
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001908 Asm->EmitInt32(0);
Devang Patel1a0df9a2010-05-10 22:49:55 +00001909 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1910 TheCU->getID()));
Devang Patel04d2f2d2009-11-24 01:14:22 +00001911 }
Devang Patel04d2f2d2009-11-24 01:14:22 +00001912}
1913
Devang Patel930143b2009-11-21 02:48:08 +00001914/// emitDebugStr - Emit visible names into a debug str section.
Bill Wendling480ff322009-05-20 23:21:38 +00001915///
Devang Patel930143b2009-11-21 02:48:08 +00001916void DwarfDebug::emitDebugStr() {
Bill Wendling480ff322009-05-20 23:21:38 +00001917 // Check to see if it is worth the effort.
Chris Lattner3d72a672010-03-09 23:38:23 +00001918 if (StringPool.empty()) return;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001919
Chris Lattner3d72a672010-03-09 23:38:23 +00001920 // Start the dwarf str section.
1921 Asm->OutStreamer.SwitchSection(
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001922 Asm->getObjFileLowering().getDwarfStrSection());
Bill Wendling480ff322009-05-20 23:21:38 +00001923
Chris Lattnerb7aa9522010-03-13 02:17:42 +00001924 // Get all of the string pool entries and put them in an array by their ID so
1925 // we can sort them.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001926 SmallVector<std::pair<unsigned,
Chris Lattnerb7aa9522010-03-13 02:17:42 +00001927 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001928
Chris Lattnerb7aa9522010-03-13 02:17:42 +00001929 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1930 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1931 Entries.push_back(std::make_pair(I->second.second, &*I));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001932
Chris Lattnerb7aa9522010-03-13 02:17:42 +00001933 array_pod_sort(Entries.begin(), Entries.end());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001934
Chris Lattnerb7aa9522010-03-13 02:17:42 +00001935 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
Chris Lattner3d72a672010-03-09 23:38:23 +00001936 // Emit a label for reference from debug information entries.
Chris Lattnerb7aa9522010-03-13 02:17:42 +00001937 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001938
Chris Lattner3d72a672010-03-09 23:38:23 +00001939 // Emit the string itself.
Chris Lattnerb7aa9522010-03-13 02:17:42 +00001940 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
Nick Lewyckyd59c0ca2011-10-27 06:44:11 +00001941 Asm->OutStreamer.EmitZeros(1, 0);
Bill Wendling480ff322009-05-20 23:21:38 +00001942 }
1943}
1944
Devang Patel930143b2009-11-21 02:48:08 +00001945/// emitDebugLoc - Emit visible names into a debug loc section.
Bill Wendling480ff322009-05-20 23:21:38 +00001946///
Devang Patel930143b2009-11-21 02:48:08 +00001947void DwarfDebug::emitDebugLoc() {
Devang Patel6b9a9fe2010-05-26 23:55:23 +00001948 if (DotDebugLocEntries.empty())
1949 return;
1950
Devang Patel116a9d72011-02-04 22:57:18 +00001951 for (SmallVector<DotDebugLocEntry, 4>::iterator
1952 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1953 I != E; ++I) {
1954 DotDebugLocEntry &Entry = *I;
1955 if (I + 1 != DotDebugLocEntries.end())
1956 Entry.Merge(I+1);
1957 }
1958
Daniel Dunbarfd95b012011-03-16 22:16:39 +00001959 // Start the dwarf loc section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001960 Asm->OutStreamer.SwitchSection(
Devang Patel9fc11702010-05-25 23:40:22 +00001961 Asm->getObjFileLowering().getDwarfLocSection());
1962 unsigned char Size = Asm->getTargetData().getPointerSize();
Devang Patel6b9a9fe2010-05-26 23:55:23 +00001963 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1964 unsigned index = 1;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001965 for (SmallVector<DotDebugLocEntry, 4>::iterator
1966 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
Devang Patel30265c42010-07-07 20:12:52 +00001967 I != E; ++I, ++index) {
Devang Patel116a9d72011-02-04 22:57:18 +00001968 DotDebugLocEntry &Entry = *I;
1969 if (Entry.isMerged()) continue;
Devang Patel9fc11702010-05-25 23:40:22 +00001970 if (Entry.isEmpty()) {
1971 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1972 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patel6b9a9fe2010-05-26 23:55:23 +00001973 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
Devang Patel9fc11702010-05-25 23:40:22 +00001974 } else {
1975 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1976 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
Devang Patel3e021532011-04-28 02:22:40 +00001977 DIVariable DV(Entry.Variable);
Rafael Espindolad23bfb82011-05-27 22:05:41 +00001978 Asm->OutStreamer.AddComment("Loc expr size");
1979 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1980 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1981 Asm->EmitLabelDifference(end, begin, 2);
1982 Asm->OutStreamer.EmitLabel(begin);
Devang Pateled9fd452011-07-08 16:49:43 +00001983 if (Entry.isInt()) {
Devang Patel324f8432011-06-01 22:03:25 +00001984 DIBasicType BTy(DV.getType());
1985 if (BTy.Verify() &&
1986 (BTy.getEncoding() == dwarf::DW_ATE_signed
1987 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1988 Asm->OutStreamer.AddComment("DW_OP_consts");
1989 Asm->EmitInt8(dwarf::DW_OP_consts);
Devang Pateled9fd452011-07-08 16:49:43 +00001990 Asm->EmitSLEB128(Entry.getInt());
Devang Patel324f8432011-06-01 22:03:25 +00001991 } else {
1992 Asm->OutStreamer.AddComment("DW_OP_constu");
1993 Asm->EmitInt8(dwarf::DW_OP_constu);
Devang Pateled9fd452011-07-08 16:49:43 +00001994 Asm->EmitULEB128(Entry.getInt());
Devang Patel324f8432011-06-01 22:03:25 +00001995 }
Devang Pateled9fd452011-07-08 16:49:43 +00001996 } else if (Entry.isLocation()) {
1997 if (!DV.hasComplexAddress())
1998 // Regular entry.
Devang Patel3e021532011-04-28 02:22:40 +00001999 Asm->EmitDwarfRegOp(Entry.Loc);
Devang Pateled9fd452011-07-08 16:49:43 +00002000 else {
2001 // Complex address entry.
2002 unsigned N = DV.getNumAddrElements();
2003 unsigned i = 0;
2004 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2005 if (Entry.Loc.getOffset()) {
2006 i = 2;
2007 Asm->EmitDwarfRegOp(Entry.Loc);
2008 Asm->OutStreamer.AddComment("DW_OP_deref");
2009 Asm->EmitInt8(dwarf::DW_OP_deref);
2010 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2011 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2012 Asm->EmitSLEB128(DV.getAddrElement(1));
2013 } else {
2014 // If first address element is OpPlus then emit
2015 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2016 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2017 Asm->EmitDwarfRegOp(Loc);
2018 i = 2;
2019 }
2020 } else {
2021 Asm->EmitDwarfRegOp(Entry.Loc);
2022 }
2023
2024 // Emit remaining complex address elements.
2025 for (; i < N; ++i) {
2026 uint64_t Element = DV.getAddrElement(i);
2027 if (Element == DIBuilder::OpPlus) {
2028 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2029 Asm->EmitULEB128(DV.getAddrElement(++i));
2030 } else if (Element == DIBuilder::OpDeref)
2031 Asm->EmitInt8(dwarf::DW_OP_deref);
2032 else llvm_unreachable("unknown Opcode found in complex address");
2033 }
Devang Patel3e021532011-04-28 02:22:40 +00002034 }
Devang Patel3e021532011-04-28 02:22:40 +00002035 }
Devang Pateled9fd452011-07-08 16:49:43 +00002036 // else ... ignore constant fp. There is not any good way to
2037 // to represent them here in dwarf.
Rafael Espindolad23bfb82011-05-27 22:05:41 +00002038 Asm->OutStreamer.EmitLabel(end);
Devang Patel9fc11702010-05-25 23:40:22 +00002039 }
2040 }
Bill Wendling480ff322009-05-20 23:21:38 +00002041}
2042
2043/// EmitDebugARanges - Emit visible names into a debug aranges section.
2044///
2045void DwarfDebug::EmitDebugARanges() {
2046 // Start the dwarf aranges section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002047 Asm->OutStreamer.SwitchSection(
2048 Asm->getObjFileLowering().getDwarfARangesSection());
Bill Wendling480ff322009-05-20 23:21:38 +00002049}
2050
Devang Patel930143b2009-11-21 02:48:08 +00002051/// emitDebugRanges - Emit visible names into a debug ranges section.
Bill Wendling480ff322009-05-20 23:21:38 +00002052///
Devang Patel930143b2009-11-21 02:48:08 +00002053void DwarfDebug::emitDebugRanges() {
Bill Wendling480ff322009-05-20 23:21:38 +00002054 // Start the dwarf ranges section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002055 Asm->OutStreamer.SwitchSection(
Devang Patel12563b32010-04-16 23:33:45 +00002056 Asm->getObjFileLowering().getDwarfRangesSection());
Devang Patel6c74a872010-04-27 19:46:33 +00002057 unsigned char Size = Asm->getTargetData().getPointerSize();
2058 for (SmallVector<const MCSymbol *, 8>::iterator
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002059 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
Devang Patel6c74a872010-04-27 19:46:33 +00002060 I != E; ++I) {
2061 if (*I)
2062 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
Devang Patel12563b32010-04-16 23:33:45 +00002063 else
Devang Patel6c74a872010-04-27 19:46:33 +00002064 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patel12563b32010-04-16 23:33:45 +00002065 }
Bill Wendling480ff322009-05-20 23:21:38 +00002066}
2067
Devang Patel930143b2009-11-21 02:48:08 +00002068/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
Bill Wendling480ff322009-05-20 23:21:38 +00002069///
Devang Patel930143b2009-11-21 02:48:08 +00002070void DwarfDebug::emitDebugMacInfo() {
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00002071 if (const MCSection *LineInfo =
Chris Lattner1472cf52009-08-02 07:24:22 +00002072 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
Bill Wendling480ff322009-05-20 23:21:38 +00002073 // Start the dwarf macinfo section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002074 Asm->OutStreamer.SwitchSection(LineInfo);
Bill Wendling480ff322009-05-20 23:21:38 +00002075 }
2076}
2077
Devang Patel930143b2009-11-21 02:48:08 +00002078/// emitDebugInlineInfo - Emit inline info using following format.
Bill Wendling480ff322009-05-20 23:21:38 +00002079/// Section Header:
2080/// 1. length of section
2081/// 2. Dwarf version number
2082/// 3. address size.
2083///
2084/// Entries (one "entry" for each function that was inlined):
2085///
2086/// 1. offset into __debug_str section for MIPS linkage name, if exists;
2087/// otherwise offset into __debug_str for regular function name.
2088/// 2. offset into __debug_str section for regular function name.
2089/// 3. an unsigned LEB128 number indicating the number of distinct inlining
2090/// instances for the function.
2091///
2092/// The rest of the entry consists of a {die_offset, low_pc} pair for each
2093/// inlined instance; the die_offset points to the inlined_subroutine die in the
2094/// __debug_info section, and the low_pc is the starting address for the
2095/// inlining instance.
Devang Patel930143b2009-11-21 02:48:08 +00002096void DwarfDebug::emitDebugInlineInfo() {
Chris Lattner3a383cb2010-04-05 00:13:49 +00002097 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
Bill Wendling480ff322009-05-20 23:21:38 +00002098 return;
2099
Devang Patel1a0df9a2010-05-10 22:49:55 +00002100 if (!FirstCU)
Bill Wendling480ff322009-05-20 23:21:38 +00002101 return;
2102
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002103 Asm->OutStreamer.SwitchSection(
2104 Asm->getObjFileLowering().getDwarfDebugInlineSection());
Chris Lattnerf5c834f2010-01-22 22:09:00 +00002105
Chris Lattner566cae92010-03-09 23:52:58 +00002106 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
Chris Lattnerf1429f12010-04-04 19:58:12 +00002107 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2108 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
Bill Wendling480ff322009-05-20 23:21:38 +00002109
Chris Lattnera179b522010-04-04 19:25:43 +00002110 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
Bill Wendling480ff322009-05-20 23:21:38 +00002111
Chris Lattner566cae92010-03-09 23:52:58 +00002112 Asm->OutStreamer.AddComment("Dwarf Version");
2113 Asm->EmitInt16(dwarf::DWARF_VERSION);
2114 Asm->OutStreamer.AddComment("Address Size (in bytes)");
Chris Lattner3a383cb2010-04-05 00:13:49 +00002115 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Bill Wendling480ff322009-05-20 23:21:38 +00002116
Devang Patel32cc43c2010-05-07 20:54:48 +00002117 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002118 E = InlinedSPNodes.end(); I != E; ++I) {
Jim Grosbach042483e2009-11-21 23:12:12 +00002119
Devang Patel32cc43c2010-05-07 20:54:48 +00002120 const MDNode *Node = *I;
2121 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
Jim Grosbach00e9c612009-11-22 19:20:36 +00002122 = InlineInfo.find(Node);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002123 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
Devang Patel80ae3492009-08-28 23:24:31 +00002124 DISubprogram SP(Node);
Devang Patel2d9caf92009-11-25 17:36:49 +00002125 StringRef LName = SP.getLinkageName();
2126 StringRef Name = SP.getName();
Bill Wendling480ff322009-05-20 23:21:38 +00002127
Chris Lattner566cae92010-03-09 23:52:58 +00002128 Asm->OutStreamer.AddComment("MIPS linkage name");
Chris Lattnerc3f23b82010-01-23 03:11:46 +00002129 if (LName.empty()) {
2130 Asm->OutStreamer.EmitBytes(Name, 0);
2131 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002132 } else
Chris Lattner70a4fce2010-04-04 23:25:33 +00002133 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2134 DwarfStrSectionSym);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002135
Chris Lattner566cae92010-03-09 23:52:58 +00002136 Asm->OutStreamer.AddComment("Function name");
Chris Lattner70a4fce2010-04-04 23:25:33 +00002137 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
Chris Lattner9efd1182010-04-04 19:09:29 +00002138 Asm->EmitULEB128(Labels.size(), "Inline count");
Bill Wendling480ff322009-05-20 23:21:38 +00002139
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002140 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
Bill Wendling480ff322009-05-20 23:21:38 +00002141 LE = Labels.end(); LI != LE; ++LI) {
Chris Lattner7bde8c02010-04-04 18:52:31 +00002142 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
Chris Lattner085b6522010-03-09 00:31:02 +00002143 Asm->EmitInt32(LI->second->getOffset());
Bill Wendling480ff322009-05-20 23:21:38 +00002144
Chris Lattner7bde8c02010-04-04 18:52:31 +00002145 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
Chris Lattner3a383cb2010-04-05 00:13:49 +00002146 Asm->OutStreamer.EmitSymbolValue(LI->first,
2147 Asm->getTargetData().getPointerSize(),0);
Bill Wendling480ff322009-05-20 23:21:38 +00002148 }
2149 }
2150
Chris Lattnera179b522010-04-04 19:25:43 +00002151 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
Bill Wendling480ff322009-05-20 23:21:38 +00002152}