blob: 07268abf05de66dd7a4d71978ed0c302b3ba2228 [file] [log] [blame]
Bill Wendling0310d762009-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 Lattner6cde3e62010-03-09 00:39:24 +000013
Devang Patele4b27562009-08-28 23:24:31 +000014#define DEBUG_TYPE "dwarfdebug"
Bill Wendling0310d762009-05-15 09:23:25 +000015#include "DwarfDebug.h"
Chris Lattner74e41f92010-04-05 05:24:55 +000016#include "DIE.h"
Devang Patel8b9df622011-04-12 17:40:32 +000017#include "DwarfCompileUnit.h"
Bill Wendling57fbba42010-04-05 22:59:21 +000018#include "llvm/Constants.h"
Bill Wendling0310d762009-05-15 09:23:25 +000019#include "llvm/Module.h"
Devang Patele449d1f2011-01-20 00:02:16 +000020#include "llvm/Instructions.h"
David Greeneb2c66fc2009-08-19 21:52:55 +000021#include "llvm/CodeGen/MachineFunction.h"
Bill Wendling0310d762009-05-15 09:23:25 +000022#include "llvm/CodeGen/MachineModuleInfo.h"
Chris Lattnerb7db7332010-03-09 01:58:53 +000023#include "llvm/MC/MCAsmInfo.h"
Chris Lattnera87dea42009-07-31 18:48:30 +000024#include "llvm/MC/MCSection.h"
Chris Lattner6c2f9e12009-08-19 05:49:37 +000025#include "llvm/MC/MCStreamer.h"
Chris Lattnerb7db7332010-03-09 01:58:53 +000026#include "llvm/MC/MCSymbol.h"
Bill Wendling0310d762009-05-15 09:23:25 +000027#include "llvm/Target/TargetData.h"
Anton Korobeynikov16c29b52011-01-10 12:39:04 +000028#include "llvm/Target/TargetFrameLowering.h"
Chris Lattnerf0144122009-07-28 03:13:23 +000029#include "llvm/Target/TargetLoweringObjectFile.h"
Chris Lattner9d1c1ad2010-04-04 18:06:11 +000030#include "llvm/Target/TargetMachine.h"
Chris Lattnerf0144122009-07-28 03:13:23 +000031#include "llvm/Target/TargetRegisterInfo.h"
Devang Patel2a4a3b72010-04-19 19:14:02 +000032#include "llvm/Target/TargetOptions.h"
Chris Lattner74e41f92010-04-05 05:24:55 +000033#include "llvm/Analysis/DebugInfo.h"
Devang Patel0eea95d2011-02-24 18:49:30 +000034#include "llvm/Analysis/DIBuilder.h"
Devang Patel9a31f0f2010-10-25 20:45:32 +000035#include "llvm/ADT/Statistic.h"
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +000036#include "llvm/ADT/STLExtras.h"
Chris Lattner23132b12009-08-24 03:52:50 +000037#include "llvm/ADT/StringExtras.h"
Devang Pateleac9c072010-04-27 19:46:33 +000038#include "llvm/Support/CommandLine.h"
Daniel Dunbar6e4bdfc2009-10-13 06:47:08 +000039#include "llvm/Support/Debug.h"
40#include "llvm/Support/ErrorHandling.h"
Devang Patel3139fcf2010-01-26 21:39:14 +000041#include "llvm/Support/ValueHandle.h"
Chris Lattner0ad9c912010-01-22 22:09:00 +000042#include "llvm/Support/FormattedStream.h"
Chris Lattnera87dea42009-07-31 18:48:30 +000043#include "llvm/Support/Timer.h"
Michael J. Spencer1f6efa32010-11-29 18:16:10 +000044#include "llvm/Support/Path.h"
Bill Wendling0310d762009-05-15 09:23:25 +000045using namespace llvm;
46
Jim Grosbach1e20b962010-07-21 21:21:52 +000047static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
Devang Patel61409622010-07-07 20:12:52 +000048 cl::Hidden,
Devang Pateleac9c072010-04-27 19:46:33 +000049 cl::desc("Disable debug info printing"));
50
Dan Gohman281d65d2010-05-07 01:08:53 +000051static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
Chris Lattner7a2bdde2011-04-15 05:18:47 +000052 cl::desc("Make an absence of debug location information explicit."),
Dan Gohman281d65d2010-05-07 01:08:53 +000053 cl::init(false));
54
Bill Wendling5f017e82010-04-07 09:28:04 +000055namespace {
56 const char *DWARFGroupName = "DWARF Emission";
57 const char *DbgTimerName = "DWARF Debug Writer";
58} // end anonymous namespace
59
Bill Wendling0310d762009-05-15 09:23:25 +000060//===----------------------------------------------------------------------===//
61
62/// Configuration values for initial hash set sizes (log2).
63///
Bill Wendling0310d762009-05-15 09:23:25 +000064static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
Bill Wendling0310d762009-05-15 09:23:25 +000065
66namespace llvm {
67
Nick Lewycky3bbb6f72011-07-29 03:49:23 +000068DIType DbgVariable::getType() const {
Devang Patel3cbee302011-04-12 22:53:02 +000069 DIType Ty = Var.getType();
70 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
71 // addresses instead.
72 if (Var.isBlockByrefVariable()) {
73 /* Byref variables, in Blocks, are declared by the programmer as
74 "SomeType VarName;", but the compiler creates a
75 __Block_byref_x_VarName struct, and gives the variable VarName
76 either the struct, or a pointer to the struct, as its type. This
77 is necessary for various behind-the-scenes things the compiler
78 needs to do with by-reference variables in blocks.
79
80 However, as far as the original *programmer* is concerned, the
81 variable should still have type 'SomeType', as originally declared.
82
83 The following function dives into the __Block_byref_x_VarName
84 struct to find the original type of the variable. This will be
85 passed back to the code generating the type for the Debug
86 Information Entry for the variable 'VarName'. 'VarName' will then
87 have the original type 'SomeType' in its debug information.
88
89 The original type 'SomeType' will be the type of the field named
90 'VarName' inside the __Block_byref_x_VarName struct.
91
92 NOTE: In order for this to not completely fail on the debugger
93 side, the Debug Information Entry for the variable VarName needs to
94 have a DW_AT_location that tells the debugger how to unwind through
95 the pointers and __Block_byref_x_VarName struct to find the actual
96 value of the variable. The function addBlockByrefType does this. */
97 DIType subType = Ty;
98 unsigned tag = Ty.getTag();
99
100 if (tag == dwarf::DW_TAG_pointer_type) {
101 DIDerivedType DTy = DIDerivedType(Ty);
102 subType = DTy.getTypeDerivedFrom();
103 }
104
105 DICompositeType blockStruct = DICompositeType(subType);
106 DIArray Elements = blockStruct.getTypeArray();
107
108 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
109 DIDescriptor Element = Elements.getElement(i);
110 DIDerivedType DT = DIDerivedType(Element);
111 if (getName() == DT.getName())
112 return (DT.getTypeDerivedFrom());
Devang Patel8bd11de2010-08-09 21:01:39 +0000113 }
114 return Ty;
115 }
Devang Patel3cbee302011-04-12 22:53:02 +0000116 return Ty;
117}
Bill Wendling0310d762009-05-15 09:23:25 +0000118
Chris Lattnerea761862010-04-05 04:09:20 +0000119} // end llvm namespace
Bill Wendling0310d762009-05-15 09:23:25 +0000120
Chris Lattner49cd6642010-04-05 05:11:15 +0000121DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
Devang Patel163a9f72010-05-10 22:49:55 +0000122 : Asm(A), MMI(Asm->MMI), FirstCU(0),
Jim Grosbach1e20b962010-07-21 21:21:52 +0000123 AbbreviationsSet(InitAbbreviationsSetSize),
Devang Patelbf47fdb2011-08-10 20:55:27 +0000124 PrevLabel(NULL) {
Chris Lattnerbc733f52010-03-13 02:17:42 +0000125 NextStringPoolNumber = 0;
Jim Grosbach1e20b962010-07-21 21:21:52 +0000126
Rafael Espindolaf2b04232011-05-06 14:56:22 +0000127 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
Chris Lattner4ad1efe2010-04-04 23:10:38 +0000128 DwarfStrSectionSym = TextSectionSym = 0;
Jim Grosbach1e20b962010-07-21 21:21:52 +0000129 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
Devang Patelc3f5f782010-05-25 23:40:22 +0000130 FunctionBeginSym = FunctionEndSym = 0;
Dan Gohman03c3dc72010-06-18 15:56:31 +0000131 {
132 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
133 beginModule(M);
Torok Edwin9c421072010-04-07 10:44:46 +0000134 }
Bill Wendling0310d762009-05-15 09:23:25 +0000135}
136DwarfDebug::~DwarfDebug() {
Bill Wendling0310d762009-05-15 09:23:25 +0000137}
138
Chris Lattnerbc733f52010-03-13 02:17:42 +0000139MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
140 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
141 if (Entry.first) return Entry.first;
142
143 Entry.second = NextStringPoolNumber++;
Chris Lattnerc0215722010-04-04 19:25:43 +0000144 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
Chris Lattnerbc733f52010-03-13 02:17:42 +0000145}
146
147
Devang Patel2c4ceb12009-11-21 02:48:08 +0000148/// assignAbbrevNumber - Define a unique number for the abbreviation.
Bill Wendling0310d762009-05-15 09:23:25 +0000149///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000150void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
Bill Wendling0310d762009-05-15 09:23:25 +0000151 // Profile the node so that we can make it unique.
152 FoldingSetNodeID ID;
153 Abbrev.Profile(ID);
154
155 // Check the set for priors.
156 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
157
158 // If it's newly added.
159 if (InSet == &Abbrev) {
160 // Add to abbreviation list.
161 Abbreviations.push_back(&Abbrev);
162
163 // Assign the vector position + 1 as its number.
164 Abbrev.setNumber(Abbreviations.size());
165 } else {
166 // Assign existing abbreviation number.
167 Abbrev.setNumber(InSet->getNumber());
168 }
169}
170
Jim Grosbach1e20b962010-07-21 21:21:52 +0000171/// getRealLinkageName - If special LLVM prefix that is used to inform the asm
Devang Patel351ca332010-01-05 01:46:14 +0000172/// printer to not emit usual symbol prefix before the symbol name is used then
173/// return linkage name after skipping this special LLVM prefix.
174static StringRef getRealLinkageName(StringRef LinkageName) {
175 char One = '\1';
176 if (LinkageName.startswith(StringRef(&One, 1)))
177 return LinkageName.substr(1);
178 return LinkageName;
179}
180
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000181/// updateSubprogramScopeDIE - Find DIE for the given subprogram and
Devang Patel2c4ceb12009-11-21 02:48:08 +0000182/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
183/// If there are global variables in this scope then create and insert
184/// DIEs for these variables.
Devang Patele9f8f5e2010-05-07 20:54:48 +0000185DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
Devang Patel163a9f72010-05-10 22:49:55 +0000186 CompileUnit *SPCU = getCompileUnit(SPNode);
187 DIE *SPDie = SPCU->getDIE(SPNode);
Devang Patel8aa61472010-07-07 22:20:57 +0000188
Chris Lattnerd38fee82010-04-05 00:13:49 +0000189 assert(SPDie && "Unable to find subprogram DIE!");
190 DISubprogram SP(SPNode);
Jim Grosbach1e20b962010-07-21 21:21:52 +0000191
Devang Patel5e06bb82011-04-22 23:10:17 +0000192 DISubprogram SPDecl = SP.getFunctionDeclaration();
193 if (SPDecl.isSubprogram())
194 // Refer function declaration directly.
Devang Patel3cbee302011-04-12 22:53:02 +0000195 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
Devang Pateldbc64af2011-08-15 17:24:54 +0000196 SPCU->getOrCreateSubprogramDIE(SPDecl));
Devang Patel5e06bb82011-04-22 23:10:17 +0000197 else {
198 // There is not any need to generate specification DIE for a function
199 // defined at compile unit level. If a function is defined inside another
200 // function then gdb prefers the definition at top level and but does not
201 // expect specification DIE in parent function. So avoid creating
202 // specification DIE for a function defined inside a function.
203 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
204 !SP.getContext().isFile() &&
205 !isSubprogramContext(SP.getContext())) {
206 SPCU-> addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
207
208 // Add arguments.
209 DICompositeType SPTy = SP.getType();
210 DIArray Args = SPTy.getTypeArray();
211 unsigned SPTag = SPTy.getTag();
212 if (SPTag == dwarf::DW_TAG_subroutine_type)
213 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
214 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
215 DIType ATy = DIType(DIType(Args.getElement(i)));
216 SPCU->addType(Arg, ATy);
217 if (ATy.isArtificial())
218 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
219 SPDie->addChild(Arg);
220 }
221 DIE *SPDeclDie = SPDie;
222 SPDie = new DIE(dwarf::DW_TAG_subprogram);
223 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
224 SPDeclDie);
225 SPCU->addDie(SPDie);
226 }
Chris Lattnerd38fee82010-04-05 00:13:49 +0000227 }
Devang Patel8aa61472010-07-07 22:20:57 +0000228 // Pick up abstract subprogram DIE.
229 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
230 SPDie = new DIE(dwarf::DW_TAG_subprogram);
Devang Patel3cbee302011-04-12 22:53:02 +0000231 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
232 dwarf::DW_FORM_ref4, AbsSPDIE);
Devang Patel8aa61472010-07-07 22:20:57 +0000233 SPCU->addDie(SPDie);
234 }
235
Devang Patel3cbee302011-04-12 22:53:02 +0000236 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
237 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
238 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
239 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
Chris Lattnerd38fee82010-04-05 00:13:49 +0000240 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
241 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
Devang Patel3cbee302011-04-12 22:53:02 +0000242 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
Devang Patelb4645642010-02-06 01:02:37 +0000243
Chris Lattnerd38fee82010-04-05 00:13:49 +0000244 return SPDie;
Devang Patel53bb5c92009-11-10 23:06:00 +0000245}
246
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000247/// constructLexicalScope - Construct new DW_TAG_lexical_block
Devang Patel2c4ceb12009-11-21 02:48:08 +0000248/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
Devang Patelbf47fdb2011-08-10 20:55:27 +0000249DIE *DwarfDebug::constructLexicalScopeDIE(LexicalScope *Scope) {
Devang Pateleac9c072010-04-27 19:46:33 +0000250
251 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
252 if (Scope->isAbstractScope())
253 return ScopeDIE;
254
Devang Patelbf47fdb2011-08-10 20:55:27 +0000255 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
Devang Pateleac9c072010-04-27 19:46:33 +0000256 if (Ranges.empty())
257 return 0;
258
Devang Patel3cbee302011-04-12 22:53:02 +0000259 CompileUnit *TheCU = getCompileUnit(Scope->getScopeNode());
Devang Patelbf47fdb2011-08-10 20:55:27 +0000260 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
Devang Pateleac9c072010-04-27 19:46:33 +0000261 if (Ranges.size() > 1) {
262 // .debug_range section has not been laid out yet. Emit offset in
Jim Grosbach1e20b962010-07-21 21:21:52 +0000263 // .debug_range as a uint, size 4, for now. emitDIE will handle
Devang Pateleac9c072010-04-27 19:46:33 +0000264 // DW_AT_ranges appropriately.
Devang Patel3cbee302011-04-12 22:53:02 +0000265 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
Devang Patel5bc942c2011-08-10 23:58:09 +0000266 DebugRangeSymbols.size()
267 * Asm->getTargetData().getPointerSize());
Devang Patelbf47fdb2011-08-10 20:55:27 +0000268 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
Devang Pateleac9c072010-04-27 19:46:33 +0000269 RE = Ranges.end(); RI != RE; ++RI) {
Devang Patelc3f5f782010-05-25 23:40:22 +0000270 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
271 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
Devang Pateleac9c072010-04-27 19:46:33 +0000272 }
273 DebugRangeSymbols.push_back(NULL);
274 DebugRangeSymbols.push_back(NULL);
275 return ScopeDIE;
276 }
277
Devang Patelc3f5f782010-05-25 23:40:22 +0000278 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
279 const MCSymbol *End = getLabelAfterInsn(RI->second);
Devang Pateleac9c072010-04-27 19:46:33 +0000280
Devang Patelc3f5f782010-05-25 23:40:22 +0000281 if (End == 0) return 0;
Devang Patel53bb5c92009-11-10 23:06:00 +0000282
Chris Lattnerb7db7332010-03-09 01:58:53 +0000283 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
284 assert(End->isDefined() && "Invalid end label for an inlined scope!");
Jim Grosbach1e20b962010-07-21 21:21:52 +0000285
Devang Patel3cbee302011-04-12 22:53:02 +0000286 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
287 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
Devang Patel53bb5c92009-11-10 23:06:00 +0000288
289 return ScopeDIE;
290}
291
Devang Patel2c4ceb12009-11-21 02:48:08 +0000292/// constructInlinedScopeDIE - This scope represents inlined body of
293/// a function. Construct DIE to represent this concrete inlined copy
294/// of the function.
Devang Patelbf47fdb2011-08-10 20:55:27 +0000295DIE *DwarfDebug::constructInlinedScopeDIE(LexicalScope *Scope) {
Devang Pateleac9c072010-04-27 19:46:33 +0000296
Devang Patelbf47fdb2011-08-10 20:55:27 +0000297 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
Jim Grosbach1e20b962010-07-21 21:21:52 +0000298 assert (Ranges.empty() == false
Devang Patelbf47fdb2011-08-10 20:55:27 +0000299 && "LexicalScope does not have instruction markers!");
Devang Pateleac9c072010-04-27 19:46:33 +0000300
Devang Patel26a92002011-07-27 00:34:13 +0000301 if (!Scope->getScopeNode())
302 return NULL;
303 DIScope DS(Scope->getScopeNode());
304 DISubprogram InlinedSP = getDISubprogram(DS);
305 CompileUnit *TheCU = getCompileUnit(InlinedSP);
306 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
307 if (!OriginDIE) {
308 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
309 return NULL;
310 }
311
Devang Patelbf47fdb2011-08-10 20:55:27 +0000312 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
Devang Patelc3f5f782010-05-25 23:40:22 +0000313 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
314 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
Devang Pateleac9c072010-04-27 19:46:33 +0000315
Devang Patel0afbf232010-07-08 22:39:20 +0000316 if (StartLabel == 0 || EndLabel == 0) {
Nick Lewycky3bbb6f72011-07-29 03:49:23 +0000317 assert (0 && "Unexpected Start and End labels for a inlined scope!");
Devang Pateleac9c072010-04-27 19:46:33 +0000318 return 0;
319 }
Chris Lattnerb7db7332010-03-09 01:58:53 +0000320 assert(StartLabel->isDefined() &&
Chris Lattnera34ec2292010-03-09 01:51:43 +0000321 "Invalid starting label for an inlined scope!");
Chris Lattnerb7db7332010-03-09 01:58:53 +0000322 assert(EndLabel->isDefined() &&
Chris Lattnera34ec2292010-03-09 01:51:43 +0000323 "Invalid end label for an inlined scope!");
Devang Pateleac9c072010-04-27 19:46:33 +0000324
Devang Pateld96efb82011-05-05 17:54:26 +0000325 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
Devang Patel3cbee302011-04-12 22:53:02 +0000326 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
327 dwarf::DW_FORM_ref4, OriginDIE);
Devang Patel53bb5c92009-11-10 23:06:00 +0000328
Devang Patel26a92002011-07-27 00:34:13 +0000329 if (Ranges.size() > 1) {
330 // .debug_range section has not been laid out yet. Emit offset in
331 // .debug_range as a uint, size 4, for now. emitDIE will handle
332 // DW_AT_ranges appropriately.
333 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
Devang Patel5bc942c2011-08-10 23:58:09 +0000334 DebugRangeSymbols.size()
335 * Asm->getTargetData().getPointerSize());
Devang Patelbf47fdb2011-08-10 20:55:27 +0000336 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
Devang Patel26a92002011-07-27 00:34:13 +0000337 RE = Ranges.end(); RI != RE; ++RI) {
338 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
339 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
340 }
341 DebugRangeSymbols.push_back(NULL);
342 DebugRangeSymbols.push_back(NULL);
343 } else {
Devang Patel5bc942c2011-08-10 23:58:09 +0000344 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
345 StartLabel);
346 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
347 EndLabel);
Devang Patel26a92002011-07-27 00:34:13 +0000348 }
Devang Patel53bb5c92009-11-10 23:06:00 +0000349
350 InlinedSubprogramDIEs.insert(OriginDIE);
351
352 // Track the start label for this inlined function.
Devang Patel26a92002011-07-27 00:34:13 +0000353 //.debug_inlined section specification does not clearly state how
354 // to emit inlined scope that is split into multiple instruction ranges.
355 // For now, use first instruction range and emit low_pc/high_pc pair and
356 // corresponding .debug_inlined section entry for this pair.
Devang Patele9f8f5e2010-05-07 20:54:48 +0000357 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
Devang Patel2db49d72010-05-07 18:11:54 +0000358 I = InlineInfo.find(InlinedSP);
Devang Patel53bb5c92009-11-10 23:06:00 +0000359
360 if (I == InlineInfo.end()) {
Devang Patel2db49d72010-05-07 18:11:54 +0000361 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
Jim Grosbach7ab38df2009-11-22 19:20:36 +0000362 ScopeDIE));
Devang Patel2db49d72010-05-07 18:11:54 +0000363 InlinedSPNodes.push_back(InlinedSP);
Devang Patel53bb5c92009-11-10 23:06:00 +0000364 } else
Chris Lattner6ed0f902010-03-09 00:31:02 +0000365 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
Devang Patel53bb5c92009-11-10 23:06:00 +0000366
Devang Patel53bb5c92009-11-10 23:06:00 +0000367 DILocation DL(Scope->getInlinedAt());
Devang Patel3cbee302011-04-12 22:53:02 +0000368 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
369 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
Devang Patel53bb5c92009-11-10 23:06:00 +0000370
371 return ScopeDIE;
372}
373
Devang Patel2c4ceb12009-11-21 02:48:08 +0000374/// constructVariableDIE - Construct a DIE for the given DbgVariable.
Devang Patelbf47fdb2011-08-10 20:55:27 +0000375DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, LexicalScope *Scope) {
Devang Patel8bd11de2010-08-09 21:01:39 +0000376 StringRef Name = DV->getName();
Devang Patel65dbc902009-11-25 17:36:49 +0000377 if (Name.empty())
Devang Patel3fb6bd62009-11-13 02:25:26 +0000378 return NULL;
Devang Patel53bb5c92009-11-10 23:06:00 +0000379
Devang Patel59bc4092011-08-15 18:35:42 +0000380 // Translate tag to proper Dwarf tag.
381 unsigned Tag = DV->getTag();
Devang Patel53bb5c92009-11-10 23:06:00 +0000382
383 // Define variable debug information entry.
384 DIE *VariableDie = new DIE(Tag);
Devang Patel9341d102011-04-25 23:05:21 +0000385 CompileUnit *VariableCU = getCompileUnit(DV->getVariable());
Devang Patel5a1a67c2011-08-15 19:01:20 +0000386 DbgVariable *AbsVar = DV->getAbstractVariable();
387 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
Devang Patel26c1e562010-05-20 16:36:41 +0000388 if (AbsDIE)
Devang Patel9341d102011-04-25 23:05:21 +0000389 VariableCU->addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
Devang Patel5a1a67c2011-08-15 19:01:20 +0000390 dwarf::DW_FORM_ref4, AbsDIE);
Devang Patel53bb5c92009-11-10 23:06:00 +0000391 else {
Devang Patel5a1a67c2011-08-15 19:01:20 +0000392 VariableCU->addString(VariableDie, dwarf::DW_AT_name,
393 dwarf::DW_FORM_string, Name);
Devang Patel9341d102011-04-25 23:05:21 +0000394 VariableCU->addSourceLine(VariableDie, DV->getVariable());
Devang Patel9341d102011-04-25 23:05:21 +0000395 VariableCU->addType(VariableDie, DV->getType());
Devang Patel53bb5c92009-11-10 23:06:00 +0000396 }
397
Devang Patela098c502011-08-15 18:40:16 +0000398 if (DV->isArtificial())
399 VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial,
Devang Patel9341d102011-04-25 23:05:21 +0000400 dwarf::DW_FORM_flag, 1);
Devang Patelc3f5f782010-05-25 23:40:22 +0000401
402 if (Scope->isAbstractScope()) {
403 DV->setDIE(VariableDie);
404 return VariableDie;
405 }
406
407 // Add variable address.
408
409 unsigned Offset = DV->getDotDebugLocOffset();
410 if (Offset != ~0U) {
Devang Patel5bc942c2011-08-10 23:58:09 +0000411 VariableCU->addLabel(VariableDie, dwarf::DW_AT_location,
412 dwarf::DW_FORM_data4,
413 Asm->GetTempSymbol("debug_loc", Offset));
Devang Patelc3f5f782010-05-25 23:40:22 +0000414 DV->setDIE(VariableDie);
Devang Patelc3f5f782010-05-25 23:40:22 +0000415 return VariableDie;
416 }
417
418 // Check if variable is described by a DBG_VALUE instruction.
Devang Patelff9dd0a2011-08-15 21:24:36 +0000419 if (const MachineInstr *DVInsn = DV->getMInsn()) {
Devang Patelc3f5f782010-05-25 23:40:22 +0000420 bool updated = false;
Devang Patelc3f5f782010-05-25 23:40:22 +0000421 if (DVInsn->getNumOperands() == 3) {
Devang Patel0b48ead2010-08-31 22:22:42 +0000422 if (DVInsn->getOperand(0).isReg()) {
423 const MachineOperand RegOp = DVInsn->getOperand(0);
424 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
425 if (DVInsn->getOperand(1).isImm() &&
426 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
Devang Patele1cdf842011-04-27 22:45:24 +0000427 unsigned FrameReg = 0;
428 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
429 int Offset =
430 TFI->getFrameIndexReference(*Asm->MF,
431 DVInsn->getOperand(1).getImm(),
432 FrameReg);
433 MachineLocation Location(FrameReg, Offset);
434 VariableCU->addVariableAddress(DV, VariableDie, Location);
435
436 } else if (RegOp.getReg())
437 VariableCU->addVariableAddress(DV, VariableDie,
438 MachineLocation(RegOp.getReg()));
439 updated = true;
Devang Patel0b48ead2010-08-31 22:22:42 +0000440 }
Devang Patelc3f5f782010-05-25 23:40:22 +0000441 else if (DVInsn->getOperand(0).isImm())
Devang Patelb58128e2011-05-27 16:45:18 +0000442 updated =
443 VariableCU->addConstantValue(VariableDie, DVInsn->getOperand(0),
444 DV->getType());
Jim Grosbach1e20b962010-07-21 21:21:52 +0000445 else if (DVInsn->getOperand(0).isFPImm())
446 updated =
Devang Patel9341d102011-04-25 23:05:21 +0000447 VariableCU->addConstantFPValue(VariableDie, DVInsn->getOperand(0));
Devang Patel8594d422011-06-24 20:46:11 +0000448 else if (DVInsn->getOperand(0).isCImm())
449 updated =
450 VariableCU->addConstantValue(VariableDie,
451 DVInsn->getOperand(0).getCImm(),
Devang Patel6f9d8ff2011-08-15 17:57:41 +0000452 DV->getType().isUnsignedDIType());
Devang Patelc3f5f782010-05-25 23:40:22 +0000453 } else {
Devang Patele1cdf842011-04-27 22:45:24 +0000454 VariableCU->addVariableAddress(DV, VariableDie,
455 Asm->getDebugValueLocation(DVInsn));
456 updated = true;
Devang Patelc3f5f782010-05-25 23:40:22 +0000457 }
458 if (!updated) {
459 // If variableDie is not updated then DBG_VALUE instruction does not
460 // have valid variable info.
461 delete VariableDie;
462 return NULL;
463 }
464 DV->setDIE(VariableDie);
465 return VariableDie;
Devang Patelff9dd0a2011-08-15 21:24:36 +0000466 } else {
467 // .. else use frame index.
468 int FI = DV->getFrameIndex();
Devang Patelc890b192011-08-15 21:35:16 +0000469 if (FI != ~0) {
Devang Patelff9dd0a2011-08-15 21:24:36 +0000470 unsigned FrameReg = 0;
471 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
472 int Offset =
473 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
474 MachineLocation Location(FrameReg, Offset);
475 VariableCU->addVariableAddress(DV, VariableDie, Location);
476 }
Devang Patele1cdf842011-04-27 22:45:24 +0000477 }
478
Devang Patel53bb5c92009-11-10 23:06:00 +0000479 DV->setDIE(VariableDie);
480 return VariableDie;
481
482}
Devang Patel2c4ceb12009-11-21 02:48:08 +0000483
484/// constructScopeDIE - Construct a DIE for this scope.
Devang Patelbf47fdb2011-08-10 20:55:27 +0000485DIE *DwarfDebug::constructScopeDIE(LexicalScope *Scope) {
Devang Patel3c91b052010-03-08 20:52:55 +0000486 if (!Scope || !Scope->getScopeNode())
487 return NULL;
Jim Grosbach1e20b962010-07-21 21:21:52 +0000488
Devang Patel5bc9fec2011-02-19 01:31:27 +0000489 SmallVector <DIE *, 8> Children;
Devang Patel0478c152011-03-01 22:58:55 +0000490
491 // Collect arguments for current function.
Devang Patelbf47fdb2011-08-10 20:55:27 +0000492 if (LScopes.isCurrentFunctionScope(Scope))
Devang Patel0478c152011-03-01 22:58:55 +0000493 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
494 if (DbgVariable *ArgDV = CurrentFnArguments[i])
495 if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
496 Children.push_back(Arg);
497
Devang Patel5bc9fec2011-02-19 01:31:27 +0000498 // Collect lexical scope childrens first.
Devang Patelbf47fdb2011-08-10 20:55:27 +0000499 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
Devang Patel5bc9fec2011-02-19 01:31:27 +0000500 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
501 if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
502 Children.push_back(Variable);
Devang Patelbf47fdb2011-08-10 20:55:27 +0000503 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
Devang Patel5bc9fec2011-02-19 01:31:27 +0000504 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
505 if (DIE *Nested = constructScopeDIE(Scopes[j]))
506 Children.push_back(Nested);
Devang Patel3c91b052010-03-08 20:52:55 +0000507 DIScope DS(Scope->getScopeNode());
508 DIE *ScopeDIE = NULL;
509 if (Scope->getInlinedAt())
510 ScopeDIE = constructInlinedScopeDIE(Scope);
511 else if (DS.isSubprogram()) {
Devang Patel0dd45582010-06-28 20:53:04 +0000512 ProcessedSPNodes.insert(DS);
Devang Patel8aa61472010-07-07 22:20:57 +0000513 if (Scope->isAbstractScope()) {
Devang Patel163a9f72010-05-10 22:49:55 +0000514 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
Devang Patel8aa61472010-07-07 22:20:57 +0000515 // Note down abstract DIE.
516 if (ScopeDIE)
517 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
518 }
Devang Patel3c91b052010-03-08 20:52:55 +0000519 else
Devang Patel2db49d72010-05-07 18:11:54 +0000520 ScopeDIE = updateSubprogramScopeDIE(DS);
Devang Patel3c91b052010-03-08 20:52:55 +0000521 }
Devang Patel5bc9fec2011-02-19 01:31:27 +0000522 else {
523 // There is no need to emit empty lexical block DIE.
524 if (Children.empty())
525 return NULL;
Devang Patel3c91b052010-03-08 20:52:55 +0000526 ScopeDIE = constructLexicalScopeDIE(Scope);
Devang Patel5bc9fec2011-02-19 01:31:27 +0000527 }
528
Devang Patelaead63c2010-03-29 22:59:58 +0000529 if (!ScopeDIE) return NULL;
Jim Grosbach1e20b962010-07-21 21:21:52 +0000530
Devang Patel5bc9fec2011-02-19 01:31:27 +0000531 // Add children
532 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
533 E = Children.end(); I != E; ++I)
534 ScopeDIE->addChild(*I);
Devang Patel193f7202009-11-24 01:14:22 +0000535
Jim Grosbach1e20b962010-07-21 21:21:52 +0000536 if (DS.isSubprogram())
Devang Patel3cbee302011-04-12 22:53:02 +0000537 getCompileUnit(DS)->addPubTypes(DISubprogram(DS));
Jim Grosbach1e20b962010-07-21 21:21:52 +0000538
Devang Patel193f7202009-11-24 01:14:22 +0000539 return ScopeDIE;
Devang Patel53bb5c92009-11-10 23:06:00 +0000540}
541
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000542/// GetOrCreateSourceID - Look up the source id with the given directory and
543/// source file names. If none currently exists, create a new id and insert it
544/// in the SourceIds map. This can update DirectoryNames and SourceFileNames
545/// maps as well.
Devang Patel2f584852010-07-24 00:53:22 +0000546
Devang Patel23670e52011-03-24 20:30:50 +0000547unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
548 StringRef DirName) {
Devang Patel1905a182010-09-16 20:57:49 +0000549 // If FE did not provide a file name, then assume stdin.
550 if (FileName.empty())
Devang Patel23670e52011-03-24 20:30:50 +0000551 return GetOrCreateSourceID("<stdin>", StringRef());
552
553 // MCStream expects full path name as filename.
Benjamin Kramerab5f7882011-06-05 14:36:47 +0000554 if (!DirName.empty() && !sys::path::is_absolute(FileName)) {
555 SmallString<128> FullPathName = DirName;
556 sys::path::append(FullPathName, FileName);
Devang Patel23670e52011-03-24 20:30:50 +0000557 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
558 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
559 }
Devang Patel1905a182010-09-16 20:57:49 +0000560
Rafael Espindola5c055632010-11-18 02:04:25 +0000561 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
562 if (Entry.getValue())
563 return Entry.getValue();
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000564
Rafael Espindola5c055632010-11-18 02:04:25 +0000565 unsigned SrcId = SourceIdMap.size();
566 Entry.setValue(SrcId);
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000567
Rafael Espindola5c055632010-11-18 02:04:25 +0000568 // Print out a .file directive to specify files for .loc directives.
Devang Patel23670e52011-03-24 20:30:50 +0000569 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000570
571 return SrcId;
572}
573
Jim Grosbach1e20b962010-07-21 21:21:52 +0000574/// constructCompileUnit - Create new CompileUnit for the given
Devang Patel163a9f72010-05-10 22:49:55 +0000575/// metadata node with tag DW_TAG_compile_unit.
Devang Patele9f8f5e2010-05-07 20:54:48 +0000576void DwarfDebug::constructCompileUnit(const MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +0000577 DICompileUnit DIUnit(N);
Devang Patel65dbc902009-11-25 17:36:49 +0000578 StringRef FN = DIUnit.getFilename();
579 StringRef Dir = DIUnit.getDirectory();
Devang Patel23670e52011-03-24 20:30:50 +0000580 unsigned ID = GetOrCreateSourceID(FN, Dir);
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000581
582 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Devang Patel3cbee302011-04-12 22:53:02 +0000583 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
584 NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
585 DIUnit.getProducer());
586 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
587 DIUnit.getLanguage());
588 NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
Devang Patel5098da02010-04-26 22:54:28 +0000589 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
590 // simplifies debug range entries.
Devang Patel3cbee302011-04-12 22:53:02 +0000591 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
Devang Patel4a602ca2010-03-22 23:11:36 +0000592 // DW_AT_stmt_list is a offset of line number information for this
Devang Patelaf608bd2010-08-24 00:06:12 +0000593 // compile unit in debug_line section.
Rafael Espindoladc52ecf2011-05-10 20:35:05 +0000594 if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
Rafael Espindola597a7662011-05-04 17:44:06 +0000595 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
Devang Patel3cbee302011-04-12 22:53:02 +0000596 Asm->GetTempSymbol("section_line"));
Devang Patelae84d5b2010-08-31 23:50:19 +0000597 else
Devang Patel3cbee302011-04-12 22:53:02 +0000598 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000599
Devang Patel65dbc902009-11-25 17:36:49 +0000600 if (!Dir.empty())
Devang Patel3cbee302011-04-12 22:53:02 +0000601 NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000602 if (DIUnit.isOptimized())
Devang Patel3cbee302011-04-12 22:53:02 +0000603 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000604
Devang Patel65dbc902009-11-25 17:36:49 +0000605 StringRef Flags = DIUnit.getFlags();
606 if (!Flags.empty())
Devang Patel5bc942c2011-08-10 23:58:09 +0000607 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string,
608 Flags);
Devang Patel3cbee302011-04-12 22:53:02 +0000609
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000610 unsigned RVer = DIUnit.getRunTimeVersion();
611 if (RVer)
Devang Patel3cbee302011-04-12 22:53:02 +0000612 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000613 dwarf::DW_FORM_data1, RVer);
614
Devang Patel163a9f72010-05-10 22:49:55 +0000615 if (!FirstCU)
616 FirstCU = NewCU;
617 CUMap.insert(std::make_pair(N, NewCU));
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000618}
619
Nick Lewycky3bbb6f72011-07-29 03:49:23 +0000620/// getCompileUnit - Get CompileUnit DIE.
Devang Patel163a9f72010-05-10 22:49:55 +0000621CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
622 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
623 DIDescriptor D(N);
624 const MDNode *CUNode = NULL;
625 if (D.isCompileUnit())
626 CUNode = N;
627 else if (D.isSubprogram())
628 CUNode = DISubprogram(N).getCompileUnit();
629 else if (D.isType())
630 CUNode = DIType(N).getCompileUnit();
631 else if (D.isGlobalVariable())
632 CUNode = DIGlobalVariable(N).getCompileUnit();
633 else if (D.isVariable())
634 CUNode = DIVariable(N).getCompileUnit();
635 else if (D.isNameSpace())
636 CUNode = DINameSpace(N).getCompileUnit();
637 else if (D.isFile())
638 CUNode = DIFile(N).getCompileUnit();
639 else
640 return FirstCU;
641
642 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
643 = CUMap.find(CUNode);
644 if (I == CUMap.end())
645 return FirstCU;
646 return I->second;
647}
648
Devang Patel163a9f72010-05-10 22:49:55 +0000649/// constructGlobalVariableDIE - Construct global variable DIE.
Devang Patele9f8f5e2010-05-07 20:54:48 +0000650void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
Devang Patel9fa539c2010-08-10 01:37:23 +0000651 DIGlobalVariable GV(N);
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000652
Devang Patel905cf5e2009-09-04 23:59:07 +0000653 // If debug information is malformed then ignore it.
Devang Patel9fa539c2010-08-10 01:37:23 +0000654 if (GV.Verify() == false)
Devang Patel905cf5e2009-09-04 23:59:07 +0000655 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000656
657 // Check for pre-existence.
Devang Patel163a9f72010-05-10 22:49:55 +0000658 CompileUnit *TheCU = getCompileUnit(N);
Devang Patel6f9d8ff2011-08-15 17:57:41 +0000659 TheCU->createGlobalVariableDIE(N);
Devang Patel13e16b62009-06-26 01:49:18 +0000660 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000661}
662
Devang Patel163a9f72010-05-10 22:49:55 +0000663/// construct SubprogramDIE - Construct subprogram DIE.
Devang Patele9f8f5e2010-05-07 20:54:48 +0000664void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +0000665 DISubprogram SP(N);
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000666
Stuart Hastings639336e2010-04-06 21:38:29 +0000667 // Check for pre-existence.
Devang Patel163a9f72010-05-10 22:49:55 +0000668 CompileUnit *TheCU = getCompileUnit(N);
669 if (TheCU->getDIE(N))
Stuart Hastings639336e2010-04-06 21:38:29 +0000670 return;
671
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000672 if (!SP.isDefinition())
673 // This is a method declaration which will be handled while constructing
674 // class type.
Devang Patel13e16b62009-06-26 01:49:18 +0000675 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000676
Devang Pateldbc64af2011-08-15 17:24:54 +0000677 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
Stuart Hastings639336e2010-04-06 21:38:29 +0000678
679 // Add to map.
Devang Patel163a9f72010-05-10 22:49:55 +0000680 TheCU->insertDIE(N, SubprogramDie);
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000681
682 // Add to context owner.
Devang Patel3cbee302011-04-12 22:53:02 +0000683 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
Devang Patel0000fad2009-12-08 23:21:45 +0000684
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000685 // Expose as global.
Devang Patel163a9f72010-05-10 22:49:55 +0000686 TheCU->addGlobal(SP.getName(), SubprogramDie);
Devang Patel193f7202009-11-24 01:14:22 +0000687
Devang Patel13e16b62009-06-26 01:49:18 +0000688 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000689}
690
Devang Patel2c4ceb12009-11-21 02:48:08 +0000691/// beginModule - Emit all Dwarf sections that should come prior to the
Daniel Dunbar00564992009-09-19 20:40:14 +0000692/// content. Create global DIEs and emit initial debug info sections.
Nick Lewycky3bbb6f72011-07-29 03:49:23 +0000693/// This is invoked by the target AsmPrinter.
Chris Lattner75f50722010-04-04 07:48:20 +0000694void DwarfDebug::beginModule(Module *M) {
Devang Pateleac9c072010-04-27 19:46:33 +0000695 if (DisableDebugInfoPrinting)
696 return;
697
Nick Lewycky3bbb6f72011-07-29 03:49:23 +0000698 // If module has named metadata anchors then use them, otherwise scan the
699 // module using debug info finder to collect debug info.
Devang Patel30692ab2011-05-03 16:45:22 +0000700 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
701 if (CU_Nodes) {
Devang Patela938dd02011-05-04 16:34:02 +0000702
703 NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv");
704 NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp");
705 if (!GV_Nodes && !SP_Nodes)
706 // If there are not any global variables or any functions then
707 // there is not any debug info in this module.
Devang Patel30692ab2011-05-03 16:45:22 +0000708 return;
709
Devang Patela938dd02011-05-04 16:34:02 +0000710 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
711 constructCompileUnit(CU_Nodes->getOperand(i));
Devang Patel30692ab2011-05-03 16:45:22 +0000712
Devang Patela938dd02011-05-04 16:34:02 +0000713 if (GV_Nodes)
714 for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i)
715 constructGlobalVariableDIE(GV_Nodes->getOperand(i));
716
717 if (SP_Nodes)
718 for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i)
719 constructSubprogramDIE(SP_Nodes->getOperand(i));
Devang Patel30692ab2011-05-03 16:45:22 +0000720
721 } else {
722
723 DebugInfoFinder DbgFinder;
724 DbgFinder.processModule(*M);
725
Devang Patela938dd02011-05-04 16:34:02 +0000726 bool HasDebugInfo = false;
Nick Lewycky3bbb6f72011-07-29 03:49:23 +0000727 // Scan all the compile-units to see if there are any marked as the main
728 // unit. If not, we do not generate debug info.
Devang Patel30692ab2011-05-03 16:45:22 +0000729 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
730 E = DbgFinder.compile_unit_end(); I != E; ++I) {
731 if (DICompileUnit(*I).isMain()) {
732 HasDebugInfo = true;
733 break;
734 }
735 }
Devang Patela938dd02011-05-04 16:34:02 +0000736 if (!HasDebugInfo) return;
Devang Patel30692ab2011-05-03 16:45:22 +0000737
738 // Create all the compile unit DIEs.
739 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
740 E = DbgFinder.compile_unit_end(); I != E; ++I)
741 constructCompileUnit(*I);
742
743 // Create DIEs for each global variable.
744 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
745 E = DbgFinder.global_variable_end(); I != E; ++I)
746 constructGlobalVariableDIE(*I);
747
748 // Create DIEs for each subprogram.
749 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
750 E = DbgFinder.subprogram_end(); I != E; ++I)
751 constructSubprogramDIE(*I);
Chris Lattnerd850ac72010-04-05 02:19:28 +0000752 }
Devang Patel30692ab2011-05-03 16:45:22 +0000753
Chris Lattnerd850ac72010-04-05 02:19:28 +0000754 // Tell MMI that we have debug info.
755 MMI->setDebugInfoAvailability(true);
Devang Patel30692ab2011-05-03 16:45:22 +0000756
Chris Lattnerbe15beb2010-04-04 23:17:54 +0000757 // Emit initial sections.
Chris Lattnerd850ac72010-04-05 02:19:28 +0000758 EmitSectionLabels();
Jim Grosbach1e20b962010-07-21 21:21:52 +0000759
Devang Patele7e5a0f2010-08-10 20:01:20 +0000760 //getOrCreateTypeDIE
761 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
Devang Patel3cbee302011-04-12 22:53:02 +0000762 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
763 DIType Ty(NMD->getOperand(i));
764 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
765 }
Devang Patele7e5a0f2010-08-10 20:01:20 +0000766
Devang Patel1a7ca032010-09-28 18:08:20 +0000767 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
Devang Patel3cbee302011-04-12 22:53:02 +0000768 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
769 DIType Ty(NMD->getOperand(i));
770 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
771 }
Devang Patel1a7ca032010-09-28 18:08:20 +0000772
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000773 // Prime section data.
Chris Lattnerf0144122009-07-28 03:13:23 +0000774 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000775}
776
Devang Patel2c4ceb12009-11-21 02:48:08 +0000777/// endModule - Emit all Dwarf sections that should come after the content.
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000778///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000779void DwarfDebug::endModule() {
Devang Patel163a9f72010-05-10 22:49:55 +0000780 if (!FirstCU) return;
Devang Patel4a1cad62010-06-28 18:25:03 +0000781 const Module *M = MMI->getModule();
Devang Patelbf47fdb2011-08-10 20:55:27 +0000782 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
Devang Patel4a1cad62010-06-28 18:25:03 +0000783 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
784 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
785 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
786 DISubprogram SP(AllSPs->getOperand(SI));
787 if (!SP.Verify()) continue;
788
789 // Collect info for variables that were optimized out.
Devang Patel8b3a6b62010-07-19 17:53:55 +0000790 if (!SP.isDefinition()) continue;
Devang Patel4a1cad62010-06-28 18:25:03 +0000791 StringRef FName = SP.getLinkageName();
792 if (FName.empty())
793 FName = SP.getName();
Devang Patel62367042010-11-10 22:19:21 +0000794 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
Devang Patel4a1cad62010-06-28 18:25:03 +0000795 if (!NMD) continue;
796 unsigned E = NMD->getNumOperands();
797 if (!E) continue;
Devang Patel5bc942c2011-08-10 23:58:09 +0000798 LexicalScope *Scope = new LexicalScope(NULL, DIDescriptor(SP), NULL,
799 false);
Devang Patele9a1cca2010-08-02 17:32:15 +0000800 DeadFnScopeMap[SP] = Scope;
Benjamin Kramer0fa5e052011-08-11 18:39:28 +0000801 SmallVector<DbgVariable, 8> Variables;
Devang Patel4a1cad62010-06-28 18:25:03 +0000802 for (unsigned I = 0; I != E; ++I) {
803 DIVariable DV(NMD->getOperand(I));
804 if (!DV.Verify()) continue;
Devang Patel5a1a67c2011-08-15 19:01:20 +0000805 Variables.push_back(DbgVariable(DV, NULL));
Devang Patel4a1cad62010-06-28 18:25:03 +0000806 }
Jim Grosbach1e20b962010-07-21 21:21:52 +0000807
Devang Patel4a1cad62010-06-28 18:25:03 +0000808 // Construct subprogram DIE and add variables DIEs.
809 constructSubprogramDIE(SP);
810 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
Devang Patel4a1cad62010-06-28 18:25:03 +0000811 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
Benjamin Kramer0fa5e052011-08-11 18:39:28 +0000812 if (DIE *VariableDIE = constructVariableDIE(&Variables[i], Scope))
Devang Patel4a1cad62010-06-28 18:25:03 +0000813 ScopeDIE->addChild(VariableDIE);
814 }
815 }
816 }
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000817
Devang Patel53bb5c92009-11-10 23:06:00 +0000818 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
819 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
820 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
821 DIE *ISP = *AI;
Devang Patel3cbee302011-04-12 22:53:02 +0000822 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
Devang Patel53bb5c92009-11-10 23:06:00 +0000823 }
824
Devang Pateldbc64af2011-08-15 17:24:54 +0000825 // Emit DW_AT_containing_type attribute to connect types with their
826 // vtable holding type.
827 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
828 CUE = CUMap.end(); CUI != CUE; ++CUI) {
829 CompileUnit *TheCU = CUI->second;
830 TheCU->constructContainingTypeDIEs();
Devang Patel5d11eb02009-12-03 19:11:07 +0000831 }
832
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000833 // Standard sections final addresses.
Chris Lattner6c2f9e12009-08-19 05:49:37 +0000834 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
Chris Lattnerc0215722010-04-04 19:25:43 +0000835 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
Chris Lattner6c2f9e12009-08-19 05:49:37 +0000836 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
Chris Lattnerc0215722010-04-04 19:25:43 +0000837 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000838
839 // End text sections.
840 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
Chris Lattner6c2f9e12009-08-19 05:49:37 +0000841 Asm->OutStreamer.SwitchSection(SectionMap[i]);
Chris Lattnerc0215722010-04-04 19:25:43 +0000842 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000843 }
844
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000845 // Compute DIE offsets and sizes.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000846 computeSizeAndOffsets();
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000847
848 // Emit all the DIEs into a debug info section
Devang Patel2c4ceb12009-11-21 02:48:08 +0000849 emitDebugInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000850
851 // Corresponding abbreviations into a abbrev section.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000852 emitAbbreviations();
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000853
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000854 // Emit info into a debug pubnames section.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000855 emitDebugPubNames();
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000856
Devang Patel193f7202009-11-24 01:14:22 +0000857 // Emit info into a debug pubtypes section.
858 emitDebugPubTypes();
859
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000860 // Emit info into a debug loc section.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000861 emitDebugLoc();
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000862
863 // Emit info into a debug aranges section.
864 EmitDebugARanges();
865
866 // Emit info into a debug ranges section.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000867 emitDebugRanges();
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000868
869 // Emit info into a debug macinfo section.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000870 emitDebugMacInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000871
872 // Emit inline info.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000873 emitDebugInlineInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000874
Chris Lattnerbc733f52010-03-13 02:17:42 +0000875 // Emit info into a debug str section.
876 emitDebugStr();
Jim Grosbach1e20b962010-07-21 21:21:52 +0000877
Devang Patele9a1cca2010-08-02 17:32:15 +0000878 // clean up.
879 DeleteContainerSeconds(DeadFnScopeMap);
Devang Patel163a9f72010-05-10 22:49:55 +0000880 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
881 E = CUMap.end(); I != E; ++I)
882 delete I->second;
883 FirstCU = NULL; // Reset for the next Module, if any.
Bill Wendlingf0fb9872009-05-20 23:19:06 +0000884}
885
Devang Patel53bb5c92009-11-10 23:06:00 +0000886/// findAbstractVariable - Find abstract variable, if any, associated with Var.
Devang Patelb549bcf2011-08-10 21:50:54 +0000887DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
Chris Lattnerde4845c2010-04-02 19:42:39 +0000888 DebugLoc ScopeLoc) {
Devang Patelb549bcf2011-08-10 21:50:54 +0000889 LLVMContext &Ctx = DV->getContext();
890 // More then one inlined variable corresponds to one abstract variable.
891 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
Devang Patel2db49d72010-05-07 18:11:54 +0000892 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
Devang Patel53bb5c92009-11-10 23:06:00 +0000893 if (AbsDbgVariable)
894 return AbsDbgVariable;
895
Devang Patelbf47fdb2011-08-10 20:55:27 +0000896 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
Devang Patel53bb5c92009-11-10 23:06:00 +0000897 if (!Scope)
898 return NULL;
899
Devang Patel5a1a67c2011-08-15 19:01:20 +0000900 AbsDbgVariable = new DbgVariable(Var, NULL);
Devang Patelbf47fdb2011-08-10 20:55:27 +0000901 addScopeVariable(Scope, AbsDbgVariable);
Devang Patel2db49d72010-05-07 18:11:54 +0000902 AbstractVariables[Var] = AbsDbgVariable;
Devang Patel53bb5c92009-11-10 23:06:00 +0000903 return AbsDbgVariable;
904}
905
Nick Lewycky3bbb6f72011-07-29 03:49:23 +0000906/// addCurrentFnArgument - If Var is a current function argument then add
907/// it to CurrentFnArguments list.
Devang Patel0478c152011-03-01 22:58:55 +0000908bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
Devang Patelbf47fdb2011-08-10 20:55:27 +0000909 DbgVariable *Var, LexicalScope *Scope) {
910 if (!LScopes.isCurrentFunctionScope(Scope))
Devang Patel0478c152011-03-01 22:58:55 +0000911 return false;
912 DIVariable DV = Var->getVariable();
913 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
914 return false;
915 unsigned ArgNo = DV.getArgNumber();
916 if (ArgNo == 0)
917 return false;
918
Devang Patelcb3a6572011-03-03 20:02:02 +0000919 size_t Size = CurrentFnArguments.size();
920 if (Size == 0)
Devang Patel0478c152011-03-01 22:58:55 +0000921 CurrentFnArguments.resize(MF->getFunction()->arg_size());
Devang Patelbbd0f452011-03-03 21:49:41 +0000922 // llvm::Function argument size is not good indicator of how many
Devang Patel6f676be2011-03-03 20:08:10 +0000923 // arguments does the function have at source level.
924 if (ArgNo > Size)
Devang Patelcb3a6572011-03-03 20:02:02 +0000925 CurrentFnArguments.resize(ArgNo * 2);
Devang Patel0478c152011-03-01 22:58:55 +0000926 CurrentFnArguments[ArgNo - 1] = Var;
927 return true;
928}
929
Devang Patelee432862010-05-20 19:57:06 +0000930/// collectVariableInfoFromMMITable - Collect variable information from
931/// side table maintained by MMI.
Jim Grosbach1e20b962010-07-21 21:21:52 +0000932void
Nick Lewycky3bbb6f72011-07-29 03:49:23 +0000933DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
Devang Patelee432862010-05-20 19:57:06 +0000934 SmallPtrSet<const MDNode *, 16> &Processed) {
Devang Patele717faa2009-10-06 01:26:37 +0000935 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
936 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
937 VE = VMap.end(); VI != VE; ++VI) {
Devang Patele9f8f5e2010-05-07 20:54:48 +0000938 const MDNode *Var = VI->first;
Devang Patel53bb5c92009-11-10 23:06:00 +0000939 if (!Var) continue;
Devang Patel98e1cac2010-05-14 21:01:35 +0000940 Processed.insert(Var);
Chris Lattnerde4845c2010-04-02 19:42:39 +0000941 DIVariable DV(Var);
942 const std::pair<unsigned, DebugLoc> &VP = VI->second;
Devang Patel53bb5c92009-11-10 23:06:00 +0000943
Devang Patelbf47fdb2011-08-10 20:55:27 +0000944 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
Jim Grosbach1e20b962010-07-21 21:21:52 +0000945
Devang Patelfb0ee432009-11-10 23:20:04 +0000946 // If variable scope is not found then skip this variable.
Chris Lattnerde4845c2010-04-02 19:42:39 +0000947 if (Scope == 0)
Devang Patelfb0ee432009-11-10 23:20:04 +0000948 continue;
Devang Patel53bb5c92009-11-10 23:06:00 +0000949
Devang Patel26c1e562010-05-20 16:36:41 +0000950 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
Devang Patel5a1a67c2011-08-15 19:01:20 +0000951 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
Devang Patelff9dd0a2011-08-15 21:24:36 +0000952 RegVar->setFrameIndex(VP.first);
Devang Patel0478c152011-03-01 22:58:55 +0000953 if (!addCurrentFnArgument(MF, RegVar, Scope))
Devang Patelbf47fdb2011-08-10 20:55:27 +0000954 addScopeVariable(Scope, RegVar);
Devang Patel5a1a67c2011-08-15 19:01:20 +0000955 if (AbsDbgVariable)
Devang Patelff9dd0a2011-08-15 21:24:36 +0000956 AbsDbgVariable->setFrameIndex(VP.first);
Devang Patele717faa2009-10-06 01:26:37 +0000957 }
Devang Patelee432862010-05-20 19:57:06 +0000958}
Devang Patel90a48ad2010-03-15 18:33:46 +0000959
Jim Grosbach1e20b962010-07-21 21:21:52 +0000960/// isDbgValueInDefinedReg - Return true if debug value, encoded by
Devang Patelc3f5f782010-05-25 23:40:22 +0000961/// DBG_VALUE instruction, is in a defined reg.
962static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
963 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +0000964 return MI->getNumOperands() == 3 &&
965 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
966 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
Devang Patelc3f5f782010-05-25 23:40:22 +0000967}
968
Nick Lewycky3bbb6f72011-07-29 03:49:23 +0000969/// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
Devang Patel90b40412011-07-08 17:09:57 +0000970/// at MI.
971static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
972 const MCSymbol *FLabel,
973 const MCSymbol *SLabel,
974 const MachineInstr *MI) {
975 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
976
977 if (MI->getNumOperands() != 3) {
978 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
979 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
980 }
981 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
982 MachineLocation MLoc;
983 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
984 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
985 }
986 if (MI->getOperand(0).isImm())
987 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
988 if (MI->getOperand(0).isFPImm())
989 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
990 if (MI->getOperand(0).isCImm())
991 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
992
993 assert (0 && "Unexpected 3 operand DBG_VALUE instruction!");
994 return DotDebugLocEntry();
995}
996
Devang Patelbf47fdb2011-08-10 20:55:27 +0000997/// collectVariableInfo - Find variables for each lexical scope.
Jim Grosbach1e20b962010-07-21 21:21:52 +0000998void
Devang Patel78e127d2010-06-25 22:07:34 +0000999DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1000 SmallPtrSet<const MDNode *, 16> &Processed) {
Jim Grosbach1e20b962010-07-21 21:21:52 +00001001
Devang Patelee432862010-05-20 19:57:06 +00001002 /// collection info from MMI table.
1003 collectVariableInfoFromMMITable(MF, Processed);
1004
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001005 for (SmallVectorImpl<const MDNode*>::const_iterator
1006 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1007 ++UVI) {
1008 const MDNode *Var = *UVI;
1009 if (Processed.count(Var))
Devang Patelee432862010-05-20 19:57:06 +00001010 continue;
1011
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001012 // History contains relevant DBG_VALUE instructions for Var and instructions
1013 // clobbering it.
1014 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1015 if (History.empty())
1016 continue;
1017 const MachineInstr *MInsn = History.front();
Devang Patelc3f5f782010-05-25 23:40:22 +00001018
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001019 DIVariable DV(Var);
Devang Patelbf47fdb2011-08-10 20:55:27 +00001020 LexicalScope *Scope = NULL;
Devang Pateld8720f42010-05-27 20:25:04 +00001021 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1022 DISubprogram(DV.getContext()).describes(MF->getFunction()))
Devang Patelbf47fdb2011-08-10 20:55:27 +00001023 Scope = LScopes.getCurrentFunctionScope();
Devang Patel40c7e412011-07-20 22:18:50 +00001024 else {
1025 if (DV.getVersion() <= LLVMDebugVersion9)
Devang Patelbf47fdb2011-08-10 20:55:27 +00001026 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
Devang Patel40c7e412011-07-20 22:18:50 +00001027 else {
1028 if (MDNode *IA = DV.getInlinedAt())
Devang Patelbf47fdb2011-08-10 20:55:27 +00001029 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
Devang Patel40c7e412011-07-20 22:18:50 +00001030 else
Devang Patelbf47fdb2011-08-10 20:55:27 +00001031 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
Devang Patel40c7e412011-07-20 22:18:50 +00001032 }
1033 }
Devang Patelee432862010-05-20 19:57:06 +00001034 // If variable scope is not found then skip this variable.
Devang Patelc0c5a262010-05-21 00:10:20 +00001035 if (!Scope)
Devang Patelee432862010-05-20 19:57:06 +00001036 continue;
1037
1038 Processed.insert(DV);
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001039 assert(MInsn->isDebugValue() && "History must begin with debug value");
Devang Patel5a1a67c2011-08-15 19:01:20 +00001040 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1041 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
Devang Patel0478c152011-03-01 22:58:55 +00001042 if (!addCurrentFnArgument(MF, RegVar, Scope))
Devang Patelbf47fdb2011-08-10 20:55:27 +00001043 addScopeVariable(Scope, RegVar);
Devang Patel5a1a67c2011-08-15 19:01:20 +00001044 if (AbsVar)
Devang Patelff9dd0a2011-08-15 21:24:36 +00001045 AbsVar->setMInsn(MInsn);
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001046
1047 // Simple ranges that are fully coalesced.
1048 if (History.size() <= 1 || (History.size() == 2 &&
1049 MInsn->isIdenticalTo(History.back()))) {
Devang Patelff9dd0a2011-08-15 21:24:36 +00001050 RegVar->setMInsn(MInsn);
Devang Patelc3f5f782010-05-25 23:40:22 +00001051 continue;
1052 }
1053
1054 // handle multiple DBG_VALUE instructions describing one variable.
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001055 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001056
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001057 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1058 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1059 const MachineInstr *Begin = *HI;
1060 assert(Begin->isDebugValue() && "Invalid History entry");
Jakob Stoklund Olesene17232e2011-03-22 00:21:41 +00001061
Devang Patel4ada1d72011-06-01 23:00:17 +00001062 // Check if DBG_VALUE is truncating a range.
1063 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1064 && !Begin->getOperand(0).getReg())
1065 continue;
1066
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001067 // Compute the range for a register location.
1068 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1069 const MCSymbol *SLabel = 0;
1070
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001071 if (HI + 1 == HE)
1072 // If Begin is the last instruction in History then its value is valid
Chris Lattner7a2bdde2011-04-15 05:18:47 +00001073 // until the end of the function.
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001074 SLabel = FunctionEndSym;
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001075 else {
1076 const MachineInstr *End = HI[1];
Devang Patel476df5f2011-07-07 21:44:42 +00001077 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1078 << "\t" << *Begin << "\t" << *End << "\n");
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001079 if (End->isDebugValue())
1080 SLabel = getLabelBeforeInsn(End);
1081 else {
1082 // End is a normal instruction clobbering the range.
1083 SLabel = getLabelAfterInsn(End);
1084 assert(SLabel && "Forgot label after clobber instruction");
1085 ++HI;
1086 }
1087 }
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001088
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001089 // The value is valid until the next DBG_VALUE or clobber.
Devang Patel90b40412011-07-08 17:09:57 +00001090 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
Devang Patelc3f5f782010-05-25 23:40:22 +00001091 }
1092 DotDebugLocEntries.push_back(DotDebugLocEntry());
Devang Patel90a48ad2010-03-15 18:33:46 +00001093 }
Devang Patel98e1cac2010-05-14 21:01:35 +00001094
1095 // Collect info for variables that were optimized out.
Devang Pateld1bbc6b2010-06-22 01:01:58 +00001096 const Function *F = MF->getFunction();
Devang Patel62367042010-11-10 22:19:21 +00001097 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
Devang Patel98e1cac2010-05-14 21:01:35 +00001098 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
Dan Gohman872814a2010-07-21 18:54:18 +00001099 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
Devang Patelee432862010-05-20 19:57:06 +00001100 if (!DV || !Processed.insert(DV))
Devang Patel98e1cac2010-05-14 21:01:35 +00001101 continue;
Devang Patelbf47fdb2011-08-10 20:55:27 +00001102 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
Devang Patel5a1a67c2011-08-15 19:01:20 +00001103 addScopeVariable(Scope, new DbgVariable(DV, NULL));
Devang Patel98e1cac2010-05-14 21:01:35 +00001104 }
1105 }
Devang Patelc3f5f782010-05-25 23:40:22 +00001106}
Devang Patel98e1cac2010-05-14 21:01:35 +00001107
Devang Patelc3f5f782010-05-25 23:40:22 +00001108/// getLabelBeforeInsn - Return Label preceding the instruction.
1109const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001110 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1111 assert(Label && "Didn't insert label before instruction");
1112 return Label;
Devang Patelc3f5f782010-05-25 23:40:22 +00001113}
1114
1115/// getLabelAfterInsn - Return Label immediately following the instruction.
1116const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001117 return LabelsAfterInsn.lookup(MI);
Devang Patele717faa2009-10-06 01:26:37 +00001118}
1119
Devang Patelcbbe2872010-10-26 17:49:02 +00001120/// beginInstruction - Process beginning of an instruction.
1121void DwarfDebug::beginInstruction(const MachineInstr *MI) {
Jakob Stoklund Olesen15a3ea02011-03-25 17:20:59 +00001122 // Check if source location changes, but ignore DBG_VALUE locations.
1123 if (!MI->isDebugValue()) {
1124 DebugLoc DL = MI->getDebugLoc();
1125 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
Devang Patel4243e672011-05-11 19:22:19 +00001126 unsigned Flags = DWARF2_FLAG_IS_STMT;
Jakob Stoklund Olesen15a3ea02011-03-25 17:20:59 +00001127 PrevInstLoc = DL;
Devang Patel4243e672011-05-11 19:22:19 +00001128 if (DL == PrologEndLoc) {
1129 Flags |= DWARF2_FLAG_PROLOGUE_END;
1130 PrologEndLoc = DebugLoc();
1131 }
Jakob Stoklund Olesen15a3ea02011-03-25 17:20:59 +00001132 if (!DL.isUnknown()) {
1133 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
Devang Patel4243e672011-05-11 19:22:19 +00001134 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
Jakob Stoklund Olesen15a3ea02011-03-25 17:20:59 +00001135 } else
Devang Patel4243e672011-05-11 19:22:19 +00001136 recordSourceLine(0, 0, 0, 0);
Jakob Stoklund Olesen15a3ea02011-03-25 17:20:59 +00001137 }
Devang Patelc3f5f782010-05-25 23:40:22 +00001138 }
Devang Patelaead63c2010-03-29 22:59:58 +00001139
Jakob Stoklund Olesen15a3ea02011-03-25 17:20:59 +00001140 // Insert labels where requested.
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001141 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1142 LabelsBeforeInsn.find(MI);
1143
1144 // No label needed.
1145 if (I == LabelsBeforeInsn.end())
1146 return;
1147
1148 // Label already assigned.
1149 if (I->second)
Devang Patelb2b31a62010-05-26 19:37:24 +00001150 return;
Devang Patel553881b2010-03-29 17:20:31 +00001151
Jakob Stoklund Olesen15a3ea02011-03-25 17:20:59 +00001152 if (!PrevLabel) {
Devang Patel77051f52010-05-26 21:23:46 +00001153 PrevLabel = MMI->getContext().CreateTempSymbol();
1154 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patelb2b31a62010-05-26 19:37:24 +00001155 }
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001156 I->second = PrevLabel;
Devang Patel0d20ac82009-10-06 01:50:42 +00001157}
1158
Devang Patelcbbe2872010-10-26 17:49:02 +00001159/// endInstruction - Process end of an instruction.
1160void DwarfDebug::endInstruction(const MachineInstr *MI) {
Jakob Stoklund Olesen15a3ea02011-03-25 17:20:59 +00001161 // Don't create a new label after DBG_VALUE instructions.
1162 // They don't generate code.
1163 if (!MI->isDebugValue())
1164 PrevLabel = 0;
1165
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001166 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1167 LabelsAfterInsn.find(MI);
1168
1169 // No label needed.
1170 if (I == LabelsAfterInsn.end())
1171 return;
1172
1173 // Label already assigned.
1174 if (I->second)
Jakob Stoklund Olesen15a3ea02011-03-25 17:20:59 +00001175 return;
1176
1177 // We need a label after this instruction.
1178 if (!PrevLabel) {
1179 PrevLabel = MMI->getContext().CreateTempSymbol();
1180 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel1c246352010-04-08 16:50:29 +00001181 }
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001182 I->second = PrevLabel;
Devang Patel53bb5c92009-11-10 23:06:00 +00001183}
1184
Jim Grosbach1e20b962010-07-21 21:21:52 +00001185/// identifyScopeMarkers() -
Devang Patel5bc942c2011-08-10 23:58:09 +00001186/// Each LexicalScope has first instruction and last instruction to mark
1187/// beginning and end of a scope respectively. Create an inverse map that list
1188/// scopes starts (and ends) with an instruction. One instruction may start (or
1189/// end) multiple scopes. Ignore scopes that are not reachable.
Devang Patele37b0c62010-04-08 18:43:56 +00001190void DwarfDebug::identifyScopeMarkers() {
Devang Patelbf47fdb2011-08-10 20:55:27 +00001191 SmallVector<LexicalScope *, 4> WorkList;
1192 WorkList.push_back(LScopes.getCurrentFunctionScope());
Devang Patel42aafd72010-01-20 02:05:23 +00001193 while (!WorkList.empty()) {
Devang Patelbf47fdb2011-08-10 20:55:27 +00001194 LexicalScope *S = WorkList.pop_back_val();
Jim Grosbach1e20b962010-07-21 21:21:52 +00001195
Devang Patelbf47fdb2011-08-10 20:55:27 +00001196 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
Jim Grosbach1e20b962010-07-21 21:21:52 +00001197 if (!Children.empty())
Devang Patelbf47fdb2011-08-10 20:55:27 +00001198 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
Devang Patel42aafd72010-01-20 02:05:23 +00001199 SE = Children.end(); SI != SE; ++SI)
1200 WorkList.push_back(*SI);
1201
Devang Patel53bb5c92009-11-10 23:06:00 +00001202 if (S->isAbstractScope())
1203 continue;
Jim Grosbach1e20b962010-07-21 21:21:52 +00001204
Devang Patelbf47fdb2011-08-10 20:55:27 +00001205 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
Devang Pateleac9c072010-04-27 19:46:33 +00001206 if (Ranges.empty())
1207 continue;
Devang Patelbf47fdb2011-08-10 20:55:27 +00001208 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
Devang Pateleac9c072010-04-27 19:46:33 +00001209 RE = Ranges.end(); RI != RE; ++RI) {
Devang Patelbf47fdb2011-08-10 20:55:27 +00001210 assert(RI->first && "InsnRange does not have first instruction!");
1211 assert(RI->second && "InsnRange does not have second instruction!");
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001212 requestLabelBeforeInsn(RI->first);
1213 requestLabelAfterInsn(RI->second);
Devang Pateleac9c072010-04-27 19:46:33 +00001214 }
Devang Patelaf9e8472009-10-01 20:31:14 +00001215 }
Devang Patelaf9e8472009-10-01 20:31:14 +00001216}
1217
Devang Patela3f48672011-05-09 22:14:49 +00001218/// getScopeNode - Get MDNode for DebugLoc's scope.
1219static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1220 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1221 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1222 return DL.getScope(Ctx);
1223}
1224
Devang Patel4243e672011-05-11 19:22:19 +00001225/// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1226/// line number info for the function.
1227static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1228 const MDNode *Scope = getScopeNode(DL, Ctx);
1229 DISubprogram SP = getDISubprogram(Scope);
1230 if (SP.Verify())
1231 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1232 return DebugLoc();
1233}
1234
Devang Patel2c4ceb12009-11-21 02:48:08 +00001235/// beginFunction - Gather pre-function debug information. Assumes being
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001236/// emitted immediately after the function entry point.
Chris Lattnereec791a2010-01-26 23:18:02 +00001237void DwarfDebug::beginFunction(const MachineFunction *MF) {
Chris Lattner994cb122010-04-05 03:52:55 +00001238 if (!MMI->hasDebugInfo()) return;
Devang Patelbf47fdb2011-08-10 20:55:27 +00001239 LScopes.initialize(*MF);
1240 if (LScopes.empty()) return;
1241 identifyScopeMarkers();
Devang Patel60b35bd2009-10-06 18:37:31 +00001242
Devang Pateleac9c072010-04-27 19:46:33 +00001243 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1244 Asm->getFunctionNumber());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001245 // Assumes in correct section after the entry point.
Devang Pateleac9c072010-04-27 19:46:33 +00001246 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001247
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001248 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1249
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001250 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001251 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1252 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1253
Devang Patelb2b31a62010-05-26 19:37:24 +00001254 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001255 I != E; ++I) {
1256 bool AtBlockEntry = true;
Devang Patelb2b31a62010-05-26 19:37:24 +00001257 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1258 II != IE; ++II) {
1259 const MachineInstr *MI = II;
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001260
Devang Patelb2b31a62010-05-26 19:37:24 +00001261 if (MI->isDebugValue()) {
Devang Patelb2b31a62010-05-26 19:37:24 +00001262 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001263
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001264 // Keep track of user variables.
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001265 const MDNode *Var =
1266 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001267
1268 // Variable is in a register, we need to check for clobbers.
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001269 if (isDbgValueInDefinedReg(MI))
1270 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1271
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001272 // Check the history of this variable.
1273 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1274 if (History.empty()) {
1275 UserVariables.push_back(Var);
1276 // The first mention of a function argument gets the FunctionBeginSym
1277 // label, so arguments are visible when breaking at function entry.
1278 DIVariable DV(Var);
1279 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1280 DISubprogram(getDISubprogram(DV.getContext()))
1281 .describes(MF->getFunction()))
1282 LabelsBeforeInsn[MI] = FunctionBeginSym;
1283 } else {
1284 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1285 const MachineInstr *Prev = History.back();
1286 if (Prev->isDebugValue()) {
1287 // Coalesce identical entries at the end of History.
1288 if (History.size() >= 2 &&
Devang Patel79862892011-07-07 00:14:27 +00001289 Prev->isIdenticalTo(History[History.size() - 2])) {
1290 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1291 << "\t" << *Prev
1292 << "\t" << *History[History.size() - 2] << "\n");
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001293 History.pop_back();
Devang Patel79862892011-07-07 00:14:27 +00001294 }
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001295
1296 // Terminate old register assignments that don't reach MI;
1297 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1298 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1299 isDbgValueInDefinedReg(Prev)) {
1300 // Previous register assignment needs to terminate at the end of
1301 // its basic block.
1302 MachineBasicBlock::const_iterator LastMI =
1303 PrevMBB->getLastNonDebugInstr();
Devang Patel79862892011-07-07 00:14:27 +00001304 if (LastMI == PrevMBB->end()) {
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001305 // Drop DBG_VALUE for empty range.
Devang Patel79862892011-07-07 00:14:27 +00001306 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1307 << "\t" << *Prev << "\n");
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001308 History.pop_back();
Devang Patel79862892011-07-07 00:14:27 +00001309 }
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001310 else {
1311 // Terminate after LastMI.
1312 History.push_back(LastMI);
1313 }
1314 }
1315 }
1316 }
1317 History.push_back(MI);
Devang Patelb2b31a62010-05-26 19:37:24 +00001318 } else {
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001319 // Not a DBG_VALUE instruction.
1320 if (!MI->isLabel())
1321 AtBlockEntry = false;
1322
Devang Patel4243e672011-05-11 19:22:19 +00001323 // First known non DBG_VALUE location marks beginning of function
1324 // body.
1325 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1326 PrologEndLoc = MI->getDebugLoc();
1327
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001328 // Check if the instruction clobbers any registers with debug vars.
1329 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1330 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1331 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1332 continue;
1333 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1334 unsigned Reg = *AI; ++AI) {
1335 const MDNode *Var = LiveUserVar[Reg];
1336 if (!Var)
1337 continue;
1338 // Reg is now clobbered.
1339 LiveUserVar[Reg] = 0;
1340
1341 // Was MD last defined by a DBG_VALUE referring to Reg?
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001342 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1343 if (HistI == DbgValues.end())
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001344 continue;
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001345 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1346 if (History.empty())
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001347 continue;
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001348 const MachineInstr *Prev = History.back();
1349 // Sanity-check: Register assignments are terminated at the end of
1350 // their block.
1351 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1352 continue;
1353 // Is the variable still in Reg?
1354 if (!isDbgValueInDefinedReg(Prev) ||
1355 Prev->getOperand(0).getReg() != Reg)
1356 continue;
1357 // Var is clobbered. Make sure the next instruction gets a label.
1358 History.push_back(MI);
Jakob Stoklund Olesen28cf1152011-03-22 22:33:08 +00001359 }
1360 }
Devang Patelb2b31a62010-05-26 19:37:24 +00001361 }
Devang Patelb2b31a62010-05-26 19:37:24 +00001362 }
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001363 }
1364
1365 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1366 I != E; ++I) {
1367 SmallVectorImpl<const MachineInstr*> &History = I->second;
1368 if (History.empty())
1369 continue;
1370
1371 // Make sure the final register assignments are terminated.
1372 const MachineInstr *Prev = History.back();
1373 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1374 const MachineBasicBlock *PrevMBB = Prev->getParent();
Devang Patel5bc942c2011-08-10 23:58:09 +00001375 MachineBasicBlock::const_iterator LastMI =
1376 PrevMBB->getLastNonDebugInstr();
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001377 if (LastMI == PrevMBB->end())
1378 // Drop DBG_VALUE for empty range.
1379 History.pop_back();
1380 else {
1381 // Terminate after LastMI.
1382 History.push_back(LastMI);
1383 }
1384 }
1385 // Request labels for the full history.
1386 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1387 const MachineInstr *MI = History[i];
1388 if (MI->isDebugValue())
1389 requestLabelBeforeInsn(MI);
1390 else
1391 requestLabelAfterInsn(MI);
1392 }
1393 }
Devang Patelb2b31a62010-05-26 19:37:24 +00001394
Jakob Stoklund Olesen15a3ea02011-03-25 17:20:59 +00001395 PrevInstLoc = DebugLoc();
Devang Patelb2b31a62010-05-26 19:37:24 +00001396 PrevLabel = FunctionBeginSym;
Devang Patel4243e672011-05-11 19:22:19 +00001397
1398 // Record beginning of function.
1399 if (!PrologEndLoc.isUnknown()) {
1400 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1401 MF->getFunction()->getContext());
1402 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1403 FnStartDL.getScope(MF->getFunction()->getContext()),
1404 DWARF2_FLAG_IS_STMT);
1405 }
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001406}
1407
Devang Patelbf47fdb2011-08-10 20:55:27 +00001408void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1409// SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1410 ScopeVariables[LS].push_back(Var);
1411// Vars.push_back(Var);
1412}
1413
Devang Patel2c4ceb12009-11-21 02:48:08 +00001414/// endFunction - Gather and emit post-function debug information.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001415///
Chris Lattnereec791a2010-01-26 23:18:02 +00001416void DwarfDebug::endFunction(const MachineFunction *MF) {
Devang Patelbf47fdb2011-08-10 20:55:27 +00001417 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
Devang Patel70d75ca2009-11-12 19:02:56 +00001418
Devang Patelbf47fdb2011-08-10 20:55:27 +00001419 // Define end label for subprogram.
1420 FunctionEndSym = Asm->GetTempSymbol("func_end",
1421 Asm->getFunctionNumber());
1422 // Assumes in correct section after the entry point.
1423 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1424
1425 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1426 collectVariableInfo(MF, ProcessedVars);
1427
1428 // Construct abstract scopes.
Devang Patelcd9f6c52011-08-12 18:10:19 +00001429 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1430 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1431 LexicalScope *AScope = AList[i];
1432 DISubprogram SP(AScope->getScopeNode());
Devang Patelbf47fdb2011-08-10 20:55:27 +00001433 if (SP.Verify()) {
1434 // Collect info for variables that were optimized out.
1435 StringRef FName = SP.getLinkageName();
1436 if (FName.empty())
1437 FName = SP.getName();
1438 if (NamedMDNode *NMD =
1439 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
1440 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
Dan Gohman872814a2010-07-21 18:54:18 +00001441 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
Devang Patel78e127d2010-06-25 22:07:34 +00001442 if (!DV || !ProcessedVars.insert(DV))
1443 continue;
Devang Patelbf47fdb2011-08-10 20:55:27 +00001444 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
Devang Patel5a1a67c2011-08-15 19:01:20 +00001445 addScopeVariable(Scope, new DbgVariable(DV, NULL));
Devang Patel78e127d2010-06-25 22:07:34 +00001446 }
1447 }
1448 }
Devang Patelcd9f6c52011-08-12 18:10:19 +00001449 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1450 constructScopeDIE(AScope);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001451 }
Devang Patelbf47fdb2011-08-10 20:55:27 +00001452
1453 DIE *CurFnDIE = constructScopeDIE(LScopes.getCurrentFunctionScope());
1454
1455 if (!DisableFramePointerElim(*MF)) {
1456 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
Devang Patel5bc942c2011-08-10 23:58:09 +00001457 CompileUnit *TheCU = getCompileUnit(FnScope->getScopeNode());
1458 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1459 dwarf::DW_FORM_flag, 1);
Devang Patelbf47fdb2011-08-10 20:55:27 +00001460 }
1461 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1462 MMI->getFrameMoves()));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001463
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001464 // Clear debug info
Devang Patelbf47fdb2011-08-10 20:55:27 +00001465 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1466 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1467 DeleteContainerPointers(I->second);
1468 ScopeVariables.clear();
Devang Pateleac0c9d2011-04-22 18:09:57 +00001469 DeleteContainerPointers(CurrentFnArguments);
Jakob Stoklund Olesenadb877d2011-03-26 02:19:36 +00001470 UserVariables.clear();
1471 DbgValues.clear();
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00001472 AbstractVariables.clear();
Devang Pateleac9c072010-04-27 19:46:33 +00001473 LabelsBeforeInsn.clear();
1474 LabelsAfterInsn.clear();
Devang Patelf2548ca2010-04-16 23:33:45 +00001475 PrevLabel = NULL;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001476}
1477
Chris Lattnerc6087842010-03-09 04:54:43 +00001478/// recordSourceLine - Register a source line with debug info. Returns the
1479/// unique label that was emitted and which provides correspondence to
1480/// the source line list.
Devang Patel4243e672011-05-11 19:22:19 +00001481void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1482 unsigned Flags) {
Devang Patel65dbc902009-11-25 17:36:49 +00001483 StringRef Fn;
Devang Patel23670e52011-03-24 20:30:50 +00001484 StringRef Dir;
Dan Gohman1cc0d622010-05-05 23:41:32 +00001485 unsigned Src = 1;
1486 if (S) {
1487 DIDescriptor Scope(S);
Devang Patelf84548d2009-10-05 18:03:19 +00001488
Dan Gohman1cc0d622010-05-05 23:41:32 +00001489 if (Scope.isCompileUnit()) {
1490 DICompileUnit CU(S);
Dan Gohman1cc0d622010-05-05 23:41:32 +00001491 Fn = CU.getFilename();
Devang Patel23670e52011-03-24 20:30:50 +00001492 Dir = CU.getDirectory();
Devang Patel3cabc9d2010-10-28 17:30:52 +00001493 } else if (Scope.isFile()) {
1494 DIFile F(S);
Devang Patel3cabc9d2010-10-28 17:30:52 +00001495 Fn = F.getFilename();
Devang Patel23670e52011-03-24 20:30:50 +00001496 Dir = F.getDirectory();
Dan Gohman1cc0d622010-05-05 23:41:32 +00001497 } else if (Scope.isSubprogram()) {
1498 DISubprogram SP(S);
Dan Gohman1cc0d622010-05-05 23:41:32 +00001499 Fn = SP.getFilename();
Devang Patel23670e52011-03-24 20:30:50 +00001500 Dir = SP.getDirectory();
Dan Gohman1cc0d622010-05-05 23:41:32 +00001501 } else if (Scope.isLexicalBlock()) {
1502 DILexicalBlock DB(S);
Dan Gohman1cc0d622010-05-05 23:41:32 +00001503 Fn = DB.getFilename();
Devang Patel23670e52011-03-24 20:30:50 +00001504 Dir = DB.getDirectory();
Dan Gohman1cc0d622010-05-05 23:41:32 +00001505 } else
1506 assert(0 && "Unexpected scope info");
1507
Devang Patel23670e52011-03-24 20:30:50 +00001508 Src = GetOrCreateSourceID(Fn, Dir);
Dan Gohman1cc0d622010-05-05 23:41:32 +00001509 }
Nick Lewycky3bbb6f72011-07-29 03:49:23 +00001510 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001511}
1512
Bill Wendling829e67b2009-05-20 23:22:40 +00001513//===----------------------------------------------------------------------===//
1514// Emit Methods
1515//===----------------------------------------------------------------------===//
1516
Devang Patel2c4ceb12009-11-21 02:48:08 +00001517/// computeSizeAndOffset - Compute the size and offset of a DIE.
Bill Wendling94d04b82009-05-20 23:21:38 +00001518///
Jim Grosbach7ab38df2009-11-22 19:20:36 +00001519unsigned
1520DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
Bill Wendling94d04b82009-05-20 23:21:38 +00001521 // Get the children.
1522 const std::vector<DIE *> &Children = Die->getChildren();
1523
1524 // If not last sibling and has children then add sibling offset attribute.
Jeffrey Yasskin638fe8d2010-03-22 18:47:14 +00001525 if (!Last && !Children.empty())
Benjamin Kramer345ef342010-03-31 19:34:01 +00001526 Die->addSiblingOffset(DIEValueAllocator);
Bill Wendling94d04b82009-05-20 23:21:38 +00001527
1528 // Record the abbreviation.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001529 assignAbbrevNumber(Die->getAbbrev());
Bill Wendling94d04b82009-05-20 23:21:38 +00001530
1531 // Get the abbreviation for this DIE.
1532 unsigned AbbrevNumber = Die->getAbbrevNumber();
1533 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1534
1535 // Set DIE offset
1536 Die->setOffset(Offset);
1537
1538 // Start the size with the size of abbreviation code.
Chris Lattneraf76e592009-08-22 20:48:53 +00001539 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
Bill Wendling94d04b82009-05-20 23:21:38 +00001540
1541 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1542 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1543
1544 // Size the DIE attribute values.
1545 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1546 // Size attribute value.
Chris Lattnera37d5382010-04-05 00:18:22 +00001547 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
Bill Wendling94d04b82009-05-20 23:21:38 +00001548
1549 // Size the DIE children if any.
1550 if (!Children.empty()) {
1551 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1552 "Children flag not set");
1553
1554 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001555 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
Bill Wendling94d04b82009-05-20 23:21:38 +00001556
1557 // End of children marker.
1558 Offset += sizeof(int8_t);
1559 }
1560
1561 Die->setSize(Offset - Die->getOffset());
1562 return Offset;
1563}
1564
Devang Patel2c4ceb12009-11-21 02:48:08 +00001565/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
Bill Wendling94d04b82009-05-20 23:21:38 +00001566///
Devang Patel2c4ceb12009-11-21 02:48:08 +00001567void DwarfDebug::computeSizeAndOffsets() {
Devang Patel163a9f72010-05-10 22:49:55 +00001568 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1569 E = CUMap.end(); I != E; ++I) {
1570 // Compute size of compile unit header.
Devang Patel513edf62011-04-12 23:10:47 +00001571 unsigned Offset =
Devang Patel163a9f72010-05-10 22:49:55 +00001572 sizeof(int32_t) + // Length of Compilation Unit Info
1573 sizeof(int16_t) + // DWARF version number
1574 sizeof(int32_t) + // Offset Into Abbrev. Section
1575 sizeof(int8_t); // Pointer Size (in bytes)
1576 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
Devang Patel163a9f72010-05-10 22:49:55 +00001577 }
Bill Wendling94d04b82009-05-20 23:21:38 +00001578}
1579
Chris Lattner11b8f302010-04-04 23:02:02 +00001580/// EmitSectionSym - Switch to the specified MCSection and emit an assembler
1581/// temporary label to it if SymbolStem is specified.
Chris Lattner9c69e285532010-04-04 22:59:04 +00001582static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
Chris Lattner11b8f302010-04-04 23:02:02 +00001583 const char *SymbolStem = 0) {
Chris Lattner9c69e285532010-04-04 22:59:04 +00001584 Asm->OutStreamer.SwitchSection(Section);
Chris Lattner11b8f302010-04-04 23:02:02 +00001585 if (!SymbolStem) return 0;
Jim Grosbach1e20b962010-07-21 21:21:52 +00001586
Chris Lattner9c69e285532010-04-04 22:59:04 +00001587 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
1588 Asm->OutStreamer.EmitLabel(TmpSym);
1589 return TmpSym;
1590}
1591
1592/// EmitSectionLabels - Emit initial Dwarf sections with a label at
1593/// the start of each one.
Chris Lattnerfa070b02010-04-04 22:33:59 +00001594void DwarfDebug::EmitSectionLabels() {
Chris Lattner6c2f9e12009-08-19 05:49:37 +00001595 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarf612ff62009-09-19 20:40:05 +00001596
Bill Wendling94d04b82009-05-20 23:21:38 +00001597 // Dwarf sections base addresses.
Jim Grosbach1e20b962010-07-21 21:21:52 +00001598 DwarfInfoSectionSym =
Chris Lattner9c69e285532010-04-04 22:59:04 +00001599 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
Jim Grosbach1e20b962010-07-21 21:21:52 +00001600 DwarfAbbrevSectionSym =
Chris Lattner9c69e285532010-04-04 22:59:04 +00001601 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
Chris Lattner11b8f302010-04-04 23:02:02 +00001602 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
Jim Grosbach1e20b962010-07-21 21:21:52 +00001603
Chris Lattner9c69e285532010-04-04 22:59:04 +00001604 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
Chris Lattner11b8f302010-04-04 23:02:02 +00001605 EmitSectionSym(Asm, MacroInfo);
Bill Wendling94d04b82009-05-20 23:21:38 +00001606
Devang Patelaf608bd2010-08-24 00:06:12 +00001607 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
Chris Lattner11b8f302010-04-04 23:02:02 +00001608 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1609 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1610 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
Jim Grosbach1e20b962010-07-21 21:21:52 +00001611 DwarfStrSectionSym =
Chris Lattner9c69e285532010-04-04 22:59:04 +00001612 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
Devang Patelf2548ca2010-04-16 23:33:45 +00001613 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1614 "debug_range");
Bill Wendling94d04b82009-05-20 23:21:38 +00001615
Devang Patelc3f5f782010-05-25 23:40:22 +00001616 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1617 "section_debug_loc");
1618
Chris Lattner9c69e285532010-04-04 22:59:04 +00001619 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
Chris Lattner4ad1efe2010-04-04 23:10:38 +00001620 EmitSectionSym(Asm, TLOF.getDataSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00001621}
1622
Nick Lewycky3bbb6f72011-07-29 03:49:23 +00001623/// emitDIE - Recursively emits a debug information entry.
Bill Wendling94d04b82009-05-20 23:21:38 +00001624///
Devang Patel2c4ceb12009-11-21 02:48:08 +00001625void DwarfDebug::emitDIE(DIE *Die) {
Bill Wendling94d04b82009-05-20 23:21:38 +00001626 // Get the abbreviation for this DIE.
1627 unsigned AbbrevNumber = Die->getAbbrevNumber();
1628 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1629
Bill Wendling94d04b82009-05-20 23:21:38 +00001630 // Emit the code (index) for the abbreviation.
Chris Lattner3f53c832010-04-04 18:52:31 +00001631 if (Asm->isVerbose())
Chris Lattner894d75a2010-01-22 23:18:42 +00001632 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1633 Twine::utohexstr(Die->getOffset()) + ":0x" +
1634 Twine::utohexstr(Die->getSize()) + " " +
1635 dwarf::TagString(Abbrev->getTag()));
Chris Lattner7e1a8f82010-04-04 19:09:29 +00001636 Asm->EmitULEB128(AbbrevNumber);
Bill Wendling94d04b82009-05-20 23:21:38 +00001637
Jeffrey Yasskin638fe8d2010-03-22 18:47:14 +00001638 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
Bill Wendling94d04b82009-05-20 23:21:38 +00001639 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1640
1641 // Emit the DIE attribute values.
1642 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1643 unsigned Attr = AbbrevData[i].getAttribute();
1644 unsigned Form = AbbrevData[i].getForm();
1645 assert(Form && "Too many attributes for DIE (check abbreviation)");
1646
Chris Lattner3f53c832010-04-04 18:52:31 +00001647 if (Asm->isVerbose())
Chris Lattnera8013622010-01-24 18:54:17 +00001648 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
Jim Grosbach1e20b962010-07-21 21:21:52 +00001649
Bill Wendling94d04b82009-05-20 23:21:38 +00001650 switch (Attr) {
1651 case dwarf::DW_AT_sibling:
Devang Patel2c4ceb12009-11-21 02:48:08 +00001652 Asm->EmitInt32(Die->getSiblingOffset());
Bill Wendling94d04b82009-05-20 23:21:38 +00001653 break;
1654 case dwarf::DW_AT_abstract_origin: {
1655 DIEEntry *E = cast<DIEEntry>(Values[i]);
1656 DIE *Origin = E->getEntry();
Devang Patel53bb5c92009-11-10 23:06:00 +00001657 unsigned Addr = Origin->getOffset();
Bill Wendling94d04b82009-05-20 23:21:38 +00001658 Asm->EmitInt32(Addr);
1659 break;
1660 }
Devang Patelf2548ca2010-04-16 23:33:45 +00001661 case dwarf::DW_AT_ranges: {
1662 // DW_AT_range Value encodes offset in debug_range section.
1663 DIEInteger *V = cast<DIEInteger>(Values[i]);
Devang Patelb1fcfbe2010-09-02 16:43:44 +00001664
1665 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1666 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1667 V->getValue(),
1668 4);
1669 } else {
1670 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1671 V->getValue(),
1672 DwarfDebugRangeSectionSym,
1673 4);
1674 }
Devang Patelf2548ca2010-04-16 23:33:45 +00001675 break;
1676 }
Devang Patelc3f5f782010-05-25 23:40:22 +00001677 case dwarf::DW_AT_location: {
Devang Patel7a328272011-08-15 21:43:21 +00001678 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
Daniel Dunbar83320a02011-03-16 22:16:39 +00001679 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
Devang Patel7a328272011-08-15 21:43:21 +00001680 else
Devang Patelc3f5f782010-05-25 23:40:22 +00001681 Values[i]->EmitValue(Asm, Form);
1682 break;
1683 }
Devang Patel2a361602010-09-29 19:08:08 +00001684 case dwarf::DW_AT_accessibility: {
1685 if (Asm->isVerbose()) {
1686 DIEInteger *V = cast<DIEInteger>(Values[i]);
1687 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1688 }
1689 Values[i]->EmitValue(Asm, Form);
1690 break;
1691 }
Bill Wendling94d04b82009-05-20 23:21:38 +00001692 default:
1693 // Emit an attribute using the defined form.
Chris Lattnerd38fee82010-04-05 00:13:49 +00001694 Values[i]->EmitValue(Asm, Form);
Bill Wendling94d04b82009-05-20 23:21:38 +00001695 break;
1696 }
Bill Wendling94d04b82009-05-20 23:21:38 +00001697 }
1698
1699 // Emit the DIE children if any.
1700 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1701 const std::vector<DIE *> &Children = Die->getChildren();
1702
1703 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001704 emitDIE(Children[j]);
Bill Wendling94d04b82009-05-20 23:21:38 +00001705
Chris Lattner3f53c832010-04-04 18:52:31 +00001706 if (Asm->isVerbose())
Chris Lattner233f52b2010-03-09 23:52:58 +00001707 Asm->OutStreamer.AddComment("End Of Children Mark");
1708 Asm->EmitInt8(0);
Bill Wendling94d04b82009-05-20 23:21:38 +00001709 }
1710}
1711
Devang Patel8a241142009-12-09 18:24:21 +00001712/// emitDebugInfo - Emit the debug info section.
Bill Wendling94d04b82009-05-20 23:21:38 +00001713///
Devang Patel8a241142009-12-09 18:24:21 +00001714void DwarfDebug::emitDebugInfo() {
1715 // Start debug info section.
1716 Asm->OutStreamer.SwitchSection(
1717 Asm->getObjFileLowering().getDwarfInfoSection());
Devang Patel163a9f72010-05-10 22:49:55 +00001718 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1719 E = CUMap.end(); I != E; ++I) {
1720 CompileUnit *TheCU = I->second;
1721 DIE *Die = TheCU->getCUDie();
Jim Grosbach1e20b962010-07-21 21:21:52 +00001722
Devang Patel163a9f72010-05-10 22:49:55 +00001723 // Emit the compile units header.
1724 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1725 TheCU->getID()));
Jim Grosbach1e20b962010-07-21 21:21:52 +00001726
Devang Patel163a9f72010-05-10 22:49:55 +00001727 // Emit size of content not including length itself
1728 unsigned ContentSize = Die->getSize() +
1729 sizeof(int16_t) + // DWARF version number
1730 sizeof(int32_t) + // Offset Into Abbrev. Section
Devang Patel65705d52011-04-13 19:41:17 +00001731 sizeof(int8_t); // Pointer Size (in bytes)
Jim Grosbach1e20b962010-07-21 21:21:52 +00001732
Devang Patel163a9f72010-05-10 22:49:55 +00001733 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1734 Asm->EmitInt32(ContentSize);
1735 Asm->OutStreamer.AddComment("DWARF version number");
1736 Asm->EmitInt16(dwarf::DWARF_VERSION);
1737 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1738 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1739 DwarfAbbrevSectionSym);
1740 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1741 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Jim Grosbach1e20b962010-07-21 21:21:52 +00001742
Devang Patel163a9f72010-05-10 22:49:55 +00001743 emitDIE(Die);
Devang Patel163a9f72010-05-10 22:49:55 +00001744 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1745 }
Bill Wendling94d04b82009-05-20 23:21:38 +00001746}
1747
Devang Patel2c4ceb12009-11-21 02:48:08 +00001748/// emitAbbreviations - Emit the abbreviation section.
Bill Wendling94d04b82009-05-20 23:21:38 +00001749///
Devang Patel2c4ceb12009-11-21 02:48:08 +00001750void DwarfDebug::emitAbbreviations() const {
Bill Wendling94d04b82009-05-20 23:21:38 +00001751 // Check to see if it is worth the effort.
1752 if (!Abbreviations.empty()) {
1753 // Start the debug abbrev section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00001754 Asm->OutStreamer.SwitchSection(
1755 Asm->getObjFileLowering().getDwarfAbbrevSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00001756
Chris Lattnerc0215722010-04-04 19:25:43 +00001757 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
Bill Wendling94d04b82009-05-20 23:21:38 +00001758
1759 // For each abbrevation.
1760 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1761 // Get abbreviation data
1762 const DIEAbbrev *Abbrev = Abbreviations[i];
1763
1764 // Emit the abbrevations code (base 1 index.)
Chris Lattner7e1a8f82010-04-04 19:09:29 +00001765 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
Bill Wendling94d04b82009-05-20 23:21:38 +00001766
1767 // Emit the abbreviations data.
Chris Lattnerd38fee82010-04-05 00:13:49 +00001768 Abbrev->Emit(Asm);
Bill Wendling94d04b82009-05-20 23:21:38 +00001769 }
1770
1771 // Mark end of abbreviations.
Chris Lattner7e1a8f82010-04-04 19:09:29 +00001772 Asm->EmitULEB128(0, "EOM(3)");
Bill Wendling94d04b82009-05-20 23:21:38 +00001773
Chris Lattnerc0215722010-04-04 19:25:43 +00001774 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00001775 }
1776}
1777
Devang Patel2c4ceb12009-11-21 02:48:08 +00001778/// emitEndOfLineMatrix - Emit the last address of the section and the end of
Bill Wendling94d04b82009-05-20 23:21:38 +00001779/// the line matrix.
1780///
Devang Patel2c4ceb12009-11-21 02:48:08 +00001781void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling94d04b82009-05-20 23:21:38 +00001782 // Define last address of section.
Chris Lattner233f52b2010-03-09 23:52:58 +00001783 Asm->OutStreamer.AddComment("Extended Op");
1784 Asm->EmitInt8(0);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001785
Chris Lattner233f52b2010-03-09 23:52:58 +00001786 Asm->OutStreamer.AddComment("Op size");
Chris Lattnerd38fee82010-04-05 00:13:49 +00001787 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner233f52b2010-03-09 23:52:58 +00001788 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1789 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1790
1791 Asm->OutStreamer.AddComment("Section end label");
Chris Lattnerd85fc6e2010-03-10 01:17:49 +00001792
Chris Lattnerc0215722010-04-04 19:25:43 +00001793 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
Chris Lattnerd38fee82010-04-05 00:13:49 +00001794 Asm->getTargetData().getPointerSize(),
1795 0/*AddrSpace*/);
Bill Wendling94d04b82009-05-20 23:21:38 +00001796
1797 // Mark end of matrix.
Chris Lattner233f52b2010-03-09 23:52:58 +00001798 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1799 Asm->EmitInt8(0);
Chris Lattner0ad9c912010-01-22 22:09:00 +00001800 Asm->EmitInt8(1);
Chris Lattner894d75a2010-01-22 23:18:42 +00001801 Asm->EmitInt8(1);
Bill Wendling94d04b82009-05-20 23:21:38 +00001802}
1803
Devang Patel8a241142009-12-09 18:24:21 +00001804/// emitDebugPubNames - Emit visible names into a debug pubnames section.
1805///
1806void DwarfDebug::emitDebugPubNames() {
Devang Patel163a9f72010-05-10 22:49:55 +00001807 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1808 E = CUMap.end(); I != E; ++I) {
1809 CompileUnit *TheCU = I->second;
1810 // Start the dwarf pubnames section.
1811 Asm->OutStreamer.SwitchSection(
1812 Asm->getObjFileLowering().getDwarfPubNamesSection());
Jim Grosbach1e20b962010-07-21 21:21:52 +00001813
Devang Patel163a9f72010-05-10 22:49:55 +00001814 Asm->OutStreamer.AddComment("Length of Public Names Info");
1815 Asm->EmitLabelDifference(
1816 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
1817 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001818
Devang Patel163a9f72010-05-10 22:49:55 +00001819 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
1820 TheCU->getID()));
Jim Grosbach1e20b962010-07-21 21:21:52 +00001821
Devang Patel163a9f72010-05-10 22:49:55 +00001822 Asm->OutStreamer.AddComment("DWARF Version");
Jim Grosbach1e20b962010-07-21 21:21:52 +00001823 Asm->EmitInt16(dwarf::DWARF_VERSION);
1824
Devang Patel163a9f72010-05-10 22:49:55 +00001825 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
Jim Grosbach1e20b962010-07-21 21:21:52 +00001826 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
Devang Patel163a9f72010-05-10 22:49:55 +00001827 DwarfInfoSectionSym);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001828
Devang Patel163a9f72010-05-10 22:49:55 +00001829 Asm->OutStreamer.AddComment("Compilation Unit Length");
1830 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1831 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1832 4);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001833
Devang Patel163a9f72010-05-10 22:49:55 +00001834 const StringMap<DIE*> &Globals = TheCU->getGlobals();
1835 for (StringMap<DIE*>::const_iterator
1836 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1837 const char *Name = GI->getKeyData();
1838 DIE *Entity = GI->second;
Jim Grosbach1e20b962010-07-21 21:21:52 +00001839
Devang Patel163a9f72010-05-10 22:49:55 +00001840 Asm->OutStreamer.AddComment("DIE offset");
1841 Asm->EmitInt32(Entity->getOffset());
Jim Grosbach1e20b962010-07-21 21:21:52 +00001842
Devang Patel163a9f72010-05-10 22:49:55 +00001843 if (Asm->isVerbose())
1844 Asm->OutStreamer.AddComment("External Name");
1845 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
1846 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00001847
Devang Patel163a9f72010-05-10 22:49:55 +00001848 Asm->OutStreamer.AddComment("End Mark");
1849 Asm->EmitInt32(0);
1850 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
Nick Lewycky3bbb6f72011-07-29 03:49:23 +00001851 TheCU->getID()));
Bill Wendling94d04b82009-05-20 23:21:38 +00001852 }
Bill Wendling94d04b82009-05-20 23:21:38 +00001853}
1854
Devang Patel193f7202009-11-24 01:14:22 +00001855void DwarfDebug::emitDebugPubTypes() {
Devang Patel163a9f72010-05-10 22:49:55 +00001856 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1857 E = CUMap.end(); I != E; ++I) {
1858 CompileUnit *TheCU = I->second;
1859 // Start the dwarf pubnames section.
1860 Asm->OutStreamer.SwitchSection(
1861 Asm->getObjFileLowering().getDwarfPubTypesSection());
1862 Asm->OutStreamer.AddComment("Length of Public Types Info");
1863 Asm->EmitLabelDifference(
1864 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1865 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001866
Devang Patel163a9f72010-05-10 22:49:55 +00001867 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1868 TheCU->getID()));
Jim Grosbach1e20b962010-07-21 21:21:52 +00001869
Devang Patel163a9f72010-05-10 22:49:55 +00001870 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1871 Asm->EmitInt16(dwarf::DWARF_VERSION);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001872
Devang Patel163a9f72010-05-10 22:49:55 +00001873 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1874 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1875 DwarfInfoSectionSym);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001876
Devang Patel163a9f72010-05-10 22:49:55 +00001877 Asm->OutStreamer.AddComment("Compilation Unit Length");
1878 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1879 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1880 4);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001881
Devang Patel163a9f72010-05-10 22:49:55 +00001882 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1883 for (StringMap<DIE*>::const_iterator
1884 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1885 const char *Name = GI->getKeyData();
Nick Lewycky3bbb6f72011-07-29 03:49:23 +00001886 DIE *Entity = GI->second;
Jim Grosbach1e20b962010-07-21 21:21:52 +00001887
Devang Patel163a9f72010-05-10 22:49:55 +00001888 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1889 Asm->EmitInt32(Entity->getOffset());
Jim Grosbach1e20b962010-07-21 21:21:52 +00001890
Devang Patel163a9f72010-05-10 22:49:55 +00001891 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1892 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1893 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00001894
Devang Patel163a9f72010-05-10 22:49:55 +00001895 Asm->OutStreamer.AddComment("End Mark");
Jim Grosbach1e20b962010-07-21 21:21:52 +00001896 Asm->EmitInt32(0);
Devang Patel163a9f72010-05-10 22:49:55 +00001897 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1898 TheCU->getID()));
Devang Patel193f7202009-11-24 01:14:22 +00001899 }
Devang Patel193f7202009-11-24 01:14:22 +00001900}
1901
Devang Patel2c4ceb12009-11-21 02:48:08 +00001902/// emitDebugStr - Emit visible names into a debug str section.
Bill Wendling94d04b82009-05-20 23:21:38 +00001903///
Devang Patel2c4ceb12009-11-21 02:48:08 +00001904void DwarfDebug::emitDebugStr() {
Bill Wendling94d04b82009-05-20 23:21:38 +00001905 // Check to see if it is worth the effort.
Chris Lattner0d9d70f2010-03-09 23:38:23 +00001906 if (StringPool.empty()) return;
Jim Grosbach1e20b962010-07-21 21:21:52 +00001907
Chris Lattner0d9d70f2010-03-09 23:38:23 +00001908 // Start the dwarf str section.
1909 Asm->OutStreamer.SwitchSection(
Chris Lattner6c2f9e12009-08-19 05:49:37 +00001910 Asm->getObjFileLowering().getDwarfStrSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00001911
Chris Lattnerbc733f52010-03-13 02:17:42 +00001912 // Get all of the string pool entries and put them in an array by their ID so
1913 // we can sort them.
Jim Grosbach1e20b962010-07-21 21:21:52 +00001914 SmallVector<std::pair<unsigned,
Chris Lattnerbc733f52010-03-13 02:17:42 +00001915 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
Jim Grosbach1e20b962010-07-21 21:21:52 +00001916
Chris Lattnerbc733f52010-03-13 02:17:42 +00001917 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1918 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1919 Entries.push_back(std::make_pair(I->second.second, &*I));
Jim Grosbach1e20b962010-07-21 21:21:52 +00001920
Chris Lattnerbc733f52010-03-13 02:17:42 +00001921 array_pod_sort(Entries.begin(), Entries.end());
Jim Grosbach1e20b962010-07-21 21:21:52 +00001922
Chris Lattnerbc733f52010-03-13 02:17:42 +00001923 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
Chris Lattner0d9d70f2010-03-09 23:38:23 +00001924 // Emit a label for reference from debug information entries.
Chris Lattnerbc733f52010-03-13 02:17:42 +00001925 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001926
Chris Lattner0d9d70f2010-03-09 23:38:23 +00001927 // Emit the string itself.
Chris Lattnerbc733f52010-03-13 02:17:42 +00001928 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
Bill Wendling94d04b82009-05-20 23:21:38 +00001929 }
1930}
1931
Devang Patel2c4ceb12009-11-21 02:48:08 +00001932/// emitDebugLoc - Emit visible names into a debug loc section.
Bill Wendling94d04b82009-05-20 23:21:38 +00001933///
Devang Patel2c4ceb12009-11-21 02:48:08 +00001934void DwarfDebug::emitDebugLoc() {
Devang Patel80250682010-05-26 23:55:23 +00001935 if (DotDebugLocEntries.empty())
1936 return;
1937
Devang Patel6c3ea902011-02-04 22:57:18 +00001938 for (SmallVector<DotDebugLocEntry, 4>::iterator
1939 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1940 I != E; ++I) {
1941 DotDebugLocEntry &Entry = *I;
1942 if (I + 1 != DotDebugLocEntries.end())
1943 Entry.Merge(I+1);
1944 }
1945
Daniel Dunbar83320a02011-03-16 22:16:39 +00001946 // Start the dwarf loc section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00001947 Asm->OutStreamer.SwitchSection(
Devang Patelc3f5f782010-05-25 23:40:22 +00001948 Asm->getObjFileLowering().getDwarfLocSection());
1949 unsigned char Size = Asm->getTargetData().getPointerSize();
Devang Patel80250682010-05-26 23:55:23 +00001950 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1951 unsigned index = 1;
Jim Grosbach1e20b962010-07-21 21:21:52 +00001952 for (SmallVector<DotDebugLocEntry, 4>::iterator
1953 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
Devang Patel61409622010-07-07 20:12:52 +00001954 I != E; ++I, ++index) {
Devang Patel6c3ea902011-02-04 22:57:18 +00001955 DotDebugLocEntry &Entry = *I;
1956 if (Entry.isMerged()) continue;
Devang Patelc3f5f782010-05-25 23:40:22 +00001957 if (Entry.isEmpty()) {
1958 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1959 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patel80250682010-05-26 23:55:23 +00001960 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
Devang Patelc3f5f782010-05-25 23:40:22 +00001961 } else {
1962 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1963 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
Devang Patelc26f5442011-04-28 02:22:40 +00001964 DIVariable DV(Entry.Variable);
Rafael Espindola5b23b7f2011-05-27 22:05:41 +00001965 Asm->OutStreamer.AddComment("Loc expr size");
1966 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1967 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1968 Asm->EmitLabelDifference(end, begin, 2);
1969 Asm->OutStreamer.EmitLabel(begin);
Devang Patel80efd4e2011-07-08 16:49:43 +00001970 if (Entry.isInt()) {
Devang Patelc4329072011-06-01 22:03:25 +00001971 DIBasicType BTy(DV.getType());
1972 if (BTy.Verify() &&
1973 (BTy.getEncoding() == dwarf::DW_ATE_signed
1974 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1975 Asm->OutStreamer.AddComment("DW_OP_consts");
1976 Asm->EmitInt8(dwarf::DW_OP_consts);
Devang Patel80efd4e2011-07-08 16:49:43 +00001977 Asm->EmitSLEB128(Entry.getInt());
Devang Patelc4329072011-06-01 22:03:25 +00001978 } else {
1979 Asm->OutStreamer.AddComment("DW_OP_constu");
1980 Asm->EmitInt8(dwarf::DW_OP_constu);
Devang Patel80efd4e2011-07-08 16:49:43 +00001981 Asm->EmitULEB128(Entry.getInt());
Devang Patelc4329072011-06-01 22:03:25 +00001982 }
Devang Patel80efd4e2011-07-08 16:49:43 +00001983 } else if (Entry.isLocation()) {
1984 if (!DV.hasComplexAddress())
1985 // Regular entry.
Devang Patelc26f5442011-04-28 02:22:40 +00001986 Asm->EmitDwarfRegOp(Entry.Loc);
Devang Patel80efd4e2011-07-08 16:49:43 +00001987 else {
1988 // Complex address entry.
1989 unsigned N = DV.getNumAddrElements();
1990 unsigned i = 0;
1991 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1992 if (Entry.Loc.getOffset()) {
1993 i = 2;
1994 Asm->EmitDwarfRegOp(Entry.Loc);
1995 Asm->OutStreamer.AddComment("DW_OP_deref");
1996 Asm->EmitInt8(dwarf::DW_OP_deref);
1997 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
1998 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
1999 Asm->EmitSLEB128(DV.getAddrElement(1));
2000 } else {
2001 // If first address element is OpPlus then emit
2002 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2003 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2004 Asm->EmitDwarfRegOp(Loc);
2005 i = 2;
2006 }
2007 } else {
2008 Asm->EmitDwarfRegOp(Entry.Loc);
2009 }
2010
2011 // Emit remaining complex address elements.
2012 for (; i < N; ++i) {
2013 uint64_t Element = DV.getAddrElement(i);
2014 if (Element == DIBuilder::OpPlus) {
2015 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2016 Asm->EmitULEB128(DV.getAddrElement(++i));
2017 } else if (Element == DIBuilder::OpDeref)
2018 Asm->EmitInt8(dwarf::DW_OP_deref);
2019 else llvm_unreachable("unknown Opcode found in complex address");
2020 }
Devang Patelc26f5442011-04-28 02:22:40 +00002021 }
Devang Patelc26f5442011-04-28 02:22:40 +00002022 }
Devang Patel80efd4e2011-07-08 16:49:43 +00002023 // else ... ignore constant fp. There is not any good way to
2024 // to represent them here in dwarf.
Rafael Espindola5b23b7f2011-05-27 22:05:41 +00002025 Asm->OutStreamer.EmitLabel(end);
Devang Patelc3f5f782010-05-25 23:40:22 +00002026 }
2027 }
Bill Wendling94d04b82009-05-20 23:21:38 +00002028}
2029
2030/// EmitDebugARanges - Emit visible names into a debug aranges section.
2031///
2032void DwarfDebug::EmitDebugARanges() {
2033 // Start the dwarf aranges section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002034 Asm->OutStreamer.SwitchSection(
2035 Asm->getObjFileLowering().getDwarfARangesSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002036}
2037
Devang Patel2c4ceb12009-11-21 02:48:08 +00002038/// emitDebugRanges - Emit visible names into a debug ranges section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002039///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002040void DwarfDebug::emitDebugRanges() {
Bill Wendling94d04b82009-05-20 23:21:38 +00002041 // Start the dwarf ranges section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002042 Asm->OutStreamer.SwitchSection(
Devang Patelf2548ca2010-04-16 23:33:45 +00002043 Asm->getObjFileLowering().getDwarfRangesSection());
Devang Pateleac9c072010-04-27 19:46:33 +00002044 unsigned char Size = Asm->getTargetData().getPointerSize();
2045 for (SmallVector<const MCSymbol *, 8>::iterator
Jim Grosbach1e20b962010-07-21 21:21:52 +00002046 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
Devang Pateleac9c072010-04-27 19:46:33 +00002047 I != E; ++I) {
2048 if (*I)
2049 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
Devang Patelf2548ca2010-04-16 23:33:45 +00002050 else
Devang Pateleac9c072010-04-27 19:46:33 +00002051 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patelf2548ca2010-04-16 23:33:45 +00002052 }
Bill Wendling94d04b82009-05-20 23:21:38 +00002053}
2054
Devang Patel2c4ceb12009-11-21 02:48:08 +00002055/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002056///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002057void DwarfDebug::emitDebugMacInfo() {
Daniel Dunbarf612ff62009-09-19 20:40:05 +00002058 if (const MCSection *LineInfo =
Chris Lattner18a4c162009-08-02 07:24:22 +00002059 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
Bill Wendling94d04b82009-05-20 23:21:38 +00002060 // Start the dwarf macinfo section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002061 Asm->OutStreamer.SwitchSection(LineInfo);
Bill Wendling94d04b82009-05-20 23:21:38 +00002062 }
2063}
2064
Devang Patel2c4ceb12009-11-21 02:48:08 +00002065/// emitDebugInlineInfo - Emit inline info using following format.
Bill Wendling94d04b82009-05-20 23:21:38 +00002066/// Section Header:
2067/// 1. length of section
2068/// 2. Dwarf version number
2069/// 3. address size.
2070///
2071/// Entries (one "entry" for each function that was inlined):
2072///
2073/// 1. offset into __debug_str section for MIPS linkage name, if exists;
2074/// otherwise offset into __debug_str for regular function name.
2075/// 2. offset into __debug_str section for regular function name.
2076/// 3. an unsigned LEB128 number indicating the number of distinct inlining
2077/// instances for the function.
2078///
2079/// The rest of the entry consists of a {die_offset, low_pc} pair for each
2080/// inlined instance; the die_offset points to the inlined_subroutine die in the
2081/// __debug_info section, and the low_pc is the starting address for the
2082/// inlining instance.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002083void DwarfDebug::emitDebugInlineInfo() {
Chris Lattnerd38fee82010-04-05 00:13:49 +00002084 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00002085 return;
2086
Devang Patel163a9f72010-05-10 22:49:55 +00002087 if (!FirstCU)
Bill Wendling94d04b82009-05-20 23:21:38 +00002088 return;
2089
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002090 Asm->OutStreamer.SwitchSection(
2091 Asm->getObjFileLowering().getDwarfDebugInlineSection());
Chris Lattner0ad9c912010-01-22 22:09:00 +00002092
Chris Lattner233f52b2010-03-09 23:52:58 +00002093 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
Chris Lattnera6437182010-04-04 19:58:12 +00002094 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2095 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
Bill Wendling94d04b82009-05-20 23:21:38 +00002096
Chris Lattnerc0215722010-04-04 19:25:43 +00002097 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
Bill Wendling94d04b82009-05-20 23:21:38 +00002098
Chris Lattner233f52b2010-03-09 23:52:58 +00002099 Asm->OutStreamer.AddComment("Dwarf Version");
2100 Asm->EmitInt16(dwarf::DWARF_VERSION);
2101 Asm->OutStreamer.AddComment("Address Size (in bytes)");
Chris Lattnerd38fee82010-04-05 00:13:49 +00002102 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Bill Wendling94d04b82009-05-20 23:21:38 +00002103
Devang Patele9f8f5e2010-05-07 20:54:48 +00002104 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
Devang Patel53bb5c92009-11-10 23:06:00 +00002105 E = InlinedSPNodes.end(); I != E; ++I) {
Jim Grosbach31ef40e2009-11-21 23:12:12 +00002106
Devang Patele9f8f5e2010-05-07 20:54:48 +00002107 const MDNode *Node = *I;
2108 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
Jim Grosbach7ab38df2009-11-22 19:20:36 +00002109 = InlineInfo.find(Node);
Devang Patel53bb5c92009-11-10 23:06:00 +00002110 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
Devang Patele4b27562009-08-28 23:24:31 +00002111 DISubprogram SP(Node);
Devang Patel65dbc902009-11-25 17:36:49 +00002112 StringRef LName = SP.getLinkageName();
2113 StringRef Name = SP.getName();
Bill Wendling94d04b82009-05-20 23:21:38 +00002114
Chris Lattner233f52b2010-03-09 23:52:58 +00002115 Asm->OutStreamer.AddComment("MIPS linkage name");
Chris Lattner4cf202b2010-01-23 03:11:46 +00002116 if (LName.empty()) {
2117 Asm->OutStreamer.EmitBytes(Name, 0);
2118 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
Jim Grosbach1e20b962010-07-21 21:21:52 +00002119 } else
Chris Lattner6189ed12010-04-04 23:25:33 +00002120 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2121 DwarfStrSectionSym);
Devang Patel53bb5c92009-11-10 23:06:00 +00002122
Chris Lattner233f52b2010-03-09 23:52:58 +00002123 Asm->OutStreamer.AddComment("Function name");
Chris Lattner6189ed12010-04-04 23:25:33 +00002124 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
Chris Lattner7e1a8f82010-04-04 19:09:29 +00002125 Asm->EmitULEB128(Labels.size(), "Inline count");
Bill Wendling94d04b82009-05-20 23:21:38 +00002126
Devang Patel53bb5c92009-11-10 23:06:00 +00002127 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
Bill Wendling94d04b82009-05-20 23:21:38 +00002128 LE = Labels.end(); LI != LE; ++LI) {
Chris Lattner3f53c832010-04-04 18:52:31 +00002129 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
Chris Lattner6ed0f902010-03-09 00:31:02 +00002130 Asm->EmitInt32(LI->second->getOffset());
Bill Wendling94d04b82009-05-20 23:21:38 +00002131
Chris Lattner3f53c832010-04-04 18:52:31 +00002132 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
Chris Lattnerd38fee82010-04-05 00:13:49 +00002133 Asm->OutStreamer.EmitSymbolValue(LI->first,
2134 Asm->getTargetData().getPointerSize(),0);
Bill Wendling94d04b82009-05-20 23:21:38 +00002135 }
2136 }
2137
Chris Lattnerc0215722010-04-04 19:25:43 +00002138 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
Bill Wendling94d04b82009-05-20 23:21:38 +00002139}