blob: 65c1d190216fa72ff85d59fdb086ae3633b3ef1f [file] [log] [blame]
Bill Wendling0310d762009-05-15 09:23:25 +00001//===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains support for writing dwarf debug info into asm files.
11//
12//===----------------------------------------------------------------------===//
Chris Lattner6cde3e62010-03-09 00:39:24 +000013
Devang Patele4b27562009-08-28 23:24:31 +000014#define DEBUG_TYPE "dwarfdebug"
Bill Wendling0310d762009-05-15 09:23:25 +000015#include "DwarfDebug.h"
Chris Lattner74e41f92010-04-05 05:24:55 +000016#include "DIE.h"
Bill Wendling57fbba42010-04-05 22:59:21 +000017#include "llvm/Constants.h"
Bill Wendling0310d762009-05-15 09:23:25 +000018#include "llvm/Module.h"
David Greeneb2c66fc2009-08-19 21:52:55 +000019#include "llvm/CodeGen/MachineFunction.h"
Bill Wendling0310d762009-05-15 09:23:25 +000020#include "llvm/CodeGen/MachineModuleInfo.h"
Chris Lattnerb7db7332010-03-09 01:58:53 +000021#include "llvm/MC/MCAsmInfo.h"
Chris Lattnera87dea42009-07-31 18:48:30 +000022#include "llvm/MC/MCSection.h"
Chris Lattner6c2f9e12009-08-19 05:49:37 +000023#include "llvm/MC/MCStreamer.h"
Chris Lattnerb7db7332010-03-09 01:58:53 +000024#include "llvm/MC/MCSymbol.h"
Chris Lattner45111d12010-01-16 21:57:06 +000025#include "llvm/Target/Mangler.h"
Bill Wendling0310d762009-05-15 09:23:25 +000026#include "llvm/Target/TargetData.h"
27#include "llvm/Target/TargetFrameInfo.h"
Chris Lattnerf0144122009-07-28 03:13:23 +000028#include "llvm/Target/TargetLoweringObjectFile.h"
Chris Lattner9d1c1ad2010-04-04 18:06:11 +000029#include "llvm/Target/TargetMachine.h"
Chris Lattnerf0144122009-07-28 03:13:23 +000030#include "llvm/Target/TargetRegisterInfo.h"
Devang Patel2a4a3b72010-04-19 19:14:02 +000031#include "llvm/Target/TargetOptions.h"
Chris Lattner74e41f92010-04-05 05:24:55 +000032#include "llvm/Analysis/DebugInfo.h"
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +000033#include "llvm/ADT/STLExtras.h"
Chris Lattner23132b12009-08-24 03:52:50 +000034#include "llvm/ADT/StringExtras.h"
Devang Pateleac9c072010-04-27 19:46:33 +000035#include "llvm/Support/CommandLine.h"
Daniel Dunbar6e4bdfc2009-10-13 06:47:08 +000036#include "llvm/Support/Debug.h"
37#include "llvm/Support/ErrorHandling.h"
Devang Patel3139fcf2010-01-26 21:39:14 +000038#include "llvm/Support/ValueHandle.h"
Chris Lattner0ad9c912010-01-22 22:09:00 +000039#include "llvm/Support/FormattedStream.h"
Chris Lattnera87dea42009-07-31 18:48:30 +000040#include "llvm/Support/Timer.h"
41#include "llvm/System/Path.h"
Bill Wendling0310d762009-05-15 09:23:25 +000042using namespace llvm;
43
Devang Pateleac9c072010-04-27 19:46:33 +000044static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
45 cl::desc("Print DbgScope information for each machine instruction"));
46
Devang Patel61409622010-07-07 20:12:52 +000047static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
48 cl::Hidden,
Devang Pateleac9c072010-04-27 19:46:33 +000049 cl::desc("Disable debug info printing"));
50
Dan Gohman281d65d2010-05-07 01:08:53 +000051static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
52 cl::desc("Make an absense of debug location information explicit."),
53 cl::init(false));
54
Bill Wendling5f017e82010-04-07 09:28:04 +000055namespace {
56 const char *DWARFGroupName = "DWARF Emission";
57 const char *DbgTimerName = "DWARF Debug Writer";
58} // end anonymous namespace
59
Bill Wendling0310d762009-05-15 09:23:25 +000060//===----------------------------------------------------------------------===//
61
62/// Configuration values for initial hash set sizes (log2).
63///
Bill Wendling0310d762009-05-15 09:23:25 +000064static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
Bill Wendling0310d762009-05-15 09:23:25 +000065
66namespace llvm {
67
68//===----------------------------------------------------------------------===//
69/// CompileUnit - This dwarf writer support class manages information associate
70/// with a source file.
Nick Lewycky5f9843f2009-11-17 08:11:44 +000071class CompileUnit {
Bill Wendling0310d762009-05-15 09:23:25 +000072 /// ID - File identifier for source.
73 ///
74 unsigned ID;
75
76 /// Die - Compile unit debug information entry.
77 ///
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +000078 const OwningPtr<DIE> CUDie;
Bill Wendling0310d762009-05-15 09:23:25 +000079
Jeffrey Yasskind0f393d2010-03-11 18:29:55 +000080 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
Devang Patel6f01d9c2009-11-21 00:31:03 +000081 DIE *IndexTyDie;
82
Devang Patel869aa462010-07-07 20:49:57 +000083 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
Bill Wendling0310d762009-05-15 09:23:25 +000084 /// variables to debug information entries.
Devang Patel869aa462010-07-07 20:49:57 +000085 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
Bill Wendling0310d762009-05-15 09:23:25 +000086
Devang Patel869aa462010-07-07 20:49:57 +000087 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
Bill Wendling0310d762009-05-15 09:23:25 +000088 /// descriptors to debug information entries using a DIEEntry proxy.
Devang Patel869aa462010-07-07 20:49:57 +000089 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
Bill Wendling0310d762009-05-15 09:23:25 +000090
91 /// Globals - A map of globally visible named entities for this unit.
92 ///
93 StringMap<DIE*> Globals;
94
Devang Patel193f7202009-11-24 01:14:22 +000095 /// GlobalTypes - A map of globally visible types for this unit.
96 ///
97 StringMap<DIE*> GlobalTypes;
98
Bill Wendling0310d762009-05-15 09:23:25 +000099public:
100 CompileUnit(unsigned I, DIE *D)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000101 : ID(I), CUDie(D), IndexTyDie(0) {}
Bill Wendling0310d762009-05-15 09:23:25 +0000102
103 // Accessors.
Devang Patel193f7202009-11-24 01:14:22 +0000104 unsigned getID() const { return ID; }
Jeffrey Yasskind0f393d2010-03-11 18:29:55 +0000105 DIE* getCUDie() const { return CUDie.get(); }
Devang Patel193f7202009-11-24 01:14:22 +0000106 const StringMap<DIE*> &getGlobals() const { return Globals; }
107 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
Bill Wendling0310d762009-05-15 09:23:25 +0000108
109 /// hasContent - Return true if this compile unit has something to write out.
110 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000111 bool hasContent() const { return !CUDie->getChildren().empty(); }
Bill Wendling0310d762009-05-15 09:23:25 +0000112
Devang Patel2c4ceb12009-11-21 02:48:08 +0000113 /// addGlobal - Add a new global entity to the compile unit.
Bill Wendling0310d762009-05-15 09:23:25 +0000114 ///
Benjamin Kramerbbb88db2010-03-31 20:15:45 +0000115 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
Bill Wendling0310d762009-05-15 09:23:25 +0000116
Devang Patel193f7202009-11-24 01:14:22 +0000117 /// addGlobalType - Add a new global type to the compile unit.
118 ///
Benjamin Kramerbbb88db2010-03-31 20:15:45 +0000119 void addGlobalType(StringRef Name, DIE *Die) {
Devang Patel193f7202009-11-24 01:14:22 +0000120 GlobalTypes[Name] = Die;
121 }
122
Devang Patel017d1212009-11-20 21:37:22 +0000123 /// getDIE - Returns the debug information entry map slot for the
Bill Wendling0310d762009-05-15 09:23:25 +0000124 /// specified debug variable.
Devang Patel869aa462010-07-07 20:49:57 +0000125 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000126
Devang Patel017d1212009-11-20 21:37:22 +0000127 /// insertDIE - Insert DIE into the map.
Devang Patele9f8f5e2010-05-07 20:54:48 +0000128 void insertDIE(const MDNode *N, DIE *D) {
Devang Patel869aa462010-07-07 20:49:57 +0000129 MDNodeToDieMap.insert(std::make_pair(N, D));
Devang Patel017d1212009-11-20 21:37:22 +0000130 }
Bill Wendling0310d762009-05-15 09:23:25 +0000131
Devang Patel017d1212009-11-20 21:37:22 +0000132 /// getDIEEntry - Returns the debug information entry for the speciefied
133 /// debug variable.
Devang Patele9f8f5e2010-05-07 20:54:48 +0000134 DIEEntry *getDIEEntry(const MDNode *N) {
Devang Patel869aa462010-07-07 20:49:57 +0000135 DenseMap<const MDNode *, DIEEntry *>::iterator I = MDNodeToDIEEntryMap.find(N);
136 if (I == MDNodeToDIEEntryMap.end())
Devang Patel6404e4e2009-12-15 19:16:48 +0000137 return NULL;
138 return I->second;
139 }
Devang Patel017d1212009-11-20 21:37:22 +0000140
141 /// insertDIEEntry - Insert debug information entry into the map.
Devang Patele9f8f5e2010-05-07 20:54:48 +0000142 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
Devang Patel869aa462010-07-07 20:49:57 +0000143 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
Bill Wendling0310d762009-05-15 09:23:25 +0000144 }
145
Devang Patel2c4ceb12009-11-21 02:48:08 +0000146 /// addDie - Adds or interns the DIE to the compile unit.
Bill Wendling0310d762009-05-15 09:23:25 +0000147 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000148 void addDie(DIE *Buffer) {
149 this->CUDie->addChild(Buffer);
Bill Wendling0310d762009-05-15 09:23:25 +0000150 }
Devang Patel6f01d9c2009-11-21 00:31:03 +0000151
152 // getIndexTyDie - Get an anonymous type for index type.
153 DIE *getIndexTyDie() {
154 return IndexTyDie;
155 }
156
Jim Grosbach7ab38df2009-11-22 19:20:36 +0000157 // setIndexTyDie - Set D as anonymous type for index which can be reused
158 // later.
Devang Patel6f01d9c2009-11-21 00:31:03 +0000159 void setIndexTyDie(DIE *D) {
160 IndexTyDie = D;
161 }
162
Bill Wendling0310d762009-05-15 09:23:25 +0000163};
164
165//===----------------------------------------------------------------------===//
166/// DbgVariable - This class is used to track local variable information.
167///
Devang Patelf76a3d62009-11-16 21:53:40 +0000168class DbgVariable {
Bill Wendling0310d762009-05-15 09:23:25 +0000169 DIVariable Var; // Variable Descriptor.
Devang Patelc3f5f782010-05-25 23:40:22 +0000170 DIE *TheDIE; // Variable DIE.
171 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
Bill Wendling0310d762009-05-15 09:23:25 +0000172public:
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000173 // AbsVar may be NULL.
Devang Patelc3f5f782010-05-25 23:40:22 +0000174 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
Bill Wendling0310d762009-05-15 09:23:25 +0000175
176 // Accessors.
Devang Patel53bb5c92009-11-10 23:06:00 +0000177 DIVariable getVariable() const { return Var; }
Devang Patel53bb5c92009-11-10 23:06:00 +0000178 void setDIE(DIE *D) { TheDIE = D; }
179 DIE *getDIE() const { return TheDIE; }
Devang Patelc3f5f782010-05-25 23:40:22 +0000180 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
181 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
Bill Wendling0310d762009-05-15 09:23:25 +0000182};
183
184//===----------------------------------------------------------------------===//
Devang Pateleac9c072010-04-27 19:46:33 +0000185/// DbgRange - This is used to track range of instructions with identical
186/// debug info scope.
187///
188typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
189
190//===----------------------------------------------------------------------===//
Bill Wendling0310d762009-05-15 09:23:25 +0000191/// DbgScope - This class is used to track scope information.
192///
Devang Patelf76a3d62009-11-16 21:53:40 +0000193class DbgScope {
Bill Wendling0310d762009-05-15 09:23:25 +0000194 DbgScope *Parent; // Parent to this scope.
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000195 DIDescriptor Desc; // Debug info descriptor for scope.
Devang Patel3139fcf2010-01-26 21:39:14 +0000196 // Location at which this scope is inlined.
Devang Patele9f8f5e2010-05-07 20:54:48 +0000197 AssertingVH<const MDNode> InlinedAtLocation;
Devang Patel53bb5c92009-11-10 23:06:00 +0000198 bool AbstractScope; // Abstract Scope
Devang Pateld38dd112009-10-01 18:25:23 +0000199 const MachineInstr *LastInsn; // Last instruction of this scope.
200 const MachineInstr *FirstInsn; // First instruction of this scope.
Devang Pateleac9c072010-04-27 19:46:33 +0000201 unsigned DFSIn, DFSOut;
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000202 // Scopes defined in scope. Contents not owned.
203 SmallVector<DbgScope *, 4> Scopes;
204 // Variables declared in scope. Contents owned.
205 SmallVector<DbgVariable *, 8> Variables;
Devang Pateleac9c072010-04-27 19:46:33 +0000206 SmallVector<DbgRange, 4> Ranges;
Owen Anderson04c05f72009-06-24 22:53:20 +0000207 // Private state for dump()
208 mutable unsigned IndentLevel;
Bill Wendling0310d762009-05-15 09:23:25 +0000209public:
Devang Patele9f8f5e2010-05-07 20:54:48 +0000210 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
Devang Patel53bb5c92009-11-10 23:06:00 +0000211 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
Devang Pateleac9c072010-04-27 19:46:33 +0000212 LastInsn(0), FirstInsn(0),
213 DFSIn(0), DFSOut(0), IndentLevel(0) {}
Bill Wendling0310d762009-05-15 09:23:25 +0000214 virtual ~DbgScope();
215
216 // Accessors.
217 DbgScope *getParent() const { return Parent; }
Devang Patel53bb5c92009-11-10 23:06:00 +0000218 void setParent(DbgScope *P) { Parent = P; }
Bill Wendling0310d762009-05-15 09:23:25 +0000219 DIDescriptor getDesc() const { return Desc; }
Devang Patele9f8f5e2010-05-07 20:54:48 +0000220 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
221 const MDNode *getScopeNode() const { return Desc; }
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000222 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
223 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
Devang Pateleac9c072010-04-27 19:46:33 +0000224 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
225
226 /// openInsnRange - This scope covers instruction range starting from MI.
227 void openInsnRange(const MachineInstr *MI) {
228 if (!FirstInsn)
229 FirstInsn = MI;
230
231 if (Parent)
232 Parent->openInsnRange(MI);
233 }
234
235 /// extendInsnRange - Extend the current instruction range covered by
236 /// this scope.
237 void extendInsnRange(const MachineInstr *MI) {
238 assert (FirstInsn && "MI Range is not open!");
239 LastInsn = MI;
240 if (Parent)
241 Parent->extendInsnRange(MI);
242 }
243
244 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
245 /// until now. This is used when a new scope is encountered while walking
246 /// machine instructions.
247 void closeInsnRange(DbgScope *NewScope = NULL) {
248 assert (LastInsn && "Last insn missing!");
249 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
250 FirstInsn = NULL;
251 LastInsn = NULL;
252 // If Parent dominates NewScope then do not close Parent's instruction
253 // range.
254 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
255 Parent->closeInsnRange(NewScope);
256 }
257
Devang Patel53bb5c92009-11-10 23:06:00 +0000258 void setAbstractScope() { AbstractScope = true; }
259 bool isAbstractScope() const { return AbstractScope; }
Devang Pateleac9c072010-04-27 19:46:33 +0000260
261 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
262 unsigned getDFSOut() const { return DFSOut; }
263 void setDFSOut(unsigned O) { DFSOut = O; }
264 unsigned getDFSIn() const { return DFSIn; }
265 void setDFSIn(unsigned I) { DFSIn = I; }
266 bool dominates(const DbgScope *S) {
267 if (S == this)
268 return true;
269 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
270 return true;
271 return false;
272 }
Devang Patel53bb5c92009-11-10 23:06:00 +0000273
Devang Patel2c4ceb12009-11-21 02:48:08 +0000274 /// addScope - Add a scope to the scope.
Bill Wendling0310d762009-05-15 09:23:25 +0000275 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000276 void addScope(DbgScope *S) { Scopes.push_back(S); }
Bill Wendling0310d762009-05-15 09:23:25 +0000277
Devang Patel2c4ceb12009-11-21 02:48:08 +0000278 /// addVariable - Add a variable to the scope.
Bill Wendling0310d762009-05-15 09:23:25 +0000279 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000280 void addVariable(DbgVariable *V) { Variables.push_back(V); }
Bill Wendling0310d762009-05-15 09:23:25 +0000281
Bill Wendling0310d762009-05-15 09:23:25 +0000282#ifndef NDEBUG
283 void dump() const;
284#endif
285};
Devang Pateleac9c072010-04-27 19:46:33 +0000286
Chris Lattnerea761862010-04-05 04:09:20 +0000287} // end llvm namespace
Bill Wendling0310d762009-05-15 09:23:25 +0000288
289#ifndef NDEBUG
290void DbgScope::dump() const {
David Greenef83adbc2009-12-24 00:31:35 +0000291 raw_ostream &err = dbgs();
Chris Lattnerc281de12009-08-23 00:51:00 +0000292 err.indent(IndentLevel);
Devang Patele9f8f5e2010-05-07 20:54:48 +0000293 const MDNode *N = Desc;
Devang Patel53bb5c92009-11-10 23:06:00 +0000294 N->dump();
Devang Patel53bb5c92009-11-10 23:06:00 +0000295 if (AbstractScope)
296 err << "Abstract Scope\n";
Bill Wendling0310d762009-05-15 09:23:25 +0000297
298 IndentLevel += 2;
Devang Patel53bb5c92009-11-10 23:06:00 +0000299 if (!Scopes.empty())
300 err << "Children ...\n";
Bill Wendling0310d762009-05-15 09:23:25 +0000301 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
302 if (Scopes[i] != this)
303 Scopes[i]->dump();
304
305 IndentLevel -= 2;
306}
307#endif
308
Bill Wendling0310d762009-05-15 09:23:25 +0000309DbgScope::~DbgScope() {
Bill Wendling0310d762009-05-15 09:23:25 +0000310 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
311 delete Variables[j];
Bill Wendling0310d762009-05-15 09:23:25 +0000312}
313
Chris Lattner49cd6642010-04-05 05:11:15 +0000314DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
Devang Patel163a9f72010-05-10 22:49:55 +0000315 : Asm(A), MMI(Asm->MMI), FirstCU(0),
Chris Lattner994cb122010-04-05 03:52:55 +0000316 AbbreviationsSet(InitAbbreviationsSetSize),
Devang Patelf2548ca2010-04-16 23:33:45 +0000317 CurrentFnDbgScope(0), PrevLabel(NULL) {
Chris Lattnerbc733f52010-03-13 02:17:42 +0000318 NextStringPoolNumber = 0;
Chris Lattner9c69e285532010-04-04 22:59:04 +0000319
Chris Lattner4ad1efe2010-04-04 23:10:38 +0000320 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
321 DwarfStrSectionSym = TextSectionSym = 0;
Devang Patelc3f5f782010-05-25 23:40:22 +0000322 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
Devang Patel1e4782d2010-06-29 20:17:53 +0000323 DwarfDebugLineSectionSym = CurrentLineSectionSym = 0;
Devang Patelc3f5f782010-05-25 23:40:22 +0000324 FunctionBeginSym = FunctionEndSym = 0;
Devang Patelca76f6f2010-07-08 20:10:35 +0000325 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
Dan Gohman03c3dc72010-06-18 15:56:31 +0000326 {
327 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
328 beginModule(M);
Torok Edwin9c421072010-04-07 10:44:46 +0000329 }
Bill Wendling0310d762009-05-15 09:23:25 +0000330}
331DwarfDebug::~DwarfDebug() {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000332 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
333 DIEBlocks[j]->~DIEBlock();
Bill Wendling0310d762009-05-15 09:23:25 +0000334}
335
Chris Lattnerbc733f52010-03-13 02:17:42 +0000336MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
337 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
338 if (Entry.first) return Entry.first;
339
340 Entry.second = NextStringPoolNumber++;
Chris Lattnerc0215722010-04-04 19:25:43 +0000341 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
Chris Lattnerbc733f52010-03-13 02:17:42 +0000342}
343
344
Devang Patel2c4ceb12009-11-21 02:48:08 +0000345/// assignAbbrevNumber - Define a unique number for the abbreviation.
Bill Wendling0310d762009-05-15 09:23:25 +0000346///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000347void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
Bill Wendling0310d762009-05-15 09:23:25 +0000348 // Profile the node so that we can make it unique.
349 FoldingSetNodeID ID;
350 Abbrev.Profile(ID);
351
352 // Check the set for priors.
353 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
354
355 // If it's newly added.
356 if (InSet == &Abbrev) {
357 // Add to abbreviation list.
358 Abbreviations.push_back(&Abbrev);
359
360 // Assign the vector position + 1 as its number.
361 Abbrev.setNumber(Abbreviations.size());
362 } else {
363 // Assign existing abbreviation number.
364 Abbrev.setNumber(InSet->getNumber());
365 }
366}
367
Devang Patel2c4ceb12009-11-21 02:48:08 +0000368/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
Bill Wendling995f80a2009-05-20 23:24:48 +0000369/// information entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000370DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000371 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
Bill Wendling0310d762009-05-15 09:23:25 +0000372 return Value;
373}
374
Devang Patel2c4ceb12009-11-21 02:48:08 +0000375/// addUInt - Add an unsigned integer attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000376///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000377void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
Bill Wendling0310d762009-05-15 09:23:25 +0000378 unsigned Form, uint64_t Integer) {
379 if (!Form) Form = DIEInteger::BestForm(false, Integer);
Devang Patelca76f6f2010-07-08 20:10:35 +0000380 DIEValue *Value = Integer == 1 ?
381 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000382 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000383}
384
Devang Patel2c4ceb12009-11-21 02:48:08 +0000385/// addSInt - Add an signed integer attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000386///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000387void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
Bill Wendling0310d762009-05-15 09:23:25 +0000388 unsigned Form, int64_t Integer) {
389 if (!Form) Form = DIEInteger::BestForm(true, Integer);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000390 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000391 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000392}
393
Devang Patel69f57b12009-12-02 15:25:16 +0000394/// addString - Add a string attribute data and value. DIEString only
395/// keeps string reference.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000396void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattner4cf202b2010-01-23 03:11:46 +0000397 StringRef String) {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000398 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000399 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000400}
401
Devang Patel2c4ceb12009-11-21 02:48:08 +0000402/// addLabel - Add a Dwarf label attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000403///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000404void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattnerb98b1bf2010-03-08 22:23:36 +0000405 const MCSymbol *Label) {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000406 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000407 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000408}
409
Devang Patel2c4ceb12009-11-21 02:48:08 +0000410/// addDelta - Add a label delta attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000411///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000412void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattnerb98b1bf2010-03-08 22:23:36 +0000413 const MCSymbol *Hi, const MCSymbol *Lo) {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000414 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000415 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000416}
417
Chris Lattner74e41f92010-04-05 05:24:55 +0000418/// addDIEEntry - Add a DIE attribute data and value.
419///
420void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
421 DIE *Entry) {
422 Die->addValue(Attribute, Form, createDIEEntry(Entry));
423}
424
425
Devang Patel2c4ceb12009-11-21 02:48:08 +0000426/// addBlock - Add block data.
Bill Wendling0310d762009-05-15 09:23:25 +0000427///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000428void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
Bill Wendling0310d762009-05-15 09:23:25 +0000429 DIEBlock *Block) {
Chris Lattnera37d5382010-04-05 00:18:22 +0000430 Block->ComputeSize(Asm);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000431 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000432 Die->addValue(Attribute, Block->BestForm(), Block);
Bill Wendling0310d762009-05-15 09:23:25 +0000433}
434
Devang Patel2c4ceb12009-11-21 02:48:08 +0000435/// addSourceLine - Add location information to specified debug information
Bill Wendling0310d762009-05-15 09:23:25 +0000436/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000437void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
Devang Patelc665a512010-05-07 23:33:41 +0000438 // Verify variable.
439 if (!V->Verify())
Bill Wendling0310d762009-05-15 09:23:25 +0000440 return;
441
442 unsigned Line = V->getLineNumber();
Devang Patel77bf2952010-03-08 22:02:50 +0000443 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
444 V->getContext().getFilename());
Bill Wendling0310d762009-05-15 09:23:25 +0000445 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000446 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
447 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling0310d762009-05-15 09:23:25 +0000448}
449
Devang Patel2c4ceb12009-11-21 02:48:08 +0000450/// addSourceLine - Add location information to specified debug information
Bill Wendling0310d762009-05-15 09:23:25 +0000451/// entry.
Devang Patela49d8772010-05-07 23:19:07 +0000452void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
Devang Patelc665a512010-05-07 23:33:41 +0000453 // Verify global variable.
454 if (!G->Verify())
Bill Wendling0310d762009-05-15 09:23:25 +0000455 return;
456
457 unsigned Line = G->getLineNumber();
Devang Patel77bf2952010-03-08 22:02:50 +0000458 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
459 G->getContext().getFilename());
Bill Wendling0310d762009-05-15 09:23:25 +0000460 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000461 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
462 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling0310d762009-05-15 09:23:25 +0000463}
Devang Patel82dfc0c2009-08-31 22:47:13 +0000464
Devang Patel2c4ceb12009-11-21 02:48:08 +0000465/// addSourceLine - Add location information to specified debug information
Devang Patel82dfc0c2009-08-31 22:47:13 +0000466/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000467void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
Devang Patelc665a512010-05-07 23:33:41 +0000468 // Verify subprogram.
469 if (!SP->Verify())
Devang Patel82dfc0c2009-08-31 22:47:13 +0000470 return;
Caroline Ticec6f9d622009-09-11 18:25:54 +0000471 // If the line number is 0, don't add it.
472 if (SP->getLineNumber() == 0)
473 return;
474
Devang Patel82dfc0c2009-08-31 22:47:13 +0000475 unsigned Line = SP->getLineNumber();
Devang Patel77bf2952010-03-08 22:02:50 +0000476 if (!SP->getContext().Verify())
477 return;
Devang Patel9bb59a22010-03-24 21:30:35 +0000478 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
479 SP->getFilename());
Devang Patel82dfc0c2009-08-31 22:47:13 +0000480 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000481 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
482 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Devang Patel82dfc0c2009-08-31 22:47:13 +0000483}
484
Devang Patel2c4ceb12009-11-21 02:48:08 +0000485/// addSourceLine - Add location information to specified debug information
Devang Patel82dfc0c2009-08-31 22:47:13 +0000486/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000487void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
Devang Patelc665a512010-05-07 23:33:41 +0000488 // Verify type.
489 if (!Ty->Verify())
Bill Wendling0310d762009-05-15 09:23:25 +0000490 return;
491
492 unsigned Line = Ty->getLineNumber();
Devang Patel77bf2952010-03-08 22:02:50 +0000493 if (!Ty->getContext().Verify())
494 return;
495 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
496 Ty->getContext().getFilename());
Bill Wendling0310d762009-05-15 09:23:25 +0000497 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000498 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
499 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling0310d762009-05-15 09:23:25 +0000500}
501
Devang Patel6404e4e2009-12-15 19:16:48 +0000502/// addSourceLine - Add location information to specified debug information
503/// entry.
504void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
Devang Patelc665a512010-05-07 23:33:41 +0000505 // Verify namespace.
506 if (!NS->Verify())
Devang Patel6404e4e2009-12-15 19:16:48 +0000507 return;
508
509 unsigned Line = NS->getLineNumber();
510 StringRef FN = NS->getFilename();
511 StringRef Dir = NS->getDirectory();
512
513 unsigned FileID = GetOrCreateSourceID(Dir, FN);
514 assert(FileID && "Invalid file id");
515 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
516 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
517}
518
Caroline Ticedc8f6042009-08-31 21:19:37 +0000519/* Byref variables, in Blocks, are declared by the programmer as
520 "SomeType VarName;", but the compiler creates a
521 __Block_byref_x_VarName struct, and gives the variable VarName
522 either the struct, or a pointer to the struct, as its type. This
523 is necessary for various behind-the-scenes things the compiler
524 needs to do with by-reference variables in blocks.
525
526 However, as far as the original *programmer* is concerned, the
527 variable should still have type 'SomeType', as originally declared.
528
529 The following function dives into the __Block_byref_x_VarName
530 struct to find the original type of the variable. This will be
531 passed back to the code generating the type for the Debug
532 Information Entry for the variable 'VarName'. 'VarName' will then
533 have the original type 'SomeType' in its debug information.
534
535 The original type 'SomeType' will be the type of the field named
536 'VarName' inside the __Block_byref_x_VarName struct.
537
538 NOTE: In order for this to not completely fail on the debugger
539 side, the Debug Information Entry for the variable VarName needs to
540 have a DW_AT_location that tells the debugger how to unwind through
541 the pointers and __Block_byref_x_VarName struct to find the actual
Devang Patel2c4ceb12009-11-21 02:48:08 +0000542 value of the variable. The function addBlockByrefType does this. */
Caroline Ticedc8f6042009-08-31 21:19:37 +0000543
544/// Find the type the programmer originally declared the variable to be
545/// and return that type.
546///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000547DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
Caroline Ticedc8f6042009-08-31 21:19:37 +0000548
549 DIType subType = Ty;
550 unsigned tag = Ty.getTag();
551
552 if (tag == dwarf::DW_TAG_pointer_type) {
Devang Patel2db49d72010-05-07 18:11:54 +0000553 DIDerivedType DTy = DIDerivedType(Ty);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000554 subType = DTy.getTypeDerivedFrom();
555 }
556
Devang Patel2db49d72010-05-07 18:11:54 +0000557 DICompositeType blockStruct = DICompositeType(subType);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000558 DIArray Elements = blockStruct.getTypeArray();
559
Caroline Ticedc8f6042009-08-31 21:19:37 +0000560 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
561 DIDescriptor Element = Elements.getElement(i);
Devang Patel2db49d72010-05-07 18:11:54 +0000562 DIDerivedType DT = DIDerivedType(Element);
Devang Patel65dbc902009-11-25 17:36:49 +0000563 if (Name == DT.getName())
Caroline Ticedc8f6042009-08-31 21:19:37 +0000564 return (DT.getTypeDerivedFrom());
565 }
566
567 return Ty;
568}
569
Devang Patel2c4ceb12009-11-21 02:48:08 +0000570/// addComplexAddress - Start with the address based on the location provided,
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000571/// and generate the DWARF information necessary to find the actual variable
572/// given the extra address information encoded in the DIVariable, starting from
573/// the starting location. Add the DWARF information to the die.
574///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000575void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000576 unsigned Attribute,
577 const MachineLocation &Location) {
578 const DIVariable &VD = DV->getVariable();
579 DIType Ty = VD.getType();
580
581 // Decode the original location, and use that as the start of the byref
582 // variable's location.
Chris Lattnerd38fee82010-04-05 00:13:49 +0000583 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000584 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000585 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000586
587 if (Location.isReg()) {
588 if (Reg < 32) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000589 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000590 } else {
591 Reg = Reg - dwarf::DW_OP_reg0;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000592 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
593 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000594 }
595 } else {
596 if (Reg < 32)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000597 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000598 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000599 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
600 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000601 }
602
Devang Patel2c4ceb12009-11-21 02:48:08 +0000603 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000604 }
605
606 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
607 uint64_t Element = VD.getAddrElement(i);
608
609 if (Element == DIFactory::OpPlus) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000610 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
611 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000612 } else if (Element == DIFactory::OpDeref) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000613 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000614 } else llvm_unreachable("unknown DIFactory Opcode");
615 }
616
617 // Now attach the location information to the DIE.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000618 addBlock(Die, Attribute, 0, Block);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000619}
620
Caroline Ticedc8f6042009-08-31 21:19:37 +0000621/* Byref variables, in Blocks, are declared by the programmer as "SomeType
622 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
623 gives the variable VarName either the struct, or a pointer to the struct, as
624 its type. This is necessary for various behind-the-scenes things the
625 compiler needs to do with by-reference variables in Blocks.
626
627 However, as far as the original *programmer* is concerned, the variable
628 should still have type 'SomeType', as originally declared.
629
Devang Patel2c4ceb12009-11-21 02:48:08 +0000630 The function getBlockByrefType dives into the __Block_byref_x_VarName
Caroline Ticedc8f6042009-08-31 21:19:37 +0000631 struct to find the original type of the variable, which is then assigned to
632 the variable's Debug Information Entry as its real type. So far, so good.
633 However now the debugger will expect the variable VarName to have the type
634 SomeType. So we need the location attribute for the variable to be an
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000635 expression that explains to the debugger how to navigate through the
Caroline Ticedc8f6042009-08-31 21:19:37 +0000636 pointers and struct to find the actual variable of type SomeType.
637
638 The following function does just that. We start by getting
639 the "normal" location for the variable. This will be the location
640 of either the struct __Block_byref_x_VarName or the pointer to the
641 struct __Block_byref_x_VarName.
642
643 The struct will look something like:
644
645 struct __Block_byref_x_VarName {
646 ... <various fields>
647 struct __Block_byref_x_VarName *forwarding;
648 ... <various other fields>
649 SomeType VarName;
650 ... <maybe more fields>
651 };
652
653 If we are given the struct directly (as our starting point) we
654 need to tell the debugger to:
655
656 1). Add the offset of the forwarding field.
657
Dan Gohmanf451cb82010-02-10 16:03:48 +0000658 2). Follow that pointer to get the real __Block_byref_x_VarName
Caroline Ticedc8f6042009-08-31 21:19:37 +0000659 struct to use (the real one may have been copied onto the heap).
660
661 3). Add the offset for the field VarName, to find the actual variable.
662
663 If we started with a pointer to the struct, then we need to
664 dereference that pointer first, before the other steps.
665 Translating this into DWARF ops, we will need to append the following
666 to the current location description for the variable:
667
668 DW_OP_deref -- optional, if we start with a pointer
669 DW_OP_plus_uconst <forward_fld_offset>
670 DW_OP_deref
671 DW_OP_plus_uconst <varName_fld_offset>
672
673 That is what this function does. */
674
Devang Patel2c4ceb12009-11-21 02:48:08 +0000675/// addBlockByrefAddress - Start with the address based on the location
Caroline Ticedc8f6042009-08-31 21:19:37 +0000676/// provided, and generate the DWARF information necessary to find the
677/// actual Block variable (navigating the Block struct) based on the
678/// starting location. Add the DWARF information to the die. For
679/// more information, read large comment just above here.
680///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000681void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
Daniel Dunbar00564992009-09-19 20:40:14 +0000682 unsigned Attribute,
683 const MachineLocation &Location) {
Caroline Ticedc8f6042009-08-31 21:19:37 +0000684 const DIVariable &VD = DV->getVariable();
685 DIType Ty = VD.getType();
686 DIType TmpTy = Ty;
687 unsigned Tag = Ty.getTag();
688 bool isPointer = false;
689
Devang Patel65dbc902009-11-25 17:36:49 +0000690 StringRef varName = VD.getName();
Caroline Ticedc8f6042009-08-31 21:19:37 +0000691
692 if (Tag == dwarf::DW_TAG_pointer_type) {
Devang Patel2db49d72010-05-07 18:11:54 +0000693 DIDerivedType DTy = DIDerivedType(Ty);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000694 TmpTy = DTy.getTypeDerivedFrom();
695 isPointer = true;
696 }
697
Devang Patel2db49d72010-05-07 18:11:54 +0000698 DICompositeType blockStruct = DICompositeType(TmpTy);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000699
Daniel Dunbar00564992009-09-19 20:40:14 +0000700 // Find the __forwarding field and the variable field in the __Block_byref
701 // struct.
Daniel Dunbar00564992009-09-19 20:40:14 +0000702 DIArray Fields = blockStruct.getTypeArray();
703 DIDescriptor varField = DIDescriptor();
704 DIDescriptor forwardingField = DIDescriptor();
Caroline Ticedc8f6042009-08-31 21:19:37 +0000705
Daniel Dunbar00564992009-09-19 20:40:14 +0000706 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
707 DIDescriptor Element = Fields.getElement(i);
Devang Patel2db49d72010-05-07 18:11:54 +0000708 DIDerivedType DT = DIDerivedType(Element);
Devang Patel65dbc902009-11-25 17:36:49 +0000709 StringRef fieldName = DT.getName();
710 if (fieldName == "__forwarding")
Daniel Dunbar00564992009-09-19 20:40:14 +0000711 forwardingField = Element;
Devang Patel65dbc902009-11-25 17:36:49 +0000712 else if (fieldName == varName)
Daniel Dunbar00564992009-09-19 20:40:14 +0000713 varField = Element;
714 }
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000715
Daniel Dunbar00564992009-09-19 20:40:14 +0000716 // Get the offsets for the forwarding field and the variable field.
Chris Lattner1d65ba72010-03-31 06:06:37 +0000717 unsigned forwardingFieldOffset =
Devang Patel2db49d72010-05-07 18:11:54 +0000718 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
Chris Lattner1d65ba72010-03-31 06:06:37 +0000719 unsigned varFieldOffset =
Devang Patel2db49d72010-05-07 18:11:54 +0000720 DIDerivedType(varField).getOffsetInBits() >> 3;
Caroline Ticedc8f6042009-08-31 21:19:37 +0000721
Mike Stump7e3720d2009-09-24 23:21:26 +0000722 // Decode the original location, and use that as the start of the byref
723 // variable's location.
Chris Lattnerd38fee82010-04-05 00:13:49 +0000724 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Daniel Dunbar00564992009-09-19 20:40:14 +0000725 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000726 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Caroline Ticedc8f6042009-08-31 21:19:37 +0000727
Daniel Dunbar00564992009-09-19 20:40:14 +0000728 if (Location.isReg()) {
729 if (Reg < 32)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000730 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000731 else {
732 Reg = Reg - dwarf::DW_OP_reg0;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000733 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
734 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000735 }
736 } else {
737 if (Reg < 32)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000738 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000739 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000740 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
741 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000742 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000743
Devang Patel2c4ceb12009-11-21 02:48:08 +0000744 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Daniel Dunbar00564992009-09-19 20:40:14 +0000745 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000746
Mike Stump7e3720d2009-09-24 23:21:26 +0000747 // If we started with a pointer to the __Block_byref... struct, then
Daniel Dunbar00564992009-09-19 20:40:14 +0000748 // the first thing we need to do is dereference the pointer (DW_OP_deref).
Daniel Dunbar00564992009-09-19 20:40:14 +0000749 if (isPointer)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000750 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000751
Daniel Dunbar00564992009-09-19 20:40:14 +0000752 // Next add the offset for the '__forwarding' field:
753 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
754 // adding the offset if it's 0.
Daniel Dunbar00564992009-09-19 20:40:14 +0000755 if (forwardingFieldOffset > 0) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000756 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
757 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
Daniel Dunbar00564992009-09-19 20:40:14 +0000758 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000759
Daniel Dunbar00564992009-09-19 20:40:14 +0000760 // Now dereference the __forwarding field to get to the real __Block_byref
761 // struct: DW_OP_deref.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000762 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000763
Daniel Dunbar00564992009-09-19 20:40:14 +0000764 // Now that we've got the real __Block_byref... struct, add the offset
765 // for the variable's field to get to the location of the actual variable:
766 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
Daniel Dunbar00564992009-09-19 20:40:14 +0000767 if (varFieldOffset > 0) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000768 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
769 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
Daniel Dunbar00564992009-09-19 20:40:14 +0000770 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000771
Daniel Dunbar00564992009-09-19 20:40:14 +0000772 // Now attach the location information to the DIE.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000773 addBlock(Die, Attribute, 0, Block);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000774}
775
Devang Patel2c4ceb12009-11-21 02:48:08 +0000776/// addAddress - Add an address attribute to a die based on the location
Bill Wendling0310d762009-05-15 09:23:25 +0000777/// provided.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000778void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
Bill Wendling0310d762009-05-15 09:23:25 +0000779 const MachineLocation &Location) {
Chris Lattnerd38fee82010-04-05 00:13:49 +0000780 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Bill Wendling0310d762009-05-15 09:23:25 +0000781 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000782 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Bill Wendling0310d762009-05-15 09:23:25 +0000783
784 if (Location.isReg()) {
785 if (Reg < 32) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000786 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000787 } else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000788 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
789 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000790 }
791 } else {
792 if (Reg < 32) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000793 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000794 } else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000795 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
796 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000797 }
798
Devang Patel2c4ceb12009-11-21 02:48:08 +0000799 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Bill Wendling0310d762009-05-15 09:23:25 +0000800 }
801
Devang Patel2c4ceb12009-11-21 02:48:08 +0000802 addBlock(Die, Attribute, 0, Block);
Bill Wendling0310d762009-05-15 09:23:25 +0000803}
804
Devang Patela43098d2010-04-28 01:03:09 +0000805/// addRegisterAddress - Add register location entry in variable DIE.
Devang Patel26c1e562010-05-20 16:36:41 +0000806bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
Devang Patela43098d2010-04-28 01:03:09 +0000807 const MachineOperand &MO) {
808 assert (MO.isReg() && "Invalid machine operand!");
809 if (!MO.getReg())
810 return false;
811 MachineLocation Location;
812 Location.set(MO.getReg());
813 addAddress(Die, dwarf::DW_AT_location, Location);
Devang Patel26c1e562010-05-20 16:36:41 +0000814 if (VS)
Devang Patela43098d2010-04-28 01:03:09 +0000815 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
816 return true;
817}
818
819/// addConstantValue - Add constant value entry in variable DIE.
Devang Patel26c1e562010-05-20 16:36:41 +0000820bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
Devang Patela43098d2010-04-28 01:03:09 +0000821 const MachineOperand &MO) {
822 assert (MO.isImm() && "Invalid machine operand!");
823 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
824 unsigned Imm = MO.getImm();
825 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
826 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
Devang Patel26c1e562010-05-20 16:36:41 +0000827 if (VS)
Devang Patela43098d2010-04-28 01:03:09 +0000828 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
829 return true;
830}
831
832/// addConstantFPValue - Add constant value entry in variable DIE.
Devang Patel26c1e562010-05-20 16:36:41 +0000833bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
Devang Patela43098d2010-04-28 01:03:09 +0000834 const MachineOperand &MO) {
835 assert (MO.isFPImm() && "Invalid machine operand!");
836 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
837 APFloat FPImm = MO.getFPImm()->getValueAPF();
838
839 // Get the raw data form of the floating point.
840 const APInt FltVal = FPImm.bitcastToAPInt();
841 const char *FltPtr = (const char*)FltVal.getRawData();
842
843 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
844 bool LittleEndian = Asm->getTargetData().isLittleEndian();
845 int Incr = (LittleEndian ? 1 : -1);
846 int Start = (LittleEndian ? 0 : NumBytes - 1);
847 int Stop = (LittleEndian ? NumBytes : -1);
848
849 // Output the constant to DWARF one byte at a time.
850 for (; Start != Stop; Start += Incr)
851 addUInt(Block, 0, dwarf::DW_FORM_data1,
852 (unsigned char)0xFF & FltPtr[Start]);
853
854 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
Devang Patel26c1e562010-05-20 16:36:41 +0000855 if (VS)
856 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
Devang Patela43098d2010-04-28 01:03:09 +0000857 return true;
858}
859
860
Devang Patelc366f832009-12-10 19:14:49 +0000861/// addToContextOwner - Add Die into the list of its context owner's children.
862void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
Devang Patel3c91b052010-03-08 20:52:55 +0000863 if (Context.isType()) {
Devang Patel2db49d72010-05-07 18:11:54 +0000864 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
Devang Patelc366f832009-12-10 19:14:49 +0000865 ContextDIE->addChild(Die);
Devang Patel6404e4e2009-12-15 19:16:48 +0000866 } else if (Context.isNameSpace()) {
Devang Patel2db49d72010-05-07 18:11:54 +0000867 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
Devang Patel6404e4e2009-12-15 19:16:48 +0000868 ContextDIE->addChild(Die);
Stuart Hastings215aa152010-06-11 20:08:44 +0000869 } else if (Context.isSubprogram()) {
870 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
871 /*MakeDecl=*/false);
872 ContextDIE->addChild(Die);
Devang Patel163a9f72010-05-10 22:49:55 +0000873 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
Devang Patelc366f832009-12-10 19:14:49 +0000874 ContextDIE->addChild(Die);
875 else
Devang Patel163a9f72010-05-10 22:49:55 +0000876 getCompileUnit(Context)->addDie(Die);
Devang Patelc366f832009-12-10 19:14:49 +0000877}
878
Devang Patel16ced732009-12-10 18:05:33 +0000879/// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
880/// given DIType.
881DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
Devang Patel163a9f72010-05-10 22:49:55 +0000882 CompileUnit *TypeCU = getCompileUnit(Ty);
883 DIE *TyDIE = TypeCU->getDIE(Ty);
Devang Patel16ced732009-12-10 18:05:33 +0000884 if (TyDIE)
885 return TyDIE;
886
887 // Create new type.
888 TyDIE = new DIE(dwarf::DW_TAG_base_type);
Devang Patel163a9f72010-05-10 22:49:55 +0000889 TypeCU->insertDIE(Ty, TyDIE);
Devang Patel16ced732009-12-10 18:05:33 +0000890 if (Ty.isBasicType())
Devang Patel2db49d72010-05-07 18:11:54 +0000891 constructTypeDIE(*TyDIE, DIBasicType(Ty));
Devang Patel16ced732009-12-10 18:05:33 +0000892 else if (Ty.isCompositeType())
Devang Patel2db49d72010-05-07 18:11:54 +0000893 constructTypeDIE(*TyDIE, DICompositeType(Ty));
Devang Patel16ced732009-12-10 18:05:33 +0000894 else {
895 assert(Ty.isDerivedType() && "Unknown kind of DIType");
Devang Patel2db49d72010-05-07 18:11:54 +0000896 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
Devang Patel16ced732009-12-10 18:05:33 +0000897 }
898
Devang Patelc366f832009-12-10 19:14:49 +0000899 addToContextOwner(TyDIE, Ty.getContext());
Devang Patel16ced732009-12-10 18:05:33 +0000900 return TyDIE;
901}
902
Devang Patel2c4ceb12009-11-21 02:48:08 +0000903/// addType - Add a new type attribute to the specified entity.
Devang Patel8a241142009-12-09 18:24:21 +0000904void DwarfDebug::addType(DIE *Entity, DIType Ty) {
Devang Patel9c004872010-05-07 21:45:47 +0000905 if (!Ty.Verify())
Bill Wendling0310d762009-05-15 09:23:25 +0000906 return;
907
908 // Check for pre-existence.
Devang Patel163a9f72010-05-10 22:49:55 +0000909 CompileUnit *TypeCU = getCompileUnit(Ty);
910 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
Bill Wendling0310d762009-05-15 09:23:25 +0000911 // If it exists then use the existing value.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000912 if (Entry) {
913 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
Bill Wendling0310d762009-05-15 09:23:25 +0000914 return;
915 }
916
Bill Wendling0310d762009-05-15 09:23:25 +0000917 // Construct type.
Devang Patel16ced732009-12-10 18:05:33 +0000918 DIE *Buffer = getOrCreateTypeDIE(Ty);
Bill Wendling0310d762009-05-15 09:23:25 +0000919
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000920 // Set up proxy.
921 Entry = createDIEEntry(Buffer);
Devang Patel163a9f72010-05-10 22:49:55 +0000922 TypeCU->insertDIEEntry(Ty, Entry);
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000923
Devang Patel2c4ceb12009-11-21 02:48:08 +0000924 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
Bill Wendling0310d762009-05-15 09:23:25 +0000925}
926
Devang Patel2c4ceb12009-11-21 02:48:08 +0000927/// constructTypeDIE - Construct basic type die from DIBasicType.
Devang Patel8a241142009-12-09 18:24:21 +0000928void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
Bill Wendling0310d762009-05-15 09:23:25 +0000929 // Get core information.
Devang Patel65dbc902009-11-25 17:36:49 +0000930 StringRef Name = BTy.getName();
Bill Wendling0310d762009-05-15 09:23:25 +0000931 Buffer.setTag(dwarf::DW_TAG_base_type);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000932 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Bill Wendling0310d762009-05-15 09:23:25 +0000933 BTy.getEncoding());
934
935 // Add name if not anonymous or intermediate type.
Devang Patel65dbc902009-11-25 17:36:49 +0000936 if (!Name.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000937 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +0000938 uint64_t Size = BTy.getSizeInBits() >> 3;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000939 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling0310d762009-05-15 09:23:25 +0000940}
941
Devang Patel2c4ceb12009-11-21 02:48:08 +0000942/// constructTypeDIE - Construct derived type die from DIDerivedType.
Devang Patel8a241142009-12-09 18:24:21 +0000943void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
Bill Wendling0310d762009-05-15 09:23:25 +0000944 // Get core information.
Devang Patel65dbc902009-11-25 17:36:49 +0000945 StringRef Name = DTy.getName();
Bill Wendling0310d762009-05-15 09:23:25 +0000946 uint64_t Size = DTy.getSizeInBits() >> 3;
947 unsigned Tag = DTy.getTag();
948
949 // FIXME - Workaround for templates.
950 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
951
952 Buffer.setTag(Tag);
953
954 // Map to main type, void will not have a type.
955 DIType FromTy = DTy.getTypeDerivedFrom();
Devang Patel8a241142009-12-09 18:24:21 +0000956 addType(&Buffer, FromTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000957
958 // Add name if not anonymous or intermediate type.
Devang Pateldeea5642009-11-30 23:56:56 +0000959 if (!Name.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000960 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +0000961
962 // Add size if non-zero (derived types might be zero-sized.)
963 if (Size)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000964 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling0310d762009-05-15 09:23:25 +0000965
966 // Add source line info if available and TyDesc is not a forward declaration.
Devang Patel05f6fa82009-11-23 18:43:37 +0000967 if (!DTy.isForwardDecl())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000968 addSourceLine(&Buffer, &DTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000969}
970
Devang Patel2c4ceb12009-11-21 02:48:08 +0000971/// constructTypeDIE - Construct type DIE from DICompositeType.
Devang Patel8a241142009-12-09 18:24:21 +0000972void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
Bill Wendling0310d762009-05-15 09:23:25 +0000973 // Get core information.
Devang Patel65dbc902009-11-25 17:36:49 +0000974 StringRef Name = CTy.getName();
Bill Wendling0310d762009-05-15 09:23:25 +0000975
976 uint64_t Size = CTy.getSizeInBits() >> 3;
977 unsigned Tag = CTy.getTag();
978 Buffer.setTag(Tag);
979
980 switch (Tag) {
981 case dwarf::DW_TAG_vector_type:
982 case dwarf::DW_TAG_array_type:
Devang Patel8a241142009-12-09 18:24:21 +0000983 constructArrayTypeDIE(Buffer, &CTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000984 break;
985 case dwarf::DW_TAG_enumeration_type: {
986 DIArray Elements = CTy.getTypeArray();
987
988 // Add enumerators to enumeration type.
989 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
990 DIE *ElemDie = NULL;
Devang Patel2db49d72010-05-07 18:11:54 +0000991 DIDescriptor Enum(Elements.getElement(i));
Devang Patel3c91b052010-03-08 20:52:55 +0000992 if (Enum.isEnumerator()) {
Devang Patel2db49d72010-05-07 18:11:54 +0000993 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
Devang Patel2c4ceb12009-11-21 02:48:08 +0000994 Buffer.addChild(ElemDie);
Devang Patelc5254722009-10-09 17:51:49 +0000995 }
Bill Wendling0310d762009-05-15 09:23:25 +0000996 }
997 }
998 break;
999 case dwarf::DW_TAG_subroutine_type: {
1000 // Add return type.
1001 DIArray Elements = CTy.getTypeArray();
1002 DIDescriptor RTy = Elements.getElement(0);
Devang Patel2db49d72010-05-07 18:11:54 +00001003 addType(&Buffer, DIType(RTy));
Bill Wendling0310d762009-05-15 09:23:25 +00001004
1005 // Add prototype flag.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001006 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001007
1008 // Add arguments.
1009 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1010 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1011 DIDescriptor Ty = Elements.getElement(i);
Devang Patel2db49d72010-05-07 18:11:54 +00001012 addType(Arg, DIType(Ty));
Devang Patel2c4ceb12009-11-21 02:48:08 +00001013 Buffer.addChild(Arg);
Bill Wendling0310d762009-05-15 09:23:25 +00001014 }
1015 }
1016 break;
1017 case dwarf::DW_TAG_structure_type:
1018 case dwarf::DW_TAG_union_type:
1019 case dwarf::DW_TAG_class_type: {
1020 // Add elements to structure type.
1021 DIArray Elements = CTy.getTypeArray();
1022
1023 // A forward struct declared type may not have elements available.
Devang Patel3c91b052010-03-08 20:52:55 +00001024 unsigned N = Elements.getNumElements();
1025 if (N == 0)
Bill Wendling0310d762009-05-15 09:23:25 +00001026 break;
1027
1028 // Add elements to structure type.
Devang Patel3c91b052010-03-08 20:52:55 +00001029 for (unsigned i = 0; i < N; ++i) {
Bill Wendling0310d762009-05-15 09:23:25 +00001030 DIDescriptor Element = Elements.getElement(i);
1031 DIE *ElemDie = NULL;
Devang Patel3c91b052010-03-08 20:52:55 +00001032 if (Element.isSubprogram())
Devang Patel2db49d72010-05-07 18:11:54 +00001033 ElemDie = createSubprogramDIE(DISubprogram(Element));
Devang Patel3c91b052010-03-08 20:52:55 +00001034 else if (Element.isVariable()) {
Devang Patel2db49d72010-05-07 18:11:54 +00001035 DIVariable DV(Element);
Devang Patel1ee0cb92010-01-30 01:08:30 +00001036 ElemDie = new DIE(dwarf::DW_TAG_variable);
1037 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1038 DV.getName());
1039 addType(ElemDie, DV.getType());
1040 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1041 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1042 addSourceLine(ElemDie, &DV);
Devang Patel3c91b052010-03-08 20:52:55 +00001043 } else if (Element.isDerivedType())
Devang Patel2db49d72010-05-07 18:11:54 +00001044 ElemDie = createMemberDIE(DIDerivedType(Element));
Devang Patel3c91b052010-03-08 20:52:55 +00001045 else
1046 continue;
Devang Patel2c4ceb12009-11-21 02:48:08 +00001047 Buffer.addChild(ElemDie);
Bill Wendling0310d762009-05-15 09:23:25 +00001048 }
1049
Devang Patela1ba2692009-08-27 23:51:51 +00001050 if (CTy.isAppleBlockExtension())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001051 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001052
1053 unsigned RLang = CTy.getRunTimeLang();
1054 if (RLang)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001055 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
Bill Wendling0310d762009-05-15 09:23:25 +00001056 dwarf::DW_FORM_data1, RLang);
Devang Patelb5544992010-01-26 21:16:06 +00001057
1058 DICompositeType ContainingType = CTy.getContainingType();
Devang Patel2db49d72010-05-07 18:11:54 +00001059 if (DIDescriptor(ContainingType).isCompositeType())
Devang Patelb5544992010-01-26 21:16:06 +00001060 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
Devang Patel2db49d72010-05-07 18:11:54 +00001061 getOrCreateTypeDIE(DIType(ContainingType)));
Stuart Hastings215aa152010-06-11 20:08:44 +00001062 else {
1063 DIDescriptor Context = CTy.getContext();
1064 addToContextOwner(&Buffer, Context);
1065 }
Bill Wendling0310d762009-05-15 09:23:25 +00001066 break;
1067 }
1068 default:
1069 break;
1070 }
1071
1072 // Add name if not anonymous or intermediate type.
Devang Patel65dbc902009-11-25 17:36:49 +00001073 if (!Name.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001074 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +00001075
Devang Patel61409622010-07-07 20:12:52 +00001076 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1077 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1078 {
Bill Wendling0310d762009-05-15 09:23:25 +00001079 // Add size if non-zero (derived types might be zero-sized.)
1080 if (Size)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001081 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling0310d762009-05-15 09:23:25 +00001082 else {
1083 // Add zero size if it is not a forward declaration.
1084 if (CTy.isForwardDecl())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001085 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001086 else
Devang Patel2c4ceb12009-11-21 02:48:08 +00001087 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
Bill Wendling0310d762009-05-15 09:23:25 +00001088 }
1089
1090 // Add source line info if available.
1091 if (!CTy.isForwardDecl())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001092 addSourceLine(&Buffer, &CTy);
Bill Wendling0310d762009-05-15 09:23:25 +00001093 }
1094}
1095
Devang Patel2c4ceb12009-11-21 02:48:08 +00001096/// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1097void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
Bill Wendling0310d762009-05-15 09:23:25 +00001098 int64_t L = SR.getLo();
1099 int64_t H = SR.getHi();
1100 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1101
Devang Patel2c4ceb12009-11-21 02:48:08 +00001102 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
Devang Patel6325a532009-08-14 20:59:16 +00001103 if (L)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001104 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
Devang Pateld55224c2009-12-04 23:10:24 +00001105 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
Bill Wendling0310d762009-05-15 09:23:25 +00001106
Devang Patel2c4ceb12009-11-21 02:48:08 +00001107 Buffer.addChild(DW_Subrange);
Bill Wendling0310d762009-05-15 09:23:25 +00001108}
1109
Devang Patel2c4ceb12009-11-21 02:48:08 +00001110/// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
Devang Patel8a241142009-12-09 18:24:21 +00001111void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
Bill Wendling0310d762009-05-15 09:23:25 +00001112 DICompositeType *CTy) {
1113 Buffer.setTag(dwarf::DW_TAG_array_type);
1114 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001115 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001116
1117 // Emit derived type.
Devang Patel8a241142009-12-09 18:24:21 +00001118 addType(&Buffer, CTy->getTypeDerivedFrom());
Bill Wendling0310d762009-05-15 09:23:25 +00001119 DIArray Elements = CTy->getTypeArray();
1120
Devang Patel6f01d9c2009-11-21 00:31:03 +00001121 // Get an anonymous type for index type.
Devang Patel163a9f72010-05-10 22:49:55 +00001122 CompileUnit *TheCU = getCompileUnit(*CTy);
1123 DIE *IdxTy = TheCU->getIndexTyDie();
Devang Patel6f01d9c2009-11-21 00:31:03 +00001124 if (!IdxTy) {
1125 // Construct an anonymous type for index type.
1126 IdxTy = new DIE(dwarf::DW_TAG_base_type);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001127 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1128 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Devang Patel6f01d9c2009-11-21 00:31:03 +00001129 dwarf::DW_ATE_signed);
Devang Patel163a9f72010-05-10 22:49:55 +00001130 TheCU->addDie(IdxTy);
1131 TheCU->setIndexTyDie(IdxTy);
Devang Patel6f01d9c2009-11-21 00:31:03 +00001132 }
Bill Wendling0310d762009-05-15 09:23:25 +00001133
1134 // Add subranges to array type.
1135 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1136 DIDescriptor Element = Elements.getElement(i);
1137 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
Devang Patel2db49d72010-05-07 18:11:54 +00001138 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
Bill Wendling0310d762009-05-15 09:23:25 +00001139 }
1140}
1141
Devang Patel2c4ceb12009-11-21 02:48:08 +00001142/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
Devang Patel3c91b052010-03-08 20:52:55 +00001143DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
Bill Wendling0310d762009-05-15 09:23:25 +00001144 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
Devang Patel3c91b052010-03-08 20:52:55 +00001145 StringRef Name = ETy.getName();
Devang Patel2c4ceb12009-11-21 02:48:08 +00001146 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Devang Patel3c91b052010-03-08 20:52:55 +00001147 int64_t Value = ETy.getEnumValue();
Devang Patel2c4ceb12009-11-21 02:48:08 +00001148 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
Bill Wendling0310d762009-05-15 09:23:25 +00001149 return Enumerator;
1150}
1151
Devang Patel351ca332010-01-05 01:46:14 +00001152/// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1153/// printer to not emit usual symbol prefix before the symbol name is used then
1154/// return linkage name after skipping this special LLVM prefix.
1155static StringRef getRealLinkageName(StringRef LinkageName) {
1156 char One = '\1';
1157 if (LinkageName.startswith(StringRef(&One, 1)))
1158 return LinkageName.substr(1);
1159 return LinkageName;
1160}
1161
Devang Patel2c4ceb12009-11-21 02:48:08 +00001162/// createGlobalVariableDIE - Create new DIE using GV.
Devang Patel8a241142009-12-09 18:24:21 +00001163DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
Jim Grosbach7ab38df2009-11-22 19:20:36 +00001164 // If the global variable was optmized out then no need to create debug info
1165 // entry.
Devang Patel84c73e92009-11-06 17:58:12 +00001166 if (!GV.getGlobal()) return NULL;
Devang Patel65dbc902009-11-25 17:36:49 +00001167 if (GV.getDisplayName().empty()) return NULL;
Devang Patel465c3be2009-11-06 01:30:04 +00001168
Bill Wendling0310d762009-05-15 09:23:25 +00001169 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001170 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
Devang Patel5ccdd102009-09-29 18:40:58 +00001171 GV.getDisplayName());
1172
Devang Patel65dbc902009-11-25 17:36:49 +00001173 StringRef LinkageName = GV.getLinkageName();
Devang Patel351ca332010-01-05 01:46:14 +00001174 if (!LinkageName.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001175 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
Devang Patel351ca332010-01-05 01:46:14 +00001176 getRealLinkageName(LinkageName));
1177
Devang Patel8a241142009-12-09 18:24:21 +00001178 addType(GVDie, GV.getType());
Bill Wendling0310d762009-05-15 09:23:25 +00001179 if (!GV.isLocalToUnit())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001180 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1181 addSourceLine(GVDie, &GV);
Devang Patelb71a16d2009-10-05 23:22:08 +00001182
Bill Wendling0310d762009-05-15 09:23:25 +00001183 return GVDie;
1184}
1185
Devang Patel2c4ceb12009-11-21 02:48:08 +00001186/// createMemberDIE - Create new member DIE.
Devang Patel8a241142009-12-09 18:24:21 +00001187DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
Bill Wendling0310d762009-05-15 09:23:25 +00001188 DIE *MemberDie = new DIE(DT.getTag());
Devang Patel65dbc902009-11-25 17:36:49 +00001189 StringRef Name = DT.getName();
1190 if (!Name.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001191 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Devang Patel65dbc902009-11-25 17:36:49 +00001192
Devang Patel8a241142009-12-09 18:24:21 +00001193 addType(MemberDie, DT.getTypeDerivedFrom());
Bill Wendling0310d762009-05-15 09:23:25 +00001194
Devang Patel2c4ceb12009-11-21 02:48:08 +00001195 addSourceLine(MemberDie, &DT);
Bill Wendling0310d762009-05-15 09:23:25 +00001196
Benjamin Kramer345ef342010-03-31 19:34:01 +00001197 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
Devang Patel2c4ceb12009-11-21 02:48:08 +00001198 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
Devang Patel33db5082009-11-04 22:06:12 +00001199
Bill Wendling0310d762009-05-15 09:23:25 +00001200 uint64_t Size = DT.getSizeInBits();
Devang Patel61ecbd12009-11-04 23:48:00 +00001201 uint64_t FieldSize = DT.getOriginalTypeSize();
Bill Wendling0310d762009-05-15 09:23:25 +00001202
1203 if (Size != FieldSize) {
1204 // Handle bitfield.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001205 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1206 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
Bill Wendling0310d762009-05-15 09:23:25 +00001207
1208 uint64_t Offset = DT.getOffsetInBits();
Bill Wendling0310d762009-05-15 09:23:25 +00001209 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1210 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
Benjamin Kramer3d594fd2010-01-07 17:50:57 +00001211 uint64_t FieldOffset = (HiMark - FieldSize);
Bill Wendling0310d762009-05-15 09:23:25 +00001212 Offset -= FieldOffset;
1213
1214 // Maybe we need to work from the other end.
Chris Lattnerd38fee82010-04-05 00:13:49 +00001215 if (Asm->getTargetData().isLittleEndian())
1216 Offset = FieldSize - (Offset + Size);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001217 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
Bill Wendling0310d762009-05-15 09:23:25 +00001218
Devang Patel33db5082009-11-04 22:06:12 +00001219 // Here WD_AT_data_member_location points to the anonymous
1220 // field that includes this bit field.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001221 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
Devang Patel33db5082009-11-04 22:06:12 +00001222
1223 } else
1224 // This is not a bitfield.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001225 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
Devang Patel33db5082009-11-04 22:06:12 +00001226
Devang Patelc1dc8ff2010-02-03 20:08:48 +00001227 if (DT.getTag() == dwarf::DW_TAG_inheritance
1228 && DT.isVirtual()) {
1229
1230 // For C++, virtual base classes are not at fixed offset. Use following
1231 // expression to extract appropriate offset from vtable.
1232 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1233
Benjamin Kramer345ef342010-03-31 19:34:01 +00001234 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
Devang Patelc1dc8ff2010-02-03 20:08:48 +00001235 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1236 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1237 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1239 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1240 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1241 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1242
1243 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1244 VBaseLocationDie);
1245 } else
1246 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
Bill Wendling0310d762009-05-15 09:23:25 +00001247
1248 if (DT.isProtected())
Devang Patel5d11eb02009-12-03 19:11:07 +00001249 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
Bill Wendling0310d762009-05-15 09:23:25 +00001250 dwarf::DW_ACCESS_protected);
1251 else if (DT.isPrivate())
Devang Patel5d11eb02009-12-03 19:11:07 +00001252 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
Bill Wendling0310d762009-05-15 09:23:25 +00001253 dwarf::DW_ACCESS_private);
Devang Patel5d11eb02009-12-03 19:11:07 +00001254 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1255 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1256 dwarf::DW_ACCESS_public);
1257 if (DT.isVirtual())
1258 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1259 dwarf::DW_VIRTUALITY_virtual);
Bill Wendling0310d762009-05-15 09:23:25 +00001260 return MemberDie;
1261}
1262
Devang Patelffe966c2009-12-14 16:18:45 +00001263/// createSubprogramDIE - Create new DIE using SP.
1264DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
Devang Patel163a9f72010-05-10 22:49:55 +00001265 CompileUnit *SPCU = getCompileUnit(SP);
1266 DIE *SPDie = SPCU->getDIE(SP);
Devang Patelffe966c2009-12-14 16:18:45 +00001267 if (SPDie)
1268 return SPDie;
1269
1270 SPDie = new DIE(dwarf::DW_TAG_subprogram);
Devang Patel1eac3e72010-03-02 17:58:15 +00001271 // Constructors and operators for anonymous aggregates do not have names.
Devang Patel6b506cb2010-03-02 01:26:20 +00001272 if (!SP.getName().empty())
1273 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
Bill Wendling0310d762009-05-15 09:23:25 +00001274
Devang Patel65dbc902009-11-25 17:36:49 +00001275 StringRef LinkageName = SP.getLinkageName();
Devang Patel351ca332010-01-05 01:46:14 +00001276 if (!LinkageName.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001277 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
Devang Patel351ca332010-01-05 01:46:14 +00001278 getRealLinkageName(LinkageName));
1279
Devang Patel2c4ceb12009-11-21 02:48:08 +00001280 addSourceLine(SPDie, &SP);
Bill Wendling0310d762009-05-15 09:23:25 +00001281
Bill Wendling0310d762009-05-15 09:23:25 +00001282 // Add prototyped tag, if C or ObjC.
1283 unsigned Lang = SP.getCompileUnit().getLanguage();
1284 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1285 Lang == dwarf::DW_LANG_ObjC)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001286 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001287
1288 // Add Return Type.
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001289 DICompositeType SPTy = SP.getType();
1290 DIArray Args = SPTy.getTypeArray();
Bill Wendling0310d762009-05-15 09:23:25 +00001291 unsigned SPTag = SPTy.getTag();
Devang Patel5d11eb02009-12-03 19:11:07 +00001292
Devang Patel3c91b052010-03-08 20:52:55 +00001293 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
Devang Patel8a241142009-12-09 18:24:21 +00001294 addType(SPDie, SPTy);
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001295 else
Devang Patel2db49d72010-05-07 18:11:54 +00001296 addType(SPDie, DIType(Args.getElement(0)));
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001297
Devang Patel5d11eb02009-12-03 19:11:07 +00001298 unsigned VK = SP.getVirtuality();
1299 if (VK) {
1300 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
Benjamin Kramer345ef342010-03-31 19:34:01 +00001301 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel5d11eb02009-12-03 19:11:07 +00001302 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1303 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1304 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
Devang Patel622b0262010-01-19 06:19:05 +00001305 ContainingTypeMap.insert(std::make_pair(SPDie,
Devang Patel2db49d72010-05-07 18:11:54 +00001306 SP.getContainingType()));
Devang Patel5d11eb02009-12-03 19:11:07 +00001307 }
1308
Devang Patelffe966c2009-12-14 16:18:45 +00001309 if (MakeDecl || !SP.isDefinition()) {
Devang Patel2c4ceb12009-11-21 02:48:08 +00001310 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001311
1312 // Add arguments. Do not add arguments for subprogram definition. They will
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001313 // be handled while processing variables.
1314 DICompositeType SPTy = SP.getType();
1315 DIArray Args = SPTy.getTypeArray();
1316 unsigned SPTag = SPTy.getTag();
1317
Bill Wendling0310d762009-05-15 09:23:25 +00001318 if (SPTag == dwarf::DW_TAG_subroutine_type)
1319 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1320 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
Devang Patel2db49d72010-05-07 18:11:54 +00001321 DIType ATy = DIType(DIType(Args.getElement(i)));
Devang Patelb4645642010-02-06 01:02:37 +00001322 addType(Arg, ATy);
1323 if (ATy.isArtificial())
1324 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001325 SPDie->addChild(Arg);
Bill Wendling0310d762009-05-15 09:23:25 +00001326 }
1327 }
1328
Devang Patel4e0d19d2010-02-03 19:57:19 +00001329 if (SP.isArtificial())
1330 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1331
Devang Patelccff8122010-04-30 19:38:23 +00001332 if (!SP.isLocalToUnit())
1333 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
Devang Patel2a4a3b72010-04-19 19:14:02 +00001334
Devang Patelccff8122010-04-30 19:38:23 +00001335 if (SP.isOptimized())
1336 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1337
Devang Patelccff8122010-04-30 19:38:23 +00001338 // DW_TAG_inlined_subroutine may refer to this DIE.
Devang Patel163a9f72010-05-10 22:49:55 +00001339 SPCU->insertDIE(SP, SPDie);
Devang Patelccff8122010-04-30 19:38:23 +00001340
Stuart Hastings215aa152010-06-11 20:08:44 +00001341 // Add to context owner.
1342 addToContextOwner(SPDie, SP.getContext());
1343
Bill Wendling0310d762009-05-15 09:23:25 +00001344 return SPDie;
1345}
1346
Devang Patele9f8f5e2010-05-07 20:54:48 +00001347DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
Chris Lattnered7a77b2010-03-31 05:36:29 +00001348 assert(N && "Invalid Scope encoding!");
Devang Patel53bb5c92009-11-10 23:06:00 +00001349
1350 DbgScope *AScope = AbstractScopes.lookup(N);
1351 if (AScope)
1352 return AScope;
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001353
Devang Patel53bb5c92009-11-10 23:06:00 +00001354 DbgScope *Parent = NULL;
1355
1356 DIDescriptor Scope(N);
1357 if (Scope.isLexicalBlock()) {
1358 DILexicalBlock DB(N);
1359 DIDescriptor ParentDesc = DB.getContext();
Devang Patel2db49d72010-05-07 18:11:54 +00001360 Parent = getOrCreateAbstractScope(ParentDesc);
Devang Patel53bb5c92009-11-10 23:06:00 +00001361 }
1362
1363 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1364
1365 if (Parent)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001366 Parent->addScope(AScope);
Devang Patel53bb5c92009-11-10 23:06:00 +00001367 AScope->setAbstractScope();
1368 AbstractScopes[N] = AScope;
1369 if (DIDescriptor(N).isSubprogram())
1370 AbstractScopesList.push_back(AScope);
1371 return AScope;
1372}
Devang Patelaf9e8472009-10-01 20:31:14 +00001373
Devang Patel5f094002010-04-06 23:53:48 +00001374/// isSubprogramContext - Return true if Context is either a subprogram
1375/// or another context nested inside a subprogram.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001376static bool isSubprogramContext(const MDNode *Context) {
Devang Patel5f094002010-04-06 23:53:48 +00001377 if (!Context)
1378 return false;
1379 DIDescriptor D(Context);
1380 if (D.isSubprogram())
1381 return true;
1382 if (D.isType())
Devang Patel2db49d72010-05-07 18:11:54 +00001383 return isSubprogramContext(DIType(Context).getContext());
Devang Patel5f094002010-04-06 23:53:48 +00001384 return false;
1385}
1386
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001387/// updateSubprogramScopeDIE - Find DIE for the given subprogram and
Devang Patel2c4ceb12009-11-21 02:48:08 +00001388/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1389/// If there are global variables in this scope then create and insert
1390/// DIEs for these variables.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001391DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
Devang Patel163a9f72010-05-10 22:49:55 +00001392 CompileUnit *SPCU = getCompileUnit(SPNode);
1393 DIE *SPDie = SPCU->getDIE(SPNode);
Devang Patel8aa61472010-07-07 22:20:57 +00001394
Chris Lattnerd38fee82010-04-05 00:13:49 +00001395 assert(SPDie && "Unable to find subprogram DIE!");
1396 DISubprogram SP(SPNode);
Chris Lattner206d61e2010-03-13 07:26:18 +00001397
Chris Lattnerd38fee82010-04-05 00:13:49 +00001398 // There is not any need to generate specification DIE for a function
1399 // defined at compile unit level. If a function is defined inside another
1400 // function then gdb prefers the definition at top level and but does not
1401 // expect specification DIE in parent function. So avoid creating
1402 // specification DIE for a function defined inside a function.
1403 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
Devang Patel5f094002010-04-06 23:53:48 +00001404 !SP.getContext().isFile() &&
Devang Patel2db49d72010-05-07 18:11:54 +00001405 !isSubprogramContext(SP.getContext())) {
Chris Lattnerd38fee82010-04-05 00:13:49 +00001406 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1407
1408 // Add arguments.
1409 DICompositeType SPTy = SP.getType();
1410 DIArray Args = SPTy.getTypeArray();
1411 unsigned SPTag = SPTy.getTag();
1412 if (SPTag == dwarf::DW_TAG_subroutine_type)
1413 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1414 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
Devang Patel2db49d72010-05-07 18:11:54 +00001415 DIType ATy = DIType(DIType(Args.getElement(i)));
Chris Lattnerd38fee82010-04-05 00:13:49 +00001416 addType(Arg, ATy);
1417 if (ATy.isArtificial())
1418 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1419 SPDie->addChild(Arg);
1420 }
1421 DIE *SPDeclDie = SPDie;
1422 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1423 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1424 SPDeclDie);
Devang Patel163a9f72010-05-10 22:49:55 +00001425 SPCU->addDie(SPDie);
Chris Lattnerd38fee82010-04-05 00:13:49 +00001426 }
1427
Devang Patel8aa61472010-07-07 22:20:57 +00001428 // Pick up abstract subprogram DIE.
1429 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1430 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1431 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1432 dwarf::DW_FORM_ref4, AbsSPDIE);
1433 SPCU->addDie(SPDie);
1434 }
1435
Chris Lattnerd38fee82010-04-05 00:13:49 +00001436 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1437 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1438 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1439 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1440 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1441 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1442 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
Devang Patelb4645642010-02-06 01:02:37 +00001443
Chris Lattnerd38fee82010-04-05 00:13:49 +00001444 return SPDie;
Devang Patel53bb5c92009-11-10 23:06:00 +00001445}
1446
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001447/// constructLexicalScope - Construct new DW_TAG_lexical_block
Devang Patel2c4ceb12009-11-21 02:48:08 +00001448/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1449DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
Devang Pateleac9c072010-04-27 19:46:33 +00001450
1451 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1452 if (Scope->isAbstractScope())
1453 return ScopeDIE;
1454
1455 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1456 if (Ranges.empty())
1457 return 0;
1458
1459 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1460 if (Ranges.size() > 1) {
1461 // .debug_range section has not been laid out yet. Emit offset in
1462 // .debug_range as a uint, size 4, for now. emitDIE will handle
1463 // DW_AT_ranges appropriately.
1464 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1465 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1466 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1467 RE = Ranges.end(); RI != RE; ++RI) {
Devang Patelc3f5f782010-05-25 23:40:22 +00001468 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1469 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
Devang Pateleac9c072010-04-27 19:46:33 +00001470 }
1471 DebugRangeSymbols.push_back(NULL);
1472 DebugRangeSymbols.push_back(NULL);
1473 return ScopeDIE;
1474 }
1475
Devang Patelc3f5f782010-05-25 23:40:22 +00001476 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1477 const MCSymbol *End = getLabelAfterInsn(RI->second);
Devang Pateleac9c072010-04-27 19:46:33 +00001478
Devang Patelc3f5f782010-05-25 23:40:22 +00001479 if (End == 0) return 0;
Devang Patel53bb5c92009-11-10 23:06:00 +00001480
Chris Lattnerb7db7332010-03-09 01:58:53 +00001481 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1482 assert(End->isDefined() && "Invalid end label for an inlined scope!");
Chris Lattnera34ec2292010-03-09 01:51:43 +00001483
Devang Pateleac9c072010-04-27 19:46:33 +00001484 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1485 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
Devang Patel53bb5c92009-11-10 23:06:00 +00001486
1487 return ScopeDIE;
1488}
1489
Devang Patel2c4ceb12009-11-21 02:48:08 +00001490/// constructInlinedScopeDIE - This scope represents inlined body of
1491/// a function. Construct DIE to represent this concrete inlined copy
1492/// of the function.
1493DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
Devang Pateleac9c072010-04-27 19:46:33 +00001494
1495 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1496 assert (Ranges.empty() == false
1497 && "DbgScope does not have instruction markers!");
1498
1499 // FIXME : .debug_inlined section specification does not clearly state how
1500 // to emit inlined scope that is split into multiple instruction ranges.
1501 // For now, use first instruction range and emit low_pc/high_pc pair and
1502 // corresponding .debug_inlined section entry for this pair.
1503 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
Devang Patelc3f5f782010-05-25 23:40:22 +00001504 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1505 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
Devang Pateleac9c072010-04-27 19:46:33 +00001506
Devang Patel0afbf232010-07-08 22:39:20 +00001507 if (StartLabel == 0 || EndLabel == 0) {
Devang Pateleac9c072010-04-27 19:46:33 +00001508 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1509 return 0;
1510 }
Chris Lattnerb7db7332010-03-09 01:58:53 +00001511 assert(StartLabel->isDefined() &&
Chris Lattnera34ec2292010-03-09 01:51:43 +00001512 "Invalid starting label for an inlined scope!");
Chris Lattnerb7db7332010-03-09 01:58:53 +00001513 assert(EndLabel->isDefined() &&
Chris Lattnera34ec2292010-03-09 01:51:43 +00001514 "Invalid end label for an inlined scope!");
Devang Pateleac9c072010-04-27 19:46:33 +00001515
Devang Patel3c91b052010-03-08 20:52:55 +00001516 if (!Scope->getScopeNode())
Devang Patel0ef3fa62010-03-08 19:20:38 +00001517 return NULL;
Devang Patel3c91b052010-03-08 20:52:55 +00001518 DIScope DS(Scope->getScopeNode());
Devang Patel53bb5c92009-11-10 23:06:00 +00001519 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1520
Devang Patel2db49d72010-05-07 18:11:54 +00001521 DISubprogram InlinedSP = getDISubprogram(DS);
Devang Patel163a9f72010-05-10 22:49:55 +00001522 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1523 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
Chris Lattnered7a77b2010-03-31 05:36:29 +00001524 assert(OriginDIE && "Unable to find Origin DIE!");
Devang Patel2c4ceb12009-11-21 02:48:08 +00001525 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
Devang Patel53bb5c92009-11-10 23:06:00 +00001526 dwarf::DW_FORM_ref4, OriginDIE);
1527
Chris Lattner6ed0f902010-03-09 00:31:02 +00001528 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
Chris Lattnerb7db7332010-03-09 01:58:53 +00001529 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
Devang Patel53bb5c92009-11-10 23:06:00 +00001530
1531 InlinedSubprogramDIEs.insert(OriginDIE);
1532
1533 // Track the start label for this inlined function.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001534 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
Devang Patel2db49d72010-05-07 18:11:54 +00001535 I = InlineInfo.find(InlinedSP);
Devang Patel53bb5c92009-11-10 23:06:00 +00001536
1537 if (I == InlineInfo.end()) {
Devang Patel2db49d72010-05-07 18:11:54 +00001538 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
Jim Grosbach7ab38df2009-11-22 19:20:36 +00001539 ScopeDIE));
Devang Patel2db49d72010-05-07 18:11:54 +00001540 InlinedSPNodes.push_back(InlinedSP);
Devang Patel53bb5c92009-11-10 23:06:00 +00001541 } else
Chris Lattner6ed0f902010-03-09 00:31:02 +00001542 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
Devang Patel53bb5c92009-11-10 23:06:00 +00001543
Devang Patel53bb5c92009-11-10 23:06:00 +00001544 DILocation DL(Scope->getInlinedAt());
Devang Patel163a9f72010-05-10 22:49:55 +00001545 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
Devang Patel2c4ceb12009-11-21 02:48:08 +00001546 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
Devang Patel53bb5c92009-11-10 23:06:00 +00001547
1548 return ScopeDIE;
1549}
1550
Devang Patel2c4ceb12009-11-21 02:48:08 +00001551
1552/// constructVariableDIE - Construct a DIE for the given DbgVariable.
Devang Patel8a241142009-12-09 18:24:21 +00001553DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
Devang Patel53bb5c92009-11-10 23:06:00 +00001554 // Get the descriptor.
1555 const DIVariable &VD = DV->getVariable();
Devang Patel65dbc902009-11-25 17:36:49 +00001556 StringRef Name = VD.getName();
1557 if (Name.empty())
Devang Patel3fb6bd62009-11-13 02:25:26 +00001558 return NULL;
Devang Patel53bb5c92009-11-10 23:06:00 +00001559
1560 // Translate tag to proper Dwarf tag. The result variable is dropped for
1561 // now.
1562 unsigned Tag;
1563 switch (VD.getTag()) {
1564 case dwarf::DW_TAG_return_variable:
1565 return NULL;
1566 case dwarf::DW_TAG_arg_variable:
1567 Tag = dwarf::DW_TAG_formal_parameter;
1568 break;
1569 case dwarf::DW_TAG_auto_variable: // fall thru
1570 default:
1571 Tag = dwarf::DW_TAG_variable;
1572 break;
1573 }
1574
1575 // Define variable debug information entry.
1576 DIE *VariableDie = new DIE(Tag);
1577
Devang Patel53bb5c92009-11-10 23:06:00 +00001578 DIE *AbsDIE = NULL;
Devang Patel26c1e562010-05-20 16:36:41 +00001579 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1580 V2AVI = VarToAbstractVarMap.find(DV);
1581 if (V2AVI != VarToAbstractVarMap.end())
1582 AbsDIE = V2AVI->second->getDIE();
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001583
Devang Patel26c1e562010-05-20 16:36:41 +00001584 if (AbsDIE)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001585 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
Devang Patel53bb5c92009-11-10 23:06:00 +00001586 dwarf::DW_FORM_ref4, AbsDIE);
Devang Patel53bb5c92009-11-10 23:06:00 +00001587 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +00001588 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1589 addSourceLine(VariableDie, &VD);
Devang Patel53bb5c92009-11-10 23:06:00 +00001590
1591 // Add variable type.
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001592 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
Devang Patel53bb5c92009-11-10 23:06:00 +00001593 // addresses instead.
1594 if (VD.isBlockByrefVariable())
Devang Patel8a241142009-12-09 18:24:21 +00001595 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
Devang Patel53bb5c92009-11-10 23:06:00 +00001596 else
Devang Patel8a241142009-12-09 18:24:21 +00001597 addType(VariableDie, VD.getType());
Devang Patel53bb5c92009-11-10 23:06:00 +00001598 }
1599
Devang Patelb4645642010-02-06 01:02:37 +00001600 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1601 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
Devang Patelc3f5f782010-05-25 23:40:22 +00001602
1603 if (Scope->isAbstractScope()) {
1604 DV->setDIE(VariableDie);
1605 return VariableDie;
1606 }
1607
1608 // Add variable address.
1609
1610 unsigned Offset = DV->getDotDebugLocOffset();
1611 if (Offset != ~0U) {
1612 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1613 Asm->GetTempSymbol("debug_loc", Offset));
1614 DV->setDIE(VariableDie);
1615 UseDotDebugLocEntry.insert(VariableDie);
1616 return VariableDie;
1617 }
1618
1619 // Check if variable is described by a DBG_VALUE instruction.
1620 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1621 DbgVariableToDbgInstMap.find(DV);
1622 if (DVI != DbgVariableToDbgInstMap.end()) {
1623 const MachineInstr *DVInsn = DVI->second;
1624 const MCSymbol *DVLabel = findVariableLabel(DV);
1625 bool updated = false;
1626 // FIXME : Handle getNumOperands != 3
1627 if (DVInsn->getNumOperands() == 3) {
1628 if (DVInsn->getOperand(0).isReg())
Devang Patel61409622010-07-07 20:12:52 +00001629 updated =
1630 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
Devang Patelc3f5f782010-05-25 23:40:22 +00001631 else if (DVInsn->getOperand(0).isImm())
1632 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1633 else if (DVInsn->getOperand(0).isFPImm())
Devang Patel61409622010-07-07 20:12:52 +00001634 updated =
1635 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
Devang Patelc3f5f782010-05-25 23:40:22 +00001636 } else {
1637 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1638 if (Location.getReg()) {
1639 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1640 if (DVLabel)
1641 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1642 DVLabel);
1643 updated = true;
1644 }
1645 }
1646 if (!updated) {
1647 // If variableDie is not updated then DBG_VALUE instruction does not
1648 // have valid variable info.
1649 delete VariableDie;
1650 return NULL;
1651 }
1652 DV->setDIE(VariableDie);
1653 return VariableDie;
1654 }
1655
1656 // .. else use frame index, if available.
1657 MachineLocation Location;
1658 unsigned FrameReg;
1659 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1660 int FI = 0;
1661 if (findVariableFrameIndex(DV, &FI)) {
1662 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1663 Location.set(FrameReg, Offset);
1664
1665 if (VD.hasComplexAddress())
1666 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1667 else if (VD.isBlockByrefVariable())
1668 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1669 else
1670 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1671 }
Devang Patel53bb5c92009-11-10 23:06:00 +00001672 DV->setDIE(VariableDie);
1673 return VariableDie;
1674
1675}
Devang Patel2c4ceb12009-11-21 02:48:08 +00001676
Devang Patel193f7202009-11-24 01:14:22 +00001677void DwarfDebug::addPubTypes(DISubprogram SP) {
1678 DICompositeType SPTy = SP.getType();
1679 unsigned SPTag = SPTy.getTag();
1680 if (SPTag != dwarf::DW_TAG_subroutine_type)
1681 return;
1682
1683 DIArray Args = SPTy.getTypeArray();
Devang Patel193f7202009-11-24 01:14:22 +00001684 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
Devang Patel2db49d72010-05-07 18:11:54 +00001685 DIType ATy(Args.getElement(i));
Devang Patel9c004872010-05-07 21:45:47 +00001686 if (!ATy.Verify())
Devang Patel193f7202009-11-24 01:14:22 +00001687 continue;
1688 DICompositeType CATy = getDICompositeType(ATy);
Devang Patel2db49d72010-05-07 18:11:54 +00001689 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
Devang Patel50d80e32010-04-13 20:35:04 +00001690 && !CATy.isForwardDecl()) {
Devang Patel163a9f72010-05-10 22:49:55 +00001691 CompileUnit *TheCU = getCompileUnit(CATy);
1692 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1693 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
Devang Patel193f7202009-11-24 01:14:22 +00001694 }
1695 }
1696}
1697
Devang Patel2c4ceb12009-11-21 02:48:08 +00001698/// constructScopeDIE - Construct a DIE for this scope.
1699DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
Devang Patel3c91b052010-03-08 20:52:55 +00001700 if (!Scope || !Scope->getScopeNode())
1701 return NULL;
1702
1703 DIScope DS(Scope->getScopeNode());
1704 DIE *ScopeDIE = NULL;
1705 if (Scope->getInlinedAt())
1706 ScopeDIE = constructInlinedScopeDIE(Scope);
1707 else if (DS.isSubprogram()) {
Devang Patel0dd45582010-06-28 20:53:04 +00001708 ProcessedSPNodes.insert(DS);
Devang Patel8aa61472010-07-07 22:20:57 +00001709 if (Scope->isAbstractScope()) {
Devang Patel163a9f72010-05-10 22:49:55 +00001710 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
Devang Patel8aa61472010-07-07 22:20:57 +00001711 // Note down abstract DIE.
1712 if (ScopeDIE)
1713 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1714 }
Devang Patel3c91b052010-03-08 20:52:55 +00001715 else
Devang Patel2db49d72010-05-07 18:11:54 +00001716 ScopeDIE = updateSubprogramScopeDIE(DS);
Devang Patel3c91b052010-03-08 20:52:55 +00001717 }
Devang Patelaead63c2010-03-29 22:59:58 +00001718 else
Devang Patel3c91b052010-03-08 20:52:55 +00001719 ScopeDIE = constructLexicalScopeDIE(Scope);
Devang Patelaead63c2010-03-29 22:59:58 +00001720 if (!ScopeDIE) return NULL;
Devang Patel3c91b052010-03-08 20:52:55 +00001721
Devang Patel53bb5c92009-11-10 23:06:00 +00001722 // Add variables to scope.
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00001723 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
Devang Patel53bb5c92009-11-10 23:06:00 +00001724 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
Devang Patel8a241142009-12-09 18:24:21 +00001725 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001726 if (VariableDIE)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001727 ScopeDIE->addChild(VariableDIE);
Devang Patel53bb5c92009-11-10 23:06:00 +00001728 }
1729
1730 // Add nested scopes.
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00001731 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
Devang Patel53bb5c92009-11-10 23:06:00 +00001732 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1733 // Define the Scope debug information entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001734 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001735 if (NestedDIE)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001736 ScopeDIE->addChild(NestedDIE);
Devang Patel53bb5c92009-11-10 23:06:00 +00001737 }
Devang Patel193f7202009-11-24 01:14:22 +00001738
1739 if (DS.isSubprogram())
Devang Patel2db49d72010-05-07 18:11:54 +00001740 addPubTypes(DISubprogram(DS));
Devang Patel193f7202009-11-24 01:14:22 +00001741
1742 return ScopeDIE;
Devang Patel53bb5c92009-11-10 23:06:00 +00001743}
1744
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001745/// GetOrCreateSourceID - Look up the source id with the given directory and
1746/// source file names. If none currently exists, create a new id and insert it
1747/// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1748/// maps as well.
Chris Lattner1d65ba72010-03-31 06:06:37 +00001749unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001750 unsigned DId;
1751 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1752 if (DI != DirectoryIdMap.end()) {
1753 DId = DI->getValue();
1754 } else {
1755 DId = DirectoryNames.size() + 1;
1756 DirectoryIdMap[DirName] = DId;
1757 DirectoryNames.push_back(DirName);
1758 }
1759
1760 unsigned FId;
1761 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1762 if (FI != SourceFileIdMap.end()) {
1763 FId = FI->getValue();
1764 } else {
1765 FId = SourceFileNames.size() + 1;
1766 SourceFileIdMap[FileName] = FId;
1767 SourceFileNames.push_back(FileName);
1768 }
1769
1770 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1771 SourceIdMap.find(std::make_pair(DId, FId));
1772 if (SI != SourceIdMap.end())
1773 return SI->second;
1774
1775 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1776 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1777 SourceIds.push_back(std::make_pair(DId, FId));
1778
1779 return SrcId;
1780}
1781
Devang Patel6404e4e2009-12-15 19:16:48 +00001782/// getOrCreateNameSpace - Create a DIE for DINameSpace.
1783DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
Devang Patel163a9f72010-05-10 22:49:55 +00001784 CompileUnit *TheCU = getCompileUnit(NS);
1785 DIE *NDie = TheCU->getDIE(NS);
Devang Patel6404e4e2009-12-15 19:16:48 +00001786 if (NDie)
1787 return NDie;
1788 NDie = new DIE(dwarf::DW_TAG_namespace);
Devang Patel163a9f72010-05-10 22:49:55 +00001789 TheCU->insertDIE(NS, NDie);
Devang Patel6404e4e2009-12-15 19:16:48 +00001790 if (!NS.getName().empty())
1791 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1792 addSourceLine(NDie, &NS);
1793 addToContextOwner(NDie, NS.getContext());
1794 return NDie;
1795}
1796
Devang Patel163a9f72010-05-10 22:49:55 +00001797/// constructCompileUnit - Create new CompileUnit for the given
1798/// metadata node with tag DW_TAG_compile_unit.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001799void DwarfDebug::constructCompileUnit(const MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +00001800 DICompileUnit DIUnit(N);
Devang Patel65dbc902009-11-25 17:36:49 +00001801 StringRef FN = DIUnit.getFilename();
1802 StringRef Dir = DIUnit.getDirectory();
Devang Patel5ccdd102009-09-29 18:40:58 +00001803 unsigned ID = GetOrCreateSourceID(Dir, FN);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001804
1805 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001806 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
Devang Patel5ccdd102009-09-29 18:40:58 +00001807 DIUnit.getProducer());
Devang Patel2c4ceb12009-11-21 02:48:08 +00001808 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001809 DIUnit.getLanguage());
Devang Patel2c4ceb12009-11-21 02:48:08 +00001810 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
Devang Patel5098da02010-04-26 22:54:28 +00001811 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1812 // simplifies debug range entries.
Devang Patel9b93b6b2010-06-28 22:22:47 +00001813 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
Devang Patel4a602ca2010-03-22 23:11:36 +00001814 // DW_AT_stmt_list is a offset of line number information for this
Devang Patel1e4782d2010-06-29 20:17:53 +00001815 // compile unit in debug_line section. This offset is calculated
1816 // during endMoudle().
1817 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001818
Devang Patel65dbc902009-11-25 17:36:49 +00001819 if (!Dir.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001820 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001821 if (DIUnit.isOptimized())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001822 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001823
Devang Patel65dbc902009-11-25 17:36:49 +00001824 StringRef Flags = DIUnit.getFlags();
1825 if (!Flags.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001826 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001827
1828 unsigned RVer = DIUnit.getRunTimeVersion();
1829 if (RVer)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001830 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001831 dwarf::DW_FORM_data1, RVer);
1832
Devang Patel163a9f72010-05-10 22:49:55 +00001833 CompileUnit *NewCU = new CompileUnit(ID, Die);
1834 if (!FirstCU)
1835 FirstCU = NewCU;
1836 CUMap.insert(std::make_pair(N, NewCU));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001837}
1838
Devang Patel163a9f72010-05-10 22:49:55 +00001839/// getCompielUnit - Get CompileUnit DIE.
1840CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1841 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1842 DIDescriptor D(N);
1843 const MDNode *CUNode = NULL;
1844 if (D.isCompileUnit())
1845 CUNode = N;
1846 else if (D.isSubprogram())
1847 CUNode = DISubprogram(N).getCompileUnit();
1848 else if (D.isType())
1849 CUNode = DIType(N).getCompileUnit();
1850 else if (D.isGlobalVariable())
1851 CUNode = DIGlobalVariable(N).getCompileUnit();
1852 else if (D.isVariable())
1853 CUNode = DIVariable(N).getCompileUnit();
1854 else if (D.isNameSpace())
1855 CUNode = DINameSpace(N).getCompileUnit();
1856 else if (D.isFile())
1857 CUNode = DIFile(N).getCompileUnit();
1858 else
1859 return FirstCU;
1860
1861 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1862 = CUMap.find(CUNode);
1863 if (I == CUMap.end())
1864 return FirstCU;
1865 return I->second;
1866}
1867
1868
1869/// constructGlobalVariableDIE - Construct global variable DIE.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001870void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +00001871 DIGlobalVariable DI_GV(N);
Daniel Dunbarf612ff62009-09-19 20:40:05 +00001872
Devang Patel905cf5e2009-09-04 23:59:07 +00001873 // If debug information is malformed then ignore it.
1874 if (DI_GV.Verify() == false)
1875 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001876
1877 // Check for pre-existence.
Devang Patel163a9f72010-05-10 22:49:55 +00001878 CompileUnit *TheCU = getCompileUnit(N);
1879 if (TheCU->getDIE(DI_GV))
Devang Patel13e16b62009-06-26 01:49:18 +00001880 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001881
Devang Patel8a241142009-12-09 18:24:21 +00001882 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
Devang Pateledb45632009-12-10 23:25:41 +00001883 if (!VariableDie)
1884 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001885
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001886 // Add to map.
Devang Patel163a9f72010-05-10 22:49:55 +00001887 TheCU->insertDIE(N, VariableDie);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001888
1889 // Add to context owner.
Devang Patelc9b16cc2010-01-15 01:12:22 +00001890 DIDescriptor GVContext = DI_GV.getContext();
1891 // Do not create specification DIE if context is either compile unit
1892 // or a subprogram.
Chris Lattner1d65ba72010-03-31 06:06:37 +00001893 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
Devang Patel5f094002010-04-06 23:53:48 +00001894 !GVContext.isFile() &&
Devang Patel2db49d72010-05-07 18:11:54 +00001895 !isSubprogramContext(GVContext)) {
Devang Patel6404e4e2009-12-15 19:16:48 +00001896 // Create specification DIE.
1897 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1898 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1899 dwarf::DW_FORM_ref4, VariableDie);
Benjamin Kramer345ef342010-03-31 19:34:01 +00001900 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel6404e4e2009-12-15 19:16:48 +00001901 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
Chris Lattner4faf59a2010-03-08 22:31:46 +00001902 addLabel(Block, 0, dwarf::DW_FORM_udata,
Chris Lattnerdeb0cba2010-03-12 21:09:07 +00001903 Asm->Mang->getSymbol(DI_GV.getGlobal()));
Devang Patel6404e4e2009-12-15 19:16:48 +00001904 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
Devang Patel8581e012010-02-09 01:58:33 +00001905 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Devang Patel163a9f72010-05-10 22:49:55 +00001906 TheCU->addDie(VariableSpecDIE);
Devang Patel6404e4e2009-12-15 19:16:48 +00001907 } else {
Benjamin Kramer345ef342010-03-31 19:34:01 +00001908 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel6404e4e2009-12-15 19:16:48 +00001909 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
Chris Lattner4faf59a2010-03-08 22:31:46 +00001910 addLabel(Block, 0, dwarf::DW_FORM_udata,
Chris Lattnerdeb0cba2010-03-12 21:09:07 +00001911 Asm->Mang->getSymbol(DI_GV.getGlobal()));
Devang Patel6404e4e2009-12-15 19:16:48 +00001912 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1913 }
Devang Patelc9b16cc2010-01-15 01:12:22 +00001914 addToContextOwner(VariableDie, GVContext);
Devang Patelc366f832009-12-10 19:14:49 +00001915
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001916 // Expose as global. FIXME - need to check external flag.
Devang Patel163a9f72010-05-10 22:49:55 +00001917 TheCU->addGlobal(DI_GV.getName(), VariableDie);
Devang Patel193f7202009-11-24 01:14:22 +00001918
1919 DIType GTy = DI_GV.getType();
Devang Patel50d80e32010-04-13 20:35:04 +00001920 if (GTy.isCompositeType() && !GTy.getName().empty()
1921 && !GTy.isForwardDecl()) {
Devang Patel163a9f72010-05-10 22:49:55 +00001922 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
Chris Lattnered7a77b2010-03-31 05:36:29 +00001923 assert(Entry && "Missing global type!");
Devang Patel163a9f72010-05-10 22:49:55 +00001924 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
Devang Patel193f7202009-11-24 01:14:22 +00001925 }
Devang Patel13e16b62009-06-26 01:49:18 +00001926 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001927}
1928
Devang Patel163a9f72010-05-10 22:49:55 +00001929/// construct SubprogramDIE - Construct subprogram DIE.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001930void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +00001931 DISubprogram SP(N);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001932
Stuart Hastings639336e2010-04-06 21:38:29 +00001933 // Check for pre-existence.
Devang Patel163a9f72010-05-10 22:49:55 +00001934 CompileUnit *TheCU = getCompileUnit(N);
1935 if (TheCU->getDIE(N))
Stuart Hastings639336e2010-04-06 21:38:29 +00001936 return;
1937
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001938 if (!SP.isDefinition())
1939 // This is a method declaration which will be handled while constructing
1940 // class type.
Devang Patel13e16b62009-06-26 01:49:18 +00001941 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001942
Stuart Hastings639336e2010-04-06 21:38:29 +00001943 DIE *SubprogramDie = createSubprogramDIE(SP);
1944
1945 // Add to map.
Devang Patel163a9f72010-05-10 22:49:55 +00001946 TheCU->insertDIE(N, SubprogramDie);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001947
1948 // Add to context owner.
Devang Patel6404e4e2009-12-15 19:16:48 +00001949 addToContextOwner(SubprogramDie, SP.getContext());
Devang Patel0000fad2009-12-08 23:21:45 +00001950
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001951 // Expose as global.
Devang Patel163a9f72010-05-10 22:49:55 +00001952 TheCU->addGlobal(SP.getName(), SubprogramDie);
Devang Patel193f7202009-11-24 01:14:22 +00001953
Devang Patel13e16b62009-06-26 01:49:18 +00001954 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001955}
1956
Devang Patel2c4ceb12009-11-21 02:48:08 +00001957/// beginModule - Emit all Dwarf sections that should come prior to the
Daniel Dunbar00564992009-09-19 20:40:14 +00001958/// content. Create global DIEs and emit initial debug info sections.
1959/// This is inovked by the target AsmPrinter.
Chris Lattner75f50722010-04-04 07:48:20 +00001960void DwarfDebug::beginModule(Module *M) {
Devang Pateleac9c072010-04-27 19:46:33 +00001961 if (DisableDebugInfoPrinting)
1962 return;
1963
Devang Patel78ab9e22009-07-30 18:56:46 +00001964 DebugInfoFinder DbgFinder;
1965 DbgFinder.processModule(*M);
Devang Patel13e16b62009-06-26 01:49:18 +00001966
Chris Lattnerd850ac72010-04-05 02:19:28 +00001967 bool HasDebugInfo = false;
1968
1969 // Scan all the compile-units to see if there are any marked as the main unit.
1970 // if not, we do not generate debug info.
1971 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1972 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1973 if (DICompileUnit(*I).isMain()) {
1974 HasDebugInfo = true;
1975 break;
1976 }
1977 }
1978
1979 if (!HasDebugInfo) return;
1980
1981 // Tell MMI that we have debug info.
1982 MMI->setDebugInfoAvailability(true);
1983
Chris Lattnerbe15beb2010-04-04 23:17:54 +00001984 // Emit initial sections.
Chris Lattnerd850ac72010-04-05 02:19:28 +00001985 EmitSectionLabels();
Chris Lattnerbe15beb2010-04-04 23:17:54 +00001986
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001987 // Create all the compile unit DIEs.
Devang Patel78ab9e22009-07-30 18:56:46 +00001988 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1989 E = DbgFinder.compile_unit_end(); I != E; ++I)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001990 constructCompileUnit(*I);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001991
Devang Patel53bb5c92009-11-10 23:06:00 +00001992 // Create DIEs for each subprogram.
Devang Patel78ab9e22009-07-30 18:56:46 +00001993 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1994 E = DbgFinder.subprogram_end(); I != E; ++I)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001995 constructSubprogramDIE(*I);
Devang Patel13e16b62009-06-26 01:49:18 +00001996
Devang Patelc366f832009-12-10 19:14:49 +00001997 // Create DIEs for each global variable.
1998 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1999 E = DbgFinder.global_variable_end(); I != E; ++I)
2000 constructGlobalVariableDIE(*I);
2001
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002002 // Prime section data.
Chris Lattnerf0144122009-07-28 03:13:23 +00002003 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002004
2005 // Print out .file directives to specify files for .loc directives. These are
2006 // printed out early so that they precede any .loc directives.
Chris Lattnerd38fee82010-04-05 00:13:49 +00002007 if (Asm->MAI->hasDotLocAndDotFile()) {
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002008 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2009 // Remember source id starts at 1.
2010 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
Chris Lattner0ad9c912010-01-22 22:09:00 +00002011 // FIXME: don't use sys::path for this! This should not depend on the
2012 // host.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002013 sys::Path FullPath(getSourceDirectoryName(Id.first));
2014 bool AppendOk =
2015 FullPath.appendComponent(getSourceFileName(Id.second));
2016 assert(AppendOk && "Could not append filename to directory!");
2017 AppendOk = false;
Chris Lattnera6594fc2010-01-25 18:58:59 +00002018 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002019 }
2020 }
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002021}
2022
Devang Patel2c4ceb12009-11-21 02:48:08 +00002023/// endModule - Emit all Dwarf sections that should come after the content.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002024///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002025void DwarfDebug::endModule() {
Devang Patel163a9f72010-05-10 22:49:55 +00002026 if (!FirstCU) return;
Devang Patel4a1cad62010-06-28 18:25:03 +00002027 const Module *M = MMI->getModule();
2028 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2029 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2030 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2031 DISubprogram SP(AllSPs->getOperand(SI));
2032 if (!SP.Verify()) continue;
2033
2034 // Collect info for variables that were optimized out.
2035 StringRef FName = SP.getLinkageName();
2036 if (FName.empty())
2037 FName = SP.getName();
2038 NamedMDNode *NMD =
2039 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2040 if (!NMD) continue;
2041 unsigned E = NMD->getNumOperands();
2042 if (!E) continue;
2043 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2044 for (unsigned I = 0; I != E; ++I) {
2045 DIVariable DV(NMD->getOperand(I));
2046 if (!DV.Verify()) continue;
2047 Scope->addVariable(new DbgVariable(DV));
2048 }
2049
2050 // Construct subprogram DIE and add variables DIEs.
2051 constructSubprogramDIE(SP);
2052 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2053 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
2054 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2055 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2056 if (VariableDIE)
2057 ScopeDIE->addChild(VariableDIE);
2058 }
2059 }
2060 }
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002061
Devang Patel53bb5c92009-11-10 23:06:00 +00002062 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2063 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2064 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2065 DIE *ISP = *AI;
Devang Patel2c4ceb12009-11-21 02:48:08 +00002066 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
Devang Patel53bb5c92009-11-10 23:06:00 +00002067 }
2068
Devang Patele9f8f5e2010-05-07 20:54:48 +00002069 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
Devang Patel5d11eb02009-12-03 19:11:07 +00002070 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2071 DIE *SPDie = CI->first;
Devang Patele9f8f5e2010-05-07 20:54:48 +00002072 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
Devang Patel5d11eb02009-12-03 19:11:07 +00002073 if (!N) continue;
Devang Patel163a9f72010-05-10 22:49:55 +00002074 DIE *NDie = getCompileUnit(N)->getDIE(N);
Devang Patel5d11eb02009-12-03 19:11:07 +00002075 if (!NDie) continue;
2076 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
Devang Patel5d11eb02009-12-03 19:11:07 +00002077 }
2078
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002079 // Standard sections final addresses.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002080 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
Chris Lattnerc0215722010-04-04 19:25:43 +00002081 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002082 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
Chris Lattnerc0215722010-04-04 19:25:43 +00002083 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002084
2085 // End text sections.
2086 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002087 Asm->OutStreamer.SwitchSection(SectionMap[i]);
Chris Lattnerc0215722010-04-04 19:25:43 +00002088 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002089 }
2090
2091 // Emit common frame information.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002092 emitCommonDebugFrame();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002093
2094 // Emit function debug frame information
2095 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2096 E = DebugFrames.end(); I != E; ++I)
Devang Patel2c4ceb12009-11-21 02:48:08 +00002097 emitFunctionDebugFrame(*I);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002098
2099 // Compute DIE offsets and sizes.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002100 computeSizeAndOffsets();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002101
Devang Patel1e4782d2010-06-29 20:17:53 +00002102 // Emit source line correspondence into a debug line section.
2103 emitDebugLines();
2104
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002105 // Emit all the DIEs into a debug info section
Devang Patel2c4ceb12009-11-21 02:48:08 +00002106 emitDebugInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002107
2108 // Corresponding abbreviations into a abbrev section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002109 emitAbbreviations();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002110
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002111 // Emit info into a debug pubnames section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002112 emitDebugPubNames();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002113
Devang Patel193f7202009-11-24 01:14:22 +00002114 // Emit info into a debug pubtypes section.
2115 emitDebugPubTypes();
2116
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002117 // Emit info into a debug loc section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002118 emitDebugLoc();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002119
2120 // Emit info into a debug aranges section.
2121 EmitDebugARanges();
2122
2123 // Emit info into a debug ranges section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002124 emitDebugRanges();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002125
2126 // Emit info into a debug macinfo section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002127 emitDebugMacInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002128
2129 // Emit inline info.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002130 emitDebugInlineInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002131
Chris Lattnerbc733f52010-03-13 02:17:42 +00002132 // Emit info into a debug str section.
2133 emitDebugStr();
2134
Devang Patel163a9f72010-05-10 22:49:55 +00002135 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2136 E = CUMap.end(); I != E; ++I)
2137 delete I->second;
2138 FirstCU = NULL; // Reset for the next Module, if any.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002139}
2140
Devang Patel53bb5c92009-11-10 23:06:00 +00002141/// findAbstractVariable - Find abstract variable, if any, associated with Var.
Devang Patel26c1e562010-05-20 16:36:41 +00002142DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
Chris Lattnerde4845c2010-04-02 19:42:39 +00002143 DebugLoc ScopeLoc) {
Devang Patel53bb5c92009-11-10 23:06:00 +00002144
Devang Patel2db49d72010-05-07 18:11:54 +00002145 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
Devang Patel53bb5c92009-11-10 23:06:00 +00002146 if (AbsDbgVariable)
2147 return AbsDbgVariable;
2148
Devang Patel2db49d72010-05-07 18:11:54 +00002149 LLVMContext &Ctx = Var->getContext();
Chris Lattnerde4845c2010-04-02 19:42:39 +00002150 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
Devang Patel53bb5c92009-11-10 23:06:00 +00002151 if (!Scope)
2152 return NULL;
2153
Devang Patel26c1e562010-05-20 16:36:41 +00002154 AbsDbgVariable = new DbgVariable(Var);
Devang Patel2c4ceb12009-11-21 02:48:08 +00002155 Scope->addVariable(AbsDbgVariable);
Devang Patel2db49d72010-05-07 18:11:54 +00002156 AbstractVariables[Var] = AbsDbgVariable;
Devang Patel53bb5c92009-11-10 23:06:00 +00002157 return AbsDbgVariable;
2158}
2159
Devang Patelee432862010-05-20 19:57:06 +00002160/// collectVariableInfoFromMMITable - Collect variable information from
2161/// side table maintained by MMI.
2162void
2163DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2164 SmallPtrSet<const MDNode *, 16> &Processed) {
Chris Lattnerd38fee82010-04-05 00:13:49 +00002165 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
Devang Patele717faa2009-10-06 01:26:37 +00002166 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2167 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2168 VE = VMap.end(); VI != VE; ++VI) {
Devang Patele9f8f5e2010-05-07 20:54:48 +00002169 const MDNode *Var = VI->first;
Devang Patel53bb5c92009-11-10 23:06:00 +00002170 if (!Var) continue;
Devang Patel98e1cac2010-05-14 21:01:35 +00002171 Processed.insert(Var);
Chris Lattnerde4845c2010-04-02 19:42:39 +00002172 DIVariable DV(Var);
2173 const std::pair<unsigned, DebugLoc> &VP = VI->second;
Devang Patel53bb5c92009-11-10 23:06:00 +00002174
Chris Lattnerde4845c2010-04-02 19:42:39 +00002175 DbgScope *Scope = 0;
Devang Patele9f8f5e2010-05-07 20:54:48 +00002176 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
Chris Lattnerde4845c2010-04-02 19:42:39 +00002177 Scope = ConcreteScopes.lookup(IA);
2178 if (Scope == 0)
2179 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2180
Devang Patelfb0ee432009-11-10 23:20:04 +00002181 // If variable scope is not found then skip this variable.
Chris Lattnerde4845c2010-04-02 19:42:39 +00002182 if (Scope == 0)
Devang Patelfb0ee432009-11-10 23:20:04 +00002183 continue;
Devang Patel53bb5c92009-11-10 23:06:00 +00002184
Devang Patel26c1e562010-05-20 16:36:41 +00002185 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2186 DbgVariable *RegVar = new DbgVariable(DV);
2187 recordVariableFrameIndex(RegVar, VP.first);
Devang Patel2c4ceb12009-11-21 02:48:08 +00002188 Scope->addVariable(RegVar);
Devang Patel26c1e562010-05-20 16:36:41 +00002189 if (AbsDbgVariable) {
2190 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2191 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2192 }
Devang Patele717faa2009-10-06 01:26:37 +00002193 }
Devang Patelee432862010-05-20 19:57:06 +00002194}
Devang Patel90a48ad2010-03-15 18:33:46 +00002195
Devang Patelc3f5f782010-05-25 23:40:22 +00002196/// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2197/// DBG_VALUE instruction, is in undefined reg.
2198static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2199 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2200 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2201 return true;
2202 return false;
2203}
2204
2205/// isDbgValueInDefinedReg - Return true if debug value, encoded by
2206/// DBG_VALUE instruction, is in a defined reg.
2207static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2208 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2209 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2210 return true;
2211 return false;
2212}
2213
Devang Patelee432862010-05-20 19:57:06 +00002214/// collectVariableInfo - Populate DbgScope entries with variables' info.
Devang Patel78e127d2010-06-25 22:07:34 +00002215void
2216DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2217 SmallPtrSet<const MDNode *, 16> &Processed) {
Devang Patelee432862010-05-20 19:57:06 +00002218
2219 /// collection info from MMI table.
2220 collectVariableInfoFromMMITable(MF, Processed);
2221
2222 SmallVector<const MachineInstr *, 8> DbgValues;
Devang Patel90a48ad2010-03-15 18:33:46 +00002223 // Collect variable information from DBG_VALUE machine instructions;
Chris Lattnerd38fee82010-04-05 00:13:49 +00002224 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
Devang Patelee432862010-05-20 19:57:06 +00002225 I != E; ++I)
Devang Patel90a48ad2010-03-15 18:33:46 +00002226 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2227 II != IE; ++II) {
2228 const MachineInstr *MInsn = II;
Devang Patelc3f5f782010-05-25 23:40:22 +00002229 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
Devang Patel90a48ad2010-03-15 18:33:46 +00002230 continue;
Devang Patelee432862010-05-20 19:57:06 +00002231 DbgValues.push_back(MInsn);
2232 }
Devang Patel90a48ad2010-03-15 18:33:46 +00002233
Devang Patelc3f5f782010-05-25 23:40:22 +00002234 // This is a collection of DBV_VALUE instructions describing same variable.
2235 SmallVector<const MachineInstr *, 4> MultipleValues;
Devang Patelee432862010-05-20 19:57:06 +00002236 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2237 E = DbgValues.end(); I != E; ++I) {
2238 const MachineInstr *MInsn = *I;
Devang Patelc3f5f782010-05-25 23:40:22 +00002239 MultipleValues.clear();
2240 if (isDbgValueInDefinedReg(MInsn))
2241 MultipleValues.push_back(MInsn);
Devang Patelee432862010-05-20 19:57:06 +00002242 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2243 if (Processed.count(DV) != 0)
2244 continue;
2245
Devang Patel354eb7e2010-06-02 19:05:13 +00002246 const MachineInstr *PrevMI = MInsn;
Devang Patelc3f5f782010-05-25 23:40:22 +00002247 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2248 ME = DbgValues.end(); MI != ME; ++MI) {
2249 const MDNode *Var =
2250 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
Devang Patel354eb7e2010-06-02 19:05:13 +00002251 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2252 !PrevMI->isIdenticalTo(*MI))
Devang Patelc3f5f782010-05-25 23:40:22 +00002253 MultipleValues.push_back(*MI);
Devang Patel354eb7e2010-06-02 19:05:13 +00002254 PrevMI = *MI;
Devang Patelc3f5f782010-05-25 23:40:22 +00002255 }
2256
Devang Patelee432862010-05-20 19:57:06 +00002257 DbgScope *Scope = findDbgScope(MInsn);
Devang Pateld8720f42010-05-27 20:25:04 +00002258 bool CurFnArg = false;
2259 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2260 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2261 CurFnArg = true;
2262 if (!Scope && CurFnArg)
Devang Patelc0c5a262010-05-21 00:10:20 +00002263 Scope = CurrentFnDbgScope;
Devang Patelee432862010-05-20 19:57:06 +00002264 // If variable scope is not found then skip this variable.
Devang Patelc0c5a262010-05-21 00:10:20 +00002265 if (!Scope)
Devang Patelee432862010-05-20 19:57:06 +00002266 continue;
2267
2268 Processed.insert(DV);
Devang Patelee432862010-05-20 19:57:06 +00002269 DbgVariable *RegVar = new DbgVariable(DV);
Devang Patelee432862010-05-20 19:57:06 +00002270 Scope->addVariable(RegVar);
Devang Pateld8720f42010-05-27 20:25:04 +00002271 if (!CurFnArg)
Devang Patelc3f5f782010-05-25 23:40:22 +00002272 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
Devang Patelc0c5a262010-05-21 00:10:20 +00002273 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2274 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2275 VarToAbstractVarMap[RegVar] = AbsVar;
Devang Patel90a48ad2010-03-15 18:33:46 +00002276 }
Devang Patelc3f5f782010-05-25 23:40:22 +00002277 if (MultipleValues.size() <= 1) {
2278 DbgVariableToDbgInstMap[RegVar] = MInsn;
2279 continue;
2280 }
2281
2282 // handle multiple DBG_VALUE instructions describing one variable.
Devang Patelc3f5f782010-05-25 23:40:22 +00002283 if (DotDebugLocEntries.empty())
Devang Patel80250682010-05-26 23:55:23 +00002284 RegVar->setDotDebugLocOffset(0);
2285 else
2286 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
Devang Patele2df8422010-05-26 17:29:32 +00002287 const MachineInstr *Begin = NULL;
2288 const MachineInstr *End = NULL;
2289 for (SmallVector<const MachineInstr *, 4>::iterator
Devang Patel61409622010-07-07 20:12:52 +00002290 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2291 MVI != MVE; ++MVI) {
Devang Patele2df8422010-05-26 17:29:32 +00002292 if (!Begin) {
2293 Begin = *MVI;
2294 continue;
2295 }
2296 End = *MVI;
Devang Patelc3f5f782010-05-25 23:40:22 +00002297 MachineLocation MLoc;
Devang Patele2df8422010-05-26 17:29:32 +00002298 MLoc.set(Begin->getOperand(0).getReg(), 0);
2299 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2300 const MCSymbol *SLabel = getLabelBeforeInsn(End);
Devang Patelc3f5f782010-05-25 23:40:22 +00002301 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
Devang Patele2df8422010-05-26 17:29:32 +00002302 Begin = End;
2303 if (MVI + 1 == MVE) {
2304 // If End is the last instruction then its value is valid
Devang Patelc3f5f782010-05-25 23:40:22 +00002305 // until the end of the funtion.
Devang Patele2df8422010-05-26 17:29:32 +00002306 MLoc.set(End->getOperand(0).getReg(), 0);
Devang Patelc3f5f782010-05-25 23:40:22 +00002307 DotDebugLocEntries.
2308 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2309 }
2310 }
2311 DotDebugLocEntries.push_back(DotDebugLocEntry());
Devang Patel90a48ad2010-03-15 18:33:46 +00002312 }
Devang Patel98e1cac2010-05-14 21:01:35 +00002313
2314 // Collect info for variables that were optimized out.
Devang Pateld1bbc6b2010-06-22 01:01:58 +00002315 const Function *F = MF->getFunction();
2316 const Module *M = F->getParent();
2317 if (NamedMDNode *NMD =
Devang Patela762b092010-06-22 01:19:38 +00002318 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2319 getRealLinkageName(F->getName())))) {
Devang Patel98e1cac2010-05-14 21:01:35 +00002320 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2321 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
Devang Patelee432862010-05-20 19:57:06 +00002322 if (!DV || !Processed.insert(DV))
Devang Patel98e1cac2010-05-14 21:01:35 +00002323 continue;
2324 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2325 if (Scope)
Devang Patel26c1e562010-05-20 16:36:41 +00002326 Scope->addVariable(new DbgVariable(DV));
Devang Patel98e1cac2010-05-14 21:01:35 +00002327 }
2328 }
Devang Patelc3f5f782010-05-25 23:40:22 +00002329}
Devang Patel98e1cac2010-05-14 21:01:35 +00002330
Devang Patelc3f5f782010-05-25 23:40:22 +00002331/// getLabelBeforeInsn - Return Label preceding the instruction.
2332const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2333 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2334 LabelsBeforeInsn.find(MI);
2335 if (I == LabelsBeforeInsn.end())
2336 // FunctionBeginSym always preceeds all the instruction in current function.
2337 return FunctionBeginSym;
2338 return I->second;
2339}
2340
2341/// getLabelAfterInsn - Return Label immediately following the instruction.
2342const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2343 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2344 LabelsAfterInsn.find(MI);
2345 if (I == LabelsAfterInsn.end())
2346 return NULL;
2347 return I->second;
Devang Patele717faa2009-10-06 01:26:37 +00002348}
2349
Devang Patel553881b2010-03-29 17:20:31 +00002350/// beginScope - Process beginning of a scope.
2351void DwarfDebug::beginScope(const MachineInstr *MI) {
Devang Patelb2b31a62010-05-26 19:37:24 +00002352 if (InsnNeedsLabel.count(MI) == 0) {
2353 LabelsBeforeInsn[MI] = PrevLabel;
Devang Patel553881b2010-03-29 17:20:31 +00002354 return;
Devang Patelc3f5f782010-05-25 23:40:22 +00002355 }
Devang Patelaead63c2010-03-29 22:59:58 +00002356
Devang Patelb2b31a62010-05-26 19:37:24 +00002357 // Check location.
2358 DebugLoc DL = MI->getDebugLoc();
2359 if (!DL.isUnknown()) {
2360 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2361 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
Devang Pateleac9c072010-04-27 19:46:33 +00002362 PrevInstLoc = DL;
Devang Patelb2b31a62010-05-26 19:37:24 +00002363 LabelsBeforeInsn[MI] = PrevLabel;
2364 return;
Devang Pateleac9c072010-04-27 19:46:33 +00002365 }
Devang Patel553881b2010-03-29 17:20:31 +00002366
Devang Patel77051f52010-05-26 21:23:46 +00002367 // If location is unknown then use temp label for this DBG_VALUE
Devang Patelb2b31a62010-05-26 19:37:24 +00002368 // instruction.
2369 if (MI->isDebugValue()) {
Devang Patel77051f52010-05-26 21:23:46 +00002370 PrevLabel = MMI->getContext().CreateTempSymbol();
2371 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patelb2b31a62010-05-26 19:37:24 +00002372 LabelsBeforeInsn[MI] = PrevLabel;
2373 return;
2374 }
2375
2376 if (UnknownLocations) {
2377 PrevLabel = recordSourceLine(0, 0, 0);
2378 LabelsBeforeInsn[MI] = PrevLabel;
2379 return;
2380 }
2381
2382 assert (0 && "Instruction is not processed!");
Devang Patel0d20ac82009-10-06 01:50:42 +00002383}
2384
Devang Patel2c4ceb12009-11-21 02:48:08 +00002385/// endScope - Process end of a scope.
2386void DwarfDebug::endScope(const MachineInstr *MI) {
Devang Patel1c246352010-04-08 16:50:29 +00002387 if (InsnsEndScopeSet.count(MI) != 0) {
2388 // Emit a label if this instruction ends a scope.
2389 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2390 Asm->OutStreamer.EmitLabel(Label);
Devang Pateleac9c072010-04-27 19:46:33 +00002391 LabelsAfterInsn[MI] = Label;
Devang Patel1c246352010-04-08 16:50:29 +00002392 }
Devang Patel53bb5c92009-11-10 23:06:00 +00002393}
2394
Devang Pateleac9c072010-04-27 19:46:33 +00002395/// getOrCreateDbgScope - Create DbgScope for the scope.
Devang Patel61409622010-07-07 20:12:52 +00002396DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2397 const MDNode *InlinedAt) {
Devang Patel53bb5c92009-11-10 23:06:00 +00002398 if (!InlinedAt) {
2399 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2400 if (WScope)
Devang Pateleac9c072010-04-27 19:46:33 +00002401 return WScope;
Devang Patel53bb5c92009-11-10 23:06:00 +00002402 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2403 DbgScopeMap.insert(std::make_pair(Scope, WScope));
Devang Pateleac9c072010-04-27 19:46:33 +00002404 if (DIDescriptor(Scope).isLexicalBlock()) {
2405 DbgScope *Parent =
Devang Patel2db49d72010-05-07 18:11:54 +00002406 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
Devang Pateleac9c072010-04-27 19:46:33 +00002407 WScope->setParent(Parent);
2408 Parent->addScope(WScope);
2409 }
2410
2411 if (!WScope->getParent()) {
2412 StringRef SPName = DISubprogram(Scope).getLinkageName();
Stuart Hastingscad22ad2010-06-15 23:06:30 +00002413 // We used to check only for a linkage name, but that fails
2414 // since we began omitting the linkage name for private
2415 // functions. The new way is to check for the name in metadata,
2416 // but that's not supported in old .ll test cases. Ergo, we
2417 // check both.
Stuart Hastings215aa152010-06-11 20:08:44 +00002418 if (SPName == Asm->MF->getFunction()->getName() ||
2419 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
Devang Pateleac9c072010-04-27 19:46:33 +00002420 CurrentFnDbgScope = WScope;
2421 }
2422
2423 return WScope;
Devang Patel53bb5c92009-11-10 23:06:00 +00002424 }
2425
Devang Patel78e127d2010-06-25 22:07:34 +00002426 getOrCreateAbstractScope(Scope);
Devang Patel53bb5c92009-11-10 23:06:00 +00002427 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2428 if (WScope)
Devang Pateleac9c072010-04-27 19:46:33 +00002429 return WScope;
Devang Patel53bb5c92009-11-10 23:06:00 +00002430
2431 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2432 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2433 DILocation DL(InlinedAt);
Devang Pateleac9c072010-04-27 19:46:33 +00002434 DbgScope *Parent =
Devang Patel2db49d72010-05-07 18:11:54 +00002435 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
Devang Pateleac9c072010-04-27 19:46:33 +00002436 WScope->setParent(Parent);
2437 Parent->addScope(WScope);
2438
2439 ConcreteScopes[InlinedAt] = WScope;
Devang Pateleac9c072010-04-27 19:46:33 +00002440
2441 return WScope;
Devang Patel0d20ac82009-10-06 01:50:42 +00002442}
2443
Devang Pateleac9c072010-04-27 19:46:33 +00002444/// hasValidLocation - Return true if debug location entry attached with
2445/// machine instruction encodes valid location info.
2446static bool hasValidLocation(LLVMContext &Ctx,
2447 const MachineInstr *MInsn,
Devang Patele9f8f5e2010-05-07 20:54:48 +00002448 const MDNode *&Scope, const MDNode *&InlinedAt) {
Devang Pateleac9c072010-04-27 19:46:33 +00002449 DebugLoc DL = MInsn->getDebugLoc();
2450 if (DL.isUnknown()) return false;
2451
Devang Patele9f8f5e2010-05-07 20:54:48 +00002452 const MDNode *S = DL.getScope(Ctx);
Devang Pateleac9c072010-04-27 19:46:33 +00002453
2454 // There is no need to create another DIE for compile unit. For all
2455 // other scopes, create one DbgScope now. This will be translated
2456 // into a scope DIE at the end.
2457 if (DIScope(S).isCompileUnit()) return false;
2458
2459 Scope = S;
2460 InlinedAt = DL.getInlinedAt(Ctx);
2461 return true;
2462}
2463
2464/// calculateDominanceGraph - Calculate dominance graph for DbgScope
2465/// hierarchy.
2466static void calculateDominanceGraph(DbgScope *Scope) {
2467 assert (Scope && "Unable to calculate scop edominance graph!");
2468 SmallVector<DbgScope *, 4> WorkStack;
2469 WorkStack.push_back(Scope);
2470 unsigned Counter = 0;
2471 while (!WorkStack.empty()) {
2472 DbgScope *WS = WorkStack.back();
2473 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2474 bool visitedChildren = false;
2475 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2476 SE = Children.end(); SI != SE; ++SI) {
2477 DbgScope *ChildScope = *SI;
2478 if (!ChildScope->getDFSOut()) {
2479 WorkStack.push_back(ChildScope);
2480 visitedChildren = true;
2481 ChildScope->setDFSIn(++Counter);
2482 break;
2483 }
2484 }
2485 if (!visitedChildren) {
2486 WorkStack.pop_back();
2487 WS->setDFSOut(++Counter);
2488 }
2489 }
2490}
2491
2492/// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2493static
2494void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2495 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2496{
2497#ifndef NDEBUG
2498 unsigned PrevDFSIn = 0;
2499 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2500 I != E; ++I) {
2501 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2502 II != IE; ++II) {
2503 const MachineInstr *MInsn = II;
Devang Patele9f8f5e2010-05-07 20:54:48 +00002504 const MDNode *Scope = NULL;
2505 const MDNode *InlinedAt = NULL;
Devang Pateleac9c072010-04-27 19:46:33 +00002506
2507 // Check if instruction has valid location information.
2508 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2509 dbgs() << " [ ";
2510 if (InlinedAt)
2511 dbgs() << "*";
2512 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2513 MI2ScopeMap.find(MInsn);
2514 if (DI != MI2ScopeMap.end()) {
2515 DbgScope *S = DI->second;
2516 dbgs() << S->getDFSIn();
2517 PrevDFSIn = S->getDFSIn();
2518 } else
2519 dbgs() << PrevDFSIn;
2520 } else
2521 dbgs() << " [ x" << PrevDFSIn;
2522 dbgs() << " ]";
2523 MInsn->dump();
2524 }
2525 dbgs() << "\n";
2526 }
2527#endif
2528}
Devang Patel2c4ceb12009-11-21 02:48:08 +00002529/// extractScopeInformation - Scan machine instructions in this function
Chris Lattner14d750d2010-03-31 05:39:57 +00002530/// and collect DbgScopes. Return true, if at least one scope was found.
Chris Lattnereec791a2010-01-26 23:18:02 +00002531bool DwarfDebug::extractScopeInformation() {
Devang Patelaf9e8472009-10-01 20:31:14 +00002532 // If scope information was extracted using .dbg intrinsics then there is not
2533 // any need to extract these information by scanning each instruction.
2534 if (!DbgScopeMap.empty())
2535 return false;
2536
Dan Gohman314bf7c2010-04-23 01:18:53 +00002537 // Scan each instruction and create scopes. First build working set of scopes.
Devang Pateleac9c072010-04-27 19:46:33 +00002538 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2539 SmallVector<DbgRange, 4> MIRanges;
2540 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
Devang Patele9f8f5e2010-05-07 20:54:48 +00002541 const MDNode *PrevScope = NULL;
2542 const MDNode *PrevInlinedAt = NULL;
Devang Pateleac9c072010-04-27 19:46:33 +00002543 const MachineInstr *RangeBeginMI = NULL;
2544 const MachineInstr *PrevMI = NULL;
Chris Lattnerd38fee82010-04-05 00:13:49 +00002545 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
Devang Patelaf9e8472009-10-01 20:31:14 +00002546 I != E; ++I) {
2547 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2548 II != IE; ++II) {
2549 const MachineInstr *MInsn = II;
Devang Patele9f8f5e2010-05-07 20:54:48 +00002550 const MDNode *Scope = NULL;
2551 const MDNode *InlinedAt = NULL;
Devang Pateleac9c072010-04-27 19:46:33 +00002552
2553 // Check if instruction has valid location information.
2554 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2555 PrevMI = MInsn;
2556 continue;
2557 }
Chris Lattnerde4845c2010-04-02 19:42:39 +00002558
Devang Pateleac9c072010-04-27 19:46:33 +00002559 // If scope has not changed then skip this instruction.
2560 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2561 PrevMI = MInsn;
2562 continue;
2563 }
2564
2565 if (RangeBeginMI) {
2566 // If we have alread seen a beginning of a instruction range and
2567 // current instruction scope does not match scope of first instruction
2568 // in this range then create a new instruction range.
2569 DbgRange R(RangeBeginMI, PrevMI);
Devang Patel61409622010-07-07 20:12:52 +00002570 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2571 PrevInlinedAt);
Devang Pateleac9c072010-04-27 19:46:33 +00002572 MIRanges.push_back(R);
2573 }
2574
2575 // This is a beginning of a new instruction range.
2576 RangeBeginMI = MInsn;
Chris Lattnerde4845c2010-04-02 19:42:39 +00002577
Devang Pateleac9c072010-04-27 19:46:33 +00002578 // Reset previous markers.
2579 PrevMI = MInsn;
2580 PrevScope = Scope;
2581 PrevInlinedAt = InlinedAt;
Devang Patel53bb5c92009-11-10 23:06:00 +00002582 }
2583 }
2584
Devang Pateleac9c072010-04-27 19:46:33 +00002585 // Create last instruction range.
2586 if (RangeBeginMI && PrevMI && PrevScope) {
2587 DbgRange R(RangeBeginMI, PrevMI);
2588 MIRanges.push_back(R);
2589 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
Devang Patelaf9e8472009-10-01 20:31:14 +00002590 }
Devang Pateleac9c072010-04-27 19:46:33 +00002591
Devang Patel344130e2010-01-04 20:44:00 +00002592 if (!CurrentFnDbgScope)
2593 return false;
2594
Devang Pateleac9c072010-04-27 19:46:33 +00002595 calculateDominanceGraph(CurrentFnDbgScope);
2596 if (PrintDbgScope)
2597 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2598
2599 // Find ranges of instructions covered by each DbgScope;
2600 DbgScope *PrevDbgScope = NULL;
2601 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2602 RE = MIRanges.end(); RI != RE; ++RI) {
2603 const DbgRange &R = *RI;
2604 DbgScope *S = MI2ScopeMap.lookup(R.first);
2605 assert (S && "Lost DbgScope for a machine instruction!");
2606 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2607 PrevDbgScope->closeInsnRange(S);
2608 S->openInsnRange(R.first);
2609 S->extendInsnRange(R.second);
2610 PrevDbgScope = S;
2611 }
2612
2613 if (PrevDbgScope)
2614 PrevDbgScope->closeInsnRange();
Devang Patelaf9e8472009-10-01 20:31:14 +00002615
Devang Patele37b0c62010-04-08 18:43:56 +00002616 identifyScopeMarkers();
Devang Patel6122a4d2010-04-08 15:37:09 +00002617
2618 return !DbgScopeMap.empty();
2619}
2620
Devang Pateleac9c072010-04-27 19:46:33 +00002621/// identifyScopeMarkers() -
2622/// Each DbgScope has first instruction and last instruction to mark beginning
2623/// and end of a scope respectively. Create an inverse map that list scopes
2624/// starts (and ends) with an instruction. One instruction may start (or end)
2625/// multiple scopes. Ignore scopes that are not reachable.
Devang Patele37b0c62010-04-08 18:43:56 +00002626void DwarfDebug::identifyScopeMarkers() {
Devang Patel42aafd72010-01-20 02:05:23 +00002627 SmallVector<DbgScope *, 4> WorkList;
2628 WorkList.push_back(CurrentFnDbgScope);
2629 while (!WorkList.empty()) {
Chris Lattner14d750d2010-03-31 05:39:57 +00002630 DbgScope *S = WorkList.pop_back_val();
Devang Pateleac9c072010-04-27 19:46:33 +00002631
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002632 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
Devang Patel42aafd72010-01-20 02:05:23 +00002633 if (!Children.empty())
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002634 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
Devang Patel42aafd72010-01-20 02:05:23 +00002635 SE = Children.end(); SI != SE; ++SI)
2636 WorkList.push_back(*SI);
2637
Devang Patel53bb5c92009-11-10 23:06:00 +00002638 if (S->isAbstractScope())
2639 continue;
Devang Pateleac9c072010-04-27 19:46:33 +00002640
2641 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2642 if (Ranges.empty())
2643 continue;
2644 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2645 RE = Ranges.end(); RI != RE; ++RI) {
Devang Patel461a6462010-05-19 21:58:28 +00002646 assert(RI->first && "DbgRange does not have first instruction!");
2647 assert(RI->second && "DbgRange does not have second instruction!");
Devang Pateleac9c072010-04-27 19:46:33 +00002648 InsnsEndScopeSet.insert(RI->second);
2649 }
Devang Patelaf9e8472009-10-01 20:31:14 +00002650 }
Devang Patelaf9e8472009-10-01 20:31:14 +00002651}
2652
Dan Gohman084751c2010-04-20 00:37:27 +00002653/// FindFirstDebugLoc - Find the first debug location in the function. This
2654/// is intended to be an approximation for the source position of the
2655/// beginning of the function.
2656static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2657 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2658 I != E; ++I)
2659 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2660 MBBI != MBBE; ++MBBI) {
2661 DebugLoc DL = MBBI->getDebugLoc();
2662 if (!DL.isUnknown())
2663 return DL;
2664 }
2665 return DebugLoc();
2666}
2667
Devang Patel2c4ceb12009-11-21 02:48:08 +00002668/// beginFunction - Gather pre-function debug information. Assumes being
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002669/// emitted immediately after the function entry point.
Chris Lattnereec791a2010-01-26 23:18:02 +00002670void DwarfDebug::beginFunction(const MachineFunction *MF) {
Chris Lattner994cb122010-04-05 03:52:55 +00002671 if (!MMI->hasDebugInfo()) return;
Bill Wendling5f017e82010-04-07 09:28:04 +00002672 if (!extractScopeInformation()) return;
Devang Patel60b35bd2009-10-06 18:37:31 +00002673
Devang Pateleac9c072010-04-27 19:46:33 +00002674 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2675 Asm->getFunctionNumber());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002676 // Assumes in correct section after the entry point.
Devang Pateleac9c072010-04-27 19:46:33 +00002677 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002678
2679 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2680 // function.
Dan Gohman084751c2010-04-20 00:37:27 +00002681 DebugLoc FDL = FindFirstDebugLoc(MF);
Chris Lattnerde4845c2010-04-02 19:42:39 +00002682 if (FDL.isUnknown()) return;
2683
Devang Patele9f8f5e2010-05-07 20:54:48 +00002684 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
Chris Lattnerde4845c2010-04-02 19:42:39 +00002685
2686 DISubprogram SP = getDISubprogram(Scope);
2687 unsigned Line, Col;
2688 if (SP.Verify()) {
2689 Line = SP.getLineNumber();
2690 Col = 0;
2691 } else {
2692 Line = FDL.getLine();
2693 Col = FDL.getCol();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002694 }
Chris Lattnerde4845c2010-04-02 19:42:39 +00002695
Stuart Hastings99cfb692010-07-08 23:25:39 +00002696 recordSourceLine(Line, Col, Scope);
Devang Patelb2b31a62010-05-26 19:37:24 +00002697
Devang Patelb9abe9f2010-06-02 16:42:51 +00002698 /// ProcessedArgs - Collection of arguments already processed.
2699 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2700
Devang Patelb2b31a62010-05-26 19:37:24 +00002701 DebugLoc PrevLoc;
2702 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2703 I != E; ++I)
2704 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2705 II != IE; ++II) {
2706 const MachineInstr *MI = II;
2707 DebugLoc DL = MI->getDebugLoc();
2708 if (MI->isDebugValue()) {
Devang Patelb2b31a62010-05-26 19:37:24 +00002709 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2710 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2711 if (!DV.Verify()) continue;
Devang Patel55e97172010-05-27 16:47:30 +00002712 // If DBG_VALUE is for a local variable then it needs a label.
Devang Patel7fb231c2010-07-01 21:38:08 +00002713 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2714 && isDbgValueInUndefinedReg(MI) == false)
Devang Patelb2b31a62010-05-26 19:37:24 +00002715 InsnNeedsLabel.insert(MI);
Devang Patel55e97172010-05-27 16:47:30 +00002716 // DBG_VALUE for inlined functions argument needs a label.
Devang Patel7fb231c2010-07-01 21:38:08 +00002717 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2718 describes(MF->getFunction()))
Devang Patel55e97172010-05-27 16:47:30 +00002719 InsnNeedsLabel.insert(MI);
2720 // DBG_VALUE indicating argument location change needs a label.
Devang Patel486ca762010-06-24 21:51:19 +00002721 else if (isDbgValueInUndefinedReg(MI) == false && !ProcessedArgs.insert(DV))
Devang Patelb2b31a62010-05-26 19:37:24 +00002722 InsnNeedsLabel.insert(MI);
2723 } else {
2724 // If location is unknown then instruction needs a location only if
2725 // UnknownLocations flag is set.
2726 if (DL.isUnknown()) {
2727 if (UnknownLocations && !PrevLoc.isUnknown())
2728 InsnNeedsLabel.insert(MI);
2729 } else if (DL != PrevLoc)
2730 // Otherwise, instruction needs a location only if it is new location.
2731 InsnNeedsLabel.insert(MI);
2732 }
2733
2734 if (!DL.isUnknown() || UnknownLocations)
2735 PrevLoc = DL;
2736 }
2737
2738 PrevLabel = FunctionBeginSym;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002739}
2740
Devang Patel2c4ceb12009-11-21 02:48:08 +00002741/// endFunction - Gather and emit post-function debug information.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002742///
Chris Lattnereec791a2010-01-26 23:18:02 +00002743void DwarfDebug::endFunction(const MachineFunction *MF) {
Bill Wendling5f017e82010-04-07 09:28:04 +00002744 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
Devang Patel70d75ca2009-11-12 19:02:56 +00002745
Devang Patel344130e2010-01-04 20:44:00 +00002746 if (CurrentFnDbgScope) {
Devang Patel65eb4822010-05-22 00:04:14 +00002747
Devang Patelc3f5f782010-05-25 23:40:22 +00002748 // Define end label for subprogram.
2749 FunctionEndSym = Asm->GetTempSymbol("func_end",
2750 Asm->getFunctionNumber());
2751 // Assumes in correct section after the entry point.
2752 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2753
Devang Patel78e127d2010-06-25 22:07:34 +00002754 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2755 collectVariableInfo(MF, ProcessedVars);
Devang Patel65eb4822010-05-22 00:04:14 +00002756
Devang Patel344130e2010-01-04 20:44:00 +00002757 // Get function line info.
2758 if (!Lines.empty()) {
2759 // Get section line info.
2760 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2761 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2762 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2763 // Append the function info to section info.
2764 SectionLineInfos.insert(SectionLineInfos.end(),
2765 Lines.begin(), Lines.end());
2766 }
2767
2768 // Construct abstract scopes.
2769 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
Devang Patel78e127d2010-06-25 22:07:34 +00002770 AE = AbstractScopesList.end(); AI != AE; ++AI) {
Devang Patel78e127d2010-06-25 22:07:34 +00002771 DISubprogram SP((*AI)->getScopeNode());
2772 if (SP.Verify()) {
2773 // Collect info for variables that were optimized out.
2774 StringRef FName = SP.getLinkageName();
2775 if (FName.empty())
2776 FName = SP.getName();
2777 const Module *M = MF->getFunction()->getParent();
2778 if (NamedMDNode *NMD =
2779 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2780 getRealLinkageName(FName)))) {
2781 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2782 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2783 if (!DV || !ProcessedVars.insert(DV))
2784 continue;
Devang Patel1d68d212010-06-30 00:11:08 +00002785 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
Devang Patel78e127d2010-06-25 22:07:34 +00002786 if (Scope)
2787 Scope->addVariable(new DbgVariable(DV));
2788 }
2789 }
2790 }
Devang Patel90e19aa2010-06-30 01:40:11 +00002791 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2792 constructScopeDIE(*AI);
Devang Patel78e127d2010-06-25 22:07:34 +00002793 }
Devang Patel61409622010-07-07 20:12:52 +00002794
Devang Patel9c488372010-05-04 06:15:30 +00002795 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
Devang Patel344130e2010-01-04 20:44:00 +00002796
Devang Patel9c488372010-05-04 06:15:30 +00002797 if (!DisableFramePointerElim(*MF))
2798 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2799 dwarf::DW_FORM_flag, 1);
2800
2801
Chris Lattnerd38fee82010-04-05 00:13:49 +00002802 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
Devang Patel344130e2010-01-04 20:44:00 +00002803 MMI->getFrameMoves()));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002804 }
2805
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002806 // Clear debug info
Devang Patelf54b8522010-01-19 01:26:02 +00002807 CurrentFnDbgScope = NULL;
Devang Patelb2b31a62010-05-26 19:37:24 +00002808 InsnNeedsLabel.clear();
Devang Patel26c1e562010-05-20 16:36:41 +00002809 DbgVariableToFrameIndexMap.clear();
2810 VarToAbstractVarMap.clear();
2811 DbgVariableToDbgInstMap.clear();
2812 DbgVariableLabelsMap.clear();
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002813 DeleteContainerSeconds(DbgScopeMap);
Devang Patel51424712010-04-09 16:04:20 +00002814 InsnsEndScopeSet.clear();
Devang Patelf54b8522010-01-19 01:26:02 +00002815 ConcreteScopes.clear();
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002816 DeleteContainerSeconds(AbstractScopes);
Devang Patelf54b8522010-01-19 01:26:02 +00002817 AbstractScopesList.clear();
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002818 AbstractVariables.clear();
Devang Pateleac9c072010-04-27 19:46:33 +00002819 LabelsBeforeInsn.clear();
2820 LabelsAfterInsn.clear();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002821 Lines.clear();
Devang Patelf2548ca2010-04-16 23:33:45 +00002822 PrevLabel = NULL;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002823}
2824
Devang Patel26c1e562010-05-20 16:36:41 +00002825/// recordVariableFrameIndex - Record a variable's index.
2826void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2827 assert (V && "Invalid DbgVariable!");
2828 DbgVariableToFrameIndexMap[V] = Index;
2829}
2830
2831/// findVariableFrameIndex - Return true if frame index for the variable
2832/// is found. Update FI to hold value of the index.
2833bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2834 assert (V && "Invalid DbgVariable!");
2835 DenseMap<const DbgVariable *, int>::iterator I =
2836 DbgVariableToFrameIndexMap.find(V);
2837 if (I == DbgVariableToFrameIndexMap.end())
2838 return false;
2839 *FI = I->second;
2840 return true;
2841}
2842
2843/// findVariableLabel - Find MCSymbol for the variable.
2844const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2845 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2846 = DbgVariableLabelsMap.find(V);
2847 if (I == DbgVariableLabelsMap.end())
2848 return NULL;
2849 else return I->second;
2850}
2851
Devang Patelee432862010-05-20 19:57:06 +00002852/// findDbgScope - Find DbgScope for the debug loc attached with an
2853/// instruction.
2854DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2855 DbgScope *Scope = NULL;
2856 LLVMContext &Ctx =
2857 MInsn->getParent()->getParent()->getFunction()->getContext();
2858 DebugLoc DL = MInsn->getDebugLoc();
2859
2860 if (DL.isUnknown())
2861 return Scope;
2862
2863 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2864 Scope = ConcreteScopes.lookup(IA);
2865 if (Scope == 0)
2866 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2867
2868 return Scope;
2869}
2870
2871
Chris Lattnerc6087842010-03-09 04:54:43 +00002872/// recordSourceLine - Register a source line with debug info. Returns the
2873/// unique label that was emitted and which provides correspondence to
2874/// the source line list.
Devang Patel61409622010-07-07 20:12:52 +00002875MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2876 const MDNode *S) {
Devang Patel65dbc902009-11-25 17:36:49 +00002877 StringRef Dir;
2878 StringRef Fn;
Devang Patelf84548d2009-10-05 18:03:19 +00002879
Dan Gohman1cc0d622010-05-05 23:41:32 +00002880 unsigned Src = 1;
2881 if (S) {
2882 DIDescriptor Scope(S);
Devang Patelf84548d2009-10-05 18:03:19 +00002883
Dan Gohman1cc0d622010-05-05 23:41:32 +00002884 if (Scope.isCompileUnit()) {
2885 DICompileUnit CU(S);
2886 Dir = CU.getDirectory();
2887 Fn = CU.getFilename();
2888 } else if (Scope.isSubprogram()) {
2889 DISubprogram SP(S);
2890 Dir = SP.getDirectory();
2891 Fn = SP.getFilename();
2892 } else if (Scope.isLexicalBlock()) {
2893 DILexicalBlock DB(S);
2894 Dir = DB.getDirectory();
2895 Fn = DB.getFilename();
2896 } else
2897 assert(0 && "Unexpected scope info");
2898
2899 Src = GetOrCreateSourceID(Dir, Fn);
2900 }
2901
Stuart Hastings99cfb692010-07-08 23:25:39 +00002902#if 0
2903 if (!Lines.empty()) {
2904 SrcLineInfo lastSrcLineInfo = Lines.back();
2905 // Emitting sequential line records with the same line number (but
2906 // different addresses) seems to confuse GDB. Avoid this.
2907 if (lastSrcLineInfo.getLine() == Line)
2908 return NULL;
2909 }
2910#endif
2911
Chris Lattner63d78362010-03-14 08:36:50 +00002912 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
Chris Lattner25b68c62010-03-14 08:15:55 +00002913 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002914
Chris Lattnerc6087842010-03-09 04:54:43 +00002915 Asm->OutStreamer.EmitLabel(Label);
2916 return Label;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002917}
2918
Bill Wendling829e67b2009-05-20 23:22:40 +00002919//===----------------------------------------------------------------------===//
2920// Emit Methods
2921//===----------------------------------------------------------------------===//
2922
Devang Patel2c4ceb12009-11-21 02:48:08 +00002923/// computeSizeAndOffset - Compute the size and offset of a DIE.
Bill Wendling94d04b82009-05-20 23:21:38 +00002924///
Jim Grosbach7ab38df2009-11-22 19:20:36 +00002925unsigned
2926DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
Bill Wendling94d04b82009-05-20 23:21:38 +00002927 // Get the children.
2928 const std::vector<DIE *> &Children = Die->getChildren();
2929
2930 // If not last sibling and has children then add sibling offset attribute.
Jeffrey Yasskin638fe8d2010-03-22 18:47:14 +00002931 if (!Last && !Children.empty())
Benjamin Kramer345ef342010-03-31 19:34:01 +00002932 Die->addSiblingOffset(DIEValueAllocator);
Bill Wendling94d04b82009-05-20 23:21:38 +00002933
2934 // Record the abbreviation.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002935 assignAbbrevNumber(Die->getAbbrev());
Bill Wendling94d04b82009-05-20 23:21:38 +00002936
2937 // Get the abbreviation for this DIE.
2938 unsigned AbbrevNumber = Die->getAbbrevNumber();
2939 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2940
2941 // Set DIE offset
2942 Die->setOffset(Offset);
2943
2944 // Start the size with the size of abbreviation code.
Chris Lattneraf76e592009-08-22 20:48:53 +00002945 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
Bill Wendling94d04b82009-05-20 23:21:38 +00002946
2947 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2948 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2949
2950 // Size the DIE attribute values.
2951 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2952 // Size attribute value.
Chris Lattnera37d5382010-04-05 00:18:22 +00002953 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
Bill Wendling94d04b82009-05-20 23:21:38 +00002954
2955 // Size the DIE children if any.
2956 if (!Children.empty()) {
2957 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2958 "Children flag not set");
2959
2960 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel2c4ceb12009-11-21 02:48:08 +00002961 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
Bill Wendling94d04b82009-05-20 23:21:38 +00002962
2963 // End of children marker.
2964 Offset += sizeof(int8_t);
2965 }
2966
2967 Die->setSize(Offset - Die->getOffset());
2968 return Offset;
2969}
2970
Devang Patel2c4ceb12009-11-21 02:48:08 +00002971/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
Bill Wendling94d04b82009-05-20 23:21:38 +00002972///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002973void DwarfDebug::computeSizeAndOffsets() {
Devang Patel163a9f72010-05-10 22:49:55 +00002974 unsigned PrevOffset = 0;
2975 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2976 E = CUMap.end(); I != E; ++I) {
2977 // Compute size of compile unit header.
2978 static unsigned Offset = PrevOffset +
2979 sizeof(int32_t) + // Length of Compilation Unit Info
2980 sizeof(int16_t) + // DWARF version number
2981 sizeof(int32_t) + // Offset Into Abbrev. Section
2982 sizeof(int8_t); // Pointer Size (in bytes)
2983 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2984 PrevOffset = Offset;
2985 }
Bill Wendling94d04b82009-05-20 23:21:38 +00002986}
2987
Chris Lattner11b8f302010-04-04 23:02:02 +00002988/// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2989/// temporary label to it if SymbolStem is specified.
Chris Lattner9c69e285532010-04-04 22:59:04 +00002990static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
Chris Lattner11b8f302010-04-04 23:02:02 +00002991 const char *SymbolStem = 0) {
Chris Lattner9c69e285532010-04-04 22:59:04 +00002992 Asm->OutStreamer.SwitchSection(Section);
Chris Lattner11b8f302010-04-04 23:02:02 +00002993 if (!SymbolStem) return 0;
2994
Chris Lattner9c69e285532010-04-04 22:59:04 +00002995 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2996 Asm->OutStreamer.EmitLabel(TmpSym);
2997 return TmpSym;
2998}
2999
3000/// EmitSectionLabels - Emit initial Dwarf sections with a label at
3001/// the start of each one.
Chris Lattnerfa070b02010-04-04 22:33:59 +00003002void DwarfDebug::EmitSectionLabels() {
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003003 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarf612ff62009-09-19 20:40:05 +00003004
Bill Wendling94d04b82009-05-20 23:21:38 +00003005 // Dwarf sections base addresses.
Chris Lattnerd38fee82010-04-05 00:13:49 +00003006 if (Asm->MAI->doesDwarfRequireFrameSection()) {
Chris Lattner9c69e285532010-04-04 22:59:04 +00003007 DwarfFrameSectionSym =
3008 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3009 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003010
Chris Lattner9c69e285532010-04-04 22:59:04 +00003011 DwarfInfoSectionSym =
3012 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3013 DwarfAbbrevSectionSym =
3014 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
Chris Lattner11b8f302010-04-04 23:02:02 +00003015 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
Chris Lattner9c69e285532010-04-04 22:59:04 +00003016
3017 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
Chris Lattner11b8f302010-04-04 23:02:02 +00003018 EmitSectionSym(Asm, MacroInfo);
Bill Wendling94d04b82009-05-20 23:21:38 +00003019
Devang Patel1e4782d2010-06-29 20:17:53 +00003020 DwarfDebugLineSectionSym =
3021 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
Chris Lattner11b8f302010-04-04 23:02:02 +00003022 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3023 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3024 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
Chris Lattner9c69e285532010-04-04 22:59:04 +00003025 DwarfStrSectionSym =
3026 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
Devang Patelf2548ca2010-04-16 23:33:45 +00003027 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3028 "debug_range");
Bill Wendling94d04b82009-05-20 23:21:38 +00003029
Devang Patelc3f5f782010-05-25 23:40:22 +00003030 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3031 "section_debug_loc");
3032
Chris Lattner9c69e285532010-04-04 22:59:04 +00003033 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
Chris Lattner4ad1efe2010-04-04 23:10:38 +00003034 EmitSectionSym(Asm, TLOF.getDataSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003035}
3036
Devang Patel2c4ceb12009-11-21 02:48:08 +00003037/// emitDIE - Recusively Emits a debug information entry.
Bill Wendling94d04b82009-05-20 23:21:38 +00003038///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003039void DwarfDebug::emitDIE(DIE *Die) {
Bill Wendling94d04b82009-05-20 23:21:38 +00003040 // Get the abbreviation for this DIE.
3041 unsigned AbbrevNumber = Die->getAbbrevNumber();
3042 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3043
Bill Wendling94d04b82009-05-20 23:21:38 +00003044 // Emit the code (index) for the abbreviation.
Chris Lattner3f53c832010-04-04 18:52:31 +00003045 if (Asm->isVerbose())
Chris Lattner894d75a2010-01-22 23:18:42 +00003046 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3047 Twine::utohexstr(Die->getOffset()) + ":0x" +
3048 Twine::utohexstr(Die->getSize()) + " " +
3049 dwarf::TagString(Abbrev->getTag()));
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003050 Asm->EmitULEB128(AbbrevNumber);
Bill Wendling94d04b82009-05-20 23:21:38 +00003051
Jeffrey Yasskin638fe8d2010-03-22 18:47:14 +00003052 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
Bill Wendling94d04b82009-05-20 23:21:38 +00003053 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3054
3055 // Emit the DIE attribute values.
3056 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3057 unsigned Attr = AbbrevData[i].getAttribute();
3058 unsigned Form = AbbrevData[i].getForm();
3059 assert(Form && "Too many attributes for DIE (check abbreviation)");
3060
Chris Lattner3f53c832010-04-04 18:52:31 +00003061 if (Asm->isVerbose())
Chris Lattnera8013622010-01-24 18:54:17 +00003062 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3063
Bill Wendling94d04b82009-05-20 23:21:38 +00003064 switch (Attr) {
3065 case dwarf::DW_AT_sibling:
Devang Patel2c4ceb12009-11-21 02:48:08 +00003066 Asm->EmitInt32(Die->getSiblingOffset());
Bill Wendling94d04b82009-05-20 23:21:38 +00003067 break;
3068 case dwarf::DW_AT_abstract_origin: {
3069 DIEEntry *E = cast<DIEEntry>(Values[i]);
3070 DIE *Origin = E->getEntry();
Devang Patel53bb5c92009-11-10 23:06:00 +00003071 unsigned Addr = Origin->getOffset();
Bill Wendling94d04b82009-05-20 23:21:38 +00003072 Asm->EmitInt32(Addr);
3073 break;
3074 }
Devang Patelf2548ca2010-04-16 23:33:45 +00003075 case dwarf::DW_AT_ranges: {
3076 // DW_AT_range Value encodes offset in debug_range section.
3077 DIEInteger *V = cast<DIEInteger>(Values[i]);
3078 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3079 V->getValue(),
3080 DwarfDebugRangeSectionSym,
3081 4);
3082 break;
3083 }
Devang Patel1e4782d2010-06-29 20:17:53 +00003084 case dwarf::DW_AT_stmt_list: {
3085 Asm->EmitLabelDifference(CurrentLineSectionSym,
3086 DwarfDebugLineSectionSym, 4);
3087 break;
3088 }
Devang Patelc3f5f782010-05-25 23:40:22 +00003089 case dwarf::DW_AT_location: {
3090 if (UseDotDebugLocEntry.count(Die) != 0) {
3091 DIELabel *L = cast<DIELabel>(Values[i]);
3092 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3093 } else
3094 Values[i]->EmitValue(Asm, Form);
3095 break;
3096 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003097 default:
3098 // Emit an attribute using the defined form.
Chris Lattnerd38fee82010-04-05 00:13:49 +00003099 Values[i]->EmitValue(Asm, Form);
Bill Wendling94d04b82009-05-20 23:21:38 +00003100 break;
3101 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003102 }
3103
3104 // Emit the DIE children if any.
3105 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3106 const std::vector<DIE *> &Children = Die->getChildren();
3107
3108 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel2c4ceb12009-11-21 02:48:08 +00003109 emitDIE(Children[j]);
Bill Wendling94d04b82009-05-20 23:21:38 +00003110
Chris Lattner3f53c832010-04-04 18:52:31 +00003111 if (Asm->isVerbose())
Chris Lattner233f52b2010-03-09 23:52:58 +00003112 Asm->OutStreamer.AddComment("End Of Children Mark");
3113 Asm->EmitInt8(0);
Bill Wendling94d04b82009-05-20 23:21:38 +00003114 }
3115}
3116
Devang Patel8a241142009-12-09 18:24:21 +00003117/// emitDebugInfo - Emit the debug info section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003118///
Devang Patel8a241142009-12-09 18:24:21 +00003119void DwarfDebug::emitDebugInfo() {
3120 // Start debug info section.
3121 Asm->OutStreamer.SwitchSection(
3122 Asm->getObjFileLowering().getDwarfInfoSection());
Devang Patel163a9f72010-05-10 22:49:55 +00003123 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3124 E = CUMap.end(); I != E; ++I) {
3125 CompileUnit *TheCU = I->second;
3126 DIE *Die = TheCU->getCUDie();
3127
3128 // Emit the compile units header.
3129 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3130 TheCU->getID()));
3131
3132 // Emit size of content not including length itself
3133 unsigned ContentSize = Die->getSize() +
3134 sizeof(int16_t) + // DWARF version number
3135 sizeof(int32_t) + // Offset Into Abbrev. Section
3136 sizeof(int8_t) + // Pointer Size (in bytes)
3137 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3138
3139 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3140 Asm->EmitInt32(ContentSize);
3141 Asm->OutStreamer.AddComment("DWARF version number");
3142 Asm->EmitInt16(dwarf::DWARF_VERSION);
3143 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3144 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3145 DwarfAbbrevSectionSym);
3146 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3147 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3148
3149 emitDIE(Die);
3150 // FIXME - extra padding for gdb bug.
3151 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3152 Asm->EmitInt8(0);
3153 Asm->EmitInt8(0);
3154 Asm->EmitInt8(0);
3155 Asm->EmitInt8(0);
3156 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3157 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003158}
3159
Devang Patel2c4ceb12009-11-21 02:48:08 +00003160/// emitAbbreviations - Emit the abbreviation section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003161///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003162void DwarfDebug::emitAbbreviations() const {
Bill Wendling94d04b82009-05-20 23:21:38 +00003163 // Check to see if it is worth the effort.
3164 if (!Abbreviations.empty()) {
3165 // Start the debug abbrev section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003166 Asm->OutStreamer.SwitchSection(
3167 Asm->getObjFileLowering().getDwarfAbbrevSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003168
Chris Lattnerc0215722010-04-04 19:25:43 +00003169 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003170
3171 // For each abbrevation.
3172 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3173 // Get abbreviation data
3174 const DIEAbbrev *Abbrev = Abbreviations[i];
3175
3176 // Emit the abbrevations code (base 1 index.)
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003177 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
Bill Wendling94d04b82009-05-20 23:21:38 +00003178
3179 // Emit the abbreviations data.
Chris Lattnerd38fee82010-04-05 00:13:49 +00003180 Abbrev->Emit(Asm);
Bill Wendling94d04b82009-05-20 23:21:38 +00003181 }
3182
3183 // Mark end of abbreviations.
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003184 Asm->EmitULEB128(0, "EOM(3)");
Bill Wendling94d04b82009-05-20 23:21:38 +00003185
Chris Lattnerc0215722010-04-04 19:25:43 +00003186 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003187 }
3188}
3189
Devang Patel2c4ceb12009-11-21 02:48:08 +00003190/// emitEndOfLineMatrix - Emit the last address of the section and the end of
Bill Wendling94d04b82009-05-20 23:21:38 +00003191/// the line matrix.
3192///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003193void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling94d04b82009-05-20 23:21:38 +00003194 // Define last address of section.
Chris Lattner233f52b2010-03-09 23:52:58 +00003195 Asm->OutStreamer.AddComment("Extended Op");
3196 Asm->EmitInt8(0);
3197
3198 Asm->OutStreamer.AddComment("Op size");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003199 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner233f52b2010-03-09 23:52:58 +00003200 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3201 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3202
3203 Asm->OutStreamer.AddComment("Section end label");
Chris Lattnerd85fc6e2010-03-10 01:17:49 +00003204
Chris Lattnerc0215722010-04-04 19:25:43 +00003205 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
Chris Lattnerd38fee82010-04-05 00:13:49 +00003206 Asm->getTargetData().getPointerSize(),
3207 0/*AddrSpace*/);
Bill Wendling94d04b82009-05-20 23:21:38 +00003208
3209 // Mark end of matrix.
Chris Lattner233f52b2010-03-09 23:52:58 +00003210 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3211 Asm->EmitInt8(0);
Chris Lattner0ad9c912010-01-22 22:09:00 +00003212 Asm->EmitInt8(1);
Chris Lattner894d75a2010-01-22 23:18:42 +00003213 Asm->EmitInt8(1);
Bill Wendling94d04b82009-05-20 23:21:38 +00003214}
3215
Devang Patel2c4ceb12009-11-21 02:48:08 +00003216/// emitDebugLines - Emit source line information.
Bill Wendling94d04b82009-05-20 23:21:38 +00003217///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003218void DwarfDebug::emitDebugLines() {
Bill Wendling94d04b82009-05-20 23:21:38 +00003219 // If the target is using .loc/.file, the assembler will be emitting the
3220 // .debug_line table automatically.
Chris Lattnerd38fee82010-04-05 00:13:49 +00003221 if (Asm->MAI->hasDotLocAndDotFile())
Bill Wendling94d04b82009-05-20 23:21:38 +00003222 return;
3223
3224 // Minimum line delta, thus ranging from -10..(255-10).
3225 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3226 // Maximum line delta, thus ranging from -10..(255-10).
3227 const int MaxLineDelta = 255 + MinLineDelta;
3228
3229 // Start the dwarf line section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003230 Asm->OutStreamer.SwitchSection(
3231 Asm->getObjFileLowering().getDwarfLineSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003232
3233 // Construct the section header.
Devang Patel1e4782d2010-06-29 20:17:53 +00003234 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3235 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
Chris Lattner233f52b2010-03-09 23:52:58 +00003236 Asm->OutStreamer.AddComment("Length of Source Line Info");
Chris Lattnera6437182010-04-04 19:58:12 +00003237 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3238 Asm->GetTempSymbol("line_begin"), 4);
Chris Lattnerc0215722010-04-04 19:25:43 +00003239 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003240
Chris Lattner233f52b2010-03-09 23:52:58 +00003241 Asm->OutStreamer.AddComment("DWARF version number");
3242 Asm->EmitInt16(dwarf::DWARF_VERSION);
Bill Wendling94d04b82009-05-20 23:21:38 +00003243
Chris Lattner233f52b2010-03-09 23:52:58 +00003244 Asm->OutStreamer.AddComment("Prolog Length");
Chris Lattnera6437182010-04-04 19:58:12 +00003245 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3246 Asm->GetTempSymbol("line_prolog_begin"), 4);
Chris Lattnerc0215722010-04-04 19:25:43 +00003247 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003248
Chris Lattner233f52b2010-03-09 23:52:58 +00003249 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3250 Asm->EmitInt8(1);
3251 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3252 Asm->EmitInt8(1);
3253 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3254 Asm->EmitInt8(MinLineDelta);
3255 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3256 Asm->EmitInt8(MaxLineDelta);
3257 Asm->OutStreamer.AddComment("Special Opcode Base");
3258 Asm->EmitInt8(-MinLineDelta);
Bill Wendling94d04b82009-05-20 23:21:38 +00003259
3260 // Line number standard opcode encodings argument count
Chris Lattner233f52b2010-03-09 23:52:58 +00003261 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3262 Asm->EmitInt8(0);
3263 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3264 Asm->EmitInt8(1);
3265 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3266 Asm->EmitInt8(1);
3267 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3268 Asm->EmitInt8(1);
3269 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3270 Asm->EmitInt8(1);
3271 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3272 Asm->EmitInt8(0);
3273 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3274 Asm->EmitInt8(0);
3275 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3276 Asm->EmitInt8(0);
3277 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3278 Asm->EmitInt8(1);
Bill Wendling94d04b82009-05-20 23:21:38 +00003279
3280 // Emit directories.
3281 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
Chris Lattner4cf202b2010-01-23 03:11:46 +00003282 const std::string &Dir = getSourceDirectoryName(DI);
Chris Lattner3f53c832010-04-04 18:52:31 +00003283 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
Chris Lattner4cf202b2010-01-23 03:11:46 +00003284 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
Bill Wendling94d04b82009-05-20 23:21:38 +00003285 }
3286
Chris Lattner233f52b2010-03-09 23:52:58 +00003287 Asm->OutStreamer.AddComment("End of directories");
3288 Asm->EmitInt8(0);
Bill Wendling94d04b82009-05-20 23:21:38 +00003289
3290 // Emit files.
3291 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3292 // Remember source id starts at 1.
3293 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
Chris Lattner4cf202b2010-01-23 03:11:46 +00003294 const std::string &FN = getSourceFileName(Id.second);
Chris Lattner3f53c832010-04-04 18:52:31 +00003295 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
Chris Lattner4cf202b2010-01-23 03:11:46 +00003296 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3297
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003298 Asm->EmitULEB128(Id.first, "Directory #");
3299 Asm->EmitULEB128(0, "Mod date");
3300 Asm->EmitULEB128(0, "File size");
Bill Wendling94d04b82009-05-20 23:21:38 +00003301 }
3302
Chris Lattner233f52b2010-03-09 23:52:58 +00003303 Asm->OutStreamer.AddComment("End of files");
3304 Asm->EmitInt8(0);
Bill Wendling94d04b82009-05-20 23:21:38 +00003305
Chris Lattnerc0215722010-04-04 19:25:43 +00003306 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003307
3308 // A sequence for each text section.
3309 unsigned SecSrcLinesSize = SectionSourceLines.size();
3310
3311 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3312 // Isolate current sections line info.
3313 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3314
Bill Wendling94d04b82009-05-20 23:21:38 +00003315 // Dwarf assumes we start with first line of first source file.
3316 unsigned Source = 1;
3317 unsigned Line = 1;
3318
3319 // Construct rows of the address, source, line, column matrix.
3320 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3321 const SrcLineInfo &LineInfo = LineInfos[i];
Chris Lattner25b68c62010-03-14 08:15:55 +00003322 MCSymbol *Label = LineInfo.getLabel();
Chris Lattnerb9130602010-03-14 02:20:58 +00003323 if (!Label->isDefined()) continue; // Not emitted, in dead code.
Bill Wendling94d04b82009-05-20 23:21:38 +00003324
Chris Lattner0d9d70f2010-03-09 23:38:23 +00003325 if (Asm->isVerbose()) {
Chris Lattner188a87d2010-03-10 01:04:13 +00003326 std::pair<unsigned, unsigned> SrcID =
Bill Wendling94d04b82009-05-20 23:21:38 +00003327 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
Chris Lattner188a87d2010-03-10 01:04:13 +00003328 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
Chris Lattner49f618a2010-03-10 02:29:31 +00003329 "/" +
3330 Twine(getSourceFileName(SrcID.second)) +
Chris Lattner188a87d2010-03-10 01:04:13 +00003331 ":" + Twine(LineInfo.getLine()));
Bill Wendling94d04b82009-05-20 23:21:38 +00003332 }
3333
3334 // Define the line address.
Chris Lattner233f52b2010-03-09 23:52:58 +00003335 Asm->OutStreamer.AddComment("Extended Op");
3336 Asm->EmitInt8(0);
3337 Asm->OutStreamer.AddComment("Op size");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003338 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner233f52b2010-03-09 23:52:58 +00003339
3340 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3341 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3342
3343 Asm->OutStreamer.AddComment("Location label");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003344 Asm->OutStreamer.EmitSymbolValue(Label,
3345 Asm->getTargetData().getPointerSize(),
Chris Lattnerb9130602010-03-14 02:20:58 +00003346 0/*AddrSpace*/);
Chris Lattnerd85fc6e2010-03-10 01:17:49 +00003347
Bill Wendling94d04b82009-05-20 23:21:38 +00003348 // If change of source, then switch to the new source.
3349 if (Source != LineInfo.getSourceID()) {
3350 Source = LineInfo.getSourceID();
Chris Lattner233f52b2010-03-09 23:52:58 +00003351 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3352 Asm->EmitInt8(dwarf::DW_LNS_set_file);
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003353 Asm->EmitULEB128(Source, "New Source");
Bill Wendling94d04b82009-05-20 23:21:38 +00003354 }
3355
3356 // If change of line.
3357 if (Line != LineInfo.getLine()) {
3358 // Determine offset.
3359 int Offset = LineInfo.getLine() - Line;
3360 int Delta = Offset - MinLineDelta;
3361
3362 // Update line.
3363 Line = LineInfo.getLine();
3364
3365 // If delta is small enough and in range...
3366 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3367 // ... then use fast opcode.
Chris Lattner233f52b2010-03-09 23:52:58 +00003368 Asm->OutStreamer.AddComment("Line Delta");
3369 Asm->EmitInt8(Delta - MinLineDelta);
Bill Wendling94d04b82009-05-20 23:21:38 +00003370 } else {
3371 // ... otherwise use long hand.
Chris Lattner233f52b2010-03-09 23:52:58 +00003372 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
Bill Wendling94d04b82009-05-20 23:21:38 +00003373 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003374 Asm->EmitSLEB128(Offset, "Line Offset");
Chris Lattner233f52b2010-03-09 23:52:58 +00003375 Asm->OutStreamer.AddComment("DW_LNS_copy");
3376 Asm->EmitInt8(dwarf::DW_LNS_copy);
Bill Wendling94d04b82009-05-20 23:21:38 +00003377 }
3378 } else {
3379 // Copy the previous row (different address or source)
Chris Lattner233f52b2010-03-09 23:52:58 +00003380 Asm->OutStreamer.AddComment("DW_LNS_copy");
3381 Asm->EmitInt8(dwarf::DW_LNS_copy);
Bill Wendling94d04b82009-05-20 23:21:38 +00003382 }
3383 }
3384
Devang Patel2c4ceb12009-11-21 02:48:08 +00003385 emitEndOfLineMatrix(j + 1);
Bill Wendling94d04b82009-05-20 23:21:38 +00003386 }
3387
3388 if (SecSrcLinesSize == 0)
3389 // Because we're emitting a debug_line section, we still need a line
3390 // table. The linker and friends expect it to exist. If there's nothing to
3391 // put into it, emit an empty table.
Devang Patel2c4ceb12009-11-21 02:48:08 +00003392 emitEndOfLineMatrix(1);
Bill Wendling94d04b82009-05-20 23:21:38 +00003393
Chris Lattnerc0215722010-04-04 19:25:43 +00003394 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003395}
3396
Devang Patel2c4ceb12009-11-21 02:48:08 +00003397/// emitCommonDebugFrame - Emit common frame info into a debug frame section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003398///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003399void DwarfDebug::emitCommonDebugFrame() {
Chris Lattnerd38fee82010-04-05 00:13:49 +00003400 if (!Asm->MAI->doesDwarfRequireFrameSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00003401 return;
3402
Chris Lattnerd38fee82010-04-05 00:13:49 +00003403 int stackGrowth = Asm->getTargetData().getPointerSize();
3404 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3405 TargetFrameInfo::StackGrowsDown)
3406 stackGrowth *= -1;
Bill Wendling94d04b82009-05-20 23:21:38 +00003407
3408 // Start the dwarf frame section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003409 Asm->OutStreamer.SwitchSection(
3410 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003411
Chris Lattnerc0215722010-04-04 19:25:43 +00003412 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
Chris Lattner233f52b2010-03-09 23:52:58 +00003413 Asm->OutStreamer.AddComment("Length of Common Information Entry");
Chris Lattnera6437182010-04-04 19:58:12 +00003414 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3415 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
Bill Wendling94d04b82009-05-20 23:21:38 +00003416
Chris Lattnerc0215722010-04-04 19:25:43 +00003417 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
Chris Lattner233f52b2010-03-09 23:52:58 +00003418 Asm->OutStreamer.AddComment("CIE Identifier Tag");
Bill Wendling94d04b82009-05-20 23:21:38 +00003419 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
Chris Lattner233f52b2010-03-09 23:52:58 +00003420 Asm->OutStreamer.AddComment("CIE Version");
Bill Wendling94d04b82009-05-20 23:21:38 +00003421 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
Chris Lattner233f52b2010-03-09 23:52:58 +00003422 Asm->OutStreamer.AddComment("CIE Augmentation");
Chris Lattner4cf202b2010-01-23 03:11:46 +00003423 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003424 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3425 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
Chris Lattner233f52b2010-03-09 23:52:58 +00003426 Asm->OutStreamer.AddComment("CIE RA Column");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003427 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Bill Wendling94d04b82009-05-20 23:21:38 +00003428 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
Bill Wendling94d04b82009-05-20 23:21:38 +00003429
3430 std::vector<MachineMove> Moves;
3431 RI->getInitialFrameState(Moves);
3432
Chris Lattner02b86b92010-04-04 23:41:46 +00003433 Asm->EmitFrameMoves(Moves, 0, false);
Bill Wendling94d04b82009-05-20 23:21:38 +00003434
Chris Lattner059ea132010-04-28 01:05:45 +00003435 Asm->EmitAlignment(2);
Chris Lattnerc0215722010-04-04 19:25:43 +00003436 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003437}
3438
Devang Patel2c4ceb12009-11-21 02:48:08 +00003439/// emitFunctionDebugFrame - Emit per function frame info into a debug frame
Bill Wendling94d04b82009-05-20 23:21:38 +00003440/// section.
Chris Lattner206d61e2010-03-13 07:26:18 +00003441void DwarfDebug::
3442emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
Chris Lattnerd38fee82010-04-05 00:13:49 +00003443 if (!Asm->MAI->doesDwarfRequireFrameSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00003444 return;
3445
3446 // Start the dwarf frame section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003447 Asm->OutStreamer.SwitchSection(
3448 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003449
Chris Lattner233f52b2010-03-09 23:52:58 +00003450 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
Chris Lattner206d61e2010-03-13 07:26:18 +00003451 MCSymbol *DebugFrameBegin =
Chris Lattnerc0215722010-04-04 19:25:43 +00003452 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
Chris Lattner206d61e2010-03-13 07:26:18 +00003453 MCSymbol *DebugFrameEnd =
Chris Lattnerc0215722010-04-04 19:25:43 +00003454 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
Chris Lattnera6437182010-04-04 19:58:12 +00003455 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
Bill Wendling94d04b82009-05-20 23:21:38 +00003456
Chris Lattner206d61e2010-03-13 07:26:18 +00003457 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
Bill Wendling94d04b82009-05-20 23:21:38 +00003458
Chris Lattner233f52b2010-03-09 23:52:58 +00003459 Asm->OutStreamer.AddComment("FDE CIE offset");
Chris Lattner6189ed12010-04-04 23:25:33 +00003460 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3461 DwarfFrameSectionSym);
Bill Wendling94d04b82009-05-20 23:21:38 +00003462
Chris Lattner233f52b2010-03-09 23:52:58 +00003463 Asm->OutStreamer.AddComment("FDE initial location");
Chris Lattnerc0215722010-04-04 19:25:43 +00003464 MCSymbol *FuncBeginSym =
3465 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
Chris Lattnerfb658072010-03-13 07:40:56 +00003466 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
Chris Lattnerd38fee82010-04-05 00:13:49 +00003467 Asm->getTargetData().getPointerSize(),
3468 0/*AddrSpace*/);
Chris Lattnerd85fc6e2010-03-10 01:17:49 +00003469
3470
Chris Lattner233f52b2010-03-09 23:52:58 +00003471 Asm->OutStreamer.AddComment("FDE address range");
Chris Lattnera6437182010-04-04 19:58:12 +00003472 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
Chris Lattnerd38fee82010-04-05 00:13:49 +00003473 FuncBeginSym, Asm->getTargetData().getPointerSize());
Bill Wendling94d04b82009-05-20 23:21:38 +00003474
Chris Lattner02b86b92010-04-04 23:41:46 +00003475 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
Bill Wendling94d04b82009-05-20 23:21:38 +00003476
Chris Lattner059ea132010-04-28 01:05:45 +00003477 Asm->EmitAlignment(2);
Chris Lattner206d61e2010-03-13 07:26:18 +00003478 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
Bill Wendling94d04b82009-05-20 23:21:38 +00003479}
3480
Devang Patel8a241142009-12-09 18:24:21 +00003481/// emitDebugPubNames - Emit visible names into a debug pubnames section.
3482///
3483void DwarfDebug::emitDebugPubNames() {
Devang Patel163a9f72010-05-10 22:49:55 +00003484 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3485 E = CUMap.end(); I != E; ++I) {
3486 CompileUnit *TheCU = I->second;
3487 // Start the dwarf pubnames section.
3488 Asm->OutStreamer.SwitchSection(
3489 Asm->getObjFileLowering().getDwarfPubNamesSection());
Chris Lattner4cf202b2010-01-23 03:11:46 +00003490
Devang Patel163a9f72010-05-10 22:49:55 +00003491 Asm->OutStreamer.AddComment("Length of Public Names Info");
3492 Asm->EmitLabelDifference(
3493 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3494 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3495
3496 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3497 TheCU->getID()));
3498
3499 Asm->OutStreamer.AddComment("DWARF Version");
3500 Asm->EmitInt16(dwarf::DWARF_VERSION);
3501
3502 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3503 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3504 DwarfInfoSectionSym);
3505
3506 Asm->OutStreamer.AddComment("Compilation Unit Length");
3507 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3508 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3509 4);
3510
3511 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3512 for (StringMap<DIE*>::const_iterator
3513 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3514 const char *Name = GI->getKeyData();
3515 DIE *Entity = GI->second;
3516
3517 Asm->OutStreamer.AddComment("DIE offset");
3518 Asm->EmitInt32(Entity->getOffset());
3519
3520 if (Asm->isVerbose())
3521 Asm->OutStreamer.AddComment("External Name");
3522 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3523 }
3524
3525 Asm->OutStreamer.AddComment("End Mark");
3526 Asm->EmitInt32(0);
3527 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3528 TheCU->getID()));
Bill Wendling94d04b82009-05-20 23:21:38 +00003529 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003530}
3531
Devang Patel193f7202009-11-24 01:14:22 +00003532void DwarfDebug::emitDebugPubTypes() {
Devang Patel163a9f72010-05-10 22:49:55 +00003533 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3534 E = CUMap.end(); I != E; ++I) {
3535 CompileUnit *TheCU = I->second;
3536 // Start the dwarf pubnames section.
3537 Asm->OutStreamer.SwitchSection(
3538 Asm->getObjFileLowering().getDwarfPubTypesSection());
3539 Asm->OutStreamer.AddComment("Length of Public Types Info");
3540 Asm->EmitLabelDifference(
3541 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3542 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
Chris Lattner4cf202b2010-01-23 03:11:46 +00003543
Devang Patel163a9f72010-05-10 22:49:55 +00003544 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3545 TheCU->getID()));
3546
3547 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3548 Asm->EmitInt16(dwarf::DWARF_VERSION);
3549
3550 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3551 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3552 DwarfInfoSectionSym);
3553
3554 Asm->OutStreamer.AddComment("Compilation Unit Length");
3555 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3556 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3557 4);
3558
3559 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3560 for (StringMap<DIE*>::const_iterator
3561 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3562 const char *Name = GI->getKeyData();
3563 DIE * Entity = GI->second;
3564
3565 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3566 Asm->EmitInt32(Entity->getOffset());
3567
3568 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3569 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3570 }
3571
3572 Asm->OutStreamer.AddComment("End Mark");
3573 Asm->EmitInt32(0);
3574 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3575 TheCU->getID()));
Devang Patel193f7202009-11-24 01:14:22 +00003576 }
Devang Patel193f7202009-11-24 01:14:22 +00003577}
3578
Devang Patel2c4ceb12009-11-21 02:48:08 +00003579/// emitDebugStr - Emit visible names into a debug str section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003580///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003581void DwarfDebug::emitDebugStr() {
Bill Wendling94d04b82009-05-20 23:21:38 +00003582 // Check to see if it is worth the effort.
Chris Lattner0d9d70f2010-03-09 23:38:23 +00003583 if (StringPool.empty()) return;
3584
3585 // Start the dwarf str section.
3586 Asm->OutStreamer.SwitchSection(
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003587 Asm->getObjFileLowering().getDwarfStrSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003588
Chris Lattnerbc733f52010-03-13 02:17:42 +00003589 // Get all of the string pool entries and put them in an array by their ID so
3590 // we can sort them.
3591 SmallVector<std::pair<unsigned,
3592 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3593
3594 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3595 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3596 Entries.push_back(std::make_pair(I->second.second, &*I));
3597
3598 array_pod_sort(Entries.begin(), Entries.end());
3599
3600 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
Chris Lattner0d9d70f2010-03-09 23:38:23 +00003601 // Emit a label for reference from debug information entries.
Chris Lattnerbc733f52010-03-13 02:17:42 +00003602 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
Chris Lattner0d9d70f2010-03-09 23:38:23 +00003603
3604 // Emit the string itself.
Chris Lattnerbc733f52010-03-13 02:17:42 +00003605 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
Bill Wendling94d04b82009-05-20 23:21:38 +00003606 }
3607}
3608
Devang Patel2c4ceb12009-11-21 02:48:08 +00003609/// emitDebugLoc - Emit visible names into a debug loc section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003610///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003611void DwarfDebug::emitDebugLoc() {
Devang Patel80250682010-05-26 23:55:23 +00003612 if (DotDebugLocEntries.empty())
3613 return;
3614
Bill Wendling94d04b82009-05-20 23:21:38 +00003615 // Start the dwarf loc section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003616 Asm->OutStreamer.SwitchSection(
Devang Patelc3f5f782010-05-25 23:40:22 +00003617 Asm->getObjFileLowering().getDwarfLocSection());
3618 unsigned char Size = Asm->getTargetData().getPointerSize();
Devang Patel80250682010-05-26 23:55:23 +00003619 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3620 unsigned index = 1;
Devang Patel61409622010-07-07 20:12:52 +00003621 for (SmallVector<DotDebugLocEntry, 4>::iterator
3622 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3623 I != E; ++I, ++index) {
Devang Patelc3f5f782010-05-25 23:40:22 +00003624 DotDebugLocEntry Entry = *I;
Devang Patelc3f5f782010-05-25 23:40:22 +00003625 if (Entry.isEmpty()) {
3626 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3627 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patel80250682010-05-26 23:55:23 +00003628 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
Devang Patelc3f5f782010-05-25 23:40:22 +00003629 } else {
3630 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3631 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3632 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3633 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3634 if (Reg < 32) {
3635 Asm->OutStreamer.AddComment("Loc expr size");
3636 Asm->EmitInt16(1);
3637 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3638 } else {
3639 Asm->OutStreamer.AddComment("Loc expr size");
3640 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3641 Asm->EmitInt8(dwarf::DW_OP_regx);
3642 Asm->EmitULEB128(Reg);
3643 }
3644 }
3645 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003646}
3647
3648/// EmitDebugARanges - Emit visible names into a debug aranges section.
3649///
3650void DwarfDebug::EmitDebugARanges() {
3651 // Start the dwarf aranges section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003652 Asm->OutStreamer.SwitchSection(
3653 Asm->getObjFileLowering().getDwarfARangesSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003654}
3655
Devang Patel2c4ceb12009-11-21 02:48:08 +00003656/// emitDebugRanges - Emit visible names into a debug ranges section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003657///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003658void DwarfDebug::emitDebugRanges() {
Bill Wendling94d04b82009-05-20 23:21:38 +00003659 // Start the dwarf ranges section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003660 Asm->OutStreamer.SwitchSection(
Devang Patelf2548ca2010-04-16 23:33:45 +00003661 Asm->getObjFileLowering().getDwarfRangesSection());
Devang Pateleac9c072010-04-27 19:46:33 +00003662 unsigned char Size = Asm->getTargetData().getPointerSize();
3663 for (SmallVector<const MCSymbol *, 8>::iterator
3664 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3665 I != E; ++I) {
3666 if (*I)
3667 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
Devang Patelf2548ca2010-04-16 23:33:45 +00003668 else
Devang Pateleac9c072010-04-27 19:46:33 +00003669 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patelf2548ca2010-04-16 23:33:45 +00003670 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003671}
3672
Devang Patel2c4ceb12009-11-21 02:48:08 +00003673/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003674///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003675void DwarfDebug::emitDebugMacInfo() {
Daniel Dunbarf612ff62009-09-19 20:40:05 +00003676 if (const MCSection *LineInfo =
Chris Lattner18a4c162009-08-02 07:24:22 +00003677 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
Bill Wendling94d04b82009-05-20 23:21:38 +00003678 // Start the dwarf macinfo section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003679 Asm->OutStreamer.SwitchSection(LineInfo);
Bill Wendling94d04b82009-05-20 23:21:38 +00003680 }
3681}
3682
Devang Patel2c4ceb12009-11-21 02:48:08 +00003683/// emitDebugInlineInfo - Emit inline info using following format.
Bill Wendling94d04b82009-05-20 23:21:38 +00003684/// Section Header:
3685/// 1. length of section
3686/// 2. Dwarf version number
3687/// 3. address size.
3688///
3689/// Entries (one "entry" for each function that was inlined):
3690///
3691/// 1. offset into __debug_str section for MIPS linkage name, if exists;
3692/// otherwise offset into __debug_str for regular function name.
3693/// 2. offset into __debug_str section for regular function name.
3694/// 3. an unsigned LEB128 number indicating the number of distinct inlining
3695/// instances for the function.
3696///
3697/// The rest of the entry consists of a {die_offset, low_pc} pair for each
3698/// inlined instance; the die_offset points to the inlined_subroutine die in the
3699/// __debug_info section, and the low_pc is the starting address for the
3700/// inlining instance.
Devang Patel2c4ceb12009-11-21 02:48:08 +00003701void DwarfDebug::emitDebugInlineInfo() {
Chris Lattnerd38fee82010-04-05 00:13:49 +00003702 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00003703 return;
3704
Devang Patel163a9f72010-05-10 22:49:55 +00003705 if (!FirstCU)
Bill Wendling94d04b82009-05-20 23:21:38 +00003706 return;
3707
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003708 Asm->OutStreamer.SwitchSection(
3709 Asm->getObjFileLowering().getDwarfDebugInlineSection());
Chris Lattner0ad9c912010-01-22 22:09:00 +00003710
Chris Lattner233f52b2010-03-09 23:52:58 +00003711 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
Chris Lattnera6437182010-04-04 19:58:12 +00003712 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3713 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
Bill Wendling94d04b82009-05-20 23:21:38 +00003714
Chris Lattnerc0215722010-04-04 19:25:43 +00003715 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
Bill Wendling94d04b82009-05-20 23:21:38 +00003716
Chris Lattner233f52b2010-03-09 23:52:58 +00003717 Asm->OutStreamer.AddComment("Dwarf Version");
3718 Asm->EmitInt16(dwarf::DWARF_VERSION);
3719 Asm->OutStreamer.AddComment("Address Size (in bytes)");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003720 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Bill Wendling94d04b82009-05-20 23:21:38 +00003721
Devang Patele9f8f5e2010-05-07 20:54:48 +00003722 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
Devang Patel53bb5c92009-11-10 23:06:00 +00003723 E = InlinedSPNodes.end(); I != E; ++I) {
Jim Grosbach31ef40e2009-11-21 23:12:12 +00003724
Devang Patele9f8f5e2010-05-07 20:54:48 +00003725 const MDNode *Node = *I;
3726 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
Jim Grosbach7ab38df2009-11-22 19:20:36 +00003727 = InlineInfo.find(Node);
Devang Patel53bb5c92009-11-10 23:06:00 +00003728 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
Devang Patele4b27562009-08-28 23:24:31 +00003729 DISubprogram SP(Node);
Devang Patel65dbc902009-11-25 17:36:49 +00003730 StringRef LName = SP.getLinkageName();
3731 StringRef Name = SP.getName();
Bill Wendling94d04b82009-05-20 23:21:38 +00003732
Chris Lattner233f52b2010-03-09 23:52:58 +00003733 Asm->OutStreamer.AddComment("MIPS linkage name");
Chris Lattner4cf202b2010-01-23 03:11:46 +00003734 if (LName.empty()) {
3735 Asm->OutStreamer.EmitBytes(Name, 0);
3736 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3737 } else
Chris Lattner6189ed12010-04-04 23:25:33 +00003738 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3739 DwarfStrSectionSym);
Devang Patel53bb5c92009-11-10 23:06:00 +00003740
Chris Lattner233f52b2010-03-09 23:52:58 +00003741 Asm->OutStreamer.AddComment("Function name");
Chris Lattner6189ed12010-04-04 23:25:33 +00003742 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003743 Asm->EmitULEB128(Labels.size(), "Inline count");
Bill Wendling94d04b82009-05-20 23:21:38 +00003744
Devang Patel53bb5c92009-11-10 23:06:00 +00003745 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
Bill Wendling94d04b82009-05-20 23:21:38 +00003746 LE = Labels.end(); LI != LE; ++LI) {
Chris Lattner3f53c832010-04-04 18:52:31 +00003747 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
Chris Lattner6ed0f902010-03-09 00:31:02 +00003748 Asm->EmitInt32(LI->second->getOffset());
Bill Wendling94d04b82009-05-20 23:21:38 +00003749
Chris Lattner3f53c832010-04-04 18:52:31 +00003750 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003751 Asm->OutStreamer.EmitSymbolValue(LI->first,
3752 Asm->getTargetData().getPointerSize(),0);
Bill Wendling94d04b82009-05-20 23:21:38 +00003753 }
3754 }
3755
Chris Lattnerc0215722010-04-04 19:25:43 +00003756 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
Bill Wendling94d04b82009-05-20 23:21:38 +00003757}