blob: 325c3d34a55388c85a24ab24bcc2e07b9c709f65 [file] [log] [blame]
Bill Wendling2f921f82009-05-15 09:23:25 +00001//===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains support for writing dwarf debug info into asm files.
11//
12//===----------------------------------------------------------------------===//
Chris Lattnerb14490d2010-03-09 00:39:24 +000013
Devang Patel80ae3492009-08-28 23:24:31 +000014#define DEBUG_TYPE "dwarfdebug"
Bill Wendling2f921f82009-05-15 09:23:25 +000015#include "DwarfDebug.h"
Chris Lattner3f3fb972010-04-05 05:24:55 +000016#include "DIE.h"
Devang Patel5eb43192011-04-12 17:40:32 +000017#include "DwarfCompileUnit.h"
Bill Wendling30346342010-04-05 22:59:21 +000018#include "llvm/Constants.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000019#include "llvm/Module.h"
Devang Patel2d9e5322011-01-20 00:02:16 +000020#include "llvm/Instructions.h"
David Greene829b3e82009-08-19 21:52:55 +000021#include "llvm/CodeGen/MachineFunction.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000022#include "llvm/CodeGen/MachineModuleInfo.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000023#include "llvm/MC/MCAsmInfo.h"
Chris Lattner4d2c0f92009-07-31 18:48:30 +000024#include "llvm/MC/MCSection.h"
Chris Lattner4b7dadb2009-08-19 05:49:37 +000025#include "llvm/MC/MCStreamer.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000026#include "llvm/MC/MCSymbol.h"
Chris Lattnerf62e3ee2010-01-16 21:57:06 +000027#include "llvm/Target/Mangler.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000028#include "llvm/Target/TargetData.h"
Anton Korobeynikov2f931282011-01-10 12:39:04 +000029#include "llvm/Target/TargetFrameLowering.h"
Chris Lattner5e693ed2009-07-28 03:13:23 +000030#include "llvm/Target/TargetLoweringObjectFile.h"
Chris Lattner21dc46e2010-04-04 18:06:11 +000031#include "llvm/Target/TargetMachine.h"
Chris Lattner5e693ed2009-07-28 03:13:23 +000032#include "llvm/Target/TargetRegisterInfo.h"
Devang Patel61880932010-04-19 19:14:02 +000033#include "llvm/Target/TargetOptions.h"
Chris Lattner3f3fb972010-04-05 05:24:55 +000034#include "llvm/Analysis/DebugInfo.h"
Devang Patela5d93242011-02-24 18:49:30 +000035#include "llvm/Analysis/DIBuilder.h"
Devang Patela86114b2010-10-25 20:45:32 +000036#include "llvm/ADT/Statistic.h"
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +000037#include "llvm/ADT/STLExtras.h"
Chris Lattner06fa1762009-08-24 03:52:50 +000038#include "llvm/ADT/StringExtras.h"
Devang Patel6c74a872010-04-27 19:46:33 +000039#include "llvm/Support/CommandLine.h"
Daniel Dunbarcdf01b52009-10-13 06:47:08 +000040#include "llvm/Support/Debug.h"
41#include "llvm/Support/ErrorHandling.h"
Devang Patel1973df22010-01-26 21:39:14 +000042#include "llvm/Support/ValueHandle.h"
Chris Lattnerf5c834f2010-01-22 22:09:00 +000043#include "llvm/Support/FormattedStream.h"
Chris Lattner4d2c0f92009-07-31 18:48:30 +000044#include "llvm/Support/Timer.h"
Michael J. Spencer447762d2010-11-29 18:16:10 +000045#include "llvm/Support/Path.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000046using namespace llvm;
47
Devang Patel6c74a872010-04-27 19:46:33 +000048static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
49 cl::desc("Print DbgScope information for each machine instruction"));
50
Jim Grosbacha8683bb2010-07-21 21:21:52 +000051static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
Devang Patel30265c42010-07-07 20:12:52 +000052 cl::Hidden,
Devang Patel6c74a872010-04-27 19:46:33 +000053 cl::desc("Disable debug info printing"));
54
Dan Gohman7421ae42010-05-07 01:08:53 +000055static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
Chris Lattner0ab5e2c2011-04-15 05:18:47 +000056 cl::desc("Make an absence of debug location information explicit."),
Dan Gohman7421ae42010-05-07 01:08:53 +000057 cl::init(false));
58
Nick Lewycky90b2ac22010-10-26 00:51:57 +000059#ifndef NDEBUG
Devang Patela86114b2010-10-25 20:45:32 +000060STATISTIC(BlocksWithoutLineNo, "Number of blocks without any line number");
Nick Lewycky90b2ac22010-10-26 00:51:57 +000061#endif
Devang Patela86114b2010-10-25 20:45:32 +000062
Bill Wendlingfcc14142010-04-07 09:28:04 +000063namespace {
64 const char *DWARFGroupName = "DWARF Emission";
65 const char *DbgTimerName = "DWARF Debug Writer";
66} // end anonymous namespace
67
Bill Wendling2f921f82009-05-15 09:23:25 +000068//===----------------------------------------------------------------------===//
69
70/// Configuration values for initial hash set sizes (log2).
71///
Bill Wendling2f921f82009-05-15 09:23:25 +000072static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
Bill Wendling2f921f82009-05-15 09:23:25 +000073
74namespace llvm {
75
Devang Patelf20c4f72011-04-12 22:53:02 +000076DIType DbgVariable::getType() const {
77 DIType Ty = Var.getType();
78 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
79 // addresses instead.
80 if (Var.isBlockByrefVariable()) {
81 /* Byref variables, in Blocks, are declared by the programmer as
82 "SomeType VarName;", but the compiler creates a
83 __Block_byref_x_VarName struct, and gives the variable VarName
84 either the struct, or a pointer to the struct, as its type. This
85 is necessary for various behind-the-scenes things the compiler
86 needs to do with by-reference variables in blocks.
87
88 However, as far as the original *programmer* is concerned, the
89 variable should still have type 'SomeType', as originally declared.
90
91 The following function dives into the __Block_byref_x_VarName
92 struct to find the original type of the variable. This will be
93 passed back to the code generating the type for the Debug
94 Information Entry for the variable 'VarName'. 'VarName' will then
95 have the original type 'SomeType' in its debug information.
96
97 The original type 'SomeType' will be the type of the field named
98 'VarName' inside the __Block_byref_x_VarName struct.
99
100 NOTE: In order for this to not completely fail on the debugger
101 side, the Debug Information Entry for the variable VarName needs to
102 have a DW_AT_location that tells the debugger how to unwind through
103 the pointers and __Block_byref_x_VarName struct to find the actual
104 value of the variable. The function addBlockByrefType does this. */
105 DIType subType = Ty;
106 unsigned tag = Ty.getTag();
107
108 if (tag == dwarf::DW_TAG_pointer_type) {
109 DIDerivedType DTy = DIDerivedType(Ty);
110 subType = DTy.getTypeDerivedFrom();
111 }
112
113 DICompositeType blockStruct = DICompositeType(subType);
114 DIArray Elements = blockStruct.getTypeArray();
115
116 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
117 DIDescriptor Element = Elements.getElement(i);
118 DIDerivedType DT = DIDerivedType(Element);
119 if (getName() == DT.getName())
120 return (DT.getTypeDerivedFrom());
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000121 }
122 return Ty;
123 }
Devang Patelf20c4f72011-04-12 22:53:02 +0000124 return Ty;
125}
Bill Wendling2f921f82009-05-15 09:23:25 +0000126
127//===----------------------------------------------------------------------===//
Devang Patel6c74a872010-04-27 19:46:33 +0000128/// DbgRange - This is used to track range of instructions with identical
129/// debug info scope.
130///
131typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
132
133//===----------------------------------------------------------------------===//
Bill Wendling2f921f82009-05-15 09:23:25 +0000134/// DbgScope - This class is used to track scope information.
135///
Devang Patelf3d7c082009-11-16 21:53:40 +0000136class DbgScope {
Bill Wendling2f921f82009-05-15 09:23:25 +0000137 DbgScope *Parent; // Parent to this scope.
Jim Grosbach042483e2009-11-21 23:12:12 +0000138 DIDescriptor Desc; // Debug info descriptor for scope.
Devang Patel1973df22010-01-26 21:39:14 +0000139 // Location at which this scope is inlined.
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000140 AssertingVH<const MDNode> InlinedAtLocation;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000141 bool AbstractScope; // Abstract Scope
Devang Patel787f94c2009-10-01 18:25:23 +0000142 const MachineInstr *LastInsn; // Last instruction of this scope.
143 const MachineInstr *FirstInsn; // First instruction of this scope.
Devang Patel6c74a872010-04-27 19:46:33 +0000144 unsigned DFSIn, DFSOut;
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +0000145 // Scopes defined in scope. Contents not owned.
146 SmallVector<DbgScope *, 4> Scopes;
147 // Variables declared in scope. Contents owned.
148 SmallVector<DbgVariable *, 8> Variables;
Devang Patel6c74a872010-04-27 19:46:33 +0000149 SmallVector<DbgRange, 4> Ranges;
Owen Anderson9becc182009-06-24 22:53:20 +0000150 // Private state for dump()
151 mutable unsigned IndentLevel;
Bill Wendling2f921f82009-05-15 09:23:25 +0000152public:
Devang Patel32cc43c2010-05-07 20:54:48 +0000153 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000154 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
Devang Patel6c74a872010-04-27 19:46:33 +0000155 LastInsn(0), FirstInsn(0),
156 DFSIn(0), DFSOut(0), IndentLevel(0) {}
Bill Wendling2f921f82009-05-15 09:23:25 +0000157 virtual ~DbgScope();
158
159 // Accessors.
160 DbgScope *getParent() const { return Parent; }
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000161 void setParent(DbgScope *P) { Parent = P; }
Bill Wendling2f921f82009-05-15 09:23:25 +0000162 DIDescriptor getDesc() const { return Desc; }
Devang Patel32cc43c2010-05-07 20:54:48 +0000163 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
164 const MDNode *getScopeNode() const { return Desc; }
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +0000165 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
Devang Patel406798a2010-08-09 18:51:29 +0000166 const SmallVector<DbgVariable *, 8> &getDbgVariables() { return Variables; }
Devang Patel6c74a872010-04-27 19:46:33 +0000167 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
168
169 /// openInsnRange - This scope covers instruction range starting from MI.
170 void openInsnRange(const MachineInstr *MI) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000171 if (!FirstInsn)
Devang Patel6c74a872010-04-27 19:46:33 +0000172 FirstInsn = MI;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000173
Devang Patel6c74a872010-04-27 19:46:33 +0000174 if (Parent)
175 Parent->openInsnRange(MI);
176 }
177
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000178 /// extendInsnRange - Extend the current instruction range covered by
Devang Patel6c74a872010-04-27 19:46:33 +0000179 /// this scope.
180 void extendInsnRange(const MachineInstr *MI) {
181 assert (FirstInsn && "MI Range is not open!");
182 LastInsn = MI;
183 if (Parent)
184 Parent->extendInsnRange(MI);
185 }
186
187 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
188 /// until now. This is used when a new scope is encountered while walking
189 /// machine instructions.
190 void closeInsnRange(DbgScope *NewScope = NULL) {
191 assert (LastInsn && "Last insn missing!");
192 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000193 FirstInsn = NULL;
Devang Patel6c74a872010-04-27 19:46:33 +0000194 LastInsn = NULL;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000195 // If Parent dominates NewScope then do not close Parent's instruction
Devang Patel6c74a872010-04-27 19:46:33 +0000196 // range.
197 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
198 Parent->closeInsnRange(NewScope);
199 }
200
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000201 void setAbstractScope() { AbstractScope = true; }
202 bool isAbstractScope() const { return AbstractScope; }
Devang Patel6c74a872010-04-27 19:46:33 +0000203
204 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
205 unsigned getDFSOut() const { return DFSOut; }
206 void setDFSOut(unsigned O) { DFSOut = O; }
207 unsigned getDFSIn() const { return DFSIn; }
208 void setDFSIn(unsigned I) { DFSIn = I; }
209 bool dominates(const DbgScope *S) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000210 if (S == this)
Devang Patel6c74a872010-04-27 19:46:33 +0000211 return true;
212 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
213 return true;
214 return false;
215 }
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000216
Devang Patel930143b2009-11-21 02:48:08 +0000217 /// addScope - Add a scope to the scope.
Bill Wendling2f921f82009-05-15 09:23:25 +0000218 ///
Devang Patel930143b2009-11-21 02:48:08 +0000219 void addScope(DbgScope *S) { Scopes.push_back(S); }
Bill Wendling2f921f82009-05-15 09:23:25 +0000220
Devang Patel930143b2009-11-21 02:48:08 +0000221 /// addVariable - Add a variable to the scope.
Bill Wendling2f921f82009-05-15 09:23:25 +0000222 ///
Devang Patel930143b2009-11-21 02:48:08 +0000223 void addVariable(DbgVariable *V) { Variables.push_back(V); }
Bill Wendling2f921f82009-05-15 09:23:25 +0000224
Bill Wendling2f921f82009-05-15 09:23:25 +0000225#ifndef NDEBUG
226 void dump() const;
227#endif
228};
Devang Patel6c74a872010-04-27 19:46:33 +0000229
Chris Lattnerf5d06362010-04-05 04:09:20 +0000230} // end llvm namespace
Bill Wendling2f921f82009-05-15 09:23:25 +0000231
232#ifndef NDEBUG
233void DbgScope::dump() const {
David Greenec230cb92009-12-24 00:31:35 +0000234 raw_ostream &err = dbgs();
Chris Lattner81e8e022009-08-23 00:51:00 +0000235 err.indent(IndentLevel);
Devang Patel32cc43c2010-05-07 20:54:48 +0000236 const MDNode *N = Desc;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000237 N->dump();
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000238 if (AbstractScope)
239 err << "Abstract Scope\n";
Bill Wendling2f921f82009-05-15 09:23:25 +0000240
241 IndentLevel += 2;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000242 if (!Scopes.empty())
243 err << "Children ...\n";
Bill Wendling2f921f82009-05-15 09:23:25 +0000244 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
245 if (Scopes[i] != this)
246 Scopes[i]->dump();
247
248 IndentLevel -= 2;
249}
250#endif
251
Bill Wendling2f921f82009-05-15 09:23:25 +0000252DbgScope::~DbgScope() {
Bill Wendling2f921f82009-05-15 09:23:25 +0000253 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
254 delete Variables[j];
Bill Wendling2f921f82009-05-15 09:23:25 +0000255}
256
Chris Lattnerf0d6bd32010-04-05 05:11:15 +0000257DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
Devang Patel1a0df9a2010-05-10 22:49:55 +0000258 : Asm(A), MMI(Asm->MMI), FirstCU(0),
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000259 AbbreviationsSet(InitAbbreviationsSetSize),
Devang Patel12563b32010-04-16 23:33:45 +0000260 CurrentFnDbgScope(0), PrevLabel(NULL) {
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000261 NextStringPoolNumber = 0;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000262
Chris Lattnere58b5472010-04-04 23:10:38 +0000263 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
264 DwarfStrSectionSym = TextSectionSym = 0;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000265 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
Devang Patel9fc11702010-05-25 23:40:22 +0000266 FunctionBeginSym = FunctionEndSym = 0;
Dan Gohman6e681a52010-06-18 15:56:31 +0000267 {
268 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
269 beginModule(M);
Torok Edwinf8dba242010-04-07 10:44:46 +0000270 }
Bill Wendling2f921f82009-05-15 09:23:25 +0000271}
272DwarfDebug::~DwarfDebug() {
Bill Wendling2f921f82009-05-15 09:23:25 +0000273}
274
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000275MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
276 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
277 if (Entry.first) return Entry.first;
278
279 Entry.second = NextStringPoolNumber++;
Chris Lattnera179b522010-04-04 19:25:43 +0000280 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000281}
282
283
Devang Patel930143b2009-11-21 02:48:08 +0000284/// assignAbbrevNumber - Define a unique number for the abbreviation.
Bill Wendling2f921f82009-05-15 09:23:25 +0000285///
Devang Patel930143b2009-11-21 02:48:08 +0000286void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
Bill Wendling2f921f82009-05-15 09:23:25 +0000287 // Profile the node so that we can make it unique.
288 FoldingSetNodeID ID;
289 Abbrev.Profile(ID);
290
291 // Check the set for priors.
292 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
293
294 // If it's newly added.
295 if (InSet == &Abbrev) {
296 // Add to abbreviation list.
297 Abbreviations.push_back(&Abbrev);
298
299 // Assign the vector position + 1 as its number.
300 Abbrev.setNumber(Abbreviations.size());
301 } else {
302 // Assign existing abbreviation number.
303 Abbrev.setNumber(InSet->getNumber());
304 }
305}
306
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000307/// getRealLinkageName - If special LLVM prefix that is used to inform the asm
Devang Patel43ef34d2010-01-05 01:46:14 +0000308/// printer to not emit usual symbol prefix before the symbol name is used then
309/// return linkage name after skipping this special LLVM prefix.
310static StringRef getRealLinkageName(StringRef LinkageName) {
311 char One = '\1';
312 if (LinkageName.startswith(StringRef(&One, 1)))
313 return LinkageName.substr(1);
314 return LinkageName;
315}
316
Devang Patel525dda02009-12-14 16:18:45 +0000317/// createSubprogramDIE - Create new DIE using SP.
Devang Patel185051c2010-09-27 23:15:27 +0000318DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) {
Devang Patel1a0df9a2010-05-10 22:49:55 +0000319 CompileUnit *SPCU = getCompileUnit(SP);
320 DIE *SPDie = SPCU->getDIE(SP);
Devang Patel525dda02009-12-14 16:18:45 +0000321 if (SPDie)
322 return SPDie;
323
324 SPDie = new DIE(dwarf::DW_TAG_subprogram);
Devang Patel1d6bbd42011-04-22 23:10:17 +0000325
326 // DW_TAG_inlined_subroutine may refer to this DIE.
327 SPCU->insertDIE(SP, SPDie);
328
329 // Add to context owner.
330 SPCU->addToContextOwner(SPDie, SP.getContext());
331
332 // Add function template parameters.
333 SPCU->addTemplateParams(*SPDie, SP.getTemplateParams());
334
335 // If this DIE is going to refer declaration info using AT_specification
336 // then there is no need to add other attributes.
337 if (SP.getFunctionDeclaration().isSubprogram())
338 return SPDie;
339
Devang Patelf200b392010-03-02 17:58:15 +0000340 // Constructors and operators for anonymous aggregates do not have names.
Devang Pateld0fa3042010-03-02 01:26:20 +0000341 if (!SP.getName().empty())
Devang Patelf20c4f72011-04-12 22:53:02 +0000342 SPCU->addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
343 SP.getName());
Bill Wendling2f921f82009-05-15 09:23:25 +0000344
Devang Patel2d9caf92009-11-25 17:36:49 +0000345 StringRef LinkageName = SP.getLinkageName();
Devang Patel43ef34d2010-01-05 01:46:14 +0000346 if (!LinkageName.empty())
Devang Patelf20c4f72011-04-12 22:53:02 +0000347 SPCU->addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
348 getRealLinkageName(LinkageName));
Devang Patel43ef34d2010-01-05 01:46:14 +0000349
Devang Patelf20c4f72011-04-12 22:53:02 +0000350 SPCU->addSourceLine(SPDie, SP);
Bill Wendling2f921f82009-05-15 09:23:25 +0000351
Devang Patel3a24f922010-10-07 22:03:01 +0000352 if (SP.isPrototyped())
Devang Patelf20c4f72011-04-12 22:53:02 +0000353 SPCU->addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Devang Patel1d6bbd42011-04-22 23:10:17 +0000354
Bill Wendling2f921f82009-05-15 09:23:25 +0000355 // Add Return Type.
Devang Patel236526d2009-12-03 01:25:38 +0000356 DICompositeType SPTy = SP.getType();
357 DIArray Args = SPTy.getTypeArray();
Bill Wendling2f921f82009-05-15 09:23:25 +0000358 unsigned SPTag = SPTy.getTag();
Devang Pateleb57c592009-12-03 19:11:07 +0000359
Devang Patel3b548aa2010-03-08 20:52:55 +0000360 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
Devang Patelf20c4f72011-04-12 22:53:02 +0000361 SPCU->addType(SPDie, SPTy);
Devang Patel236526d2009-12-03 01:25:38 +0000362 else
Devang Patelf20c4f72011-04-12 22:53:02 +0000363 SPCU->addType(SPDie, DIType(Args.getElement(0)));
Devang Patel236526d2009-12-03 01:25:38 +0000364
Devang Pateleb57c592009-12-03 19:11:07 +0000365 unsigned VK = SP.getVirtuality();
366 if (VK) {
Devang Patelf20c4f72011-04-12 22:53:02 +0000367 SPCU->addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
368 DIEBlock *Block = SPCU->getDIEBlock();
369 SPCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
370 SPCU->addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
371 SPCU->addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000372 ContainingTypeMap.insert(std::make_pair(SPDie,
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000373 SP.getContainingType()));
Devang Pateleb57c592009-12-03 19:11:07 +0000374 }
375
Devang Patel185051c2010-09-27 23:15:27 +0000376 if (!SP.isDefinition()) {
Devang Patelf20c4f72011-04-12 22:53:02 +0000377 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
378
Bill Wendling2f921f82009-05-15 09:23:25 +0000379 // Add arguments. Do not add arguments for subprogram definition. They will
Devang Patel236526d2009-12-03 01:25:38 +0000380 // be handled while processing variables.
381 DICompositeType SPTy = SP.getType();
382 DIArray Args = SPTy.getTypeArray();
383 unsigned SPTag = SPTy.getTag();
384
Bill Wendling2f921f82009-05-15 09:23:25 +0000385 if (SPTag == dwarf::DW_TAG_subroutine_type)
386 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
387 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000388 DIType ATy = DIType(DIType(Args.getElement(i)));
Devang Patelf20c4f72011-04-12 22:53:02 +0000389 SPCU->addType(Arg, ATy);
Devang Patel6efc8e52010-02-06 01:02:37 +0000390 if (ATy.isArtificial())
Devang Patelf20c4f72011-04-12 22:53:02 +0000391 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
Devang Patel930143b2009-11-21 02:48:08 +0000392 SPDie->addChild(Arg);
Bill Wendling2f921f82009-05-15 09:23:25 +0000393 }
394 }
395
Devang Patel999b4992010-02-03 19:57:19 +0000396 if (SP.isArtificial())
Devang Patelf20c4f72011-04-12 22:53:02 +0000397 SPCU->addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
Devang Patel999b4992010-02-03 19:57:19 +0000398
Devang Patelb4e3b902010-04-30 19:38:23 +0000399 if (!SP.isLocalToUnit())
Devang Patelf20c4f72011-04-12 22:53:02 +0000400 SPCU->addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000401
Devang Patelb4e3b902010-04-30 19:38:23 +0000402 if (SP.isOptimized())
Devang Patelf20c4f72011-04-12 22:53:02 +0000403 SPCU->addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
Devang Patelb4e3b902010-04-30 19:38:23 +0000404
Jim Grosbach965a73a2010-07-21 23:03:52 +0000405 if (unsigned isa = Asm->getISAEncoding()) {
Devang Patelf20c4f72011-04-12 22:53:02 +0000406 SPCU->addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
Jim Grosbach965a73a2010-07-21 23:03:52 +0000407 }
408
Bill Wendling2f921f82009-05-15 09:23:25 +0000409 return SPDie;
410}
411
Devang Patel32cc43c2010-05-07 20:54:48 +0000412DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
Chris Lattner8d2fe282010-03-31 05:36:29 +0000413 assert(N && "Invalid Scope encoding!");
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000414
415 DbgScope *AScope = AbstractScopes.lookup(N);
416 if (AScope)
417 return AScope;
Jim Grosbach042483e2009-11-21 23:12:12 +0000418
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000419 DbgScope *Parent = NULL;
420
421 DIDescriptor Scope(N);
422 if (Scope.isLexicalBlock()) {
423 DILexicalBlock DB(N);
424 DIDescriptor ParentDesc = DB.getContext();
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000425 Parent = getOrCreateAbstractScope(ParentDesc);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000426 }
427
428 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
429
430 if (Parent)
Devang Patel930143b2009-11-21 02:48:08 +0000431 Parent->addScope(AScope);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000432 AScope->setAbstractScope();
433 AbstractScopes[N] = AScope;
434 if (DIDescriptor(N).isSubprogram())
435 AbstractScopesList.push_back(AScope);
436 return AScope;
437}
Devang Patel75cc16c2009-10-01 20:31:14 +0000438
Devang Patel019922d2010-04-06 23:53:48 +0000439/// isSubprogramContext - Return true if Context is either a subprogram
440/// or another context nested inside a subprogram.
Devang Patel32cc43c2010-05-07 20:54:48 +0000441static bool isSubprogramContext(const MDNode *Context) {
Devang Patel019922d2010-04-06 23:53:48 +0000442 if (!Context)
443 return false;
444 DIDescriptor D(Context);
445 if (D.isSubprogram())
446 return true;
447 if (D.isType())
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000448 return isSubprogramContext(DIType(Context).getContext());
Devang Patel019922d2010-04-06 23:53:48 +0000449 return false;
450}
451
Jim Grosbach042483e2009-11-21 23:12:12 +0000452/// updateSubprogramScopeDIE - Find DIE for the given subprogram and
Devang Patel930143b2009-11-21 02:48:08 +0000453/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
454/// If there are global variables in this scope then create and insert
455/// DIEs for these variables.
Devang Patel32cc43c2010-05-07 20:54:48 +0000456DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
Devang Patel1a0df9a2010-05-10 22:49:55 +0000457 CompileUnit *SPCU = getCompileUnit(SPNode);
458 DIE *SPDie = SPCU->getDIE(SPNode);
Devang Patela37a95e2010-07-07 22:20:57 +0000459
Chris Lattner3a383cb2010-04-05 00:13:49 +0000460 assert(SPDie && "Unable to find subprogram DIE!");
461 DISubprogram SP(SPNode);
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000462
Devang Patel1d6bbd42011-04-22 23:10:17 +0000463 DISubprogram SPDecl = SP.getFunctionDeclaration();
464 if (SPDecl.isSubprogram())
465 // Refer function declaration directly.
Devang Patelf20c4f72011-04-12 22:53:02 +0000466 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
Devang Patel1d6bbd42011-04-22 23:10:17 +0000467 createSubprogramDIE(SPDecl));
468 else {
469 // There is not any need to generate specification DIE for a function
470 // defined at compile unit level. If a function is defined inside another
471 // function then gdb prefers the definition at top level and but does not
472 // expect specification DIE in parent function. So avoid creating
473 // specification DIE for a function defined inside a function.
474 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
475 !SP.getContext().isFile() &&
476 !isSubprogramContext(SP.getContext())) {
477 SPCU-> addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
478
479 // Add arguments.
480 DICompositeType SPTy = SP.getType();
481 DIArray Args = SPTy.getTypeArray();
482 unsigned SPTag = SPTy.getTag();
483 if (SPTag == dwarf::DW_TAG_subroutine_type)
484 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
485 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
486 DIType ATy = DIType(DIType(Args.getElement(i)));
487 SPCU->addType(Arg, ATy);
488 if (ATy.isArtificial())
489 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
490 SPDie->addChild(Arg);
491 }
492 DIE *SPDeclDie = SPDie;
493 SPDie = new DIE(dwarf::DW_TAG_subprogram);
494 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
495 SPDeclDie);
496 SPCU->addDie(SPDie);
497 }
Chris Lattner3a383cb2010-04-05 00:13:49 +0000498 }
Devang Patela37a95e2010-07-07 22:20:57 +0000499 // Pick up abstract subprogram DIE.
500 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
501 SPDie = new DIE(dwarf::DW_TAG_subprogram);
Devang Patelf20c4f72011-04-12 22:53:02 +0000502 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
503 dwarf::DW_FORM_ref4, AbsSPDIE);
Devang Patela37a95e2010-07-07 22:20:57 +0000504 SPCU->addDie(SPDie);
505 }
506
Devang Patelf20c4f72011-04-12 22:53:02 +0000507 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
508 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
509 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
510 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
Chris Lattner3a383cb2010-04-05 00:13:49 +0000511 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
512 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
Devang Patelf20c4f72011-04-12 22:53:02 +0000513 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
Devang Patel6efc8e52010-02-06 01:02:37 +0000514
Chris Lattner3a383cb2010-04-05 00:13:49 +0000515 return SPDie;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000516}
517
Jim Grosbach042483e2009-11-21 23:12:12 +0000518/// constructLexicalScope - Construct new DW_TAG_lexical_block
Devang Patel930143b2009-11-21 02:48:08 +0000519/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
520DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
Devang Patel6c74a872010-04-27 19:46:33 +0000521
522 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
523 if (Scope->isAbstractScope())
524 return ScopeDIE;
525
526 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
527 if (Ranges.empty())
528 return 0;
529
Devang Patelf20c4f72011-04-12 22:53:02 +0000530 CompileUnit *TheCU = getCompileUnit(Scope->getScopeNode());
Devang Patel6c74a872010-04-27 19:46:33 +0000531 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
532 if (Ranges.size() > 1) {
533 // .debug_range section has not been laid out yet. Emit offset in
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000534 // .debug_range as a uint, size 4, for now. emitDIE will handle
Devang Patel6c74a872010-04-27 19:46:33 +0000535 // DW_AT_ranges appropriately.
Devang Patelf20c4f72011-04-12 22:53:02 +0000536 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
537 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
Devang Patel6c74a872010-04-27 19:46:33 +0000538 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
539 RE = Ranges.end(); RI != RE; ++RI) {
Devang Patel9fc11702010-05-25 23:40:22 +0000540 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
541 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
Devang Patel6c74a872010-04-27 19:46:33 +0000542 }
543 DebugRangeSymbols.push_back(NULL);
544 DebugRangeSymbols.push_back(NULL);
545 return ScopeDIE;
546 }
547
Devang Patel9fc11702010-05-25 23:40:22 +0000548 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
549 const MCSymbol *End = getLabelAfterInsn(RI->second);
Devang Patel6c74a872010-04-27 19:46:33 +0000550
Devang Patel9fc11702010-05-25 23:40:22 +0000551 if (End == 0) return 0;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000552
Chris Lattnere13c3722010-03-09 01:58:53 +0000553 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
554 assert(End->isDefined() && "Invalid end label for an inlined scope!");
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000555
Devang Patelf20c4f72011-04-12 22:53:02 +0000556 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
557 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000558
559 return ScopeDIE;
560}
561
Devang Patel930143b2009-11-21 02:48:08 +0000562/// constructInlinedScopeDIE - This scope represents inlined body of
563/// a function. Construct DIE to represent this concrete inlined copy
564/// of the function.
565DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
Devang Patel6c74a872010-04-27 19:46:33 +0000566
567 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000568 assert (Ranges.empty() == false
Devang Patel6c74a872010-04-27 19:46:33 +0000569 && "DbgScope does not have instruction markers!");
570
571 // FIXME : .debug_inlined section specification does not clearly state how
572 // to emit inlined scope that is split into multiple instruction ranges.
573 // For now, use first instruction range and emit low_pc/high_pc pair and
574 // corresponding .debug_inlined section entry for this pair.
575 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
Devang Patel9fc11702010-05-25 23:40:22 +0000576 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
577 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
Devang Patel6c74a872010-04-27 19:46:33 +0000578
Devang Patel4c6bd662010-07-08 22:39:20 +0000579 if (StartLabel == 0 || EndLabel == 0) {
Devang Patel6c74a872010-04-27 19:46:33 +0000580 assert (0 && "Unexpected Start and End labels for a inlined scope!");
581 return 0;
582 }
Chris Lattnere13c3722010-03-09 01:58:53 +0000583 assert(StartLabel->isDefined() &&
Chris Lattnerc3b70f62010-03-09 01:51:43 +0000584 "Invalid starting label for an inlined scope!");
Chris Lattnere13c3722010-03-09 01:58:53 +0000585 assert(EndLabel->isDefined() &&
Chris Lattnerc3b70f62010-03-09 01:51:43 +0000586 "Invalid end label for an inlined scope!");
Devang Patel6c74a872010-04-27 19:46:33 +0000587
Devang Patel3b548aa2010-03-08 20:52:55 +0000588 if (!Scope->getScopeNode())
Devang Patelbc97f6b2010-03-08 19:20:38 +0000589 return NULL;
Devang Patel3b548aa2010-03-08 20:52:55 +0000590 DIScope DS(Scope->getScopeNode());
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000591 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
592
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000593 DISubprogram InlinedSP = getDISubprogram(DS);
Devang Patel1a0df9a2010-05-10 22:49:55 +0000594 CompileUnit *TheCU = getCompileUnit(InlinedSP);
595 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
Chris Lattner8d2fe282010-03-31 05:36:29 +0000596 assert(OriginDIE && "Unable to find Origin DIE!");
Devang Patelf20c4f72011-04-12 22:53:02 +0000597 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
598 dwarf::DW_FORM_ref4, OriginDIE);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000599
Devang Patelf20c4f72011-04-12 22:53:02 +0000600 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
601 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000602
603 InlinedSubprogramDIEs.insert(OriginDIE);
604
605 // Track the start label for this inlined function.
Devang Patel32cc43c2010-05-07 20:54:48 +0000606 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000607 I = InlineInfo.find(InlinedSP);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000608
609 if (I == InlineInfo.end()) {
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000610 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
Jim Grosbach00e9c612009-11-22 19:20:36 +0000611 ScopeDIE));
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000612 InlinedSPNodes.push_back(InlinedSP);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000613 } else
Chris Lattner085b6522010-03-09 00:31:02 +0000614 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000615
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000616 DILocation DL(Scope->getInlinedAt());
Devang Patelf20c4f72011-04-12 22:53:02 +0000617 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
618 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000619
620 return ScopeDIE;
621}
622
Devang Patel930143b2009-11-21 02:48:08 +0000623
624/// constructVariableDIE - Construct a DIE for the given DbgVariable.
Devang Patel9ccfb642009-12-09 18:24:21 +0000625DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000626 StringRef Name = DV->getName();
Devang Patel2d9caf92009-11-25 17:36:49 +0000627 if (Name.empty())
Devang Patel97f99fa2009-11-13 02:25:26 +0000628 return NULL;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000629
630 // Translate tag to proper Dwarf tag. The result variable is dropped for
631 // now.
632 unsigned Tag;
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000633 switch (DV->getTag()) {
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000634 case dwarf::DW_TAG_return_variable:
635 return NULL;
636 case dwarf::DW_TAG_arg_variable:
637 Tag = dwarf::DW_TAG_formal_parameter;
638 break;
639 case dwarf::DW_TAG_auto_variable: // fall thru
640 default:
641 Tag = dwarf::DW_TAG_variable;
642 break;
643 }
644
645 // Define variable debug information entry.
646 DIE *VariableDie = new DIE(Tag);
Devang Patelf20c4f72011-04-12 22:53:02 +0000647 CompileUnit *TheCU = getCompileUnit(DV->getVariable());
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000648 DIE *AbsDIE = NULL;
Devang Patele1c53f22010-05-20 16:36:41 +0000649 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
650 V2AVI = VarToAbstractVarMap.find(DV);
651 if (V2AVI != VarToAbstractVarMap.end())
652 AbsDIE = V2AVI->second->getDIE();
Jim Grosbach042483e2009-11-21 23:12:12 +0000653
Devang Patele1c53f22010-05-20 16:36:41 +0000654 if (AbsDIE)
Devang Patelf20c4f72011-04-12 22:53:02 +0000655 TheCU->addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
656 dwarf::DW_FORM_ref4, AbsDIE);
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000657 else {
Devang Patelf20c4f72011-04-12 22:53:02 +0000658 TheCU->addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
659 TheCU->addSourceLine(VariableDie, DV->getVariable());
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000660
661 // Add variable type.
Devang Patelf20c4f72011-04-12 22:53:02 +0000662 TheCU->addType(VariableDie, DV->getType());
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000663 }
664
Devang Patel6d9f9fe2010-08-09 21:01:39 +0000665 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
Devang Patelf20c4f72011-04-12 22:53:02 +0000666 TheCU->addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
Devang Patelbea08d12010-09-29 23:07:21 +0000667 else if (DIVariable(DV->getVariable()).isArtificial())
Devang Patelf20c4f72011-04-12 22:53:02 +0000668 TheCU->addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
Devang Patel9fc11702010-05-25 23:40:22 +0000669
670 if (Scope->isAbstractScope()) {
671 DV->setDIE(VariableDie);
672 return VariableDie;
673 }
674
675 // Add variable address.
676
677 unsigned Offset = DV->getDotDebugLocOffset();
678 if (Offset != ~0U) {
Devang Patelf20c4f72011-04-12 22:53:02 +0000679 TheCU->addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
Devang Patel9fc11702010-05-25 23:40:22 +0000680 Asm->GetTempSymbol("debug_loc", Offset));
681 DV->setDIE(VariableDie);
682 UseDotDebugLocEntry.insert(VariableDie);
683 return VariableDie;
684 }
685
686 // Check if variable is described by a DBG_VALUE instruction.
687 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
688 DbgVariableToDbgInstMap.find(DV);
689 if (DVI != DbgVariableToDbgInstMap.end()) {
690 const MachineInstr *DVInsn = DVI->second;
Devang Patel9fc11702010-05-25 23:40:22 +0000691 bool updated = false;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000692 // FIXME : Handle getNumOperands != 3
Devang Patel9fc11702010-05-25 23:40:22 +0000693 if (DVInsn->getNumOperands() == 3) {
Devang Patel86ec8b32010-08-31 22:22:42 +0000694 if (DVInsn->getOperand(0).isReg()) {
695 const MachineOperand RegOp = DVInsn->getOperand(0);
696 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
697 if (DVInsn->getOperand(1).isImm() &&
698 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
Devang Patelf20c4f72011-04-12 22:53:02 +0000699 TheCU->addVariableAddress(DV, VariableDie, DVInsn->getOperand(1).getImm());
Devang Patel86ec8b32010-08-31 22:22:42 +0000700 updated = true;
701 } else
Devang Patelf20c4f72011-04-12 22:53:02 +0000702 updated = TheCU->addRegisterAddress(VariableDie, RegOp);
Devang Patel86ec8b32010-08-31 22:22:42 +0000703 }
Devang Patel9fc11702010-05-25 23:40:22 +0000704 else if (DVInsn->getOperand(0).isImm())
Devang Patelf20c4f72011-04-12 22:53:02 +0000705 updated = TheCU->addConstantValue(VariableDie, DVInsn->getOperand(0));
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000706 else if (DVInsn->getOperand(0).isFPImm())
707 updated =
Devang Patelf20c4f72011-04-12 22:53:02 +0000708 TheCU->addConstantFPValue(VariableDie, DVInsn->getOperand(0));
Devang Patel9fc11702010-05-25 23:40:22 +0000709 } else {
710 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
711 if (Location.getReg()) {
Devang Patel2688e4a2011-04-25 22:52:55 +0000712 if (DV->getVariable().hasComplexAddress())
713 TheCU->addComplexAddress(DV, VariableDie, dwarf::DW_AT_location,
714 Location);
715 else
716 TheCU->addAddress(VariableDie, dwarf::DW_AT_location, Location);
Devang Patel9fc11702010-05-25 23:40:22 +0000717 updated = true;
718 }
719 }
720 if (!updated) {
721 // If variableDie is not updated then DBG_VALUE instruction does not
722 // have valid variable info.
723 delete VariableDie;
724 return NULL;
725 }
726 DV->setDIE(VariableDie);
727 return VariableDie;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000728 }
Devang Patel9fc11702010-05-25 23:40:22 +0000729
730 // .. else use frame index, if available.
Devang Patel9fc11702010-05-25 23:40:22 +0000731 int FI = 0;
Devang Patel2cfc3af2010-08-31 06:11:28 +0000732 if (findVariableFrameIndex(DV, &FI))
Devang Patelf20c4f72011-04-12 22:53:02 +0000733 TheCU->addVariableAddress(DV, VariableDie, FI);
Devang Patel2cfc3af2010-08-31 06:11:28 +0000734
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000735 DV->setDIE(VariableDie);
736 return VariableDie;
737
738}
Devang Patel930143b2009-11-21 02:48:08 +0000739
Devang Patelf20c4f72011-04-12 22:53:02 +0000740void CompileUnit::addPubTypes(DISubprogram SP) {
Devang Patel04d2f2d2009-11-24 01:14:22 +0000741 DICompositeType SPTy = SP.getType();
742 unsigned SPTag = SPTy.getTag();
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000743 if (SPTag != dwarf::DW_TAG_subroutine_type)
Devang Patel04d2f2d2009-11-24 01:14:22 +0000744 return;
745
746 DIArray Args = SPTy.getTypeArray();
Devang Patel04d2f2d2009-11-24 01:14:22 +0000747 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000748 DIType ATy(Args.getElement(i));
Devang Patel8d6a2b72010-05-07 21:45:47 +0000749 if (!ATy.Verify())
Devang Patel04d2f2d2009-11-24 01:14:22 +0000750 continue;
751 DICompositeType CATy = getDICompositeType(ATy);
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000752 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
Devang Patel12d150e2010-04-13 20:35:04 +0000753 && !CATy.isForwardDecl()) {
Devang Patelf20c4f72011-04-12 22:53:02 +0000754 if (DIEEntry *Entry = getDIEEntry(CATy))
755 addGlobalType(CATy.getName(), Entry->getEntry());
Devang Patel04d2f2d2009-11-24 01:14:22 +0000756 }
757 }
758}
759
Devang Patel930143b2009-11-21 02:48:08 +0000760/// constructScopeDIE - Construct a DIE for this scope.
761DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
Devang Patel3b548aa2010-03-08 20:52:55 +0000762 if (!Scope || !Scope->getScopeNode())
763 return NULL;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000764
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000765 SmallVector <DIE *, 8> Children;
Devang Patel6c622ef2011-03-01 22:58:55 +0000766
767 // Collect arguments for current function.
768 if (Scope == CurrentFnDbgScope)
769 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
770 if (DbgVariable *ArgDV = CurrentFnArguments[i])
771 if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
772 Children.push_back(Arg);
773
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000774 // Collect lexical scope childrens first.
775 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
776 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
777 if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
778 Children.push_back(Variable);
779 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
780 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
781 if (DIE *Nested = constructScopeDIE(Scopes[j]))
782 Children.push_back(Nested);
Devang Patel3b548aa2010-03-08 20:52:55 +0000783 DIScope DS(Scope->getScopeNode());
784 DIE *ScopeDIE = NULL;
785 if (Scope->getInlinedAt())
786 ScopeDIE = constructInlinedScopeDIE(Scope);
787 else if (DS.isSubprogram()) {
Devang Pateld10b2af2010-06-28 20:53:04 +0000788 ProcessedSPNodes.insert(DS);
Devang Patela37a95e2010-07-07 22:20:57 +0000789 if (Scope->isAbstractScope()) {
Devang Patel1a0df9a2010-05-10 22:49:55 +0000790 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
Devang Patela37a95e2010-07-07 22:20:57 +0000791 // Note down abstract DIE.
792 if (ScopeDIE)
793 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
794 }
Devang Patel3b548aa2010-03-08 20:52:55 +0000795 else
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000796 ScopeDIE = updateSubprogramScopeDIE(DS);
Devang Patel3b548aa2010-03-08 20:52:55 +0000797 }
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000798 else {
799 // There is no need to emit empty lexical block DIE.
800 if (Children.empty())
801 return NULL;
Devang Patel3b548aa2010-03-08 20:52:55 +0000802 ScopeDIE = constructLexicalScopeDIE(Scope);
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000803 }
804
Devang Patel23b2ae62010-03-29 22:59:58 +0000805 if (!ScopeDIE) return NULL;
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000806
Devang Patel5f1b4cd2011-02-19 01:31:27 +0000807 // Add children
808 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
809 E = Children.end(); I != E; ++I)
810 ScopeDIE->addChild(*I);
Devang Patel04d2f2d2009-11-24 01:14:22 +0000811
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000812 if (DS.isSubprogram())
Devang Patelf20c4f72011-04-12 22:53:02 +0000813 getCompileUnit(DS)->addPubTypes(DISubprogram(DS));
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000814
Devang Patel04d2f2d2009-11-24 01:14:22 +0000815 return ScopeDIE;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000816}
817
Bill Wendling2b128d72009-05-20 23:19:06 +0000818/// GetOrCreateSourceID - Look up the source id with the given directory and
819/// source file names. If none currently exists, create a new id and insert it
820/// in the SourceIds map. This can update DirectoryNames and SourceFileNames
821/// maps as well.
Devang Patel498877d2010-07-24 00:53:22 +0000822
Devang Patele01b75c2011-03-24 20:30:50 +0000823unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
824 StringRef DirName) {
Devang Patel871d0b12010-09-16 20:57:49 +0000825 // If FE did not provide a file name, then assume stdin.
826 if (FileName.empty())
Devang Patele01b75c2011-03-24 20:30:50 +0000827 return GetOrCreateSourceID("<stdin>", StringRef());
828
829 // MCStream expects full path name as filename.
830 if (!DirName.empty() && !FileName.startswith("/")) {
831 std::string FullPathName(DirName.data());
832 if (!DirName.endswith("/"))
833 FullPathName += "/";
834 FullPathName += FileName.data();
835 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
836 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
837 }
Devang Patel871d0b12010-09-16 20:57:49 +0000838
Rafael Espindola67c6ab82010-11-18 02:04:25 +0000839 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
840 if (Entry.getValue())
841 return Entry.getValue();
Bill Wendling2b128d72009-05-20 23:19:06 +0000842
Rafael Espindola67c6ab82010-11-18 02:04:25 +0000843 unsigned SrcId = SourceIdMap.size();
844 Entry.setValue(SrcId);
Bill Wendling2b128d72009-05-20 23:19:06 +0000845
Rafael Espindola67c6ab82010-11-18 02:04:25 +0000846 // Print out a .file directive to specify files for .loc directives.
Devang Patele01b75c2011-03-24 20:30:50 +0000847 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
Bill Wendling2b128d72009-05-20 23:19:06 +0000848
849 return SrcId;
850}
851
Devang Patel1f4690c2009-12-15 19:16:48 +0000852/// getOrCreateNameSpace - Create a DIE for DINameSpace.
Devang Patelf20c4f72011-04-12 22:53:02 +0000853DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
854 DIE *NDie = getDIE(NS);
Devang Patel1f4690c2009-12-15 19:16:48 +0000855 if (NDie)
856 return NDie;
857 NDie = new DIE(dwarf::DW_TAG_namespace);
Devang Patelf20c4f72011-04-12 22:53:02 +0000858 insertDIE(NS, NDie);
Devang Patel1f4690c2009-12-15 19:16:48 +0000859 if (!NS.getName().empty())
860 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
Devang Patelb6511a32010-08-09 20:20:05 +0000861 addSourceLine(NDie, NS);
Devang Patel1f4690c2009-12-15 19:16:48 +0000862 addToContextOwner(NDie, NS.getContext());
863 return NDie;
864}
865
Jim Grosbacha8683bb2010-07-21 21:21:52 +0000866/// constructCompileUnit - Create new CompileUnit for the given
Devang Patel1a0df9a2010-05-10 22:49:55 +0000867/// metadata node with tag DW_TAG_compile_unit.
Devang Patel32cc43c2010-05-07 20:54:48 +0000868void DwarfDebug::constructCompileUnit(const MDNode *N) {
Devang Patel80ae3492009-08-28 23:24:31 +0000869 DICompileUnit DIUnit(N);
Devang Patel2d9caf92009-11-25 17:36:49 +0000870 StringRef FN = DIUnit.getFilename();
871 StringRef Dir = DIUnit.getDirectory();
Devang Patele01b75c2011-03-24 20:30:50 +0000872 unsigned ID = GetOrCreateSourceID(FN, Dir);
Bill Wendling2b128d72009-05-20 23:19:06 +0000873
874 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Devang Patelf20c4f72011-04-12 22:53:02 +0000875 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
876 NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
877 DIUnit.getProducer());
878 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
879 DIUnit.getLanguage());
880 NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
Devang Patelbd798ce2010-04-26 22:54:28 +0000881 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
882 // simplifies debug range entries.
Devang Patelf20c4f72011-04-12 22:53:02 +0000883 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
Devang Pateld22ed622010-03-22 23:11:36 +0000884 // DW_AT_stmt_list is a offset of line number information for this
Devang Patel4a213872010-08-24 00:06:12 +0000885 // compile unit in debug_line section.
Devang Patelea636392010-08-31 23:50:19 +0000886 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList())
Devang Patelf20c4f72011-04-12 22:53:02 +0000887 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr,
888 Asm->GetTempSymbol("section_line"));
Devang Patelea636392010-08-31 23:50:19 +0000889 else
Devang Patelf20c4f72011-04-12 22:53:02 +0000890 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
Bill Wendling2b128d72009-05-20 23:19:06 +0000891
Devang Patel2d9caf92009-11-25 17:36:49 +0000892 if (!Dir.empty())
Devang Patelf20c4f72011-04-12 22:53:02 +0000893 NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
Bill Wendling2b128d72009-05-20 23:19:06 +0000894 if (DIUnit.isOptimized())
Devang Patelf20c4f72011-04-12 22:53:02 +0000895 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
Bill Wendling2b128d72009-05-20 23:19:06 +0000896
Devang Patel2d9caf92009-11-25 17:36:49 +0000897 StringRef Flags = DIUnit.getFlags();
898 if (!Flags.empty())
Devang Patelf20c4f72011-04-12 22:53:02 +0000899 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
900
Bill Wendling2b128d72009-05-20 23:19:06 +0000901 unsigned RVer = DIUnit.getRunTimeVersion();
902 if (RVer)
Devang Patelf20c4f72011-04-12 22:53:02 +0000903 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
Bill Wendling2b128d72009-05-20 23:19:06 +0000904 dwarf::DW_FORM_data1, RVer);
905
Devang Patel1a0df9a2010-05-10 22:49:55 +0000906 if (!FirstCU)
907 FirstCU = NewCU;
908 CUMap.insert(std::make_pair(N, NewCU));
Bill Wendling2b128d72009-05-20 23:19:06 +0000909}
910
Devang Patel1a0df9a2010-05-10 22:49:55 +0000911/// getCompielUnit - Get CompileUnit DIE.
912CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
913 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
914 DIDescriptor D(N);
915 const MDNode *CUNode = NULL;
916 if (D.isCompileUnit())
917 CUNode = N;
918 else if (D.isSubprogram())
919 CUNode = DISubprogram(N).getCompileUnit();
920 else if (D.isType())
921 CUNode = DIType(N).getCompileUnit();
922 else if (D.isGlobalVariable())
923 CUNode = DIGlobalVariable(N).getCompileUnit();
924 else if (D.isVariable())
925 CUNode = DIVariable(N).getCompileUnit();
926 else if (D.isNameSpace())
927 CUNode = DINameSpace(N).getCompileUnit();
928 else if (D.isFile())
929 CUNode = DIFile(N).getCompileUnit();
930 else
931 return FirstCU;
932
933 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
934 = CUMap.find(CUNode);
935 if (I == CUMap.end())
936 return FirstCU;
937 return I->second;
938}
939
Devang Patela8652672010-08-23 18:25:56 +0000940/// isUnsignedDIType - Return true if type encoding is unsigned.
941static bool isUnsignedDIType(DIType Ty) {
942 DIDerivedType DTy(Ty);
943 if (DTy.Verify())
944 return isUnsignedDIType(DTy.getTypeDerivedFrom());
945
946 DIBasicType BTy(Ty);
947 if (BTy.Verify()) {
948 unsigned Encoding = BTy.getEncoding();
949 if (Encoding == dwarf::DW_ATE_unsigned ||
950 Encoding == dwarf::DW_ATE_unsigned_char)
951 return true;
952 }
953 return false;
954}
Devang Patel1a0df9a2010-05-10 22:49:55 +0000955
Devang Patel2d9e5322011-01-20 00:02:16 +0000956// Return const exprssion if value is a GEP to access merged global
957// constant. e.g.
958// i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
959static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
960 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
961 if (!CE || CE->getNumOperands() != 3 ||
962 CE->getOpcode() != Instruction::GetElementPtr)
963 return NULL;
964
965 // First operand points to a global value.
966 if (!isa<GlobalValue>(CE->getOperand(0)))
967 return NULL;
968
969 // Second operand is zero.
970 const ConstantInt *CI =
971 dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
972 if (!CI || !CI->isZero())
973 return NULL;
974
975 // Third operand is offset.
976 if (!isa<ConstantInt>(CE->getOperand(2)))
977 return NULL;
978
979 return CE;
980}
981
Devang Patel1a0df9a2010-05-10 22:49:55 +0000982/// constructGlobalVariableDIE - Construct global variable DIE.
Devang Patel32cc43c2010-05-07 20:54:48 +0000983void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
Devang Patel469c12d22010-08-10 01:37:23 +0000984 DIGlobalVariable GV(N);
Daniel Dunbarc418d6b2009-09-19 20:40:05 +0000985
Devang Patelf5d53602009-09-04 23:59:07 +0000986 // If debug information is malformed then ignore it.
Devang Patel469c12d22010-08-10 01:37:23 +0000987 if (GV.Verify() == false)
Devang Patelf5d53602009-09-04 23:59:07 +0000988 return;
Bill Wendling2b128d72009-05-20 23:19:06 +0000989
990 // Check for pre-existence.
Devang Patel1a0df9a2010-05-10 22:49:55 +0000991 CompileUnit *TheCU = getCompileUnit(N);
Devang Patel469c12d22010-08-10 01:37:23 +0000992 if (TheCU->getDIE(GV))
Devang Patel0751a282009-06-26 01:49:18 +0000993 return;
Bill Wendling2b128d72009-05-20 23:19:06 +0000994
Devang Patel469c12d22010-08-10 01:37:23 +0000995 DIType GTy = GV.getType();
Devang Patelb2197462010-08-10 07:11:13 +0000996 DIE *VariableDIE = new DIE(GV.getTag());
997
998 bool isGlobalVariable = GV.getGlobal() != NULL;
Bill Wendling2b128d72009-05-20 23:19:06 +0000999
Devang Patel469c12d22010-08-10 01:37:23 +00001000 // Add name.
Devang Patelf20c4f72011-04-12 22:53:02 +00001001 TheCU->addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1002 GV.getDisplayName());
Devang Patel469c12d22010-08-10 01:37:23 +00001003 StringRef LinkageName = GV.getLinkageName();
Devang Patelb2197462010-08-10 07:11:13 +00001004 if (!LinkageName.empty() && isGlobalVariable)
Devang Patelf20c4f72011-04-12 22:53:02 +00001005 TheCU->addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1006 dwarf::DW_FORM_string,
1007 getRealLinkageName(LinkageName));
Devang Patel469c12d22010-08-10 01:37:23 +00001008 // Add type.
Devang Patelf20c4f72011-04-12 22:53:02 +00001009 TheCU->addType(VariableDIE, GTy);
Devang Patel12d150e2010-04-13 20:35:04 +00001010 if (GTy.isCompositeType() && !GTy.getName().empty()
1011 && !GTy.isForwardDecl()) {
Devang Patel1a0df9a2010-05-10 22:49:55 +00001012 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
Chris Lattner8d2fe282010-03-31 05:36:29 +00001013 assert(Entry && "Missing global type!");
Devang Patel1a0df9a2010-05-10 22:49:55 +00001014 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
Devang Patel04d2f2d2009-11-24 01:14:22 +00001015 }
Devang Patel469c12d22010-08-10 01:37:23 +00001016 // Add scoping info.
1017 if (!GV.isLocalToUnit()) {
Devang Patelf20c4f72011-04-12 22:53:02 +00001018 TheCU->addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
Devang Patel469c12d22010-08-10 01:37:23 +00001019 // Expose as global.
1020 TheCU->addGlobal(GV.getName(), VariableDIE);
1021 }
1022 // Add line number info.
Devang Patelf20c4f72011-04-12 22:53:02 +00001023 TheCU->addSourceLine(VariableDIE, GV);
Devang Patel469c12d22010-08-10 01:37:23 +00001024 // Add to map.
1025 TheCU->insertDIE(N, VariableDIE);
1026 // Add to context owner.
1027 DIDescriptor GVContext = GV.getContext();
Devang Patelf20c4f72011-04-12 22:53:02 +00001028 TheCU->addToContextOwner(VariableDIE, GVContext);
Devang Patel469c12d22010-08-10 01:37:23 +00001029 // Add location.
Devang Patelb2197462010-08-10 07:11:13 +00001030 if (isGlobalVariable) {
1031 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patelf20c4f72011-04-12 22:53:02 +00001032 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1033 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
Devang Patelb2197462010-08-10 07:11:13 +00001034 Asm->Mang->getSymbol(GV.getGlobal()));
1035 // Do not create specification DIE if context is either compile unit
1036 // or a subprogram.
1037 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1038 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1039 // Create specification DIE.
1040 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
Devang Patelf20c4f72011-04-12 22:53:02 +00001041 TheCU->addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
Devang Patelb2197462010-08-10 07:11:13 +00001042 dwarf::DW_FORM_ref4, VariableDIE);
Devang Patelf20c4f72011-04-12 22:53:02 +00001043 TheCU->addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1044 TheCU->addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Devang Patelb2197462010-08-10 07:11:13 +00001045 TheCU->addDie(VariableSpecDIE);
1046 } else {
Devang Patelf20c4f72011-04-12 22:53:02 +00001047 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
Devang Patelb2197462010-08-10 07:11:13 +00001048 }
Devang Patel70eb9822011-01-06 21:39:25 +00001049 } else if (ConstantInt *CI =
1050 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
Devang Patelf20c4f72011-04-12 22:53:02 +00001051 TheCU->addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
Devang Patel2d9e5322011-01-20 00:02:16 +00001052 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1053 // GV is a merged global.
1054 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patelf20c4f72011-04-12 22:53:02 +00001055 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1056 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1057 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
Devang Patel2d9e5322011-01-20 00:02:16 +00001058 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
Devang Patelf20c4f72011-04-12 22:53:02 +00001059 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1060 TheCU->addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
1061 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1062 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
Devang Patel2d9e5322011-01-20 00:02:16 +00001063 }
Devang Patel70eb9822011-01-06 21:39:25 +00001064
Devang Patel0751a282009-06-26 01:49:18 +00001065 return;
Bill Wendling2b128d72009-05-20 23:19:06 +00001066}
1067
Devang Patel1a0df9a2010-05-10 22:49:55 +00001068/// construct SubprogramDIE - Construct subprogram DIE.
Devang Patel32cc43c2010-05-07 20:54:48 +00001069void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
Devang Patel80ae3492009-08-28 23:24:31 +00001070 DISubprogram SP(N);
Bill Wendling2b128d72009-05-20 23:19:06 +00001071
Stuart Hastings4bd3dd92010-04-06 21:38:29 +00001072 // Check for pre-existence.
Devang Patel1a0df9a2010-05-10 22:49:55 +00001073 CompileUnit *TheCU = getCompileUnit(N);
1074 if (TheCU->getDIE(N))
Stuart Hastings4bd3dd92010-04-06 21:38:29 +00001075 return;
1076
Bill Wendling2b128d72009-05-20 23:19:06 +00001077 if (!SP.isDefinition())
1078 // This is a method declaration which will be handled while constructing
1079 // class type.
Devang Patel0751a282009-06-26 01:49:18 +00001080 return;
Bill Wendling2b128d72009-05-20 23:19:06 +00001081
Stuart Hastings4bd3dd92010-04-06 21:38:29 +00001082 DIE *SubprogramDie = createSubprogramDIE(SP);
1083
1084 // Add to map.
Devang Patel1a0df9a2010-05-10 22:49:55 +00001085 TheCU->insertDIE(N, SubprogramDie);
Bill Wendling2b128d72009-05-20 23:19:06 +00001086
1087 // Add to context owner.
Devang Patelf20c4f72011-04-12 22:53:02 +00001088 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
Devang Patel512001a2009-12-08 23:21:45 +00001089
Bill Wendling2b128d72009-05-20 23:19:06 +00001090 // Expose as global.
Devang Patel1a0df9a2010-05-10 22:49:55 +00001091 TheCU->addGlobal(SP.getName(), SubprogramDie);
Devang Patel04d2f2d2009-11-24 01:14:22 +00001092
Devang Patel0751a282009-06-26 01:49:18 +00001093 return;
Bill Wendling2b128d72009-05-20 23:19:06 +00001094}
1095
Devang Patel930143b2009-11-21 02:48:08 +00001096/// beginModule - Emit all Dwarf sections that should come prior to the
Daniel Dunbarbe22ec42009-09-19 20:40:14 +00001097/// content. Create global DIEs and emit initial debug info sections.
1098/// This is inovked by the target AsmPrinter.
Chris Lattner11980022010-04-04 07:48:20 +00001099void DwarfDebug::beginModule(Module *M) {
Devang Patel6c74a872010-04-27 19:46:33 +00001100 if (DisableDebugInfoPrinting)
1101 return;
1102
Devang Patel63524442009-07-30 18:56:46 +00001103 DebugInfoFinder DbgFinder;
1104 DbgFinder.processModule(*M);
Devang Patel0751a282009-06-26 01:49:18 +00001105
Chris Lattner7cfa70e2010-04-05 02:19:28 +00001106 bool HasDebugInfo = false;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001107
Chris Lattner7cfa70e2010-04-05 02:19:28 +00001108 // Scan all the compile-units to see if there are any marked as the main unit.
1109 // if not, we do not generate debug info.
1110 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1111 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1112 if (DICompileUnit(*I).isMain()) {
1113 HasDebugInfo = true;
1114 break;
1115 }
1116 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001117
Chris Lattner7cfa70e2010-04-05 02:19:28 +00001118 if (!HasDebugInfo) return;
1119
1120 // Tell MMI that we have debug info.
1121 MMI->setDebugInfoAvailability(true);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001122
Chris Lattnerd442aa32010-04-04 23:17:54 +00001123 // Emit initial sections.
Chris Lattner7cfa70e2010-04-05 02:19:28 +00001124 EmitSectionLabels();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001125
Bill Wendling2b128d72009-05-20 23:19:06 +00001126 // Create all the compile unit DIEs.
Devang Patel63524442009-07-30 18:56:46 +00001127 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1128 E = DbgFinder.compile_unit_end(); I != E; ++I)
Devang Patel930143b2009-11-21 02:48:08 +00001129 constructCompileUnit(*I);
Bill Wendling2b128d72009-05-20 23:19:06 +00001130
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001131 // Create DIEs for each subprogram.
Devang Patel63524442009-07-30 18:56:46 +00001132 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1133 E = DbgFinder.subprogram_end(); I != E; ++I)
Devang Patel930143b2009-11-21 02:48:08 +00001134 constructSubprogramDIE(*I);
Devang Patel0751a282009-06-26 01:49:18 +00001135
Devang Patel2b75ed22009-12-10 19:14:49 +00001136 // Create DIEs for each global variable.
1137 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1138 E = DbgFinder.global_variable_end(); I != E; ++I)
1139 constructGlobalVariableDIE(*I);
1140
Devang Patel8e06a5e2010-08-10 20:01:20 +00001141 //getOrCreateTypeDIE
1142 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
Devang Patelf20c4f72011-04-12 22:53:02 +00001143 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1144 DIType Ty(NMD->getOperand(i));
1145 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1146 }
Devang Patel8e06a5e2010-08-10 20:01:20 +00001147
Devang Patel7a554812010-09-28 18:08:20 +00001148 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
Devang Patelf20c4f72011-04-12 22:53:02 +00001149 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1150 DIType Ty(NMD->getOperand(i));
1151 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1152 }
Devang Patel7a554812010-09-28 18:08:20 +00001153
Bill Wendling2b128d72009-05-20 23:19:06 +00001154 // Prime section data.
Chris Lattner5e693ed2009-07-28 03:13:23 +00001155 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
Bill Wendling2b128d72009-05-20 23:19:06 +00001156}
1157
Devang Patel930143b2009-11-21 02:48:08 +00001158/// endModule - Emit all Dwarf sections that should come after the content.
Bill Wendling2b128d72009-05-20 23:19:06 +00001159///
Devang Patel930143b2009-11-21 02:48:08 +00001160void DwarfDebug::endModule() {
Devang Patel1a0df9a2010-05-10 22:49:55 +00001161 if (!FirstCU) return;
Devang Patelf3b2db62010-06-28 18:25:03 +00001162 const Module *M = MMI->getModule();
Devang Pateld0701282010-08-02 17:32:15 +00001163 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
Devang Patelf3b2db62010-06-28 18:25:03 +00001164 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
1165 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
1166 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
1167 DISubprogram SP(AllSPs->getOperand(SI));
1168 if (!SP.Verify()) continue;
1169
1170 // Collect info for variables that were optimized out.
Devang Patel18efced2010-07-19 17:53:55 +00001171 if (!SP.isDefinition()) continue;
Devang Patelf3b2db62010-06-28 18:25:03 +00001172 StringRef FName = SP.getLinkageName();
1173 if (FName.empty())
1174 FName = SP.getName();
Devang Patel364bf042010-11-10 22:19:21 +00001175 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
Devang Patelf3b2db62010-06-28 18:25:03 +00001176 if (!NMD) continue;
1177 unsigned E = NMD->getNumOperands();
1178 if (!E) continue;
1179 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
Devang Pateld0701282010-08-02 17:32:15 +00001180 DeadFnScopeMap[SP] = Scope;
Devang Patelf3b2db62010-06-28 18:25:03 +00001181 for (unsigned I = 0; I != E; ++I) {
1182 DIVariable DV(NMD->getOperand(I));
1183 if (!DV.Verify()) continue;
1184 Scope->addVariable(new DbgVariable(DV));
1185 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001186
Devang Patelf3b2db62010-06-28 18:25:03 +00001187 // Construct subprogram DIE and add variables DIEs.
1188 constructSubprogramDIE(SP);
1189 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
Devang Patel406798a2010-08-09 18:51:29 +00001190 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
Devang Patelf3b2db62010-06-28 18:25:03 +00001191 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1192 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1193 if (VariableDIE)
1194 ScopeDIE->addChild(VariableDIE);
1195 }
1196 }
1197 }
Bill Wendling2b128d72009-05-20 23:19:06 +00001198
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001199 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1200 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1201 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1202 DIE *ISP = *AI;
Devang Patelf20c4f72011-04-12 22:53:02 +00001203 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001204 }
1205
Devang Patel32cc43c2010-05-07 20:54:48 +00001206 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
Devang Pateleb57c592009-12-03 19:11:07 +00001207 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1208 DIE *SPDie = CI->first;
Devang Patel32cc43c2010-05-07 20:54:48 +00001209 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
Devang Pateleb57c592009-12-03 19:11:07 +00001210 if (!N) continue;
Devang Patel1a0df9a2010-05-10 22:49:55 +00001211 DIE *NDie = getCompileUnit(N)->getDIE(N);
Devang Pateleb57c592009-12-03 19:11:07 +00001212 if (!NDie) continue;
Devang Patelf20c4f72011-04-12 22:53:02 +00001213 getCompileUnit(N)->addDIEEntry(SPDie, dwarf::DW_AT_containing_type,
1214 dwarf::DW_FORM_ref4, NDie);
Devang Pateleb57c592009-12-03 19:11:07 +00001215 }
1216
Bill Wendling2b128d72009-05-20 23:19:06 +00001217 // Standard sections final addresses.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001218 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
Chris Lattnera179b522010-04-04 19:25:43 +00001219 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001220 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
Chris Lattnera179b522010-04-04 19:25:43 +00001221 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
Bill Wendling2b128d72009-05-20 23:19:06 +00001222
1223 // End text sections.
1224 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
Chris Lattner4b7dadb2009-08-19 05:49:37 +00001225 Asm->OutStreamer.SwitchSection(SectionMap[i]);
Chris Lattnera179b522010-04-04 19:25:43 +00001226 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
Bill Wendling2b128d72009-05-20 23:19:06 +00001227 }
1228
1229 // Emit common frame information.
Devang Patel930143b2009-11-21 02:48:08 +00001230 emitCommonDebugFrame();
Bill Wendling2b128d72009-05-20 23:19:06 +00001231
1232 // Emit function debug frame information
1233 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1234 E = DebugFrames.end(); I != E; ++I)
Devang Patel930143b2009-11-21 02:48:08 +00001235 emitFunctionDebugFrame(*I);
Bill Wendling2b128d72009-05-20 23:19:06 +00001236
1237 // Compute DIE offsets and sizes.
Devang Patel930143b2009-11-21 02:48:08 +00001238 computeSizeAndOffsets();
Bill Wendling2b128d72009-05-20 23:19:06 +00001239
1240 // Emit all the DIEs into a debug info section
Devang Patel930143b2009-11-21 02:48:08 +00001241 emitDebugInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +00001242
1243 // Corresponding abbreviations into a abbrev section.
Devang Patel930143b2009-11-21 02:48:08 +00001244 emitAbbreviations();
Bill Wendling2b128d72009-05-20 23:19:06 +00001245
Bill Wendling2b128d72009-05-20 23:19:06 +00001246 // Emit info into a debug pubnames section.
Devang Patel930143b2009-11-21 02:48:08 +00001247 emitDebugPubNames();
Bill Wendling2b128d72009-05-20 23:19:06 +00001248
Devang Patel04d2f2d2009-11-24 01:14:22 +00001249 // Emit info into a debug pubtypes section.
1250 emitDebugPubTypes();
1251
Bill Wendling2b128d72009-05-20 23:19:06 +00001252 // Emit info into a debug loc section.
Devang Patel930143b2009-11-21 02:48:08 +00001253 emitDebugLoc();
Bill Wendling2b128d72009-05-20 23:19:06 +00001254
1255 // Emit info into a debug aranges section.
1256 EmitDebugARanges();
1257
1258 // Emit info into a debug ranges section.
Devang Patel930143b2009-11-21 02:48:08 +00001259 emitDebugRanges();
Bill Wendling2b128d72009-05-20 23:19:06 +00001260
1261 // Emit info into a debug macinfo section.
Devang Patel930143b2009-11-21 02:48:08 +00001262 emitDebugMacInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +00001263
1264 // Emit inline info.
Devang Patel930143b2009-11-21 02:48:08 +00001265 emitDebugInlineInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +00001266
Chris Lattnerb7aa9522010-03-13 02:17:42 +00001267 // Emit info into a debug str section.
1268 emitDebugStr();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001269
Devang Pateld0701282010-08-02 17:32:15 +00001270 // clean up.
1271 DeleteContainerSeconds(DeadFnScopeMap);
Devang Patel1a0df9a2010-05-10 22:49:55 +00001272 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1273 E = CUMap.end(); I != E; ++I)
1274 delete I->second;
1275 FirstCU = NULL; // Reset for the next Module, if any.
Bill Wendling2b128d72009-05-20 23:19:06 +00001276}
1277
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001278/// findAbstractVariable - Find abstract variable, if any, associated with Var.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001279DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
Chris Lattner915c5f92010-04-02 19:42:39 +00001280 DebugLoc ScopeLoc) {
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001281
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001282 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001283 if (AbsDbgVariable)
1284 return AbsDbgVariable;
1285
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001286 LLVMContext &Ctx = Var->getContext();
Chris Lattner915c5f92010-04-02 19:42:39 +00001287 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001288 if (!Scope)
1289 return NULL;
1290
Devang Patele1c53f22010-05-20 16:36:41 +00001291 AbsDbgVariable = new DbgVariable(Var);
Devang Patel930143b2009-11-21 02:48:08 +00001292 Scope->addVariable(AbsDbgVariable);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001293 AbstractVariables[Var] = AbsDbgVariable;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001294 return AbsDbgVariable;
1295}
1296
Devang Patel6c622ef2011-03-01 22:58:55 +00001297/// addCurrentFnArgument - If Var is an current function argument that add
1298/// it in CurrentFnArguments list.
1299bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1300 DbgVariable *Var, DbgScope *Scope) {
1301 if (Scope != CurrentFnDbgScope)
1302 return false;
1303 DIVariable DV = Var->getVariable();
1304 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1305 return false;
1306 unsigned ArgNo = DV.getArgNumber();
1307 if (ArgNo == 0)
1308 return false;
1309
Devang Patel4ab660b2011-03-03 20:02:02 +00001310 size_t Size = CurrentFnArguments.size();
1311 if (Size == 0)
Devang Patel6c622ef2011-03-01 22:58:55 +00001312 CurrentFnArguments.resize(MF->getFunction()->arg_size());
Devang Patel63b3e762011-03-03 21:49:41 +00001313 // llvm::Function argument size is not good indicator of how many
Devang Patel34a7ab42011-03-03 20:08:10 +00001314 // arguments does the function have at source level.
1315 if (ArgNo > Size)
Devang Patel4ab660b2011-03-03 20:02:02 +00001316 CurrentFnArguments.resize(ArgNo * 2);
Devang Patel6c622ef2011-03-01 22:58:55 +00001317 CurrentFnArguments[ArgNo - 1] = Var;
1318 return true;
1319}
1320
Devang Patel490c8ab2010-05-20 19:57:06 +00001321/// collectVariableInfoFromMMITable - Collect variable information from
1322/// side table maintained by MMI.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001323void
Devang Patel490c8ab2010-05-20 19:57:06 +00001324DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
1325 SmallPtrSet<const MDNode *, 16> &Processed) {
Chris Lattner3a383cb2010-04-05 00:13:49 +00001326 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
Devang Patel475d32a2009-10-06 01:26:37 +00001327 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1328 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1329 VE = VMap.end(); VI != VE; ++VI) {
Devang Patel32cc43c2010-05-07 20:54:48 +00001330 const MDNode *Var = VI->first;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001331 if (!Var) continue;
Devang Patele0a94bf2010-05-14 21:01:35 +00001332 Processed.insert(Var);
Chris Lattner915c5f92010-04-02 19:42:39 +00001333 DIVariable DV(Var);
1334 const std::pair<unsigned, DebugLoc> &VP = VI->second;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001335
Chris Lattner915c5f92010-04-02 19:42:39 +00001336 DbgScope *Scope = 0;
Devang Patel32cc43c2010-05-07 20:54:48 +00001337 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
Chris Lattner915c5f92010-04-02 19:42:39 +00001338 Scope = ConcreteScopes.lookup(IA);
1339 if (Scope == 0)
1340 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001341
Devang Patelcdb7d442009-11-10 23:20:04 +00001342 // If variable scope is not found then skip this variable.
Chris Lattner915c5f92010-04-02 19:42:39 +00001343 if (Scope == 0)
Devang Patelcdb7d442009-11-10 23:20:04 +00001344 continue;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001345
Devang Patele1c53f22010-05-20 16:36:41 +00001346 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1347 DbgVariable *RegVar = new DbgVariable(DV);
1348 recordVariableFrameIndex(RegVar, VP.first);
Devang Patel6c622ef2011-03-01 22:58:55 +00001349 if (!addCurrentFnArgument(MF, RegVar, Scope))
1350 Scope->addVariable(RegVar);
Devang Patele1c53f22010-05-20 16:36:41 +00001351 if (AbsDbgVariable) {
1352 recordVariableFrameIndex(AbsDbgVariable, VP.first);
1353 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
1354 }
Devang Patel475d32a2009-10-06 01:26:37 +00001355 }
Devang Patel490c8ab2010-05-20 19:57:06 +00001356}
Devang Patela3e9c9c2010-03-15 18:33:46 +00001357
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001358/// isDbgValueInDefinedReg - Return true if debug value, encoded by
Devang Patel9fc11702010-05-25 23:40:22 +00001359/// DBG_VALUE instruction, is in a defined reg.
1360static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1361 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001362 return MI->getNumOperands() == 3 &&
1363 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1364 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
Devang Patel9fc11702010-05-25 23:40:22 +00001365}
1366
Devang Patel490c8ab2010-05-20 19:57:06 +00001367/// collectVariableInfo - Populate DbgScope entries with variables' info.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001368void
Devang Patel5c0f85c2010-06-25 22:07:34 +00001369DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1370 SmallPtrSet<const MDNode *, 16> &Processed) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001371
Devang Patel490c8ab2010-05-20 19:57:06 +00001372 /// collection info from MMI table.
1373 collectVariableInfoFromMMITable(MF, Processed);
1374
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001375 for (SmallVectorImpl<const MDNode*>::const_iterator
1376 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1377 ++UVI) {
1378 const MDNode *Var = *UVI;
1379 if (Processed.count(Var))
Devang Patel490c8ab2010-05-20 19:57:06 +00001380 continue;
1381
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001382 // History contains relevant DBG_VALUE instructions for Var and instructions
1383 // clobbering it.
1384 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1385 if (History.empty())
1386 continue;
1387 const MachineInstr *MInsn = History.front();
Devang Patel9fc11702010-05-25 23:40:22 +00001388
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001389 DIVariable DV(Var);
Devang Patel447cb382011-01-11 21:42:10 +00001390 DbgScope *Scope = NULL;
Devang Patel7a9dedf2010-05-27 20:25:04 +00001391 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1392 DISubprogram(DV.getContext()).describes(MF->getFunction()))
Devang Patelfbd6c452010-05-21 00:10:20 +00001393 Scope = CurrentFnDbgScope;
Devang Patel447cb382011-01-11 21:42:10 +00001394 else
1395 Scope = findDbgScope(MInsn);
Devang Patel490c8ab2010-05-20 19:57:06 +00001396 // If variable scope is not found then skip this variable.
Devang Patelfbd6c452010-05-21 00:10:20 +00001397 if (!Scope)
Devang Patel490c8ab2010-05-20 19:57:06 +00001398 continue;
1399
1400 Processed.insert(DV);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001401 assert(MInsn->isDebugValue() && "History must begin with debug value");
Devang Patel490c8ab2010-05-20 19:57:06 +00001402 DbgVariable *RegVar = new DbgVariable(DV);
Devang Patel6c622ef2011-03-01 22:58:55 +00001403 if (!addCurrentFnArgument(MF, RegVar, Scope))
1404 Scope->addVariable(RegVar);
Devang Patelfbd6c452010-05-21 00:10:20 +00001405 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
1406 DbgVariableToDbgInstMap[AbsVar] = MInsn;
1407 VarToAbstractVarMap[RegVar] = AbsVar;
Devang Patela3e9c9c2010-03-15 18:33:46 +00001408 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001409
1410 // Simple ranges that are fully coalesced.
1411 if (History.size() <= 1 || (History.size() == 2 &&
1412 MInsn->isIdenticalTo(History.back()))) {
Devang Patel9fc11702010-05-25 23:40:22 +00001413 DbgVariableToDbgInstMap[RegVar] = MInsn;
1414 continue;
1415 }
1416
1417 // handle multiple DBG_VALUE instructions describing one variable.
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001418 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001419
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001420 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1421 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1422 const MachineInstr *Begin = *HI;
1423 assert(Begin->isDebugValue() && "Invalid History entry");
Devang Patel9fc11702010-05-25 23:40:22 +00001424 MachineLocation MLoc;
Devang Patel0e60e672010-08-04 18:40:52 +00001425 if (Begin->getNumOperands() == 3) {
1426 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
1427 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
1428 } else
1429 MLoc = Asm->getDebugValueLocation(Begin);
1430
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001431 // FIXME: emitDebugLoc only understands registers.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001432 if (!MLoc.getReg())
1433 continue;
Jakob Stoklund Olesen9c057ee2011-03-22 00:21:41 +00001434
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001435 // Compute the range for a register location.
1436 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1437 const MCSymbol *SLabel = 0;
1438
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001439 if (HI + 1 == HE)
1440 // If Begin is the last instruction in History then its value is valid
Chris Lattner0ab5e2c2011-04-15 05:18:47 +00001441 // until the end of the function.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001442 SLabel = FunctionEndSym;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001443 else {
1444 const MachineInstr *End = HI[1];
1445 if (End->isDebugValue())
1446 SLabel = getLabelBeforeInsn(End);
1447 else {
1448 // End is a normal instruction clobbering the range.
1449 SLabel = getLabelAfterInsn(End);
1450 assert(SLabel && "Forgot label after clobber instruction");
1451 ++HI;
1452 }
1453 }
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001454
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001455 // The value is valid until the next DBG_VALUE or clobber.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001456 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
Devang Patel9fc11702010-05-25 23:40:22 +00001457 }
1458 DotDebugLocEntries.push_back(DotDebugLocEntry());
Devang Patela3e9c9c2010-03-15 18:33:46 +00001459 }
Devang Patele0a94bf2010-05-14 21:01:35 +00001460
1461 // Collect info for variables that were optimized out.
Devang Patelad517352010-06-22 01:01:58 +00001462 const Function *F = MF->getFunction();
Devang Patel364bf042010-11-10 22:19:21 +00001463 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
Devang Patele0a94bf2010-05-14 21:01:35 +00001464 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
Dan Gohman093cb792010-07-21 18:54:18 +00001465 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
Devang Patel490c8ab2010-05-20 19:57:06 +00001466 if (!DV || !Processed.insert(DV))
Devang Patele0a94bf2010-05-14 21:01:35 +00001467 continue;
1468 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
1469 if (Scope)
Devang Patele1c53f22010-05-20 16:36:41 +00001470 Scope->addVariable(new DbgVariable(DV));
Devang Patele0a94bf2010-05-14 21:01:35 +00001471 }
1472 }
Devang Patel9fc11702010-05-25 23:40:22 +00001473}
Devang Patele0a94bf2010-05-14 21:01:35 +00001474
Devang Patel9fc11702010-05-25 23:40:22 +00001475/// getLabelBeforeInsn - Return Label preceding the instruction.
1476const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001477 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1478 assert(Label && "Didn't insert label before instruction");
1479 return Label;
Devang Patel9fc11702010-05-25 23:40:22 +00001480}
1481
1482/// getLabelAfterInsn - Return Label immediately following the instruction.
1483const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001484 return LabelsAfterInsn.lookup(MI);
Devang Patel475d32a2009-10-06 01:26:37 +00001485}
1486
Devang Patelb5694e72010-10-26 17:49:02 +00001487/// beginInstruction - Process beginning of an instruction.
1488void DwarfDebug::beginInstruction(const MachineInstr *MI) {
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001489 // Check if source location changes, but ignore DBG_VALUE locations.
1490 if (!MI->isDebugValue()) {
1491 DebugLoc DL = MI->getDebugLoc();
1492 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1493 PrevInstLoc = DL;
1494 if (!DL.isUnknown()) {
1495 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1496 recordSourceLine(DL.getLine(), DL.getCol(), Scope);
1497 } else
1498 recordSourceLine(0, 0, 0);
1499 }
Devang Patel9fc11702010-05-25 23:40:22 +00001500 }
Devang Patel23b2ae62010-03-29 22:59:58 +00001501
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001502 // Insert labels where requested.
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001503 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1504 LabelsBeforeInsn.find(MI);
1505
1506 // No label needed.
1507 if (I == LabelsBeforeInsn.end())
1508 return;
1509
1510 // Label already assigned.
1511 if (I->second)
Devang Patel002d54d2010-05-26 19:37:24 +00001512 return;
Devang Patelbd477be2010-03-29 17:20:31 +00001513
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001514 if (!PrevLabel) {
Devang Patelacc32a52010-05-26 21:23:46 +00001515 PrevLabel = MMI->getContext().CreateTempSymbol();
1516 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel002d54d2010-05-26 19:37:24 +00001517 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001518 I->second = PrevLabel;
Devang Patel8db360d2009-10-06 01:50:42 +00001519}
1520
Devang Patelb5694e72010-10-26 17:49:02 +00001521/// endInstruction - Process end of an instruction.
1522void DwarfDebug::endInstruction(const MachineInstr *MI) {
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001523 // Don't create a new label after DBG_VALUE instructions.
1524 // They don't generate code.
1525 if (!MI->isDebugValue())
1526 PrevLabel = 0;
1527
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001528 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1529 LabelsAfterInsn.find(MI);
1530
1531 // No label needed.
1532 if (I == LabelsAfterInsn.end())
1533 return;
1534
1535 // Label already assigned.
1536 if (I->second)
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00001537 return;
1538
1539 // We need a label after this instruction.
1540 if (!PrevLabel) {
1541 PrevLabel = MMI->getContext().CreateTempSymbol();
1542 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel3ebd8932010-04-08 16:50:29 +00001543 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001544 I->second = PrevLabel;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001545}
1546
Devang Patel6c74a872010-04-27 19:46:33 +00001547/// getOrCreateDbgScope - Create DbgScope for the scope.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001548DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
Devang Patel30265c42010-07-07 20:12:52 +00001549 const MDNode *InlinedAt) {
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001550 if (!InlinedAt) {
1551 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1552 if (WScope)
Devang Patel6c74a872010-04-27 19:46:33 +00001553 return WScope;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001554 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1555 DbgScopeMap.insert(std::make_pair(Scope, WScope));
Devang Patel6c74a872010-04-27 19:46:33 +00001556 if (DIDescriptor(Scope).isLexicalBlock()) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001557 DbgScope *Parent =
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001558 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
Devang Patel6c74a872010-04-27 19:46:33 +00001559 WScope->setParent(Parent);
1560 Parent->addScope(WScope);
1561 }
1562
1563 if (!WScope->getParent()) {
1564 StringRef SPName = DISubprogram(Scope).getLinkageName();
Stuart Hastings9b5005c2010-06-15 23:06:30 +00001565 // We used to check only for a linkage name, but that fails
1566 // since we began omitting the linkage name for private
1567 // functions. The new way is to check for the name in metadata,
1568 // but that's not supported in old .ll test cases. Ergo, we
1569 // check both.
Stuart Hastingsafe54f12010-06-11 20:08:44 +00001570 if (SPName == Asm->MF->getFunction()->getName() ||
1571 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
Devang Patel6c74a872010-04-27 19:46:33 +00001572 CurrentFnDbgScope = WScope;
1573 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001574
Devang Patel6c74a872010-04-27 19:46:33 +00001575 return WScope;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001576 }
1577
Devang Patel5c0f85c2010-06-25 22:07:34 +00001578 getOrCreateAbstractScope(Scope);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001579 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1580 if (WScope)
Devang Patel6c74a872010-04-27 19:46:33 +00001581 return WScope;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001582
1583 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1584 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1585 DILocation DL(InlinedAt);
Devang Patel6c74a872010-04-27 19:46:33 +00001586 DbgScope *Parent =
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001587 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
Devang Patel6c74a872010-04-27 19:46:33 +00001588 WScope->setParent(Parent);
1589 Parent->addScope(WScope);
1590
1591 ConcreteScopes[InlinedAt] = WScope;
Devang Patel6c74a872010-04-27 19:46:33 +00001592
1593 return WScope;
Devang Patel8db360d2009-10-06 01:50:42 +00001594}
1595
Devang Patel6c74a872010-04-27 19:46:33 +00001596/// hasValidLocation - Return true if debug location entry attached with
1597/// machine instruction encodes valid location info.
1598static bool hasValidLocation(LLVMContext &Ctx,
1599 const MachineInstr *MInsn,
Devang Patel32cc43c2010-05-07 20:54:48 +00001600 const MDNode *&Scope, const MDNode *&InlinedAt) {
Devang Patel6c74a872010-04-27 19:46:33 +00001601 DebugLoc DL = MInsn->getDebugLoc();
1602 if (DL.isUnknown()) return false;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001603
Devang Patel32cc43c2010-05-07 20:54:48 +00001604 const MDNode *S = DL.getScope(Ctx);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001605
Devang Patel6c74a872010-04-27 19:46:33 +00001606 // There is no need to create another DIE for compile unit. For all
1607 // other scopes, create one DbgScope now. This will be translated
1608 // into a scope DIE at the end.
1609 if (DIScope(S).isCompileUnit()) return false;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001610
Devang Patel6c74a872010-04-27 19:46:33 +00001611 Scope = S;
1612 InlinedAt = DL.getInlinedAt(Ctx);
1613 return true;
1614}
1615
1616/// calculateDominanceGraph - Calculate dominance graph for DbgScope
1617/// hierarchy.
1618static void calculateDominanceGraph(DbgScope *Scope) {
1619 assert (Scope && "Unable to calculate scop edominance graph!");
1620 SmallVector<DbgScope *, 4> WorkStack;
1621 WorkStack.push_back(Scope);
1622 unsigned Counter = 0;
1623 while (!WorkStack.empty()) {
1624 DbgScope *WS = WorkStack.back();
1625 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1626 bool visitedChildren = false;
1627 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1628 SE = Children.end(); SI != SE; ++SI) {
1629 DbgScope *ChildScope = *SI;
1630 if (!ChildScope->getDFSOut()) {
1631 WorkStack.push_back(ChildScope);
1632 visitedChildren = true;
1633 ChildScope->setDFSIn(++Counter);
1634 break;
1635 }
1636 }
1637 if (!visitedChildren) {
1638 WorkStack.pop_back();
1639 WS->setDFSOut(++Counter);
1640 }
1641 }
1642}
1643
1644/// printDbgScopeInfo - Print DbgScope info for each machine instruction.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001645static
Devang Patel6c74a872010-04-27 19:46:33 +00001646void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
1647 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1648{
1649#ifndef NDEBUG
1650 unsigned PrevDFSIn = 0;
1651 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1652 I != E; ++I) {
1653 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1654 II != IE; ++II) {
1655 const MachineInstr *MInsn = II;
Devang Patel32cc43c2010-05-07 20:54:48 +00001656 const MDNode *Scope = NULL;
1657 const MDNode *InlinedAt = NULL;
Devang Patel6c74a872010-04-27 19:46:33 +00001658
1659 // Check if instruction has valid location information.
1660 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1661 dbgs() << " [ ";
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001662 if (InlinedAt)
Devang Patel6c74a872010-04-27 19:46:33 +00001663 dbgs() << "*";
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001664 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
Devang Patel6c74a872010-04-27 19:46:33 +00001665 MI2ScopeMap.find(MInsn);
1666 if (DI != MI2ScopeMap.end()) {
1667 DbgScope *S = DI->second;
1668 dbgs() << S->getDFSIn();
1669 PrevDFSIn = S->getDFSIn();
1670 } else
1671 dbgs() << PrevDFSIn;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001672 } else
Devang Patel6c74a872010-04-27 19:46:33 +00001673 dbgs() << " [ x" << PrevDFSIn;
1674 dbgs() << " ]";
1675 MInsn->dump();
1676 }
1677 dbgs() << "\n";
1678 }
1679#endif
1680}
Devang Patel930143b2009-11-21 02:48:08 +00001681/// extractScopeInformation - Scan machine instructions in this function
Chris Lattner848c7d22010-03-31 05:39:57 +00001682/// and collect DbgScopes. Return true, if at least one scope was found.
Chris Lattner76555b52010-01-26 23:18:02 +00001683bool DwarfDebug::extractScopeInformation() {
Devang Patel75cc16c2009-10-01 20:31:14 +00001684 // If scope information was extracted using .dbg intrinsics then there is not
1685 // any need to extract these information by scanning each instruction.
1686 if (!DbgScopeMap.empty())
1687 return false;
1688
Dan Gohmane9135cb2010-04-23 01:18:53 +00001689 // Scan each instruction and create scopes. First build working set of scopes.
Devang Patel6c74a872010-04-27 19:46:33 +00001690 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1691 SmallVector<DbgRange, 4> MIRanges;
1692 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
Devang Patel32cc43c2010-05-07 20:54:48 +00001693 const MDNode *PrevScope = NULL;
1694 const MDNode *PrevInlinedAt = NULL;
Devang Patel6c74a872010-04-27 19:46:33 +00001695 const MachineInstr *RangeBeginMI = NULL;
1696 const MachineInstr *PrevMI = NULL;
Chris Lattner3a383cb2010-04-05 00:13:49 +00001697 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
Devang Patel75cc16c2009-10-01 20:31:14 +00001698 I != E; ++I) {
1699 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1700 II != IE; ++II) {
1701 const MachineInstr *MInsn = II;
Devang Patel32cc43c2010-05-07 20:54:48 +00001702 const MDNode *Scope = NULL;
1703 const MDNode *InlinedAt = NULL;
Devang Patel6c74a872010-04-27 19:46:33 +00001704
1705 // Check if instruction has valid location information.
1706 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1707 PrevMI = MInsn;
1708 continue;
1709 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001710
Devang Patel6c74a872010-04-27 19:46:33 +00001711 // If scope has not changed then skip this instruction.
1712 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
1713 PrevMI = MInsn;
1714 continue;
1715 }
1716
Devang Pateld12c0a22011-02-15 17:56:09 +00001717 // Ignore DBG_VALUE. It does not contribute any instruction in output.
1718 if (MInsn->isDebugValue())
1719 continue;
1720
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001721 if (RangeBeginMI) {
1722 // If we have alread seen a beginning of a instruction range and
Devang Patel6c74a872010-04-27 19:46:33 +00001723 // current instruction scope does not match scope of first instruction
1724 // in this range then create a new instruction range.
1725 DbgRange R(RangeBeginMI, PrevMI);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001726 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
Devang Patel30265c42010-07-07 20:12:52 +00001727 PrevInlinedAt);
Devang Patel6c74a872010-04-27 19:46:33 +00001728 MIRanges.push_back(R);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001729 }
Devang Patel6c74a872010-04-27 19:46:33 +00001730
1731 // This is a beginning of a new instruction range.
1732 RangeBeginMI = MInsn;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001733
Devang Patel6c74a872010-04-27 19:46:33 +00001734 // Reset previous markers.
1735 PrevMI = MInsn;
1736 PrevScope = Scope;
1737 PrevInlinedAt = InlinedAt;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001738 }
1739 }
1740
Devang Patel6c74a872010-04-27 19:46:33 +00001741 // Create last instruction range.
1742 if (RangeBeginMI && PrevMI && PrevScope) {
1743 DbgRange R(RangeBeginMI, PrevMI);
1744 MIRanges.push_back(R);
1745 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
Devang Patel75cc16c2009-10-01 20:31:14 +00001746 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001747
Devang Patel530a0752010-01-04 20:44:00 +00001748 if (!CurrentFnDbgScope)
1749 return false;
1750
Devang Patel6c74a872010-04-27 19:46:33 +00001751 calculateDominanceGraph(CurrentFnDbgScope);
1752 if (PrintDbgScope)
1753 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
1754
1755 // Find ranges of instructions covered by each DbgScope;
1756 DbgScope *PrevDbgScope = NULL;
1757 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1758 RE = MIRanges.end(); RI != RE; ++RI) {
1759 const DbgRange &R = *RI;
1760 DbgScope *S = MI2ScopeMap.lookup(R.first);
1761 assert (S && "Lost DbgScope for a machine instruction!");
1762 if (PrevDbgScope && !PrevDbgScope->dominates(S))
1763 PrevDbgScope->closeInsnRange(S);
1764 S->openInsnRange(R.first);
1765 S->extendInsnRange(R.second);
1766 PrevDbgScope = S;
1767 }
1768
1769 if (PrevDbgScope)
1770 PrevDbgScope->closeInsnRange();
Devang Patel75cc16c2009-10-01 20:31:14 +00001771
Devang Patel359b0132010-04-08 18:43:56 +00001772 identifyScopeMarkers();
Devang Patelf1d5a1e2010-04-08 15:37:09 +00001773
1774 return !DbgScopeMap.empty();
1775}
1776
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001777/// identifyScopeMarkers() -
Devang Patel6c74a872010-04-27 19:46:33 +00001778/// Each DbgScope has first instruction and last instruction to mark beginning
1779/// and end of a scope respectively. Create an inverse map that list scopes
1780/// starts (and ends) with an instruction. One instruction may start (or end)
1781/// multiple scopes. Ignore scopes that are not reachable.
Devang Patel359b0132010-04-08 18:43:56 +00001782void DwarfDebug::identifyScopeMarkers() {
Devang Patel7771b7c2010-01-20 02:05:23 +00001783 SmallVector<DbgScope *, 4> WorkList;
1784 WorkList.push_back(CurrentFnDbgScope);
1785 while (!WorkList.empty()) {
Chris Lattner848c7d22010-03-31 05:39:57 +00001786 DbgScope *S = WorkList.pop_back_val();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001787
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00001788 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001789 if (!Children.empty())
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00001790 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
Devang Patel7771b7c2010-01-20 02:05:23 +00001791 SE = Children.end(); SI != SE; ++SI)
1792 WorkList.push_back(*SI);
1793
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001794 if (S->isAbstractScope())
1795 continue;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001796
Devang Patel6c74a872010-04-27 19:46:33 +00001797 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1798 if (Ranges.empty())
1799 continue;
1800 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1801 RE = Ranges.end(); RI != RE; ++RI) {
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001802 assert(RI->first && "DbgRange does not have first instruction!");
1803 assert(RI->second && "DbgRange does not have second instruction!");
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001804 requestLabelBeforeInsn(RI->first);
1805 requestLabelAfterInsn(RI->second);
Devang Patel6c74a872010-04-27 19:46:33 +00001806 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001807 }
Devang Patel75cc16c2009-10-01 20:31:14 +00001808}
1809
Dan Gohman3df671a2010-04-20 00:37:27 +00001810/// FindFirstDebugLoc - Find the first debug location in the function. This
1811/// is intended to be an approximation for the source position of the
1812/// beginning of the function.
1813static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
1814 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1815 I != E; ++I)
1816 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
1817 MBBI != MBBE; ++MBBI) {
1818 DebugLoc DL = MBBI->getDebugLoc();
1819 if (!DL.isUnknown())
1820 return DL;
1821 }
1822 return DebugLoc();
1823}
1824
Devang Patela86114b2010-10-25 20:45:32 +00001825#ifndef NDEBUG
1826/// CheckLineNumbers - Count basicblocks whose instructions do not have any
1827/// line number information.
1828static void CheckLineNumbers(const MachineFunction *MF) {
1829 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1830 I != E; ++I) {
1831 bool FoundLineNo = false;
1832 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1833 II != IE; ++II) {
1834 const MachineInstr *MI = II;
1835 if (!MI->getDebugLoc().isUnknown()) {
1836 FoundLineNo = true;
1837 break;
1838 }
1839 }
Devang Patel6e0d5892010-10-28 22:11:59 +00001840 if (!FoundLineNo && I->size())
Devang Patela86114b2010-10-25 20:45:32 +00001841 ++BlocksWithoutLineNo;
1842 }
1843}
1844#endif
1845
Devang Patel930143b2009-11-21 02:48:08 +00001846/// beginFunction - Gather pre-function debug information. Assumes being
Bill Wendling2b128d72009-05-20 23:19:06 +00001847/// emitted immediately after the function entry point.
Chris Lattner76555b52010-01-26 23:18:02 +00001848void DwarfDebug::beginFunction(const MachineFunction *MF) {
Chris Lattner196dbdc2010-04-05 03:52:55 +00001849 if (!MMI->hasDebugInfo()) return;
Bill Wendlingfcc14142010-04-07 09:28:04 +00001850 if (!extractScopeInformation()) return;
Devang Patel4598eb62009-10-06 18:37:31 +00001851
Devang Patela86114b2010-10-25 20:45:32 +00001852#ifndef NDEBUG
1853 CheckLineNumbers(MF);
1854#endif
1855
Devang Patel6c74a872010-04-27 19:46:33 +00001856 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1857 Asm->getFunctionNumber());
Bill Wendling2b128d72009-05-20 23:19:06 +00001858 // Assumes in correct section after the entry point.
Devang Patel6c74a872010-04-27 19:46:33 +00001859 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
Bill Wendling2b128d72009-05-20 23:19:06 +00001860
1861 // Emit label for the implicitly defined dbg.stoppoint at the start of the
1862 // function.
Dan Gohman3df671a2010-04-20 00:37:27 +00001863 DebugLoc FDL = FindFirstDebugLoc(MF);
Chris Lattner915c5f92010-04-02 19:42:39 +00001864 if (FDL.isUnknown()) return;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001865
Devang Patel32cc43c2010-05-07 20:54:48 +00001866 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
Stuart Hastings61475c52010-07-19 23:56:30 +00001867 const MDNode *TheScope = 0;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001868
Chris Lattner915c5f92010-04-02 19:42:39 +00001869 DISubprogram SP = getDISubprogram(Scope);
1870 unsigned Line, Col;
1871 if (SP.Verify()) {
1872 Line = SP.getLineNumber();
1873 Col = 0;
Stuart Hastings61475c52010-07-19 23:56:30 +00001874 TheScope = SP;
Chris Lattner915c5f92010-04-02 19:42:39 +00001875 } else {
1876 Line = FDL.getLine();
1877 Col = FDL.getCol();
Stuart Hastings61475c52010-07-19 23:56:30 +00001878 TheScope = Scope;
Bill Wendling2b128d72009-05-20 23:19:06 +00001879 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00001880
Stuart Hastings61475c52010-07-19 23:56:30 +00001881 recordSourceLine(Line, Col, TheScope);
Devang Patel002d54d2010-05-26 19:37:24 +00001882
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001883 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1884
Devang Patel21ccf052010-06-02 16:42:51 +00001885 /// ProcessedArgs - Collection of arguments already processed.
1886 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
1887
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001888 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1889
1890 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1891 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1892
Devang Patel002d54d2010-05-26 19:37:24 +00001893 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001894 I != E; ++I) {
1895 bool AtBlockEntry = true;
Devang Patel002d54d2010-05-26 19:37:24 +00001896 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1897 II != IE; ++II) {
1898 const MachineInstr *MI = II;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001899
Devang Patel002d54d2010-05-26 19:37:24 +00001900 if (MI->isDebugValue()) {
Devang Patel002d54d2010-05-26 19:37:24 +00001901 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001902
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001903 // Keep track of user variables.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001904 const MDNode *Var =
1905 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001906
1907 // Variable is in a register, we need to check for clobbers.
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001908 if (isDbgValueInDefinedReg(MI))
1909 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1910
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001911 // Check the history of this variable.
1912 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1913 if (History.empty()) {
1914 UserVariables.push_back(Var);
1915 // The first mention of a function argument gets the FunctionBeginSym
1916 // label, so arguments are visible when breaking at function entry.
1917 DIVariable DV(Var);
1918 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1919 DISubprogram(getDISubprogram(DV.getContext()))
1920 .describes(MF->getFunction()))
1921 LabelsBeforeInsn[MI] = FunctionBeginSym;
1922 } else {
1923 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1924 const MachineInstr *Prev = History.back();
1925 if (Prev->isDebugValue()) {
1926 // Coalesce identical entries at the end of History.
1927 if (History.size() >= 2 &&
1928 Prev->isIdenticalTo(History[History.size() - 2]))
1929 History.pop_back();
1930
1931 // Terminate old register assignments that don't reach MI;
1932 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1933 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1934 isDbgValueInDefinedReg(Prev)) {
1935 // Previous register assignment needs to terminate at the end of
1936 // its basic block.
1937 MachineBasicBlock::const_iterator LastMI =
1938 PrevMBB->getLastNonDebugInstr();
1939 if (LastMI == PrevMBB->end())
1940 // Drop DBG_VALUE for empty range.
1941 History.pop_back();
1942 else {
1943 // Terminate after LastMI.
1944 History.push_back(LastMI);
1945 }
1946 }
1947 }
1948 }
1949 History.push_back(MI);
Devang Patel002d54d2010-05-26 19:37:24 +00001950 } else {
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001951 // Not a DBG_VALUE instruction.
1952 if (!MI->isLabel())
1953 AtBlockEntry = false;
1954
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001955 // Check if the instruction clobbers any registers with debug vars.
1956 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1957 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1958 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1959 continue;
1960 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1961 unsigned Reg = *AI; ++AI) {
1962 const MDNode *Var = LiveUserVar[Reg];
1963 if (!Var)
1964 continue;
1965 // Reg is now clobbered.
1966 LiveUserVar[Reg] = 0;
1967
1968 // Was MD last defined by a DBG_VALUE referring to Reg?
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001969 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1970 if (HistI == DbgValues.end())
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001971 continue;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001972 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1973 if (History.empty())
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001974 continue;
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001975 const MachineInstr *Prev = History.back();
1976 // Sanity-check: Register assignments are terminated at the end of
1977 // their block.
1978 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1979 continue;
1980 // Is the variable still in Reg?
1981 if (!isDbgValueInDefinedReg(Prev) ||
1982 Prev->getOperand(0).getReg() != Reg)
1983 continue;
1984 // Var is clobbered. Make sure the next instruction gets a label.
1985 History.push_back(MI);
Jakob Stoklund Olesenec0ac3c2011-03-22 22:33:08 +00001986 }
1987 }
Devang Patel002d54d2010-05-26 19:37:24 +00001988 }
Devang Patel002d54d2010-05-26 19:37:24 +00001989 }
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00001990 }
1991
1992 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1993 I != E; ++I) {
1994 SmallVectorImpl<const MachineInstr*> &History = I->second;
1995 if (History.empty())
1996 continue;
1997
1998 // Make sure the final register assignments are terminated.
1999 const MachineInstr *Prev = History.back();
2000 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
2001 const MachineBasicBlock *PrevMBB = Prev->getParent();
2002 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
2003 if (LastMI == PrevMBB->end())
2004 // Drop DBG_VALUE for empty range.
2005 History.pop_back();
2006 else {
2007 // Terminate after LastMI.
2008 History.push_back(LastMI);
2009 }
2010 }
2011 // Request labels for the full history.
2012 for (unsigned i = 0, e = History.size(); i != e; ++i) {
2013 const MachineInstr *MI = History[i];
2014 if (MI->isDebugValue())
2015 requestLabelBeforeInsn(MI);
2016 else
2017 requestLabelAfterInsn(MI);
2018 }
2019 }
Devang Patel002d54d2010-05-26 19:37:24 +00002020
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00002021 PrevInstLoc = DebugLoc();
Devang Patel002d54d2010-05-26 19:37:24 +00002022 PrevLabel = FunctionBeginSym;
Bill Wendling2b128d72009-05-20 23:19:06 +00002023}
2024
Devang Patel930143b2009-11-21 02:48:08 +00002025/// endFunction - Gather and emit post-function debug information.
Bill Wendling2b128d72009-05-20 23:19:06 +00002026///
Chris Lattner76555b52010-01-26 23:18:02 +00002027void DwarfDebug::endFunction(const MachineFunction *MF) {
Bill Wendlingfcc14142010-04-07 09:28:04 +00002028 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
Devang Patel2904aa92009-11-12 19:02:56 +00002029
Devang Patel530a0752010-01-04 20:44:00 +00002030 if (CurrentFnDbgScope) {
Devang Patel4a8e6e82010-05-22 00:04:14 +00002031
Devang Patel9fc11702010-05-25 23:40:22 +00002032 // Define end label for subprogram.
2033 FunctionEndSym = Asm->GetTempSymbol("func_end",
2034 Asm->getFunctionNumber());
2035 // Assumes in correct section after the entry point.
2036 Asm->OutStreamer.EmitLabel(FunctionEndSym);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002037
Devang Patel5c0f85c2010-06-25 22:07:34 +00002038 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2039 collectVariableInfo(MF, ProcessedVars);
Devang Patel4a8e6e82010-05-22 00:04:14 +00002040
Devang Patel530a0752010-01-04 20:44:00 +00002041 // Construct abstract scopes.
2042 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
Devang Patel5c0f85c2010-06-25 22:07:34 +00002043 AE = AbstractScopesList.end(); AI != AE; ++AI) {
Devang Patel5c0f85c2010-06-25 22:07:34 +00002044 DISubprogram SP((*AI)->getScopeNode());
2045 if (SP.Verify()) {
2046 // Collect info for variables that were optimized out.
2047 StringRef FName = SP.getLinkageName();
2048 if (FName.empty())
2049 FName = SP.getName();
Devang Patel364bf042010-11-10 22:19:21 +00002050 if (NamedMDNode *NMD =
2051 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
Devang Patel5c0f85c2010-06-25 22:07:34 +00002052 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
Dan Gohman093cb792010-07-21 18:54:18 +00002053 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
Devang Patel5c0f85c2010-06-25 22:07:34 +00002054 if (!DV || !ProcessedVars.insert(DV))
2055 continue;
Devang Patel648df7b2010-06-30 00:11:08 +00002056 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
Devang Patel5c0f85c2010-06-25 22:07:34 +00002057 if (Scope)
2058 Scope->addVariable(new DbgVariable(DV));
2059 }
2060 }
2061 }
Devang Patelc5b31092010-06-30 01:40:11 +00002062 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2063 constructScopeDIE(*AI);
Devang Patel5c0f85c2010-06-25 22:07:34 +00002064 }
Devang Patel30265c42010-07-07 20:12:52 +00002065
Devang Patel075e9b52010-05-04 06:15:30 +00002066 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002067
Devang Patel075e9b52010-05-04 06:15:30 +00002068 if (!DisableFramePointerElim(*MF))
Devang Patelf20c4f72011-04-12 22:53:02 +00002069 getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2070 dwarf::DW_AT_APPLE_omit_frame_ptr,
2071 dwarf::DW_FORM_flag, 1);
Devang Patel075e9b52010-05-04 06:15:30 +00002072
2073
Chris Lattner3a383cb2010-04-05 00:13:49 +00002074 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
Devang Patel530a0752010-01-04 20:44:00 +00002075 MMI->getFrameMoves()));
Bill Wendling2b128d72009-05-20 23:19:06 +00002076 }
2077
Bill Wendling2b128d72009-05-20 23:19:06 +00002078 // Clear debug info
Devang Patelfe189e62010-01-19 01:26:02 +00002079 CurrentFnDbgScope = NULL;
Devang Patelad45d912011-04-22 18:09:57 +00002080 DeleteContainerPointers(CurrentFnArguments);
Devang Patele1c53f22010-05-20 16:36:41 +00002081 DbgVariableToFrameIndexMap.clear();
2082 VarToAbstractVarMap.clear();
2083 DbgVariableToDbgInstMap.clear();
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00002084 DeleteContainerSeconds(DbgScopeMap);
Jakob Stoklund Olesen9a624fa2011-03-26 02:19:36 +00002085 UserVariables.clear();
2086 DbgValues.clear();
Devang Patelfe189e62010-01-19 01:26:02 +00002087 ConcreteScopes.clear();
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00002088 DeleteContainerSeconds(AbstractScopes);
Devang Patelfe189e62010-01-19 01:26:02 +00002089 AbstractScopesList.clear();
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00002090 AbstractVariables.clear();
Devang Patel6c74a872010-04-27 19:46:33 +00002091 LabelsBeforeInsn.clear();
2092 LabelsAfterInsn.clear();
Devang Patel12563b32010-04-16 23:33:45 +00002093 PrevLabel = NULL;
Bill Wendling2b128d72009-05-20 23:19:06 +00002094}
2095
Devang Patele1c53f22010-05-20 16:36:41 +00002096/// recordVariableFrameIndex - Record a variable's index.
2097void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2098 assert (V && "Invalid DbgVariable!");
2099 DbgVariableToFrameIndexMap[V] = Index;
2100}
2101
2102/// findVariableFrameIndex - Return true if frame index for the variable
2103/// is found. Update FI to hold value of the index.
2104bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2105 assert (V && "Invalid DbgVariable!");
2106 DenseMap<const DbgVariable *, int>::iterator I =
2107 DbgVariableToFrameIndexMap.find(V);
2108 if (I == DbgVariableToFrameIndexMap.end())
2109 return false;
2110 *FI = I->second;
2111 return true;
2112}
2113
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002114/// findDbgScope - Find DbgScope for the debug loc attached with an
Devang Patel490c8ab2010-05-20 19:57:06 +00002115/// instruction.
2116DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2117 DbgScope *Scope = NULL;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002118 LLVMContext &Ctx =
Devang Patel490c8ab2010-05-20 19:57:06 +00002119 MInsn->getParent()->getParent()->getFunction()->getContext();
2120 DebugLoc DL = MInsn->getDebugLoc();
2121
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002122 if (DL.isUnknown())
Devang Patel490c8ab2010-05-20 19:57:06 +00002123 return Scope;
2124
2125 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2126 Scope = ConcreteScopes.lookup(IA);
2127 if (Scope == 0)
2128 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002129
Devang Patel490c8ab2010-05-20 19:57:06 +00002130 return Scope;
2131}
2132
2133
Chris Lattnerba35a672010-03-09 04:54:43 +00002134/// recordSourceLine - Register a source line with debug info. Returns the
2135/// unique label that was emitted and which provides correspondence to
2136/// the source line list.
Jakob Stoklund Olesen1886a4c2011-03-25 17:20:59 +00002137void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S){
Devang Patel2d9caf92009-11-25 17:36:49 +00002138 StringRef Fn;
Devang Patele01b75c2011-03-24 20:30:50 +00002139 StringRef Dir;
Dan Gohman50849c62010-05-05 23:41:32 +00002140 unsigned Src = 1;
2141 if (S) {
2142 DIDescriptor Scope(S);
Devang Patel2089d162009-10-05 18:03:19 +00002143
Dan Gohman50849c62010-05-05 23:41:32 +00002144 if (Scope.isCompileUnit()) {
2145 DICompileUnit CU(S);
Dan Gohman50849c62010-05-05 23:41:32 +00002146 Fn = CU.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00002147 Dir = CU.getDirectory();
Devang Patelc4b69052010-10-28 17:30:52 +00002148 } else if (Scope.isFile()) {
2149 DIFile F(S);
Devang Patelc4b69052010-10-28 17:30:52 +00002150 Fn = F.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00002151 Dir = F.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00002152 } else if (Scope.isSubprogram()) {
2153 DISubprogram SP(S);
Dan Gohman50849c62010-05-05 23:41:32 +00002154 Fn = SP.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00002155 Dir = SP.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00002156 } else if (Scope.isLexicalBlock()) {
2157 DILexicalBlock DB(S);
Dan Gohman50849c62010-05-05 23:41:32 +00002158 Fn = DB.getFilename();
Devang Patele01b75c2011-03-24 20:30:50 +00002159 Dir = DB.getDirectory();
Dan Gohman50849c62010-05-05 23:41:32 +00002160 } else
2161 assert(0 && "Unexpected scope info");
2162
Devang Patele01b75c2011-03-24 20:30:50 +00002163 Src = GetOrCreateSourceID(Fn, Dir);
Dan Gohman50849c62010-05-05 23:41:32 +00002164 }
Rafael Espindola67c6ab82010-11-18 02:04:25 +00002165 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, DWARF2_FLAG_IS_STMT,
Devang Patel17740e72011-04-18 20:26:49 +00002166 0, 0, Fn);
Bill Wendling2b128d72009-05-20 23:19:06 +00002167}
2168
Bill Wendling806535f2009-05-20 23:22:40 +00002169//===----------------------------------------------------------------------===//
2170// Emit Methods
2171//===----------------------------------------------------------------------===//
2172
Devang Patel930143b2009-11-21 02:48:08 +00002173/// computeSizeAndOffset - Compute the size and offset of a DIE.
Bill Wendling480ff322009-05-20 23:21:38 +00002174///
Jim Grosbach00e9c612009-11-22 19:20:36 +00002175unsigned
2176DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
Bill Wendling480ff322009-05-20 23:21:38 +00002177 // Get the children.
2178 const std::vector<DIE *> &Children = Die->getChildren();
2179
2180 // If not last sibling and has children then add sibling offset attribute.
Jeffrey Yasskin54ebc982010-03-22 18:47:14 +00002181 if (!Last && !Children.empty())
Benjamin Kramer74729ae2010-03-31 19:34:01 +00002182 Die->addSiblingOffset(DIEValueAllocator);
Bill Wendling480ff322009-05-20 23:21:38 +00002183
2184 // Record the abbreviation.
Devang Patel930143b2009-11-21 02:48:08 +00002185 assignAbbrevNumber(Die->getAbbrev());
Bill Wendling480ff322009-05-20 23:21:38 +00002186
2187 // Get the abbreviation for this DIE.
2188 unsigned AbbrevNumber = Die->getAbbrevNumber();
2189 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2190
2191 // Set DIE offset
2192 Die->setOffset(Offset);
2193
2194 // Start the size with the size of abbreviation code.
Chris Lattner7b26fce2009-08-22 20:48:53 +00002195 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
Bill Wendling480ff322009-05-20 23:21:38 +00002196
2197 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2198 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2199
2200 // Size the DIE attribute values.
2201 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2202 // Size attribute value.
Chris Lattner5a00dea2010-04-05 00:18:22 +00002203 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
Bill Wendling480ff322009-05-20 23:21:38 +00002204
2205 // Size the DIE children if any.
2206 if (!Children.empty()) {
2207 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2208 "Children flag not set");
2209
2210 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel930143b2009-11-21 02:48:08 +00002211 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
Bill Wendling480ff322009-05-20 23:21:38 +00002212
2213 // End of children marker.
2214 Offset += sizeof(int8_t);
2215 }
2216
2217 Die->setSize(Offset - Die->getOffset());
2218 return Offset;
2219}
2220
Devang Patel930143b2009-11-21 02:48:08 +00002221/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
Bill Wendling480ff322009-05-20 23:21:38 +00002222///
Devang Patel930143b2009-11-21 02:48:08 +00002223void DwarfDebug::computeSizeAndOffsets() {
Devang Patel1a0df9a2010-05-10 22:49:55 +00002224 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2225 E = CUMap.end(); I != E; ++I) {
2226 // Compute size of compile unit header.
Devang Patel28dce702011-04-12 23:10:47 +00002227 unsigned Offset =
Devang Patel1a0df9a2010-05-10 22:49:55 +00002228 sizeof(int32_t) + // Length of Compilation Unit Info
2229 sizeof(int16_t) + // DWARF version number
2230 sizeof(int32_t) + // Offset Into Abbrev. Section
2231 sizeof(int8_t); // Pointer Size (in bytes)
2232 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
Devang Patel1a0df9a2010-05-10 22:49:55 +00002233 }
Bill Wendling480ff322009-05-20 23:21:38 +00002234}
2235
Chris Lattner1fbf53b2010-04-04 23:02:02 +00002236/// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2237/// temporary label to it if SymbolStem is specified.
Chris Lattner6629ca92010-04-04 22:59:04 +00002238static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
Chris Lattner1fbf53b2010-04-04 23:02:02 +00002239 const char *SymbolStem = 0) {
Chris Lattner6629ca92010-04-04 22:59:04 +00002240 Asm->OutStreamer.SwitchSection(Section);
Chris Lattner1fbf53b2010-04-04 23:02:02 +00002241 if (!SymbolStem) return 0;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002242
Chris Lattner6629ca92010-04-04 22:59:04 +00002243 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2244 Asm->OutStreamer.EmitLabel(TmpSym);
2245 return TmpSym;
2246}
2247
2248/// EmitSectionLabels - Emit initial Dwarf sections with a label at
2249/// the start of each one.
Chris Lattner46355d82010-04-04 22:33:59 +00002250void DwarfDebug::EmitSectionLabels() {
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002251 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00002252
Bill Wendling480ff322009-05-20 23:21:38 +00002253 // Dwarf sections base addresses.
Chris Lattner3a383cb2010-04-05 00:13:49 +00002254 if (Asm->MAI->doesDwarfRequireFrameSection()) {
Chris Lattner6629ca92010-04-04 22:59:04 +00002255 DwarfFrameSectionSym =
2256 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2257 }
Bill Wendling480ff322009-05-20 23:21:38 +00002258
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002259 DwarfInfoSectionSym =
Chris Lattner6629ca92010-04-04 22:59:04 +00002260 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002261 DwarfAbbrevSectionSym =
Chris Lattner6629ca92010-04-04 22:59:04 +00002262 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
Chris Lattner1fbf53b2010-04-04 23:02:02 +00002263 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002264
Chris Lattner6629ca92010-04-04 22:59:04 +00002265 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
Chris Lattner1fbf53b2010-04-04 23:02:02 +00002266 EmitSectionSym(Asm, MacroInfo);
Bill Wendling480ff322009-05-20 23:21:38 +00002267
Devang Patel4a213872010-08-24 00:06:12 +00002268 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
Chris Lattner1fbf53b2010-04-04 23:02:02 +00002269 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2270 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2271 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002272 DwarfStrSectionSym =
Chris Lattner6629ca92010-04-04 22:59:04 +00002273 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
Devang Patel12563b32010-04-16 23:33:45 +00002274 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2275 "debug_range");
Bill Wendling480ff322009-05-20 23:21:38 +00002276
Devang Patel9fc11702010-05-25 23:40:22 +00002277 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2278 "section_debug_loc");
2279
Chris Lattner6629ca92010-04-04 22:59:04 +00002280 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
Chris Lattnere58b5472010-04-04 23:10:38 +00002281 EmitSectionSym(Asm, TLOF.getDataSection());
Bill Wendling480ff322009-05-20 23:21:38 +00002282}
2283
Devang Patel930143b2009-11-21 02:48:08 +00002284/// emitDIE - Recusively Emits a debug information entry.
Bill Wendling480ff322009-05-20 23:21:38 +00002285///
Devang Patel930143b2009-11-21 02:48:08 +00002286void DwarfDebug::emitDIE(DIE *Die) {
Bill Wendling480ff322009-05-20 23:21:38 +00002287 // Get the abbreviation for this DIE.
2288 unsigned AbbrevNumber = Die->getAbbrevNumber();
2289 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2290
Bill Wendling480ff322009-05-20 23:21:38 +00002291 // Emit the code (index) for the abbreviation.
Chris Lattner7bde8c02010-04-04 18:52:31 +00002292 if (Asm->isVerbose())
Chris Lattnerfa823552010-01-22 23:18:42 +00002293 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2294 Twine::utohexstr(Die->getOffset()) + ":0x" +
2295 Twine::utohexstr(Die->getSize()) + " " +
2296 dwarf::TagString(Abbrev->getTag()));
Chris Lattner9efd1182010-04-04 19:09:29 +00002297 Asm->EmitULEB128(AbbrevNumber);
Bill Wendling480ff322009-05-20 23:21:38 +00002298
Jeffrey Yasskin54ebc982010-03-22 18:47:14 +00002299 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
Bill Wendling480ff322009-05-20 23:21:38 +00002300 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2301
2302 // Emit the DIE attribute values.
2303 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2304 unsigned Attr = AbbrevData[i].getAttribute();
2305 unsigned Form = AbbrevData[i].getForm();
2306 assert(Form && "Too many attributes for DIE (check abbreviation)");
2307
Chris Lattner7bde8c02010-04-04 18:52:31 +00002308 if (Asm->isVerbose())
Chris Lattner5adf9872010-01-24 18:54:17 +00002309 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002310
Bill Wendling480ff322009-05-20 23:21:38 +00002311 switch (Attr) {
2312 case dwarf::DW_AT_sibling:
Devang Patel930143b2009-11-21 02:48:08 +00002313 Asm->EmitInt32(Die->getSiblingOffset());
Bill Wendling480ff322009-05-20 23:21:38 +00002314 break;
2315 case dwarf::DW_AT_abstract_origin: {
2316 DIEEntry *E = cast<DIEEntry>(Values[i]);
2317 DIE *Origin = E->getEntry();
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002318 unsigned Addr = Origin->getOffset();
Bill Wendling480ff322009-05-20 23:21:38 +00002319 Asm->EmitInt32(Addr);
2320 break;
2321 }
Devang Patel12563b32010-04-16 23:33:45 +00002322 case dwarf::DW_AT_ranges: {
2323 // DW_AT_range Value encodes offset in debug_range section.
2324 DIEInteger *V = cast<DIEInteger>(Values[i]);
Devang Patelda3ef852010-09-02 16:43:44 +00002325
2326 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2327 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2328 V->getValue(),
2329 4);
2330 } else {
2331 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2332 V->getValue(),
2333 DwarfDebugRangeSectionSym,
2334 4);
2335 }
Devang Patel12563b32010-04-16 23:33:45 +00002336 break;
2337 }
Devang Patel9fc11702010-05-25 23:40:22 +00002338 case dwarf::DW_AT_location: {
2339 if (UseDotDebugLocEntry.count(Die) != 0) {
2340 DIELabel *L = cast<DIELabel>(Values[i]);
Daniel Dunbarfd95b012011-03-16 22:16:39 +00002341 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
Devang Patel9fc11702010-05-25 23:40:22 +00002342 } else
2343 Values[i]->EmitValue(Asm, Form);
2344 break;
2345 }
Devang Patela1bd5a12010-09-29 19:08:08 +00002346 case dwarf::DW_AT_accessibility: {
2347 if (Asm->isVerbose()) {
2348 DIEInteger *V = cast<DIEInteger>(Values[i]);
2349 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2350 }
2351 Values[i]->EmitValue(Asm, Form);
2352 break;
2353 }
Bill Wendling480ff322009-05-20 23:21:38 +00002354 default:
2355 // Emit an attribute using the defined form.
Chris Lattner3a383cb2010-04-05 00:13:49 +00002356 Values[i]->EmitValue(Asm, Form);
Bill Wendling480ff322009-05-20 23:21:38 +00002357 break;
2358 }
Bill Wendling480ff322009-05-20 23:21:38 +00002359 }
2360
2361 // Emit the DIE children if any.
2362 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2363 const std::vector<DIE *> &Children = Die->getChildren();
2364
2365 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel930143b2009-11-21 02:48:08 +00002366 emitDIE(Children[j]);
Bill Wendling480ff322009-05-20 23:21:38 +00002367
Chris Lattner7bde8c02010-04-04 18:52:31 +00002368 if (Asm->isVerbose())
Chris Lattner566cae92010-03-09 23:52:58 +00002369 Asm->OutStreamer.AddComment("End Of Children Mark");
2370 Asm->EmitInt8(0);
Bill Wendling480ff322009-05-20 23:21:38 +00002371 }
2372}
2373
Devang Patel9ccfb642009-12-09 18:24:21 +00002374/// emitDebugInfo - Emit the debug info section.
Bill Wendling480ff322009-05-20 23:21:38 +00002375///
Devang Patel9ccfb642009-12-09 18:24:21 +00002376void DwarfDebug::emitDebugInfo() {
2377 // Start debug info section.
2378 Asm->OutStreamer.SwitchSection(
2379 Asm->getObjFileLowering().getDwarfInfoSection());
Devang Patel1a0df9a2010-05-10 22:49:55 +00002380 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2381 E = CUMap.end(); I != E; ++I) {
2382 CompileUnit *TheCU = I->second;
2383 DIE *Die = TheCU->getCUDie();
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002384
Devang Patel1a0df9a2010-05-10 22:49:55 +00002385 // Emit the compile units header.
2386 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2387 TheCU->getID()));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002388
Devang Patel1a0df9a2010-05-10 22:49:55 +00002389 // Emit size of content not including length itself
2390 unsigned ContentSize = Die->getSize() +
2391 sizeof(int16_t) + // DWARF version number
2392 sizeof(int32_t) + // Offset Into Abbrev. Section
Devang Patele141234942011-04-13 19:41:17 +00002393 sizeof(int8_t); // Pointer Size (in bytes)
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002394
Devang Patel1a0df9a2010-05-10 22:49:55 +00002395 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2396 Asm->EmitInt32(ContentSize);
2397 Asm->OutStreamer.AddComment("DWARF version number");
2398 Asm->EmitInt16(dwarf::DWARF_VERSION);
2399 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2400 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2401 DwarfAbbrevSectionSym);
2402 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2403 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002404
Devang Patel1a0df9a2010-05-10 22:49:55 +00002405 emitDIE(Die);
Devang Patel1a0df9a2010-05-10 22:49:55 +00002406 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2407 }
Bill Wendling480ff322009-05-20 23:21:38 +00002408}
2409
Devang Patel930143b2009-11-21 02:48:08 +00002410/// emitAbbreviations - Emit the abbreviation section.
Bill Wendling480ff322009-05-20 23:21:38 +00002411///
Devang Patel930143b2009-11-21 02:48:08 +00002412void DwarfDebug::emitAbbreviations() const {
Bill Wendling480ff322009-05-20 23:21:38 +00002413 // Check to see if it is worth the effort.
2414 if (!Abbreviations.empty()) {
2415 // Start the debug abbrev section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002416 Asm->OutStreamer.SwitchSection(
2417 Asm->getObjFileLowering().getDwarfAbbrevSection());
Bill Wendling480ff322009-05-20 23:21:38 +00002418
Chris Lattnera179b522010-04-04 19:25:43 +00002419 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
Bill Wendling480ff322009-05-20 23:21:38 +00002420
2421 // For each abbrevation.
2422 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2423 // Get abbreviation data
2424 const DIEAbbrev *Abbrev = Abbreviations[i];
2425
2426 // Emit the abbrevations code (base 1 index.)
Chris Lattner9efd1182010-04-04 19:09:29 +00002427 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
Bill Wendling480ff322009-05-20 23:21:38 +00002428
2429 // Emit the abbreviations data.
Chris Lattner3a383cb2010-04-05 00:13:49 +00002430 Abbrev->Emit(Asm);
Bill Wendling480ff322009-05-20 23:21:38 +00002431 }
2432
2433 // Mark end of abbreviations.
Chris Lattner9efd1182010-04-04 19:09:29 +00002434 Asm->EmitULEB128(0, "EOM(3)");
Bill Wendling480ff322009-05-20 23:21:38 +00002435
Chris Lattnera179b522010-04-04 19:25:43 +00002436 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
Bill Wendling480ff322009-05-20 23:21:38 +00002437 }
2438}
2439
Devang Patel930143b2009-11-21 02:48:08 +00002440/// emitEndOfLineMatrix - Emit the last address of the section and the end of
Bill Wendling480ff322009-05-20 23:21:38 +00002441/// the line matrix.
2442///
Devang Patel930143b2009-11-21 02:48:08 +00002443void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling480ff322009-05-20 23:21:38 +00002444 // Define last address of section.
Chris Lattner566cae92010-03-09 23:52:58 +00002445 Asm->OutStreamer.AddComment("Extended Op");
2446 Asm->EmitInt8(0);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002447
Chris Lattner566cae92010-03-09 23:52:58 +00002448 Asm->OutStreamer.AddComment("Op size");
Chris Lattner3a383cb2010-04-05 00:13:49 +00002449 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner566cae92010-03-09 23:52:58 +00002450 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2451 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2452
2453 Asm->OutStreamer.AddComment("Section end label");
Chris Lattnerb245dfb2010-03-10 01:17:49 +00002454
Chris Lattnera179b522010-04-04 19:25:43 +00002455 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
Chris Lattner3a383cb2010-04-05 00:13:49 +00002456 Asm->getTargetData().getPointerSize(),
2457 0/*AddrSpace*/);
Bill Wendling480ff322009-05-20 23:21:38 +00002458
2459 // Mark end of matrix.
Chris Lattner566cae92010-03-09 23:52:58 +00002460 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2461 Asm->EmitInt8(0);
Chris Lattnerf5c834f2010-01-22 22:09:00 +00002462 Asm->EmitInt8(1);
Chris Lattnerfa823552010-01-22 23:18:42 +00002463 Asm->EmitInt8(1);
Bill Wendling480ff322009-05-20 23:21:38 +00002464}
2465
Devang Patel930143b2009-11-21 02:48:08 +00002466/// emitCommonDebugFrame - Emit common frame info into a debug frame section.
Bill Wendling480ff322009-05-20 23:21:38 +00002467///
Devang Patel930143b2009-11-21 02:48:08 +00002468void DwarfDebug::emitCommonDebugFrame() {
Chris Lattner3a383cb2010-04-05 00:13:49 +00002469 if (!Asm->MAI->doesDwarfRequireFrameSection())
Bill Wendling480ff322009-05-20 23:21:38 +00002470 return;
2471
Chris Lattner3a383cb2010-04-05 00:13:49 +00002472 int stackGrowth = Asm->getTargetData().getPointerSize();
Anton Korobeynikov2f931282011-01-10 12:39:04 +00002473 if (Asm->TM.getFrameLowering()->getStackGrowthDirection() ==
2474 TargetFrameLowering::StackGrowsDown)
Chris Lattner3a383cb2010-04-05 00:13:49 +00002475 stackGrowth *= -1;
Bill Wendling480ff322009-05-20 23:21:38 +00002476
2477 // Start the dwarf frame section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002478 Asm->OutStreamer.SwitchSection(
2479 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling480ff322009-05-20 23:21:38 +00002480
Chris Lattnera179b522010-04-04 19:25:43 +00002481 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
Chris Lattner566cae92010-03-09 23:52:58 +00002482 Asm->OutStreamer.AddComment("Length of Common Information Entry");
Chris Lattnerf1429f12010-04-04 19:58:12 +00002483 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
2484 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
Bill Wendling480ff322009-05-20 23:21:38 +00002485
Chris Lattnera179b522010-04-04 19:25:43 +00002486 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
Chris Lattner566cae92010-03-09 23:52:58 +00002487 Asm->OutStreamer.AddComment("CIE Identifier Tag");
Bill Wendling480ff322009-05-20 23:21:38 +00002488 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
Chris Lattner566cae92010-03-09 23:52:58 +00002489 Asm->OutStreamer.AddComment("CIE Version");
Bill Wendling480ff322009-05-20 23:21:38 +00002490 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
Chris Lattner566cae92010-03-09 23:52:58 +00002491 Asm->OutStreamer.AddComment("CIE Augmentation");
Chris Lattnerc3f23b82010-01-23 03:11:46 +00002492 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
Chris Lattner9efd1182010-04-04 19:09:29 +00002493 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
2494 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
Chris Lattner566cae92010-03-09 23:52:58 +00002495 Asm->OutStreamer.AddComment("CIE RA Column");
Chris Lattner3a383cb2010-04-05 00:13:49 +00002496 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Anton Korobeynikov2f931282011-01-10 12:39:04 +00002497 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
Bill Wendling480ff322009-05-20 23:21:38 +00002498 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
Bill Wendling480ff322009-05-20 23:21:38 +00002499
2500 std::vector<MachineMove> Moves;
Anton Korobeynikov14ee3442010-11-18 23:25:52 +00002501 TFI->getInitialFrameState(Moves);
Bill Wendling480ff322009-05-20 23:21:38 +00002502
Chris Lattneraabc6042010-04-04 23:41:46 +00002503 Asm->EmitFrameMoves(Moves, 0, false);
Bill Wendling480ff322009-05-20 23:21:38 +00002504
Chris Lattner9e06e532010-04-28 01:05:45 +00002505 Asm->EmitAlignment(2);
Chris Lattnera179b522010-04-04 19:25:43 +00002506 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
Bill Wendling480ff322009-05-20 23:21:38 +00002507}
2508
Devang Patel930143b2009-11-21 02:48:08 +00002509/// emitFunctionDebugFrame - Emit per function frame info into a debug frame
Bill Wendling480ff322009-05-20 23:21:38 +00002510/// section.
Chris Lattner2c3f4782010-03-13 07:26:18 +00002511void DwarfDebug::
2512emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
Chris Lattner3a383cb2010-04-05 00:13:49 +00002513 if (!Asm->MAI->doesDwarfRequireFrameSection())
Bill Wendling480ff322009-05-20 23:21:38 +00002514 return;
2515
2516 // Start the dwarf frame section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002517 Asm->OutStreamer.SwitchSection(
2518 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling480ff322009-05-20 23:21:38 +00002519
Chris Lattner566cae92010-03-09 23:52:58 +00002520 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
Chris Lattner2c3f4782010-03-13 07:26:18 +00002521 MCSymbol *DebugFrameBegin =
Chris Lattnera179b522010-04-04 19:25:43 +00002522 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
Chris Lattner2c3f4782010-03-13 07:26:18 +00002523 MCSymbol *DebugFrameEnd =
Chris Lattnera179b522010-04-04 19:25:43 +00002524 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
Chris Lattnerf1429f12010-04-04 19:58:12 +00002525 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
Bill Wendling480ff322009-05-20 23:21:38 +00002526
Chris Lattner2c3f4782010-03-13 07:26:18 +00002527 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
Bill Wendling480ff322009-05-20 23:21:38 +00002528
Chris Lattner566cae92010-03-09 23:52:58 +00002529 Asm->OutStreamer.AddComment("FDE CIE offset");
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002530 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
Chris Lattner70a4fce2010-04-04 23:25:33 +00002531 DwarfFrameSectionSym);
Bill Wendling480ff322009-05-20 23:21:38 +00002532
Chris Lattner566cae92010-03-09 23:52:58 +00002533 Asm->OutStreamer.AddComment("FDE initial location");
Chris Lattnera179b522010-04-04 19:25:43 +00002534 MCSymbol *FuncBeginSym =
2535 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
Chris Lattner8811e122010-03-13 07:40:56 +00002536 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
Chris Lattner3a383cb2010-04-05 00:13:49 +00002537 Asm->getTargetData().getPointerSize(),
2538 0/*AddrSpace*/);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002539
2540
Chris Lattner566cae92010-03-09 23:52:58 +00002541 Asm->OutStreamer.AddComment("FDE address range");
Chris Lattnerf1429f12010-04-04 19:58:12 +00002542 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
Chris Lattner3a383cb2010-04-05 00:13:49 +00002543 FuncBeginSym, Asm->getTargetData().getPointerSize());
Bill Wendling480ff322009-05-20 23:21:38 +00002544
Chris Lattneraabc6042010-04-04 23:41:46 +00002545 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
Bill Wendling480ff322009-05-20 23:21:38 +00002546
Chris Lattner9e06e532010-04-28 01:05:45 +00002547 Asm->EmitAlignment(2);
Chris Lattner2c3f4782010-03-13 07:26:18 +00002548 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
Bill Wendling480ff322009-05-20 23:21:38 +00002549}
2550
Devang Patel9ccfb642009-12-09 18:24:21 +00002551/// emitDebugPubNames - Emit visible names into a debug pubnames section.
2552///
2553void DwarfDebug::emitDebugPubNames() {
Devang Patel1a0df9a2010-05-10 22:49:55 +00002554 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2555 E = CUMap.end(); I != E; ++I) {
2556 CompileUnit *TheCU = I->second;
2557 // Start the dwarf pubnames section.
2558 Asm->OutStreamer.SwitchSection(
2559 Asm->getObjFileLowering().getDwarfPubNamesSection());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002560
Devang Patel1a0df9a2010-05-10 22:49:55 +00002561 Asm->OutStreamer.AddComment("Length of Public Names Info");
2562 Asm->EmitLabelDifference(
2563 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2564 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002565
Devang Patel1a0df9a2010-05-10 22:49:55 +00002566 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2567 TheCU->getID()));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002568
Devang Patel1a0df9a2010-05-10 22:49:55 +00002569 Asm->OutStreamer.AddComment("DWARF Version");
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002570 Asm->EmitInt16(dwarf::DWARF_VERSION);
2571
Devang Patel1a0df9a2010-05-10 22:49:55 +00002572 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002573 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
Devang Patel1a0df9a2010-05-10 22:49:55 +00002574 DwarfInfoSectionSym);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002575
Devang Patel1a0df9a2010-05-10 22:49:55 +00002576 Asm->OutStreamer.AddComment("Compilation Unit Length");
2577 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2578 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2579 4);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002580
Devang Patel1a0df9a2010-05-10 22:49:55 +00002581 const StringMap<DIE*> &Globals = TheCU->getGlobals();
2582 for (StringMap<DIE*>::const_iterator
2583 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2584 const char *Name = GI->getKeyData();
2585 DIE *Entity = GI->second;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002586
Devang Patel1a0df9a2010-05-10 22:49:55 +00002587 Asm->OutStreamer.AddComment("DIE offset");
2588 Asm->EmitInt32(Entity->getOffset());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002589
Devang Patel1a0df9a2010-05-10 22:49:55 +00002590 if (Asm->isVerbose())
2591 Asm->OutStreamer.AddComment("External Name");
2592 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2593 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002594
Devang Patel1a0df9a2010-05-10 22:49:55 +00002595 Asm->OutStreamer.AddComment("End Mark");
2596 Asm->EmitInt32(0);
2597 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2598 TheCU->getID()));
Bill Wendling480ff322009-05-20 23:21:38 +00002599 }
Bill Wendling480ff322009-05-20 23:21:38 +00002600}
2601
Devang Patel04d2f2d2009-11-24 01:14:22 +00002602void DwarfDebug::emitDebugPubTypes() {
Devang Patel1a0df9a2010-05-10 22:49:55 +00002603 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2604 E = CUMap.end(); I != E; ++I) {
2605 CompileUnit *TheCU = I->second;
2606 // Start the dwarf pubnames section.
2607 Asm->OutStreamer.SwitchSection(
2608 Asm->getObjFileLowering().getDwarfPubTypesSection());
2609 Asm->OutStreamer.AddComment("Length of Public Types Info");
2610 Asm->EmitLabelDifference(
2611 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2612 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002613
Devang Patel1a0df9a2010-05-10 22:49:55 +00002614 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2615 TheCU->getID()));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002616
Devang Patel1a0df9a2010-05-10 22:49:55 +00002617 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2618 Asm->EmitInt16(dwarf::DWARF_VERSION);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002619
Devang Patel1a0df9a2010-05-10 22:49:55 +00002620 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2621 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2622 DwarfInfoSectionSym);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002623
Devang Patel1a0df9a2010-05-10 22:49:55 +00002624 Asm->OutStreamer.AddComment("Compilation Unit Length");
2625 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2626 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2627 4);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002628
Devang Patel1a0df9a2010-05-10 22:49:55 +00002629 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2630 for (StringMap<DIE*>::const_iterator
2631 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2632 const char *Name = GI->getKeyData();
2633 DIE * Entity = GI->second;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002634
Devang Patel1a0df9a2010-05-10 22:49:55 +00002635 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2636 Asm->EmitInt32(Entity->getOffset());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002637
Devang Patel1a0df9a2010-05-10 22:49:55 +00002638 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2639 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2640 }
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002641
Devang Patel1a0df9a2010-05-10 22:49:55 +00002642 Asm->OutStreamer.AddComment("End Mark");
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002643 Asm->EmitInt32(0);
Devang Patel1a0df9a2010-05-10 22:49:55 +00002644 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2645 TheCU->getID()));
Devang Patel04d2f2d2009-11-24 01:14:22 +00002646 }
Devang Patel04d2f2d2009-11-24 01:14:22 +00002647}
2648
Devang Patel930143b2009-11-21 02:48:08 +00002649/// emitDebugStr - Emit visible names into a debug str section.
Bill Wendling480ff322009-05-20 23:21:38 +00002650///
Devang Patel930143b2009-11-21 02:48:08 +00002651void DwarfDebug::emitDebugStr() {
Bill Wendling480ff322009-05-20 23:21:38 +00002652 // Check to see if it is worth the effort.
Chris Lattner3d72a672010-03-09 23:38:23 +00002653 if (StringPool.empty()) return;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002654
Chris Lattner3d72a672010-03-09 23:38:23 +00002655 // Start the dwarf str section.
2656 Asm->OutStreamer.SwitchSection(
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002657 Asm->getObjFileLowering().getDwarfStrSection());
Bill Wendling480ff322009-05-20 23:21:38 +00002658
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002659 // Get all of the string pool entries and put them in an array by their ID so
2660 // we can sort them.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002661 SmallVector<std::pair<unsigned,
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002662 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002663
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002664 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2665 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2666 Entries.push_back(std::make_pair(I->second.second, &*I));
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002667
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002668 array_pod_sort(Entries.begin(), Entries.end());
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002669
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002670 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
Chris Lattner3d72a672010-03-09 23:38:23 +00002671 // Emit a label for reference from debug information entries.
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002672 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002673
Chris Lattner3d72a672010-03-09 23:38:23 +00002674 // Emit the string itself.
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002675 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
Bill Wendling480ff322009-05-20 23:21:38 +00002676 }
2677}
2678
Devang Patel930143b2009-11-21 02:48:08 +00002679/// emitDebugLoc - Emit visible names into a debug loc section.
Bill Wendling480ff322009-05-20 23:21:38 +00002680///
Devang Patel930143b2009-11-21 02:48:08 +00002681void DwarfDebug::emitDebugLoc() {
Devang Patel6b9a9fe2010-05-26 23:55:23 +00002682 if (DotDebugLocEntries.empty())
2683 return;
2684
Devang Patel116a9d72011-02-04 22:57:18 +00002685 for (SmallVector<DotDebugLocEntry, 4>::iterator
2686 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2687 I != E; ++I) {
2688 DotDebugLocEntry &Entry = *I;
2689 if (I + 1 != DotDebugLocEntries.end())
2690 Entry.Merge(I+1);
2691 }
2692
Daniel Dunbarfd95b012011-03-16 22:16:39 +00002693 // Start the dwarf loc section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002694 Asm->OutStreamer.SwitchSection(
Devang Patel9fc11702010-05-25 23:40:22 +00002695 Asm->getObjFileLowering().getDwarfLocSection());
2696 unsigned char Size = Asm->getTargetData().getPointerSize();
Devang Patel6b9a9fe2010-05-26 23:55:23 +00002697 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2698 unsigned index = 1;
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002699 for (SmallVector<DotDebugLocEntry, 4>::iterator
2700 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
Devang Patel30265c42010-07-07 20:12:52 +00002701 I != E; ++I, ++index) {
Devang Patel116a9d72011-02-04 22:57:18 +00002702 DotDebugLocEntry &Entry = *I;
2703 if (Entry.isMerged()) continue;
Devang Patel9fc11702010-05-25 23:40:22 +00002704 if (Entry.isEmpty()) {
2705 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2706 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patel6b9a9fe2010-05-26 23:55:23 +00002707 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
Devang Patel9fc11702010-05-25 23:40:22 +00002708 } else {
2709 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2710 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
Devang Patel2266aa82011-04-21 21:07:35 +00002711 Asm->EmitDwarfRegOp(Entry.Loc);
Devang Patel9fc11702010-05-25 23:40:22 +00002712 }
2713 }
Bill Wendling480ff322009-05-20 23:21:38 +00002714}
2715
2716/// EmitDebugARanges - Emit visible names into a debug aranges section.
2717///
2718void DwarfDebug::EmitDebugARanges() {
2719 // Start the dwarf aranges section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002720 Asm->OutStreamer.SwitchSection(
2721 Asm->getObjFileLowering().getDwarfARangesSection());
Bill Wendling480ff322009-05-20 23:21:38 +00002722}
2723
Devang Patel930143b2009-11-21 02:48:08 +00002724/// emitDebugRanges - Emit visible names into a debug ranges section.
Bill Wendling480ff322009-05-20 23:21:38 +00002725///
Devang Patel930143b2009-11-21 02:48:08 +00002726void DwarfDebug::emitDebugRanges() {
Bill Wendling480ff322009-05-20 23:21:38 +00002727 // Start the dwarf ranges section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002728 Asm->OutStreamer.SwitchSection(
Devang Patel12563b32010-04-16 23:33:45 +00002729 Asm->getObjFileLowering().getDwarfRangesSection());
Devang Patel6c74a872010-04-27 19:46:33 +00002730 unsigned char Size = Asm->getTargetData().getPointerSize();
2731 for (SmallVector<const MCSymbol *, 8>::iterator
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002732 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
Devang Patel6c74a872010-04-27 19:46:33 +00002733 I != E; ++I) {
2734 if (*I)
2735 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
Devang Patel12563b32010-04-16 23:33:45 +00002736 else
Devang Patel6c74a872010-04-27 19:46:33 +00002737 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patel12563b32010-04-16 23:33:45 +00002738 }
Bill Wendling480ff322009-05-20 23:21:38 +00002739}
2740
Devang Patel930143b2009-11-21 02:48:08 +00002741/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
Bill Wendling480ff322009-05-20 23:21:38 +00002742///
Devang Patel930143b2009-11-21 02:48:08 +00002743void DwarfDebug::emitDebugMacInfo() {
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00002744 if (const MCSection *LineInfo =
Chris Lattner1472cf52009-08-02 07:24:22 +00002745 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
Bill Wendling480ff322009-05-20 23:21:38 +00002746 // Start the dwarf macinfo section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002747 Asm->OutStreamer.SwitchSection(LineInfo);
Bill Wendling480ff322009-05-20 23:21:38 +00002748 }
2749}
2750
Devang Patel930143b2009-11-21 02:48:08 +00002751/// emitDebugInlineInfo - Emit inline info using following format.
Bill Wendling480ff322009-05-20 23:21:38 +00002752/// Section Header:
2753/// 1. length of section
2754/// 2. Dwarf version number
2755/// 3. address size.
2756///
2757/// Entries (one "entry" for each function that was inlined):
2758///
2759/// 1. offset into __debug_str section for MIPS linkage name, if exists;
2760/// otherwise offset into __debug_str for regular function name.
2761/// 2. offset into __debug_str section for regular function name.
2762/// 3. an unsigned LEB128 number indicating the number of distinct inlining
2763/// instances for the function.
2764///
2765/// The rest of the entry consists of a {die_offset, low_pc} pair for each
2766/// inlined instance; the die_offset points to the inlined_subroutine die in the
2767/// __debug_info section, and the low_pc is the starting address for the
2768/// inlining instance.
Devang Patel930143b2009-11-21 02:48:08 +00002769void DwarfDebug::emitDebugInlineInfo() {
Chris Lattner3a383cb2010-04-05 00:13:49 +00002770 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
Bill Wendling480ff322009-05-20 23:21:38 +00002771 return;
2772
Devang Patel1a0df9a2010-05-10 22:49:55 +00002773 if (!FirstCU)
Bill Wendling480ff322009-05-20 23:21:38 +00002774 return;
2775
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002776 Asm->OutStreamer.SwitchSection(
2777 Asm->getObjFileLowering().getDwarfDebugInlineSection());
Chris Lattnerf5c834f2010-01-22 22:09:00 +00002778
Chris Lattner566cae92010-03-09 23:52:58 +00002779 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
Chris Lattnerf1429f12010-04-04 19:58:12 +00002780 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2781 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
Bill Wendling480ff322009-05-20 23:21:38 +00002782
Chris Lattnera179b522010-04-04 19:25:43 +00002783 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
Bill Wendling480ff322009-05-20 23:21:38 +00002784
Chris Lattner566cae92010-03-09 23:52:58 +00002785 Asm->OutStreamer.AddComment("Dwarf Version");
2786 Asm->EmitInt16(dwarf::DWARF_VERSION);
2787 Asm->OutStreamer.AddComment("Address Size (in bytes)");
Chris Lattner3a383cb2010-04-05 00:13:49 +00002788 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Bill Wendling480ff322009-05-20 23:21:38 +00002789
Devang Patel32cc43c2010-05-07 20:54:48 +00002790 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002791 E = InlinedSPNodes.end(); I != E; ++I) {
Jim Grosbach042483e2009-11-21 23:12:12 +00002792
Devang Patel32cc43c2010-05-07 20:54:48 +00002793 const MDNode *Node = *I;
2794 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
Jim Grosbach00e9c612009-11-22 19:20:36 +00002795 = InlineInfo.find(Node);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002796 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
Devang Patel80ae3492009-08-28 23:24:31 +00002797 DISubprogram SP(Node);
Devang Patel2d9caf92009-11-25 17:36:49 +00002798 StringRef LName = SP.getLinkageName();
2799 StringRef Name = SP.getName();
Bill Wendling480ff322009-05-20 23:21:38 +00002800
Chris Lattner566cae92010-03-09 23:52:58 +00002801 Asm->OutStreamer.AddComment("MIPS linkage name");
Chris Lattnerc3f23b82010-01-23 03:11:46 +00002802 if (LName.empty()) {
2803 Asm->OutStreamer.EmitBytes(Name, 0);
2804 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
Jim Grosbacha8683bb2010-07-21 21:21:52 +00002805 } else
Chris Lattner70a4fce2010-04-04 23:25:33 +00002806 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2807 DwarfStrSectionSym);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002808
Chris Lattner566cae92010-03-09 23:52:58 +00002809 Asm->OutStreamer.AddComment("Function name");
Chris Lattner70a4fce2010-04-04 23:25:33 +00002810 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
Chris Lattner9efd1182010-04-04 19:09:29 +00002811 Asm->EmitULEB128(Labels.size(), "Inline count");
Bill Wendling480ff322009-05-20 23:21:38 +00002812
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002813 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
Bill Wendling480ff322009-05-20 23:21:38 +00002814 LE = Labels.end(); LI != LE; ++LI) {
Chris Lattner7bde8c02010-04-04 18:52:31 +00002815 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
Chris Lattner085b6522010-03-09 00:31:02 +00002816 Asm->EmitInt32(LI->second->getOffset());
Bill Wendling480ff322009-05-20 23:21:38 +00002817
Chris Lattner7bde8c02010-04-04 18:52:31 +00002818 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
Chris Lattner3a383cb2010-04-05 00:13:49 +00002819 Asm->OutStreamer.EmitSymbolValue(LI->first,
2820 Asm->getTargetData().getPointerSize(),0);
Bill Wendling480ff322009-05-20 23:21:38 +00002821 }
2822 }
2823
Chris Lattnera179b522010-04-04 19:25:43 +00002824 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
Bill Wendling480ff322009-05-20 23:21:38 +00002825}