blob: b81aad92cbb9f4474d28cb7c5d85474d53e50799 [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
Jim Grosbach1e20b962010-07-21 21:21:52 +000047static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
Devang Patel61409622010-07-07 20:12:52 +000048 cl::Hidden,
Devang Pateleac9c072010-04-27 19:46:33 +000049 cl::desc("Disable debug info printing"));
50
Dan Gohman281d65d2010-05-07 01:08:53 +000051static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
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 ///
Jim Grosbach1e20b962010-07-21 21:21:52 +0000119 void addGlobalType(StringRef Name, DIE *Die) {
120 GlobalTypes[Name] = Die;
Devang Patel193f7202009-11-24 01:14:22 +0000121 }
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.
Jim Grosbach1e20b962010-07-21 21:21:52 +0000134 DIEEntry *getDIEEntry(const MDNode *N) {
135 DenseMap<const MDNode *, DIEEntry *>::iterator I =
136 MDNodeToDIEEntryMap.find(N);
Devang Patel869aa462010-07-07 20:49:57 +0000137 if (I == MDNodeToDIEEntryMap.end())
Devang Patel6404e4e2009-12-15 19:16:48 +0000138 return NULL;
139 return I->second;
140 }
Devang Patel017d1212009-11-20 21:37:22 +0000141
142 /// insertDIEEntry - Insert debug information entry into the map.
Devang Patele9f8f5e2010-05-07 20:54:48 +0000143 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
Devang Patel869aa462010-07-07 20:49:57 +0000144 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
Bill Wendling0310d762009-05-15 09:23:25 +0000145 }
146
Devang Patel2c4ceb12009-11-21 02:48:08 +0000147 /// addDie - Adds or interns the DIE to the compile unit.
Bill Wendling0310d762009-05-15 09:23:25 +0000148 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000149 void addDie(DIE *Buffer) {
150 this->CUDie->addChild(Buffer);
Bill Wendling0310d762009-05-15 09:23:25 +0000151 }
Devang Patel6f01d9c2009-11-21 00:31:03 +0000152
153 // getIndexTyDie - Get an anonymous type for index type.
154 DIE *getIndexTyDie() {
155 return IndexTyDie;
156 }
157
Jim Grosbach7ab38df2009-11-22 19:20:36 +0000158 // setIndexTyDie - Set D as anonymous type for index which can be reused
159 // later.
Devang Patel6f01d9c2009-11-21 00:31:03 +0000160 void setIndexTyDie(DIE *D) {
161 IndexTyDie = D;
162 }
163
Bill Wendling0310d762009-05-15 09:23:25 +0000164};
165
166//===----------------------------------------------------------------------===//
167/// DbgVariable - This class is used to track local variable information.
168///
Devang Patelf76a3d62009-11-16 21:53:40 +0000169class DbgVariable {
Bill Wendling0310d762009-05-15 09:23:25 +0000170 DIVariable Var; // Variable Descriptor.
Devang Patelc3f5f782010-05-25 23:40:22 +0000171 DIE *TheDIE; // Variable DIE.
172 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
Bill Wendling0310d762009-05-15 09:23:25 +0000173public:
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000174 // AbsVar may be NULL.
Devang Patelc3f5f782010-05-25 23:40:22 +0000175 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
Bill Wendling0310d762009-05-15 09:23:25 +0000176
177 // Accessors.
Devang Patel53bb5c92009-11-10 23:06:00 +0000178 DIVariable getVariable() const { return Var; }
Devang Patel53bb5c92009-11-10 23:06:00 +0000179 void setDIE(DIE *D) { TheDIE = D; }
180 DIE *getDIE() const { return TheDIE; }
Devang Patelc3f5f782010-05-25 23:40:22 +0000181 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
182 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
Bill Wendling0310d762009-05-15 09:23:25 +0000183};
184
185//===----------------------------------------------------------------------===//
Devang Pateleac9c072010-04-27 19:46:33 +0000186/// DbgRange - This is used to track range of instructions with identical
187/// debug info scope.
188///
189typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
190
191//===----------------------------------------------------------------------===//
Bill Wendling0310d762009-05-15 09:23:25 +0000192/// DbgScope - This class is used to track scope information.
193///
Devang Patelf76a3d62009-11-16 21:53:40 +0000194class DbgScope {
Bill Wendling0310d762009-05-15 09:23:25 +0000195 DbgScope *Parent; // Parent to this scope.
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000196 DIDescriptor Desc; // Debug info descriptor for scope.
Devang Patel3139fcf2010-01-26 21:39:14 +0000197 // Location at which this scope is inlined.
Jim Grosbach1e20b962010-07-21 21:21:52 +0000198 AssertingVH<const MDNode> InlinedAtLocation;
Devang Patel53bb5c92009-11-10 23:06:00 +0000199 bool AbstractScope; // Abstract Scope
Devang Pateld38dd112009-10-01 18:25:23 +0000200 const MachineInstr *LastInsn; // Last instruction of this scope.
201 const MachineInstr *FirstInsn; // First instruction of this scope.
Devang Pateleac9c072010-04-27 19:46:33 +0000202 unsigned DFSIn, DFSOut;
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000203 // Scopes defined in scope. Contents not owned.
204 SmallVector<DbgScope *, 4> Scopes;
205 // Variables declared in scope. Contents owned.
206 SmallVector<DbgVariable *, 8> Variables;
Devang Pateleac9c072010-04-27 19:46:33 +0000207 SmallVector<DbgRange, 4> Ranges;
Owen Anderson04c05f72009-06-24 22:53:20 +0000208 // Private state for dump()
209 mutable unsigned IndentLevel;
Bill Wendling0310d762009-05-15 09:23:25 +0000210public:
Devang Patele9f8f5e2010-05-07 20:54:48 +0000211 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
Devang Patel53bb5c92009-11-10 23:06:00 +0000212 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
Devang Pateleac9c072010-04-27 19:46:33 +0000213 LastInsn(0), FirstInsn(0),
214 DFSIn(0), DFSOut(0), IndentLevel(0) {}
Bill Wendling0310d762009-05-15 09:23:25 +0000215 virtual ~DbgScope();
216
217 // Accessors.
218 DbgScope *getParent() const { return Parent; }
Devang Patel53bb5c92009-11-10 23:06:00 +0000219 void setParent(DbgScope *P) { Parent = P; }
Bill Wendling0310d762009-05-15 09:23:25 +0000220 DIDescriptor getDesc() const { return Desc; }
Devang Patele9f8f5e2010-05-07 20:54:48 +0000221 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
222 const MDNode *getScopeNode() const { return Desc; }
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000223 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
224 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
Devang Pateleac9c072010-04-27 19:46:33 +0000225 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
226
227 /// openInsnRange - This scope covers instruction range starting from MI.
228 void openInsnRange(const MachineInstr *MI) {
Jim Grosbach1e20b962010-07-21 21:21:52 +0000229 if (!FirstInsn)
Devang Pateleac9c072010-04-27 19:46:33 +0000230 FirstInsn = MI;
Jim Grosbach1e20b962010-07-21 21:21:52 +0000231
Devang Pateleac9c072010-04-27 19:46:33 +0000232 if (Parent)
233 Parent->openInsnRange(MI);
234 }
235
Jim Grosbach1e20b962010-07-21 21:21:52 +0000236 /// extendInsnRange - Extend the current instruction range covered by
Devang Pateleac9c072010-04-27 19:46:33 +0000237 /// this scope.
238 void extendInsnRange(const MachineInstr *MI) {
239 assert (FirstInsn && "MI Range is not open!");
240 LastInsn = MI;
241 if (Parent)
242 Parent->extendInsnRange(MI);
243 }
244
245 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
246 /// until now. This is used when a new scope is encountered while walking
247 /// machine instructions.
248 void closeInsnRange(DbgScope *NewScope = NULL) {
249 assert (LastInsn && "Last insn missing!");
250 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
Jim Grosbach1e20b962010-07-21 21:21:52 +0000251 FirstInsn = NULL;
Devang Pateleac9c072010-04-27 19:46:33 +0000252 LastInsn = NULL;
Jim Grosbach1e20b962010-07-21 21:21:52 +0000253 // If Parent dominates NewScope then do not close Parent's instruction
Devang Pateleac9c072010-04-27 19:46:33 +0000254 // range.
255 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
256 Parent->closeInsnRange(NewScope);
257 }
258
Devang Patel53bb5c92009-11-10 23:06:00 +0000259 void setAbstractScope() { AbstractScope = true; }
260 bool isAbstractScope() const { return AbstractScope; }
Devang Pateleac9c072010-04-27 19:46:33 +0000261
262 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
263 unsigned getDFSOut() const { return DFSOut; }
264 void setDFSOut(unsigned O) { DFSOut = O; }
265 unsigned getDFSIn() const { return DFSIn; }
266 void setDFSIn(unsigned I) { DFSIn = I; }
267 bool dominates(const DbgScope *S) {
Jim Grosbach1e20b962010-07-21 21:21:52 +0000268 if (S == this)
Devang Pateleac9c072010-04-27 19:46:33 +0000269 return true;
270 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
271 return true;
272 return false;
273 }
Devang Patel53bb5c92009-11-10 23:06:00 +0000274
Devang Patel2c4ceb12009-11-21 02:48:08 +0000275 /// addScope - Add a scope to the scope.
Bill Wendling0310d762009-05-15 09:23:25 +0000276 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000277 void addScope(DbgScope *S) { Scopes.push_back(S); }
Bill Wendling0310d762009-05-15 09:23:25 +0000278
Devang Patel2c4ceb12009-11-21 02:48:08 +0000279 /// addVariable - Add a variable to the scope.
Bill Wendling0310d762009-05-15 09:23:25 +0000280 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000281 void addVariable(DbgVariable *V) { Variables.push_back(V); }
Bill Wendling0310d762009-05-15 09:23:25 +0000282
Bill Wendling0310d762009-05-15 09:23:25 +0000283#ifndef NDEBUG
284 void dump() const;
285#endif
286};
Devang Pateleac9c072010-04-27 19:46:33 +0000287
Chris Lattnerea761862010-04-05 04:09:20 +0000288} // end llvm namespace
Bill Wendling0310d762009-05-15 09:23:25 +0000289
290#ifndef NDEBUG
291void DbgScope::dump() const {
David Greenef83adbc2009-12-24 00:31:35 +0000292 raw_ostream &err = dbgs();
Chris Lattnerc281de12009-08-23 00:51:00 +0000293 err.indent(IndentLevel);
Devang Patele9f8f5e2010-05-07 20:54:48 +0000294 const MDNode *N = Desc;
Devang Patel53bb5c92009-11-10 23:06:00 +0000295 N->dump();
Devang Patel53bb5c92009-11-10 23:06:00 +0000296 if (AbstractScope)
297 err << "Abstract Scope\n";
Bill Wendling0310d762009-05-15 09:23:25 +0000298
299 IndentLevel += 2;
Devang Patel53bb5c92009-11-10 23:06:00 +0000300 if (!Scopes.empty())
301 err << "Children ...\n";
Bill Wendling0310d762009-05-15 09:23:25 +0000302 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
303 if (Scopes[i] != this)
304 Scopes[i]->dump();
305
306 IndentLevel -= 2;
307}
308#endif
309
Bill Wendling0310d762009-05-15 09:23:25 +0000310DbgScope::~DbgScope() {
Bill Wendling0310d762009-05-15 09:23:25 +0000311 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
312 delete Variables[j];
Bill Wendling0310d762009-05-15 09:23:25 +0000313}
314
Chris Lattner49cd6642010-04-05 05:11:15 +0000315DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
Devang Patel163a9f72010-05-10 22:49:55 +0000316 : Asm(A), MMI(Asm->MMI), FirstCU(0),
Jim Grosbach1e20b962010-07-21 21:21:52 +0000317 AbbreviationsSet(InitAbbreviationsSetSize),
Devang Patelf2548ca2010-04-16 23:33:45 +0000318 CurrentFnDbgScope(0), PrevLabel(NULL) {
Chris Lattnerbc733f52010-03-13 02:17:42 +0000319 NextStringPoolNumber = 0;
Jim Grosbach1e20b962010-07-21 21:21:52 +0000320
Chris Lattner4ad1efe2010-04-04 23:10:38 +0000321 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
322 DwarfStrSectionSym = TextSectionSym = 0;
Jim Grosbach1e20b962010-07-21 21:21:52 +0000323 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
Devang Patel1e4782d2010-06-29 20:17:53 +0000324 DwarfDebugLineSectionSym = CurrentLineSectionSym = 0;
Devang Patelc3f5f782010-05-25 23:40:22 +0000325 FunctionBeginSym = FunctionEndSym = 0;
Devang Patelca76f6f2010-07-08 20:10:35 +0000326 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
Dan Gohman03c3dc72010-06-18 15:56:31 +0000327 {
328 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
329 beginModule(M);
Torok Edwin9c421072010-04-07 10:44:46 +0000330 }
Bill Wendling0310d762009-05-15 09:23:25 +0000331}
332DwarfDebug::~DwarfDebug() {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000333 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
334 DIEBlocks[j]->~DIEBlock();
Bill Wendling0310d762009-05-15 09:23:25 +0000335}
336
Chris Lattnerbc733f52010-03-13 02:17:42 +0000337MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
338 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
339 if (Entry.first) return Entry.first;
340
341 Entry.second = NextStringPoolNumber++;
Chris Lattnerc0215722010-04-04 19:25:43 +0000342 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
Chris Lattnerbc733f52010-03-13 02:17:42 +0000343}
344
345
Devang Patel2c4ceb12009-11-21 02:48:08 +0000346/// assignAbbrevNumber - Define a unique number for the abbreviation.
Bill Wendling0310d762009-05-15 09:23:25 +0000347///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000348void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
Bill Wendling0310d762009-05-15 09:23:25 +0000349 // Profile the node so that we can make it unique.
350 FoldingSetNodeID ID;
351 Abbrev.Profile(ID);
352
353 // Check the set for priors.
354 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
355
356 // If it's newly added.
357 if (InSet == &Abbrev) {
358 // Add to abbreviation list.
359 Abbreviations.push_back(&Abbrev);
360
361 // Assign the vector position + 1 as its number.
362 Abbrev.setNumber(Abbreviations.size());
363 } else {
364 // Assign existing abbreviation number.
365 Abbrev.setNumber(InSet->getNumber());
366 }
367}
368
Devang Patel2c4ceb12009-11-21 02:48:08 +0000369/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
Bill Wendling995f80a2009-05-20 23:24:48 +0000370/// information entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000371DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000372 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
Bill Wendling0310d762009-05-15 09:23:25 +0000373 return Value;
374}
375
Devang Patel2c4ceb12009-11-21 02:48:08 +0000376/// addUInt - Add an unsigned integer attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000377///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000378void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
Bill Wendling0310d762009-05-15 09:23:25 +0000379 unsigned Form, uint64_t Integer) {
380 if (!Form) Form = DIEInteger::BestForm(false, Integer);
Jim Grosbach1e20b962010-07-21 21:21:52 +0000381 DIEValue *Value = Integer == 1 ?
Devang Patelca76f6f2010-07-08 20:10:35 +0000382 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000383 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000384}
385
Devang Patel2c4ceb12009-11-21 02:48:08 +0000386/// addSInt - Add an signed integer attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000387///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000388void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
Bill Wendling0310d762009-05-15 09:23:25 +0000389 unsigned Form, int64_t Integer) {
390 if (!Form) Form = DIEInteger::BestForm(true, Integer);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000391 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000392 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000393}
394
Devang Patel69f57b12009-12-02 15:25:16 +0000395/// addString - Add a string attribute data and value. DIEString only
Jim Grosbach1e20b962010-07-21 21:21:52 +0000396/// keeps string reference.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000397void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattner4cf202b2010-01-23 03:11:46 +0000398 StringRef String) {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000399 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000400 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000401}
402
Devang Patel2c4ceb12009-11-21 02:48:08 +0000403/// addLabel - Add a Dwarf label attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000404///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000405void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattnerb98b1bf2010-03-08 22:23:36 +0000406 const MCSymbol *Label) {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000407 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000408 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000409}
410
Devang Patel2c4ceb12009-11-21 02:48:08 +0000411/// addDelta - Add a label delta attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000412///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000413void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattnerb98b1bf2010-03-08 22:23:36 +0000414 const MCSymbol *Hi, const MCSymbol *Lo) {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000415 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000416 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000417}
418
Chris Lattner74e41f92010-04-05 05:24:55 +0000419/// addDIEEntry - Add a DIE attribute data and value.
420///
421void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
422 DIE *Entry) {
423 Die->addValue(Attribute, Form, createDIEEntry(Entry));
424}
425
426
Devang Patel2c4ceb12009-11-21 02:48:08 +0000427/// addBlock - Add block data.
Bill Wendling0310d762009-05-15 09:23:25 +0000428///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000429void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
Bill Wendling0310d762009-05-15 09:23:25 +0000430 DIEBlock *Block) {
Chris Lattnera37d5382010-04-05 00:18:22 +0000431 Block->ComputeSize(Asm);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000432 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000433 Die->addValue(Attribute, Block->BestForm(), Block);
Bill Wendling0310d762009-05-15 09:23:25 +0000434}
435
Devang Patel2c4ceb12009-11-21 02:48:08 +0000436/// addSourceLine - Add location information to specified debug information
Bill Wendling0310d762009-05-15 09:23:25 +0000437/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000438void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
Devang Patelc665a512010-05-07 23:33:41 +0000439 // Verify variable.
440 if (!V->Verify())
Bill Wendling0310d762009-05-15 09:23:25 +0000441 return;
442
443 unsigned Line = V->getLineNumber();
Devang Patel77bf2952010-03-08 22:02:50 +0000444 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
445 V->getContext().getFilename());
Bill Wendling0310d762009-05-15 09:23:25 +0000446 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000447 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
448 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling0310d762009-05-15 09:23:25 +0000449}
450
Devang Patel2c4ceb12009-11-21 02:48:08 +0000451/// addSourceLine - Add location information to specified debug information
Bill Wendling0310d762009-05-15 09:23:25 +0000452/// entry.
Devang Patela49d8772010-05-07 23:19:07 +0000453void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
Devang Patelc665a512010-05-07 23:33:41 +0000454 // Verify global variable.
455 if (!G->Verify())
Bill Wendling0310d762009-05-15 09:23:25 +0000456 return;
457
458 unsigned Line = G->getLineNumber();
Devang Patel77bf2952010-03-08 22:02:50 +0000459 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
460 G->getContext().getFilename());
Bill Wendling0310d762009-05-15 09:23:25 +0000461 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000462 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
463 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling0310d762009-05-15 09:23:25 +0000464}
Devang Patel82dfc0c2009-08-31 22:47:13 +0000465
Devang Patel2c4ceb12009-11-21 02:48:08 +0000466/// addSourceLine - Add location information to specified debug information
Devang Patel82dfc0c2009-08-31 22:47:13 +0000467/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000468void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
Devang Patelc665a512010-05-07 23:33:41 +0000469 // Verify subprogram.
470 if (!SP->Verify())
Devang Patel82dfc0c2009-08-31 22:47:13 +0000471 return;
Caroline Ticec6f9d622009-09-11 18:25:54 +0000472 // If the line number is 0, don't add it.
473 if (SP->getLineNumber() == 0)
474 return;
475
Devang Patel82dfc0c2009-08-31 22:47:13 +0000476 unsigned Line = SP->getLineNumber();
Devang Patel77bf2952010-03-08 22:02:50 +0000477 if (!SP->getContext().Verify())
478 return;
Devang Patel9bb59a22010-03-24 21:30:35 +0000479 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
480 SP->getFilename());
Devang Patel82dfc0c2009-08-31 22:47:13 +0000481 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000482 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
483 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Devang Patel82dfc0c2009-08-31 22:47:13 +0000484}
485
Devang Patel2c4ceb12009-11-21 02:48:08 +0000486/// addSourceLine - Add location information to specified debug information
Devang Patel82dfc0c2009-08-31 22:47:13 +0000487/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000488void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
Devang Patelc665a512010-05-07 23:33:41 +0000489 // Verify type.
490 if (!Ty->Verify())
Bill Wendling0310d762009-05-15 09:23:25 +0000491 return;
492
493 unsigned Line = Ty->getLineNumber();
Devang Patel77bf2952010-03-08 22:02:50 +0000494 if (!Ty->getContext().Verify())
495 return;
496 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
497 Ty->getContext().getFilename());
Bill Wendling0310d762009-05-15 09:23:25 +0000498 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000499 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
500 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling0310d762009-05-15 09:23:25 +0000501}
502
Devang Patel6404e4e2009-12-15 19:16:48 +0000503/// addSourceLine - Add location information to specified debug information
504/// entry.
505void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
Devang Patelc665a512010-05-07 23:33:41 +0000506 // Verify namespace.
507 if (!NS->Verify())
Devang Patel6404e4e2009-12-15 19:16:48 +0000508 return;
509
510 unsigned Line = NS->getLineNumber();
511 StringRef FN = NS->getFilename();
512 StringRef Dir = NS->getDirectory();
513
514 unsigned FileID = GetOrCreateSourceID(Dir, FN);
515 assert(FileID && "Invalid file id");
516 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
517 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
518}
519
Caroline Ticedc8f6042009-08-31 21:19:37 +0000520/* Byref variables, in Blocks, are declared by the programmer as
521 "SomeType VarName;", but the compiler creates a
522 __Block_byref_x_VarName struct, and gives the variable VarName
523 either the struct, or a pointer to the struct, as its type. This
524 is necessary for various behind-the-scenes things the compiler
525 needs to do with by-reference variables in blocks.
526
527 However, as far as the original *programmer* is concerned, the
528 variable should still have type 'SomeType', as originally declared.
529
530 The following function dives into the __Block_byref_x_VarName
531 struct to find the original type of the variable. This will be
532 passed back to the code generating the type for the Debug
533 Information Entry for the variable 'VarName'. 'VarName' will then
534 have the original type 'SomeType' in its debug information.
535
536 The original type 'SomeType' will be the type of the field named
537 'VarName' inside the __Block_byref_x_VarName struct.
538
539 NOTE: In order for this to not completely fail on the debugger
540 side, the Debug Information Entry for the variable VarName needs to
541 have a DW_AT_location that tells the debugger how to unwind through
542 the pointers and __Block_byref_x_VarName struct to find the actual
Devang Patel2c4ceb12009-11-21 02:48:08 +0000543 value of the variable. The function addBlockByrefType does this. */
Caroline Ticedc8f6042009-08-31 21:19:37 +0000544
545/// Find the type the programmer originally declared the variable to be
546/// and return that type.
547///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000548DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
Caroline Ticedc8f6042009-08-31 21:19:37 +0000549
550 DIType subType = Ty;
551 unsigned tag = Ty.getTag();
552
553 if (tag == dwarf::DW_TAG_pointer_type) {
Devang Patel2db49d72010-05-07 18:11:54 +0000554 DIDerivedType DTy = DIDerivedType(Ty);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000555 subType = DTy.getTypeDerivedFrom();
556 }
557
Devang Patel2db49d72010-05-07 18:11:54 +0000558 DICompositeType blockStruct = DICompositeType(subType);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000559 DIArray Elements = blockStruct.getTypeArray();
560
Caroline Ticedc8f6042009-08-31 21:19:37 +0000561 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
562 DIDescriptor Element = Elements.getElement(i);
Devang Patel2db49d72010-05-07 18:11:54 +0000563 DIDerivedType DT = DIDerivedType(Element);
Devang Patel65dbc902009-11-25 17:36:49 +0000564 if (Name == DT.getName())
Caroline Ticedc8f6042009-08-31 21:19:37 +0000565 return (DT.getTypeDerivedFrom());
566 }
567
568 return Ty;
569}
570
Devang Patel2c4ceb12009-11-21 02:48:08 +0000571/// addComplexAddress - Start with the address based on the location provided,
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000572/// and generate the DWARF information necessary to find the actual variable
573/// given the extra address information encoded in the DIVariable, starting from
574/// the starting location. Add the DWARF information to the die.
575///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000576void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000577 unsigned Attribute,
578 const MachineLocation &Location) {
579 const DIVariable &VD = DV->getVariable();
580 DIType Ty = VD.getType();
581
582 // Decode the original location, and use that as the start of the byref
583 // variable's location.
Chris Lattnerd38fee82010-04-05 00:13:49 +0000584 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000585 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000586 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000587
588 if (Location.isReg()) {
589 if (Reg < 32) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000590 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000591 } else {
592 Reg = Reg - dwarf::DW_OP_reg0;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000593 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
594 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000595 }
596 } else {
597 if (Reg < 32)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000598 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000599 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000600 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
601 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000602 }
603
Devang Patel2c4ceb12009-11-21 02:48:08 +0000604 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000605 }
606
607 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
608 uint64_t Element = VD.getAddrElement(i);
609
610 if (Element == DIFactory::OpPlus) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000611 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
612 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000613 } else if (Element == DIFactory::OpDeref) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000614 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000615 } else llvm_unreachable("unknown DIFactory Opcode");
616 }
617
618 // Now attach the location information to the DIE.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000619 addBlock(Die, Attribute, 0, Block);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000620}
621
Caroline Ticedc8f6042009-08-31 21:19:37 +0000622/* Byref variables, in Blocks, are declared by the programmer as "SomeType
623 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
624 gives the variable VarName either the struct, or a pointer to the struct, as
625 its type. This is necessary for various behind-the-scenes things the
626 compiler needs to do with by-reference variables in Blocks.
627
628 However, as far as the original *programmer* is concerned, the variable
629 should still have type 'SomeType', as originally declared.
630
Devang Patel2c4ceb12009-11-21 02:48:08 +0000631 The function getBlockByrefType dives into the __Block_byref_x_VarName
Caroline Ticedc8f6042009-08-31 21:19:37 +0000632 struct to find the original type of the variable, which is then assigned to
633 the variable's Debug Information Entry as its real type. So far, so good.
634 However now the debugger will expect the variable VarName to have the type
635 SomeType. So we need the location attribute for the variable to be an
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000636 expression that explains to the debugger how to navigate through the
Caroline Ticedc8f6042009-08-31 21:19:37 +0000637 pointers and struct to find the actual variable of type SomeType.
638
639 The following function does just that. We start by getting
640 the "normal" location for the variable. This will be the location
641 of either the struct __Block_byref_x_VarName or the pointer to the
642 struct __Block_byref_x_VarName.
643
644 The struct will look something like:
645
646 struct __Block_byref_x_VarName {
647 ... <various fields>
648 struct __Block_byref_x_VarName *forwarding;
649 ... <various other fields>
650 SomeType VarName;
651 ... <maybe more fields>
652 };
653
654 If we are given the struct directly (as our starting point) we
655 need to tell the debugger to:
656
657 1). Add the offset of the forwarding field.
658
Dan Gohmanf451cb82010-02-10 16:03:48 +0000659 2). Follow that pointer to get the real __Block_byref_x_VarName
Caroline Ticedc8f6042009-08-31 21:19:37 +0000660 struct to use (the real one may have been copied onto the heap).
661
662 3). Add the offset for the field VarName, to find the actual variable.
663
664 If we started with a pointer to the struct, then we need to
665 dereference that pointer first, before the other steps.
666 Translating this into DWARF ops, we will need to append the following
667 to the current location description for the variable:
668
669 DW_OP_deref -- optional, if we start with a pointer
670 DW_OP_plus_uconst <forward_fld_offset>
671 DW_OP_deref
672 DW_OP_plus_uconst <varName_fld_offset>
673
674 That is what this function does. */
675
Devang Patel2c4ceb12009-11-21 02:48:08 +0000676/// addBlockByrefAddress - Start with the address based on the location
Caroline Ticedc8f6042009-08-31 21:19:37 +0000677/// provided, and generate the DWARF information necessary to find the
678/// actual Block variable (navigating the Block struct) based on the
679/// starting location. Add the DWARF information to the die. For
680/// more information, read large comment just above here.
681///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000682void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
Daniel Dunbar00564992009-09-19 20:40:14 +0000683 unsigned Attribute,
684 const MachineLocation &Location) {
Caroline Ticedc8f6042009-08-31 21:19:37 +0000685 const DIVariable &VD = DV->getVariable();
686 DIType Ty = VD.getType();
687 DIType TmpTy = Ty;
688 unsigned Tag = Ty.getTag();
689 bool isPointer = false;
690
Devang Patel65dbc902009-11-25 17:36:49 +0000691 StringRef varName = VD.getName();
Caroline Ticedc8f6042009-08-31 21:19:37 +0000692
693 if (Tag == dwarf::DW_TAG_pointer_type) {
Devang Patel2db49d72010-05-07 18:11:54 +0000694 DIDerivedType DTy = DIDerivedType(Ty);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000695 TmpTy = DTy.getTypeDerivedFrom();
696 isPointer = true;
697 }
698
Devang Patel2db49d72010-05-07 18:11:54 +0000699 DICompositeType blockStruct = DICompositeType(TmpTy);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000700
Daniel Dunbar00564992009-09-19 20:40:14 +0000701 // Find the __forwarding field and the variable field in the __Block_byref
702 // struct.
Daniel Dunbar00564992009-09-19 20:40:14 +0000703 DIArray Fields = blockStruct.getTypeArray();
704 DIDescriptor varField = DIDescriptor();
705 DIDescriptor forwardingField = DIDescriptor();
Caroline Ticedc8f6042009-08-31 21:19:37 +0000706
Daniel Dunbar00564992009-09-19 20:40:14 +0000707 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
708 DIDescriptor Element = Fields.getElement(i);
Devang Patel2db49d72010-05-07 18:11:54 +0000709 DIDerivedType DT = DIDerivedType(Element);
Devang Patel65dbc902009-11-25 17:36:49 +0000710 StringRef fieldName = DT.getName();
711 if (fieldName == "__forwarding")
Daniel Dunbar00564992009-09-19 20:40:14 +0000712 forwardingField = Element;
Devang Patel65dbc902009-11-25 17:36:49 +0000713 else if (fieldName == varName)
Daniel Dunbar00564992009-09-19 20:40:14 +0000714 varField = Element;
715 }
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000716
Daniel Dunbar00564992009-09-19 20:40:14 +0000717 // Get the offsets for the forwarding field and the variable field.
Chris Lattner1d65ba72010-03-31 06:06:37 +0000718 unsigned forwardingFieldOffset =
Devang Patel2db49d72010-05-07 18:11:54 +0000719 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
Chris Lattner1d65ba72010-03-31 06:06:37 +0000720 unsigned varFieldOffset =
Devang Patel2db49d72010-05-07 18:11:54 +0000721 DIDerivedType(varField).getOffsetInBits() >> 3;
Caroline Ticedc8f6042009-08-31 21:19:37 +0000722
Mike Stump7e3720d2009-09-24 23:21:26 +0000723 // Decode the original location, and use that as the start of the byref
724 // variable's location.
Chris Lattnerd38fee82010-04-05 00:13:49 +0000725 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Daniel Dunbar00564992009-09-19 20:40:14 +0000726 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000727 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Caroline Ticedc8f6042009-08-31 21:19:37 +0000728
Daniel Dunbar00564992009-09-19 20:40:14 +0000729 if (Location.isReg()) {
730 if (Reg < 32)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000731 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000732 else {
733 Reg = Reg - dwarf::DW_OP_reg0;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000734 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
735 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000736 }
737 } else {
738 if (Reg < 32)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000739 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000740 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000741 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
742 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000743 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000744
Devang Patel2c4ceb12009-11-21 02:48:08 +0000745 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Daniel Dunbar00564992009-09-19 20:40:14 +0000746 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000747
Mike Stump7e3720d2009-09-24 23:21:26 +0000748 // If we started with a pointer to the __Block_byref... struct, then
Daniel Dunbar00564992009-09-19 20:40:14 +0000749 // the first thing we need to do is dereference the pointer (DW_OP_deref).
Daniel Dunbar00564992009-09-19 20:40:14 +0000750 if (isPointer)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000751 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000752
Daniel Dunbar00564992009-09-19 20:40:14 +0000753 // Next add the offset for the '__forwarding' field:
754 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
755 // adding the offset if it's 0.
Daniel Dunbar00564992009-09-19 20:40:14 +0000756 if (forwardingFieldOffset > 0) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000757 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
758 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
Daniel Dunbar00564992009-09-19 20:40:14 +0000759 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000760
Daniel Dunbar00564992009-09-19 20:40:14 +0000761 // Now dereference the __forwarding field to get to the real __Block_byref
762 // struct: DW_OP_deref.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000763 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000764
Daniel Dunbar00564992009-09-19 20:40:14 +0000765 // Now that we've got the real __Block_byref... struct, add the offset
766 // for the variable's field to get to the location of the actual variable:
767 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
Daniel Dunbar00564992009-09-19 20:40:14 +0000768 if (varFieldOffset > 0) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000769 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
770 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
Daniel Dunbar00564992009-09-19 20:40:14 +0000771 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000772
Daniel Dunbar00564992009-09-19 20:40:14 +0000773 // Now attach the location information to the DIE.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000774 addBlock(Die, Attribute, 0, Block);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000775}
776
Devang Patel2c4ceb12009-11-21 02:48:08 +0000777/// addAddress - Add an address attribute to a die based on the location
Bill Wendling0310d762009-05-15 09:23:25 +0000778/// provided.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000779void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
Bill Wendling0310d762009-05-15 09:23:25 +0000780 const MachineLocation &Location) {
Chris Lattnerd38fee82010-04-05 00:13:49 +0000781 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Bill Wendling0310d762009-05-15 09:23:25 +0000782 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000783 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Bill Wendling0310d762009-05-15 09:23:25 +0000784
785 if (Location.isReg()) {
786 if (Reg < 32) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000787 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000788 } else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000789 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
790 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000791 }
792 } else {
793 if (Reg < 32) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000794 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000795 } else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000796 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
797 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000798 }
799
Devang Patel2c4ceb12009-11-21 02:48:08 +0000800 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Bill Wendling0310d762009-05-15 09:23:25 +0000801 }
802
Devang Patel2c4ceb12009-11-21 02:48:08 +0000803 addBlock(Die, Attribute, 0, Block);
Bill Wendling0310d762009-05-15 09:23:25 +0000804}
805
Devang Patela43098d2010-04-28 01:03:09 +0000806/// addRegisterAddress - Add register location entry in variable DIE.
Devang Patel26c1e562010-05-20 16:36:41 +0000807bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
Devang Patela43098d2010-04-28 01:03:09 +0000808 const MachineOperand &MO) {
809 assert (MO.isReg() && "Invalid machine operand!");
810 if (!MO.getReg())
811 return false;
812 MachineLocation Location;
813 Location.set(MO.getReg());
814 addAddress(Die, dwarf::DW_AT_location, Location);
Devang Patel26c1e562010-05-20 16:36:41 +0000815 if (VS)
Devang Patela43098d2010-04-28 01:03:09 +0000816 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
817 return true;
818}
819
820/// addConstantValue - Add constant value entry in variable DIE.
Devang Patel26c1e562010-05-20 16:36:41 +0000821bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
Devang Patela43098d2010-04-28 01:03:09 +0000822 const MachineOperand &MO) {
823 assert (MO.isImm() && "Invalid machine operand!");
824 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
825 unsigned Imm = MO.getImm();
826 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
827 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
Devang Patel26c1e562010-05-20 16:36:41 +0000828 if (VS)
Devang Patela43098d2010-04-28 01:03:09 +0000829 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
830 return true;
831}
832
833/// addConstantFPValue - Add constant value entry in variable DIE.
Devang Patel26c1e562010-05-20 16:36:41 +0000834bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
Devang Patela43098d2010-04-28 01:03:09 +0000835 const MachineOperand &MO) {
836 assert (MO.isFPImm() && "Invalid machine operand!");
837 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
838 APFloat FPImm = MO.getFPImm()->getValueAPF();
Jim Grosbach1e20b962010-07-21 21:21:52 +0000839
Devang Patela43098d2010-04-28 01:03:09 +0000840 // Get the raw data form of the floating point.
841 const APInt FltVal = FPImm.bitcastToAPInt();
842 const char *FltPtr = (const char*)FltVal.getRawData();
Jim Grosbach1e20b962010-07-21 21:21:52 +0000843
Devang Patela43098d2010-04-28 01:03:09 +0000844 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
845 bool LittleEndian = Asm->getTargetData().isLittleEndian();
846 int Incr = (LittleEndian ? 1 : -1);
847 int Start = (LittleEndian ? 0 : NumBytes - 1);
848 int Stop = (LittleEndian ? NumBytes : -1);
Jim Grosbach1e20b962010-07-21 21:21:52 +0000849
Devang Patela43098d2010-04-28 01:03:09 +0000850 // Output the constant to DWARF one byte at a time.
851 for (; Start != Stop; Start += Incr)
852 addUInt(Block, 0, dwarf::DW_FORM_data1,
853 (unsigned char)0xFF & FltPtr[Start]);
Jim Grosbach1e20b962010-07-21 21:21:52 +0000854
Devang Patela43098d2010-04-28 01:03:09 +0000855 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
Devang Patel26c1e562010-05-20 16:36:41 +0000856 if (VS)
857 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
Jim Grosbach1e20b962010-07-21 21:21:52 +0000858 return true;
Devang Patela43098d2010-04-28 01:03:09 +0000859}
860
861
Devang Patelc366f832009-12-10 19:14:49 +0000862/// addToContextOwner - Add Die into the list of its context owner's children.
863void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
Devang Patel3c91b052010-03-08 20:52:55 +0000864 if (Context.isType()) {
Devang Patel2db49d72010-05-07 18:11:54 +0000865 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
Devang Patelc366f832009-12-10 19:14:49 +0000866 ContextDIE->addChild(Die);
Devang Patel6404e4e2009-12-15 19:16:48 +0000867 } else if (Context.isNameSpace()) {
Devang Patel2db49d72010-05-07 18:11:54 +0000868 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
Devang Patel6404e4e2009-12-15 19:16:48 +0000869 ContextDIE->addChild(Die);
Stuart Hastings215aa152010-06-11 20:08:44 +0000870 } else if (Context.isSubprogram()) {
871 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
872 /*MakeDecl=*/false);
873 ContextDIE->addChild(Die);
Devang Patel163a9f72010-05-10 22:49:55 +0000874 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
Devang Patelc366f832009-12-10 19:14:49 +0000875 ContextDIE->addChild(Die);
Jim Grosbach1e20b962010-07-21 21:21:52 +0000876 else
Devang Patel163a9f72010-05-10 22:49:55 +0000877 getCompileUnit(Context)->addDie(Die);
Devang Patelc366f832009-12-10 19:14:49 +0000878}
879
Devang Patel16ced732009-12-10 18:05:33 +0000880/// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
881/// given DIType.
882DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
Devang Patel163a9f72010-05-10 22:49:55 +0000883 CompileUnit *TypeCU = getCompileUnit(Ty);
884 DIE *TyDIE = TypeCU->getDIE(Ty);
Devang Patel16ced732009-12-10 18:05:33 +0000885 if (TyDIE)
886 return TyDIE;
887
888 // Create new type.
889 TyDIE = new DIE(dwarf::DW_TAG_base_type);
Devang Patel163a9f72010-05-10 22:49:55 +0000890 TypeCU->insertDIE(Ty, TyDIE);
Devang Patel16ced732009-12-10 18:05:33 +0000891 if (Ty.isBasicType())
Devang Patel2db49d72010-05-07 18:11:54 +0000892 constructTypeDIE(*TyDIE, DIBasicType(Ty));
Devang Patel16ced732009-12-10 18:05:33 +0000893 else if (Ty.isCompositeType())
Devang Patel2db49d72010-05-07 18:11:54 +0000894 constructTypeDIE(*TyDIE, DICompositeType(Ty));
Devang Patel16ced732009-12-10 18:05:33 +0000895 else {
896 assert(Ty.isDerivedType() && "Unknown kind of DIType");
Devang Patel2db49d72010-05-07 18:11:54 +0000897 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
Devang Patel16ced732009-12-10 18:05:33 +0000898 }
899
Devang Patelc366f832009-12-10 19:14:49 +0000900 addToContextOwner(TyDIE, Ty.getContext());
Devang Patel16ced732009-12-10 18:05:33 +0000901 return TyDIE;
902}
903
Devang Patel2c4ceb12009-11-21 02:48:08 +0000904/// addType - Add a new type attribute to the specified entity.
Devang Patel8a241142009-12-09 18:24:21 +0000905void DwarfDebug::addType(DIE *Entity, DIType Ty) {
Devang Patel9c004872010-05-07 21:45:47 +0000906 if (!Ty.Verify())
Bill Wendling0310d762009-05-15 09:23:25 +0000907 return;
908
909 // Check for pre-existence.
Devang Patel163a9f72010-05-10 22:49:55 +0000910 CompileUnit *TypeCU = getCompileUnit(Ty);
911 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
Bill Wendling0310d762009-05-15 09:23:25 +0000912 // If it exists then use the existing value.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000913 if (Entry) {
914 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
Bill Wendling0310d762009-05-15 09:23:25 +0000915 return;
916 }
917
Bill Wendling0310d762009-05-15 09:23:25 +0000918 // Construct type.
Devang Patel16ced732009-12-10 18:05:33 +0000919 DIE *Buffer = getOrCreateTypeDIE(Ty);
Bill Wendling0310d762009-05-15 09:23:25 +0000920
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000921 // Set up proxy.
922 Entry = createDIEEntry(Buffer);
Devang Patel163a9f72010-05-10 22:49:55 +0000923 TypeCU->insertDIEEntry(Ty, Entry);
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000924
Devang Patel2c4ceb12009-11-21 02:48:08 +0000925 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
Bill Wendling0310d762009-05-15 09:23:25 +0000926}
927
Devang Patel2c4ceb12009-11-21 02:48:08 +0000928/// constructTypeDIE - Construct basic type die from DIBasicType.
Devang Patel8a241142009-12-09 18:24:21 +0000929void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
Bill Wendling0310d762009-05-15 09:23:25 +0000930 // Get core information.
Devang Patel65dbc902009-11-25 17:36:49 +0000931 StringRef Name = BTy.getName();
Bill Wendling0310d762009-05-15 09:23:25 +0000932 Buffer.setTag(dwarf::DW_TAG_base_type);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000933 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Bill Wendling0310d762009-05-15 09:23:25 +0000934 BTy.getEncoding());
935
936 // Add name if not anonymous or intermediate type.
Devang Patel65dbc902009-11-25 17:36:49 +0000937 if (!Name.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000938 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +0000939 uint64_t Size = BTy.getSizeInBits() >> 3;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000940 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling0310d762009-05-15 09:23:25 +0000941}
942
Devang Patel2c4ceb12009-11-21 02:48:08 +0000943/// constructTypeDIE - Construct derived type die from DIDerivedType.
Devang Patel8a241142009-12-09 18:24:21 +0000944void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
Bill Wendling0310d762009-05-15 09:23:25 +0000945 // Get core information.
Devang Patel65dbc902009-11-25 17:36:49 +0000946 StringRef Name = DTy.getName();
Bill Wendling0310d762009-05-15 09:23:25 +0000947 uint64_t Size = DTy.getSizeInBits() >> 3;
948 unsigned Tag = DTy.getTag();
949
950 // FIXME - Workaround for templates.
951 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
952
953 Buffer.setTag(Tag);
954
955 // Map to main type, void will not have a type.
956 DIType FromTy = DTy.getTypeDerivedFrom();
Devang Patel8a241142009-12-09 18:24:21 +0000957 addType(&Buffer, FromTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000958
959 // Add name if not anonymous or intermediate type.
Devang Pateldeea5642009-11-30 23:56:56 +0000960 if (!Name.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000961 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +0000962
963 // Add size if non-zero (derived types might be zero-sized.)
964 if (Size)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000965 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling0310d762009-05-15 09:23:25 +0000966
967 // Add source line info if available and TyDesc is not a forward declaration.
Devang Patel05f6fa82009-11-23 18:43:37 +0000968 if (!DTy.isForwardDecl())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000969 addSourceLine(&Buffer, &DTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000970}
971
Devang Patel2c4ceb12009-11-21 02:48:08 +0000972/// constructTypeDIE - Construct type DIE from DICompositeType.
Devang Patel8a241142009-12-09 18:24:21 +0000973void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
Bill Wendling0310d762009-05-15 09:23:25 +0000974 // Get core information.
Devang Patel65dbc902009-11-25 17:36:49 +0000975 StringRef Name = CTy.getName();
Bill Wendling0310d762009-05-15 09:23:25 +0000976
977 uint64_t Size = CTy.getSizeInBits() >> 3;
978 unsigned Tag = CTy.getTag();
979 Buffer.setTag(Tag);
980
981 switch (Tag) {
982 case dwarf::DW_TAG_vector_type:
983 case dwarf::DW_TAG_array_type:
Devang Patel8a241142009-12-09 18:24:21 +0000984 constructArrayTypeDIE(Buffer, &CTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000985 break;
986 case dwarf::DW_TAG_enumeration_type: {
987 DIArray Elements = CTy.getTypeArray();
988
989 // Add enumerators to enumeration type.
990 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
991 DIE *ElemDie = NULL;
Devang Patel2db49d72010-05-07 18:11:54 +0000992 DIDescriptor Enum(Elements.getElement(i));
Devang Patel3c91b052010-03-08 20:52:55 +0000993 if (Enum.isEnumerator()) {
Devang Patel2db49d72010-05-07 18:11:54 +0000994 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
Devang Patel2c4ceb12009-11-21 02:48:08 +0000995 Buffer.addChild(ElemDie);
Devang Patelc5254722009-10-09 17:51:49 +0000996 }
Bill Wendling0310d762009-05-15 09:23:25 +0000997 }
998 }
999 break;
1000 case dwarf::DW_TAG_subroutine_type: {
1001 // Add return type.
1002 DIArray Elements = CTy.getTypeArray();
1003 DIDescriptor RTy = Elements.getElement(0);
Devang Patel2db49d72010-05-07 18:11:54 +00001004 addType(&Buffer, DIType(RTy));
Bill Wendling0310d762009-05-15 09:23:25 +00001005
1006 // Add prototype flag.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001007 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001008
1009 // Add arguments.
1010 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1011 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1012 DIDescriptor Ty = Elements.getElement(i);
Devang Patel2db49d72010-05-07 18:11:54 +00001013 addType(Arg, DIType(Ty));
Devang Patel2c4ceb12009-11-21 02:48:08 +00001014 Buffer.addChild(Arg);
Bill Wendling0310d762009-05-15 09:23:25 +00001015 }
1016 }
1017 break;
1018 case dwarf::DW_TAG_structure_type:
1019 case dwarf::DW_TAG_union_type:
1020 case dwarf::DW_TAG_class_type: {
1021 // Add elements to structure type.
1022 DIArray Elements = CTy.getTypeArray();
1023
1024 // A forward struct declared type may not have elements available.
Devang Patel3c91b052010-03-08 20:52:55 +00001025 unsigned N = Elements.getNumElements();
1026 if (N == 0)
Bill Wendling0310d762009-05-15 09:23:25 +00001027 break;
1028
1029 // Add elements to structure type.
Devang Patel3c91b052010-03-08 20:52:55 +00001030 for (unsigned i = 0; i < N; ++i) {
Bill Wendling0310d762009-05-15 09:23:25 +00001031 DIDescriptor Element = Elements.getElement(i);
1032 DIE *ElemDie = NULL;
Devang Patel3c91b052010-03-08 20:52:55 +00001033 if (Element.isSubprogram())
Devang Patel2db49d72010-05-07 18:11:54 +00001034 ElemDie = createSubprogramDIE(DISubprogram(Element));
Devang Patel3c91b052010-03-08 20:52:55 +00001035 else if (Element.isVariable()) {
Devang Patel2db49d72010-05-07 18:11:54 +00001036 DIVariable DV(Element);
Devang Patel1ee0cb92010-01-30 01:08:30 +00001037 ElemDie = new DIE(dwarf::DW_TAG_variable);
1038 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1039 DV.getName());
1040 addType(ElemDie, DV.getType());
1041 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1042 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1043 addSourceLine(ElemDie, &DV);
Devang Patel3c91b052010-03-08 20:52:55 +00001044 } else if (Element.isDerivedType())
Devang Patel2db49d72010-05-07 18:11:54 +00001045 ElemDie = createMemberDIE(DIDerivedType(Element));
Devang Patel3c91b052010-03-08 20:52:55 +00001046 else
1047 continue;
Devang Patel2c4ceb12009-11-21 02:48:08 +00001048 Buffer.addChild(ElemDie);
Bill Wendling0310d762009-05-15 09:23:25 +00001049 }
1050
Devang Patela1ba2692009-08-27 23:51:51 +00001051 if (CTy.isAppleBlockExtension())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001052 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001053
1054 unsigned RLang = CTy.getRunTimeLang();
1055 if (RLang)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001056 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
Bill Wendling0310d762009-05-15 09:23:25 +00001057 dwarf::DW_FORM_data1, RLang);
Devang Patelb5544992010-01-26 21:16:06 +00001058
1059 DICompositeType ContainingType = CTy.getContainingType();
Devang Patel2db49d72010-05-07 18:11:54 +00001060 if (DIDescriptor(ContainingType).isCompositeType())
Jim Grosbach1e20b962010-07-21 21:21:52 +00001061 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
Devang Patel2db49d72010-05-07 18:11:54 +00001062 getOrCreateTypeDIE(DIType(ContainingType)));
Stuart Hastings215aa152010-06-11 20:08:44 +00001063 else {
1064 DIDescriptor Context = CTy.getContext();
1065 addToContextOwner(&Buffer, Context);
1066 }
Bill Wendling0310d762009-05-15 09:23:25 +00001067 break;
1068 }
1069 default:
1070 break;
1071 }
1072
1073 // Add name if not anonymous or intermediate type.
Devang Patel65dbc902009-11-25 17:36:49 +00001074 if (!Name.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001075 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +00001076
Jim Grosbach1e20b962010-07-21 21:21:52 +00001077 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
Devang Patel61409622010-07-07 20:12:52 +00001078 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1079 {
Bill Wendling0310d762009-05-15 09:23:25 +00001080 // Add size if non-zero (derived types might be zero-sized.)
1081 if (Size)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001082 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling0310d762009-05-15 09:23:25 +00001083 else {
1084 // Add zero size if it is not a forward declaration.
1085 if (CTy.isForwardDecl())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001086 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001087 else
Devang Patel2c4ceb12009-11-21 02:48:08 +00001088 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
Bill Wendling0310d762009-05-15 09:23:25 +00001089 }
1090
1091 // Add source line info if available.
1092 if (!CTy.isForwardDecl())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001093 addSourceLine(&Buffer, &CTy);
Bill Wendling0310d762009-05-15 09:23:25 +00001094 }
1095}
1096
Devang Patel2c4ceb12009-11-21 02:48:08 +00001097/// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1098void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
Bill Wendling0310d762009-05-15 09:23:25 +00001099 int64_t L = SR.getLo();
1100 int64_t H = SR.getHi();
1101 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1102
Devang Patel2c4ceb12009-11-21 02:48:08 +00001103 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
Devang Patel6325a532009-08-14 20:59:16 +00001104 if (L)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001105 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
Devang Pateld55224c2009-12-04 23:10:24 +00001106 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
Bill Wendling0310d762009-05-15 09:23:25 +00001107
Devang Patel2c4ceb12009-11-21 02:48:08 +00001108 Buffer.addChild(DW_Subrange);
Bill Wendling0310d762009-05-15 09:23:25 +00001109}
1110
Devang Patel2c4ceb12009-11-21 02:48:08 +00001111/// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
Devang Patel8a241142009-12-09 18:24:21 +00001112void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
Bill Wendling0310d762009-05-15 09:23:25 +00001113 DICompositeType *CTy) {
1114 Buffer.setTag(dwarf::DW_TAG_array_type);
1115 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001116 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001117
1118 // Emit derived type.
Devang Patel8a241142009-12-09 18:24:21 +00001119 addType(&Buffer, CTy->getTypeDerivedFrom());
Bill Wendling0310d762009-05-15 09:23:25 +00001120 DIArray Elements = CTy->getTypeArray();
1121
Devang Patel6f01d9c2009-11-21 00:31:03 +00001122 // Get an anonymous type for index type.
Devang Patel163a9f72010-05-10 22:49:55 +00001123 CompileUnit *TheCU = getCompileUnit(*CTy);
1124 DIE *IdxTy = TheCU->getIndexTyDie();
Devang Patel6f01d9c2009-11-21 00:31:03 +00001125 if (!IdxTy) {
1126 // Construct an anonymous type for index type.
1127 IdxTy = new DIE(dwarf::DW_TAG_base_type);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001128 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1129 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Devang Patel6f01d9c2009-11-21 00:31:03 +00001130 dwarf::DW_ATE_signed);
Devang Patel163a9f72010-05-10 22:49:55 +00001131 TheCU->addDie(IdxTy);
1132 TheCU->setIndexTyDie(IdxTy);
Devang Patel6f01d9c2009-11-21 00:31:03 +00001133 }
Bill Wendling0310d762009-05-15 09:23:25 +00001134
1135 // Add subranges to array type.
1136 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1137 DIDescriptor Element = Elements.getElement(i);
1138 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
Devang Patel2db49d72010-05-07 18:11:54 +00001139 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
Bill Wendling0310d762009-05-15 09:23:25 +00001140 }
1141}
1142
Devang Patel2c4ceb12009-11-21 02:48:08 +00001143/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
Devang Patel3c91b052010-03-08 20:52:55 +00001144DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
Bill Wendling0310d762009-05-15 09:23:25 +00001145 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
Devang Patel3c91b052010-03-08 20:52:55 +00001146 StringRef Name = ETy.getName();
Devang Patel2c4ceb12009-11-21 02:48:08 +00001147 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Devang Patel3c91b052010-03-08 20:52:55 +00001148 int64_t Value = ETy.getEnumValue();
Devang Patel2c4ceb12009-11-21 02:48:08 +00001149 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
Bill Wendling0310d762009-05-15 09:23:25 +00001150 return Enumerator;
1151}
1152
Jim Grosbach1e20b962010-07-21 21:21:52 +00001153/// getRealLinkageName - If special LLVM prefix that is used to inform the asm
Devang Patel351ca332010-01-05 01:46:14 +00001154/// printer to not emit usual symbol prefix before the symbol name is used then
1155/// return linkage name after skipping this special LLVM prefix.
1156static StringRef getRealLinkageName(StringRef LinkageName) {
1157 char One = '\1';
1158 if (LinkageName.startswith(StringRef(&One, 1)))
1159 return LinkageName.substr(1);
1160 return LinkageName;
1161}
1162
Devang Patel2c4ceb12009-11-21 02:48:08 +00001163/// createGlobalVariableDIE - Create new DIE using GV.
Devang Patel8a241142009-12-09 18:24:21 +00001164DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
Jim Grosbach7ab38df2009-11-22 19:20:36 +00001165 // If the global variable was optmized out then no need to create debug info
1166 // entry.
Devang Patel84c73e92009-11-06 17:58:12 +00001167 if (!GV.getGlobal()) return NULL;
Devang Patel65dbc902009-11-25 17:36:49 +00001168 if (GV.getDisplayName().empty()) return NULL;
Devang Patel465c3be2009-11-06 01:30:04 +00001169
Bill Wendling0310d762009-05-15 09:23:25 +00001170 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001171 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
Devang Patel5ccdd102009-09-29 18:40:58 +00001172 GV.getDisplayName());
1173
Devang Patel65dbc902009-11-25 17:36:49 +00001174 StringRef LinkageName = GV.getLinkageName();
Devang Patel351ca332010-01-05 01:46:14 +00001175 if (!LinkageName.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001176 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
Devang Patel351ca332010-01-05 01:46:14 +00001177 getRealLinkageName(LinkageName));
1178
Devang Patel8a241142009-12-09 18:24:21 +00001179 addType(GVDie, GV.getType());
Bill Wendling0310d762009-05-15 09:23:25 +00001180 if (!GV.isLocalToUnit())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001181 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1182 addSourceLine(GVDie, &GV);
Devang Patelb71a16d2009-10-05 23:22:08 +00001183
Bill Wendling0310d762009-05-15 09:23:25 +00001184 return GVDie;
1185}
1186
Devang Patel2c4ceb12009-11-21 02:48:08 +00001187/// createMemberDIE - Create new member DIE.
Devang Patel8a241142009-12-09 18:24:21 +00001188DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
Bill Wendling0310d762009-05-15 09:23:25 +00001189 DIE *MemberDie = new DIE(DT.getTag());
Devang Patel65dbc902009-11-25 17:36:49 +00001190 StringRef Name = DT.getName();
1191 if (!Name.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001192 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001193
Devang Patel8a241142009-12-09 18:24:21 +00001194 addType(MemberDie, DT.getTypeDerivedFrom());
Bill Wendling0310d762009-05-15 09:23:25 +00001195
Devang Patel2c4ceb12009-11-21 02:48:08 +00001196 addSourceLine(MemberDie, &DT);
Bill Wendling0310d762009-05-15 09:23:25 +00001197
Benjamin Kramer345ef342010-03-31 19:34:01 +00001198 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
Devang Patel2c4ceb12009-11-21 02:48:08 +00001199 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
Devang Patel33db5082009-11-04 22:06:12 +00001200
Bill Wendling0310d762009-05-15 09:23:25 +00001201 uint64_t Size = DT.getSizeInBits();
Devang Patel61ecbd12009-11-04 23:48:00 +00001202 uint64_t FieldSize = DT.getOriginalTypeSize();
Bill Wendling0310d762009-05-15 09:23:25 +00001203
1204 if (Size != FieldSize) {
1205 // Handle bitfield.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001206 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1207 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
Bill Wendling0310d762009-05-15 09:23:25 +00001208
1209 uint64_t Offset = DT.getOffsetInBits();
Bill Wendling0310d762009-05-15 09:23:25 +00001210 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1211 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
Benjamin Kramer3d594fd2010-01-07 17:50:57 +00001212 uint64_t FieldOffset = (HiMark - FieldSize);
Bill Wendling0310d762009-05-15 09:23:25 +00001213 Offset -= FieldOffset;
1214
1215 // Maybe we need to work from the other end.
Chris Lattnerd38fee82010-04-05 00:13:49 +00001216 if (Asm->getTargetData().isLittleEndian())
1217 Offset = FieldSize - (Offset + Size);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001218 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
Bill Wendling0310d762009-05-15 09:23:25 +00001219
Devang Patel33db5082009-11-04 22:06:12 +00001220 // Here WD_AT_data_member_location points to the anonymous
1221 // field that includes this bit field.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001222 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
Devang Patel33db5082009-11-04 22:06:12 +00001223
1224 } else
1225 // This is not a bitfield.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001226 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
Devang Patel33db5082009-11-04 22:06:12 +00001227
Devang Patelc1dc8ff2010-02-03 20:08:48 +00001228 if (DT.getTag() == dwarf::DW_TAG_inheritance
1229 && DT.isVirtual()) {
1230
1231 // For C++, virtual base classes are not at fixed offset. Use following
1232 // expression to extract appropriate offset from vtable.
1233 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1234
Benjamin Kramer345ef342010-03-31 19:34:01 +00001235 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
Devang Patelc1dc8ff2010-02-03 20:08:48 +00001236 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1237 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1239 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1240 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1241 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1242 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1243
Jim Grosbach1e20b962010-07-21 21:21:52 +00001244 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
Devang Patelc1dc8ff2010-02-03 20:08:48 +00001245 VBaseLocationDie);
1246 } else
1247 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
Bill Wendling0310d762009-05-15 09:23:25 +00001248
1249 if (DT.isProtected())
Devang Patel5d11eb02009-12-03 19:11:07 +00001250 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
Bill Wendling0310d762009-05-15 09:23:25 +00001251 dwarf::DW_ACCESS_protected);
1252 else if (DT.isPrivate())
Devang Patel5d11eb02009-12-03 19:11:07 +00001253 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
Bill Wendling0310d762009-05-15 09:23:25 +00001254 dwarf::DW_ACCESS_private);
Devang Patel5d11eb02009-12-03 19:11:07 +00001255 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1256 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1257 dwarf::DW_ACCESS_public);
1258 if (DT.isVirtual())
1259 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1260 dwarf::DW_VIRTUALITY_virtual);
Bill Wendling0310d762009-05-15 09:23:25 +00001261 return MemberDie;
1262}
1263
Devang Patelffe966c2009-12-14 16:18:45 +00001264/// createSubprogramDIE - Create new DIE using SP.
1265DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
Devang Patel163a9f72010-05-10 22:49:55 +00001266 CompileUnit *SPCU = getCompileUnit(SP);
1267 DIE *SPDie = SPCU->getDIE(SP);
Devang Patelffe966c2009-12-14 16:18:45 +00001268 if (SPDie)
1269 return SPDie;
1270
1271 SPDie = new DIE(dwarf::DW_TAG_subprogram);
Devang Patel1eac3e72010-03-02 17:58:15 +00001272 // Constructors and operators for anonymous aggregates do not have names.
Devang Patel6b506cb2010-03-02 01:26:20 +00001273 if (!SP.getName().empty())
1274 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
Bill Wendling0310d762009-05-15 09:23:25 +00001275
Devang Patel65dbc902009-11-25 17:36:49 +00001276 StringRef LinkageName = SP.getLinkageName();
Devang Patel351ca332010-01-05 01:46:14 +00001277 if (!LinkageName.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001278 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
Devang Patel351ca332010-01-05 01:46:14 +00001279 getRealLinkageName(LinkageName));
1280
Devang Patel2c4ceb12009-11-21 02:48:08 +00001281 addSourceLine(SPDie, &SP);
Bill Wendling0310d762009-05-15 09:23:25 +00001282
Bill Wendling0310d762009-05-15 09:23:25 +00001283 // Add prototyped tag, if C or ObjC.
1284 unsigned Lang = SP.getCompileUnit().getLanguage();
1285 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1286 Lang == dwarf::DW_LANG_ObjC)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001287 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001288
1289 // Add Return Type.
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001290 DICompositeType SPTy = SP.getType();
1291 DIArray Args = SPTy.getTypeArray();
Bill Wendling0310d762009-05-15 09:23:25 +00001292 unsigned SPTag = SPTy.getTag();
Devang Patel5d11eb02009-12-03 19:11:07 +00001293
Devang Patel3c91b052010-03-08 20:52:55 +00001294 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
Devang Patel8a241142009-12-09 18:24:21 +00001295 addType(SPDie, SPTy);
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001296 else
Devang Patel2db49d72010-05-07 18:11:54 +00001297 addType(SPDie, DIType(Args.getElement(0)));
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001298
Devang Patel5d11eb02009-12-03 19:11:07 +00001299 unsigned VK = SP.getVirtuality();
1300 if (VK) {
1301 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
Benjamin Kramer345ef342010-03-31 19:34:01 +00001302 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel5d11eb02009-12-03 19:11:07 +00001303 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1304 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1305 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001306 ContainingTypeMap.insert(std::make_pair(SPDie,
Devang Patel2db49d72010-05-07 18:11:54 +00001307 SP.getContainingType()));
Devang Patel5d11eb02009-12-03 19:11:07 +00001308 }
1309
Devang Patelffe966c2009-12-14 16:18:45 +00001310 if (MakeDecl || !SP.isDefinition()) {
Devang Patel2c4ceb12009-11-21 02:48:08 +00001311 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001312
1313 // Add arguments. Do not add arguments for subprogram definition. They will
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001314 // be handled while processing variables.
1315 DICompositeType SPTy = SP.getType();
1316 DIArray Args = SPTy.getTypeArray();
1317 unsigned SPTag = SPTy.getTag();
1318
Bill Wendling0310d762009-05-15 09:23:25 +00001319 if (SPTag == dwarf::DW_TAG_subroutine_type)
1320 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1321 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
Devang Patel2db49d72010-05-07 18:11:54 +00001322 DIType ATy = DIType(DIType(Args.getElement(i)));
Devang Patelb4645642010-02-06 01:02:37 +00001323 addType(Arg, ATy);
1324 if (ATy.isArtificial())
1325 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001326 SPDie->addChild(Arg);
Bill Wendling0310d762009-05-15 09:23:25 +00001327 }
1328 }
1329
Devang Patel4e0d19d2010-02-03 19:57:19 +00001330 if (SP.isArtificial())
1331 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1332
Devang Patelccff8122010-04-30 19:38:23 +00001333 if (!SP.isLocalToUnit())
1334 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001335
Devang Patelccff8122010-04-30 19:38:23 +00001336 if (SP.isOptimized())
1337 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1338
Jim Grosbach91729002010-07-21 23:03:52 +00001339 if (unsigned isa = Asm->getISAEncoding()) {
1340 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1341 }
1342
Devang Patelccff8122010-04-30 19:38:23 +00001343 // DW_TAG_inlined_subroutine may refer to this DIE.
Devang Patel163a9f72010-05-10 22:49:55 +00001344 SPCU->insertDIE(SP, SPDie);
Devang Patelccff8122010-04-30 19:38:23 +00001345
Stuart Hastings215aa152010-06-11 20:08:44 +00001346 // Add to context owner.
1347 addToContextOwner(SPDie, SP.getContext());
1348
Bill Wendling0310d762009-05-15 09:23:25 +00001349 return SPDie;
1350}
1351
Devang Patele9f8f5e2010-05-07 20:54:48 +00001352DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
Chris Lattnered7a77b2010-03-31 05:36:29 +00001353 assert(N && "Invalid Scope encoding!");
Devang Patel53bb5c92009-11-10 23:06:00 +00001354
1355 DbgScope *AScope = AbstractScopes.lookup(N);
1356 if (AScope)
1357 return AScope;
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001358
Devang Patel53bb5c92009-11-10 23:06:00 +00001359 DbgScope *Parent = NULL;
1360
1361 DIDescriptor Scope(N);
1362 if (Scope.isLexicalBlock()) {
1363 DILexicalBlock DB(N);
1364 DIDescriptor ParentDesc = DB.getContext();
Devang Patel2db49d72010-05-07 18:11:54 +00001365 Parent = getOrCreateAbstractScope(ParentDesc);
Devang Patel53bb5c92009-11-10 23:06:00 +00001366 }
1367
1368 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1369
1370 if (Parent)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001371 Parent->addScope(AScope);
Devang Patel53bb5c92009-11-10 23:06:00 +00001372 AScope->setAbstractScope();
1373 AbstractScopes[N] = AScope;
1374 if (DIDescriptor(N).isSubprogram())
1375 AbstractScopesList.push_back(AScope);
1376 return AScope;
1377}
Devang Patelaf9e8472009-10-01 20:31:14 +00001378
Devang Patel5f094002010-04-06 23:53:48 +00001379/// isSubprogramContext - Return true if Context is either a subprogram
1380/// or another context nested inside a subprogram.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001381static bool isSubprogramContext(const MDNode *Context) {
Devang Patel5f094002010-04-06 23:53:48 +00001382 if (!Context)
1383 return false;
1384 DIDescriptor D(Context);
1385 if (D.isSubprogram())
1386 return true;
1387 if (D.isType())
Devang Patel2db49d72010-05-07 18:11:54 +00001388 return isSubprogramContext(DIType(Context).getContext());
Devang Patel5f094002010-04-06 23:53:48 +00001389 return false;
1390}
1391
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001392/// updateSubprogramScopeDIE - Find DIE for the given subprogram and
Devang Patel2c4ceb12009-11-21 02:48:08 +00001393/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1394/// If there are global variables in this scope then create and insert
1395/// DIEs for these variables.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001396DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
Devang Patel163a9f72010-05-10 22:49:55 +00001397 CompileUnit *SPCU = getCompileUnit(SPNode);
1398 DIE *SPDie = SPCU->getDIE(SPNode);
Devang Patel8aa61472010-07-07 22:20:57 +00001399
Chris Lattnerd38fee82010-04-05 00:13:49 +00001400 assert(SPDie && "Unable to find subprogram DIE!");
1401 DISubprogram SP(SPNode);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001402
Chris Lattnerd38fee82010-04-05 00:13:49 +00001403 // There is not any need to generate specification DIE for a function
1404 // defined at compile unit level. If a function is defined inside another
1405 // function then gdb prefers the definition at top level and but does not
Jim Grosbach1e20b962010-07-21 21:21:52 +00001406 // expect specification DIE in parent function. So avoid creating
Chris Lattnerd38fee82010-04-05 00:13:49 +00001407 // specification DIE for a function defined inside a function.
1408 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
Jim Grosbach1e20b962010-07-21 21:21:52 +00001409 !SP.getContext().isFile() &&
Devang Patel2db49d72010-05-07 18:11:54 +00001410 !isSubprogramContext(SP.getContext())) {
Chris Lattnerd38fee82010-04-05 00:13:49 +00001411 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001412
1413 // Add arguments.
Chris Lattnerd38fee82010-04-05 00:13:49 +00001414 DICompositeType SPTy = SP.getType();
1415 DIArray Args = SPTy.getTypeArray();
1416 unsigned SPTag = SPTy.getTag();
1417 if (SPTag == dwarf::DW_TAG_subroutine_type)
1418 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1419 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
Devang Patel2db49d72010-05-07 18:11:54 +00001420 DIType ATy = DIType(DIType(Args.getElement(i)));
Chris Lattnerd38fee82010-04-05 00:13:49 +00001421 addType(Arg, ATy);
1422 if (ATy.isArtificial())
1423 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1424 SPDie->addChild(Arg);
1425 }
1426 DIE *SPDeclDie = SPDie;
1427 SPDie = new DIE(dwarf::DW_TAG_subprogram);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001428 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
Chris Lattnerd38fee82010-04-05 00:13:49 +00001429 SPDeclDie);
Devang Patel163a9f72010-05-10 22:49:55 +00001430 SPCU->addDie(SPDie);
Chris Lattnerd38fee82010-04-05 00:13:49 +00001431 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00001432
Devang Patel8aa61472010-07-07 22:20:57 +00001433 // Pick up abstract subprogram DIE.
1434 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1435 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1436 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1437 dwarf::DW_FORM_ref4, AbsSPDIE);
1438 SPCU->addDie(SPDie);
1439 }
1440
Chris Lattnerd38fee82010-04-05 00:13:49 +00001441 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1442 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1443 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1444 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1445 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1446 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1447 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
Devang Patelb4645642010-02-06 01:02:37 +00001448
Chris Lattnerd38fee82010-04-05 00:13:49 +00001449 return SPDie;
Devang Patel53bb5c92009-11-10 23:06:00 +00001450}
1451
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001452/// constructLexicalScope - Construct new DW_TAG_lexical_block
Devang Patel2c4ceb12009-11-21 02:48:08 +00001453/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1454DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
Devang Pateleac9c072010-04-27 19:46:33 +00001455
1456 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1457 if (Scope->isAbstractScope())
1458 return ScopeDIE;
1459
1460 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1461 if (Ranges.empty())
1462 return 0;
1463
1464 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1465 if (Ranges.size() > 1) {
1466 // .debug_range section has not been laid out yet. Emit offset in
Jim Grosbach1e20b962010-07-21 21:21:52 +00001467 // .debug_range as a uint, size 4, for now. emitDIE will handle
Devang Pateleac9c072010-04-27 19:46:33 +00001468 // DW_AT_ranges appropriately.
1469 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1470 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1471 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1472 RE = Ranges.end(); RI != RE; ++RI) {
Devang Patelc3f5f782010-05-25 23:40:22 +00001473 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1474 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
Devang Pateleac9c072010-04-27 19:46:33 +00001475 }
1476 DebugRangeSymbols.push_back(NULL);
1477 DebugRangeSymbols.push_back(NULL);
1478 return ScopeDIE;
1479 }
1480
Devang Patelc3f5f782010-05-25 23:40:22 +00001481 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1482 const MCSymbol *End = getLabelAfterInsn(RI->second);
Devang Pateleac9c072010-04-27 19:46:33 +00001483
Devang Patelc3f5f782010-05-25 23:40:22 +00001484 if (End == 0) return 0;
Devang Patel53bb5c92009-11-10 23:06:00 +00001485
Chris Lattnerb7db7332010-03-09 01:58:53 +00001486 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1487 assert(End->isDefined() && "Invalid end label for an inlined scope!");
Jim Grosbach1e20b962010-07-21 21:21:52 +00001488
Devang Pateleac9c072010-04-27 19:46:33 +00001489 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1490 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
Devang Patel53bb5c92009-11-10 23:06:00 +00001491
1492 return ScopeDIE;
1493}
1494
Devang Patel2c4ceb12009-11-21 02:48:08 +00001495/// constructInlinedScopeDIE - This scope represents inlined body of
1496/// a function. Construct DIE to represent this concrete inlined copy
1497/// of the function.
1498DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
Devang Pateleac9c072010-04-27 19:46:33 +00001499
1500 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
Jim Grosbach1e20b962010-07-21 21:21:52 +00001501 assert (Ranges.empty() == false
Devang Pateleac9c072010-04-27 19:46:33 +00001502 && "DbgScope does not have instruction markers!");
1503
1504 // FIXME : .debug_inlined section specification does not clearly state how
1505 // to emit inlined scope that is split into multiple instruction ranges.
1506 // For now, use first instruction range and emit low_pc/high_pc pair and
1507 // corresponding .debug_inlined section entry for this pair.
1508 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
Devang Patelc3f5f782010-05-25 23:40:22 +00001509 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1510 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
Devang Pateleac9c072010-04-27 19:46:33 +00001511
Devang Patel0afbf232010-07-08 22:39:20 +00001512 if (StartLabel == 0 || EndLabel == 0) {
Devang Pateleac9c072010-04-27 19:46:33 +00001513 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1514 return 0;
1515 }
Chris Lattnerb7db7332010-03-09 01:58:53 +00001516 assert(StartLabel->isDefined() &&
Chris Lattnera34ec2292010-03-09 01:51:43 +00001517 "Invalid starting label for an inlined scope!");
Chris Lattnerb7db7332010-03-09 01:58:53 +00001518 assert(EndLabel->isDefined() &&
Chris Lattnera34ec2292010-03-09 01:51:43 +00001519 "Invalid end label for an inlined scope!");
Devang Pateleac9c072010-04-27 19:46:33 +00001520
Devang Patel3c91b052010-03-08 20:52:55 +00001521 if (!Scope->getScopeNode())
Devang Patel0ef3fa62010-03-08 19:20:38 +00001522 return NULL;
Devang Patel3c91b052010-03-08 20:52:55 +00001523 DIScope DS(Scope->getScopeNode());
Devang Patel53bb5c92009-11-10 23:06:00 +00001524 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1525
Devang Patel2db49d72010-05-07 18:11:54 +00001526 DISubprogram InlinedSP = getDISubprogram(DS);
Devang Patel163a9f72010-05-10 22:49:55 +00001527 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1528 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
Chris Lattnered7a77b2010-03-31 05:36:29 +00001529 assert(OriginDIE && "Unable to find Origin DIE!");
Devang Patel2c4ceb12009-11-21 02:48:08 +00001530 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
Devang Patel53bb5c92009-11-10 23:06:00 +00001531 dwarf::DW_FORM_ref4, OriginDIE);
1532
Chris Lattner6ed0f902010-03-09 00:31:02 +00001533 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
Chris Lattnerb7db7332010-03-09 01:58:53 +00001534 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
Devang Patel53bb5c92009-11-10 23:06:00 +00001535
1536 InlinedSubprogramDIEs.insert(OriginDIE);
1537
1538 // Track the start label for this inlined function.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001539 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
Devang Patel2db49d72010-05-07 18:11:54 +00001540 I = InlineInfo.find(InlinedSP);
Devang Patel53bb5c92009-11-10 23:06:00 +00001541
1542 if (I == InlineInfo.end()) {
Devang Patel2db49d72010-05-07 18:11:54 +00001543 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
Jim Grosbach7ab38df2009-11-22 19:20:36 +00001544 ScopeDIE));
Devang Patel2db49d72010-05-07 18:11:54 +00001545 InlinedSPNodes.push_back(InlinedSP);
Devang Patel53bb5c92009-11-10 23:06:00 +00001546 } else
Chris Lattner6ed0f902010-03-09 00:31:02 +00001547 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
Devang Patel53bb5c92009-11-10 23:06:00 +00001548
Devang Patel53bb5c92009-11-10 23:06:00 +00001549 DILocation DL(Scope->getInlinedAt());
Devang Patel163a9f72010-05-10 22:49:55 +00001550 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
Devang Patel2c4ceb12009-11-21 02:48:08 +00001551 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
Devang Patel53bb5c92009-11-10 23:06:00 +00001552
1553 return ScopeDIE;
1554}
1555
Devang Patel2c4ceb12009-11-21 02:48:08 +00001556
1557/// constructVariableDIE - Construct a DIE for the given DbgVariable.
Devang Patel8a241142009-12-09 18:24:21 +00001558DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
Devang Patel53bb5c92009-11-10 23:06:00 +00001559 // Get the descriptor.
1560 const DIVariable &VD = DV->getVariable();
Devang Patel65dbc902009-11-25 17:36:49 +00001561 StringRef Name = VD.getName();
1562 if (Name.empty())
Devang Patel3fb6bd62009-11-13 02:25:26 +00001563 return NULL;
Devang Patel53bb5c92009-11-10 23:06:00 +00001564
1565 // Translate tag to proper Dwarf tag. The result variable is dropped for
1566 // now.
1567 unsigned Tag;
1568 switch (VD.getTag()) {
1569 case dwarf::DW_TAG_return_variable:
1570 return NULL;
1571 case dwarf::DW_TAG_arg_variable:
1572 Tag = dwarf::DW_TAG_formal_parameter;
1573 break;
1574 case dwarf::DW_TAG_auto_variable: // fall thru
1575 default:
1576 Tag = dwarf::DW_TAG_variable;
1577 break;
1578 }
1579
1580 // Define variable debug information entry.
1581 DIE *VariableDie = new DIE(Tag);
1582
Devang Patel53bb5c92009-11-10 23:06:00 +00001583 DIE *AbsDIE = NULL;
Devang Patel26c1e562010-05-20 16:36:41 +00001584 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1585 V2AVI = VarToAbstractVarMap.find(DV);
1586 if (V2AVI != VarToAbstractVarMap.end())
1587 AbsDIE = V2AVI->second->getDIE();
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001588
Devang Patel26c1e562010-05-20 16:36:41 +00001589 if (AbsDIE)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001590 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
Devang Patel53bb5c92009-11-10 23:06:00 +00001591 dwarf::DW_FORM_ref4, AbsDIE);
Devang Patel53bb5c92009-11-10 23:06:00 +00001592 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +00001593 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1594 addSourceLine(VariableDie, &VD);
Devang Patel53bb5c92009-11-10 23:06:00 +00001595
1596 // Add variable type.
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001597 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
Devang Patel53bb5c92009-11-10 23:06:00 +00001598 // addresses instead.
1599 if (VD.isBlockByrefVariable())
Devang Patel8a241142009-12-09 18:24:21 +00001600 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
Devang Patel53bb5c92009-11-10 23:06:00 +00001601 else
Devang Patel8a241142009-12-09 18:24:21 +00001602 addType(VariableDie, VD.getType());
Devang Patel53bb5c92009-11-10 23:06:00 +00001603 }
1604
Devang Patelb4645642010-02-06 01:02:37 +00001605 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1606 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
Devang Patelc3f5f782010-05-25 23:40:22 +00001607
1608 if (Scope->isAbstractScope()) {
1609 DV->setDIE(VariableDie);
1610 return VariableDie;
1611 }
1612
1613 // Add variable address.
1614
1615 unsigned Offset = DV->getDotDebugLocOffset();
1616 if (Offset != ~0U) {
1617 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1618 Asm->GetTempSymbol("debug_loc", Offset));
1619 DV->setDIE(VariableDie);
1620 UseDotDebugLocEntry.insert(VariableDie);
1621 return VariableDie;
1622 }
1623
1624 // Check if variable is described by a DBG_VALUE instruction.
1625 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1626 DbgVariableToDbgInstMap.find(DV);
1627 if (DVI != DbgVariableToDbgInstMap.end()) {
1628 const MachineInstr *DVInsn = DVI->second;
1629 const MCSymbol *DVLabel = findVariableLabel(DV);
1630 bool updated = false;
Jim Grosbach1e20b962010-07-21 21:21:52 +00001631 // FIXME : Handle getNumOperands != 3
Devang Patelc3f5f782010-05-25 23:40:22 +00001632 if (DVInsn->getNumOperands() == 3) {
1633 if (DVInsn->getOperand(0).isReg())
Jim Grosbach1e20b962010-07-21 21:21:52 +00001634 updated =
Devang Patel61409622010-07-07 20:12:52 +00001635 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
Devang Patelc3f5f782010-05-25 23:40:22 +00001636 else if (DVInsn->getOperand(0).isImm())
1637 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
Jim Grosbach1e20b962010-07-21 21:21:52 +00001638 else if (DVInsn->getOperand(0).isFPImm())
1639 updated =
Devang Patel61409622010-07-07 20:12:52 +00001640 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
Devang Patelc3f5f782010-05-25 23:40:22 +00001641 } else {
1642 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1643 if (Location.getReg()) {
1644 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1645 if (DVLabel)
1646 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1647 DVLabel);
1648 updated = true;
1649 }
1650 }
1651 if (!updated) {
1652 // If variableDie is not updated then DBG_VALUE instruction does not
1653 // have valid variable info.
1654 delete VariableDie;
1655 return NULL;
1656 }
1657 DV->setDIE(VariableDie);
1658 return VariableDie;
Jim Grosbach1e20b962010-07-21 21:21:52 +00001659 }
Devang Patelc3f5f782010-05-25 23:40:22 +00001660
1661 // .. else use frame index, if available.
1662 MachineLocation Location;
1663 unsigned FrameReg;
1664 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1665 int FI = 0;
1666 if (findVariableFrameIndex(DV, &FI)) {
1667 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1668 Location.set(FrameReg, Offset);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001669
Devang Patelc3f5f782010-05-25 23:40:22 +00001670 if (VD.hasComplexAddress())
1671 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1672 else if (VD.isBlockByrefVariable())
1673 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1674 else
1675 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1676 }
Devang Patel53bb5c92009-11-10 23:06:00 +00001677 DV->setDIE(VariableDie);
1678 return VariableDie;
1679
1680}
Devang Patel2c4ceb12009-11-21 02:48:08 +00001681
Devang Patel193f7202009-11-24 01:14:22 +00001682void DwarfDebug::addPubTypes(DISubprogram SP) {
1683 DICompositeType SPTy = SP.getType();
1684 unsigned SPTag = SPTy.getTag();
Jim Grosbach1e20b962010-07-21 21:21:52 +00001685 if (SPTag != dwarf::DW_TAG_subroutine_type)
Devang Patel193f7202009-11-24 01:14:22 +00001686 return;
1687
1688 DIArray Args = SPTy.getTypeArray();
Devang Patel193f7202009-11-24 01:14:22 +00001689 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
Devang Patel2db49d72010-05-07 18:11:54 +00001690 DIType ATy(Args.getElement(i));
Devang Patel9c004872010-05-07 21:45:47 +00001691 if (!ATy.Verify())
Devang Patel193f7202009-11-24 01:14:22 +00001692 continue;
1693 DICompositeType CATy = getDICompositeType(ATy);
Devang Patel2db49d72010-05-07 18:11:54 +00001694 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
Devang Patel50d80e32010-04-13 20:35:04 +00001695 && !CATy.isForwardDecl()) {
Devang Patel163a9f72010-05-10 22:49:55 +00001696 CompileUnit *TheCU = getCompileUnit(CATy);
1697 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1698 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
Devang Patel193f7202009-11-24 01:14:22 +00001699 }
1700 }
1701}
1702
Devang Patel2c4ceb12009-11-21 02:48:08 +00001703/// constructScopeDIE - Construct a DIE for this scope.
1704DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
Devang Patel3c91b052010-03-08 20:52:55 +00001705 if (!Scope || !Scope->getScopeNode())
1706 return NULL;
Jim Grosbach1e20b962010-07-21 21:21:52 +00001707
Devang Patel3c91b052010-03-08 20:52:55 +00001708 DIScope DS(Scope->getScopeNode());
1709 DIE *ScopeDIE = NULL;
1710 if (Scope->getInlinedAt())
1711 ScopeDIE = constructInlinedScopeDIE(Scope);
1712 else if (DS.isSubprogram()) {
Devang Patel0dd45582010-06-28 20:53:04 +00001713 ProcessedSPNodes.insert(DS);
Devang Patel8aa61472010-07-07 22:20:57 +00001714 if (Scope->isAbstractScope()) {
Devang Patel163a9f72010-05-10 22:49:55 +00001715 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
Devang Patel8aa61472010-07-07 22:20:57 +00001716 // Note down abstract DIE.
1717 if (ScopeDIE)
1718 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1719 }
Devang Patel3c91b052010-03-08 20:52:55 +00001720 else
Devang Patel2db49d72010-05-07 18:11:54 +00001721 ScopeDIE = updateSubprogramScopeDIE(DS);
Devang Patel3c91b052010-03-08 20:52:55 +00001722 }
Devang Patelaead63c2010-03-29 22:59:58 +00001723 else
Devang Patel3c91b052010-03-08 20:52:55 +00001724 ScopeDIE = constructLexicalScopeDIE(Scope);
Devang Patelaead63c2010-03-29 22:59:58 +00001725 if (!ScopeDIE) return NULL;
Jim Grosbach1e20b962010-07-21 21:21:52 +00001726
Devang Patel53bb5c92009-11-10 23:06:00 +00001727 // Add variables to scope.
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00001728 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
Devang Patel53bb5c92009-11-10 23:06:00 +00001729 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
Devang Patel8a241142009-12-09 18:24:21 +00001730 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001731 if (VariableDIE)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001732 ScopeDIE->addChild(VariableDIE);
Devang Patel53bb5c92009-11-10 23:06:00 +00001733 }
1734
1735 // Add nested scopes.
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00001736 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
Devang Patel53bb5c92009-11-10 23:06:00 +00001737 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1738 // Define the Scope debug information entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001739 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001740 if (NestedDIE)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001741 ScopeDIE->addChild(NestedDIE);
Devang Patel53bb5c92009-11-10 23:06:00 +00001742 }
Devang Patel193f7202009-11-24 01:14:22 +00001743
Jim Grosbach1e20b962010-07-21 21:21:52 +00001744 if (DS.isSubprogram())
Devang Patel2db49d72010-05-07 18:11:54 +00001745 addPubTypes(DISubprogram(DS));
Jim Grosbach1e20b962010-07-21 21:21:52 +00001746
Devang Patel193f7202009-11-24 01:14:22 +00001747 return ScopeDIE;
Devang Patel53bb5c92009-11-10 23:06:00 +00001748}
1749
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001750/// GetOrCreateSourceID - Look up the source id with the given directory and
1751/// source file names. If none currently exists, create a new id and insert it
1752/// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1753/// maps as well.
Chris Lattner1d65ba72010-03-31 06:06:37 +00001754unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001755 unsigned DId;
Devang Patel2f584852010-07-24 00:53:22 +00001756 if (DirName.empty()) {
1757 llvm::sys::Path CWD = llvm::sys::Path::GetCurrentDirectory();
1758 DirName = StringRef(CWD.c_str(), CWD.size());
1759 }
1760
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001761 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1762 if (DI != DirectoryIdMap.end()) {
1763 DId = DI->getValue();
1764 } else {
1765 DId = DirectoryNames.size() + 1;
1766 DirectoryIdMap[DirName] = DId;
1767 DirectoryNames.push_back(DirName);
1768 }
1769
1770 unsigned FId;
1771 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1772 if (FI != SourceFileIdMap.end()) {
1773 FId = FI->getValue();
1774 } else {
1775 FId = SourceFileNames.size() + 1;
1776 SourceFileIdMap[FileName] = FId;
1777 SourceFileNames.push_back(FileName);
1778 }
1779
1780 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1781 SourceIdMap.find(std::make_pair(DId, FId));
1782 if (SI != SourceIdMap.end())
1783 return SI->second;
1784
1785 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1786 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1787 SourceIds.push_back(std::make_pair(DId, FId));
1788
1789 return SrcId;
1790}
1791
Devang Patel6404e4e2009-12-15 19:16:48 +00001792/// getOrCreateNameSpace - Create a DIE for DINameSpace.
1793DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
Devang Patel163a9f72010-05-10 22:49:55 +00001794 CompileUnit *TheCU = getCompileUnit(NS);
1795 DIE *NDie = TheCU->getDIE(NS);
Devang Patel6404e4e2009-12-15 19:16:48 +00001796 if (NDie)
1797 return NDie;
1798 NDie = new DIE(dwarf::DW_TAG_namespace);
Devang Patel163a9f72010-05-10 22:49:55 +00001799 TheCU->insertDIE(NS, NDie);
Devang Patel6404e4e2009-12-15 19:16:48 +00001800 if (!NS.getName().empty())
1801 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1802 addSourceLine(NDie, &NS);
1803 addToContextOwner(NDie, NS.getContext());
1804 return NDie;
1805}
1806
Jim Grosbach1e20b962010-07-21 21:21:52 +00001807/// constructCompileUnit - Create new CompileUnit for the given
Devang Patel163a9f72010-05-10 22:49:55 +00001808/// metadata node with tag DW_TAG_compile_unit.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001809void DwarfDebug::constructCompileUnit(const MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +00001810 DICompileUnit DIUnit(N);
Devang Patel65dbc902009-11-25 17:36:49 +00001811 StringRef FN = DIUnit.getFilename();
1812 StringRef Dir = DIUnit.getDirectory();
Devang Patel5ccdd102009-09-29 18:40:58 +00001813 unsigned ID = GetOrCreateSourceID(Dir, FN);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001814
1815 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001816 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
Devang Patel5ccdd102009-09-29 18:40:58 +00001817 DIUnit.getProducer());
Devang Patel2c4ceb12009-11-21 02:48:08 +00001818 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001819 DIUnit.getLanguage());
Devang Patel2c4ceb12009-11-21 02:48:08 +00001820 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
Devang Patel5098da02010-04-26 22:54:28 +00001821 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1822 // simplifies debug range entries.
Devang Patel9b93b6b2010-06-28 22:22:47 +00001823 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
Devang Patel4a602ca2010-03-22 23:11:36 +00001824 // DW_AT_stmt_list is a offset of line number information for this
Jim Grosbach1e20b962010-07-21 21:21:52 +00001825 // compile unit in debug_line section. This offset is calculated
Devang Patel1e4782d2010-06-29 20:17:53 +00001826 // during endMoudle().
1827 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001828
Devang Patel65dbc902009-11-25 17:36:49 +00001829 if (!Dir.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001830 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001831 if (DIUnit.isOptimized())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001832 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001833
Devang Patel65dbc902009-11-25 17:36:49 +00001834 StringRef Flags = DIUnit.getFlags();
1835 if (!Flags.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001836 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001837
1838 unsigned RVer = DIUnit.getRunTimeVersion();
1839 if (RVer)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001840 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001841 dwarf::DW_FORM_data1, RVer);
1842
Devang Patel163a9f72010-05-10 22:49:55 +00001843 CompileUnit *NewCU = new CompileUnit(ID, Die);
1844 if (!FirstCU)
1845 FirstCU = NewCU;
1846 CUMap.insert(std::make_pair(N, NewCU));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001847}
1848
Devang Patel163a9f72010-05-10 22:49:55 +00001849/// getCompielUnit - Get CompileUnit DIE.
1850CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1851 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1852 DIDescriptor D(N);
1853 const MDNode *CUNode = NULL;
1854 if (D.isCompileUnit())
1855 CUNode = N;
1856 else if (D.isSubprogram())
1857 CUNode = DISubprogram(N).getCompileUnit();
1858 else if (D.isType())
1859 CUNode = DIType(N).getCompileUnit();
1860 else if (D.isGlobalVariable())
1861 CUNode = DIGlobalVariable(N).getCompileUnit();
1862 else if (D.isVariable())
1863 CUNode = DIVariable(N).getCompileUnit();
1864 else if (D.isNameSpace())
1865 CUNode = DINameSpace(N).getCompileUnit();
1866 else if (D.isFile())
1867 CUNode = DIFile(N).getCompileUnit();
1868 else
1869 return FirstCU;
1870
1871 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1872 = CUMap.find(CUNode);
1873 if (I == CUMap.end())
1874 return FirstCU;
1875 return I->second;
1876}
1877
1878
1879/// constructGlobalVariableDIE - Construct global variable DIE.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001880void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +00001881 DIGlobalVariable DI_GV(N);
Daniel Dunbarf612ff62009-09-19 20:40:05 +00001882
Devang Patel905cf5e2009-09-04 23:59:07 +00001883 // If debug information is malformed then ignore it.
1884 if (DI_GV.Verify() == false)
1885 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001886
1887 // Check for pre-existence.
Devang Patel163a9f72010-05-10 22:49:55 +00001888 CompileUnit *TheCU = getCompileUnit(N);
1889 if (TheCU->getDIE(DI_GV))
Devang Patel13e16b62009-06-26 01:49:18 +00001890 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001891
Devang Patel8a241142009-12-09 18:24:21 +00001892 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
Devang Pateledb45632009-12-10 23:25:41 +00001893 if (!VariableDie)
1894 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001895
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001896 // Add to map.
Devang Patel163a9f72010-05-10 22:49:55 +00001897 TheCU->insertDIE(N, VariableDie);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001898
1899 // Add to context owner.
Devang Patelc9b16cc2010-01-15 01:12:22 +00001900 DIDescriptor GVContext = DI_GV.getContext();
1901 // Do not create specification DIE if context is either compile unit
1902 // or a subprogram.
Chris Lattner1d65ba72010-03-31 06:06:37 +00001903 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
Jim Grosbach1e20b962010-07-21 21:21:52 +00001904 !GVContext.isFile() &&
Devang Patel2db49d72010-05-07 18:11:54 +00001905 !isSubprogramContext(GVContext)) {
Devang Patel6404e4e2009-12-15 19:16:48 +00001906 // Create specification DIE.
1907 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1908 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1909 dwarf::DW_FORM_ref4, VariableDie);
Benjamin Kramer345ef342010-03-31 19:34:01 +00001910 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel6404e4e2009-12-15 19:16:48 +00001911 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
Chris Lattner4faf59a2010-03-08 22:31:46 +00001912 addLabel(Block, 0, dwarf::DW_FORM_udata,
Chris Lattnerdeb0cba2010-03-12 21:09:07 +00001913 Asm->Mang->getSymbol(DI_GV.getGlobal()));
Devang Patel6404e4e2009-12-15 19:16:48 +00001914 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
Devang Patel8581e012010-02-09 01:58:33 +00001915 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Devang Patel163a9f72010-05-10 22:49:55 +00001916 TheCU->addDie(VariableSpecDIE);
Devang Patel6404e4e2009-12-15 19:16:48 +00001917 } else {
Benjamin Kramer345ef342010-03-31 19:34:01 +00001918 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel6404e4e2009-12-15 19:16:48 +00001919 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
Chris Lattner4faf59a2010-03-08 22:31:46 +00001920 addLabel(Block, 0, dwarf::DW_FORM_udata,
Chris Lattnerdeb0cba2010-03-12 21:09:07 +00001921 Asm->Mang->getSymbol(DI_GV.getGlobal()));
Devang Patel6404e4e2009-12-15 19:16:48 +00001922 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1923 }
Devang Patelc9b16cc2010-01-15 01:12:22 +00001924 addToContextOwner(VariableDie, GVContext);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001925
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001926 // Expose as global. FIXME - need to check external flag.
Devang Patel163a9f72010-05-10 22:49:55 +00001927 TheCU->addGlobal(DI_GV.getName(), VariableDie);
Devang Patel193f7202009-11-24 01:14:22 +00001928
1929 DIType GTy = DI_GV.getType();
Devang Patel50d80e32010-04-13 20:35:04 +00001930 if (GTy.isCompositeType() && !GTy.getName().empty()
1931 && !GTy.isForwardDecl()) {
Devang Patel163a9f72010-05-10 22:49:55 +00001932 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
Chris Lattnered7a77b2010-03-31 05:36:29 +00001933 assert(Entry && "Missing global type!");
Devang Patel163a9f72010-05-10 22:49:55 +00001934 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
Devang Patel193f7202009-11-24 01:14:22 +00001935 }
Devang Patel13e16b62009-06-26 01:49:18 +00001936 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001937}
1938
Devang Patel163a9f72010-05-10 22:49:55 +00001939/// construct SubprogramDIE - Construct subprogram DIE.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001940void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +00001941 DISubprogram SP(N);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001942
Stuart Hastings639336e2010-04-06 21:38:29 +00001943 // Check for pre-existence.
Devang Patel163a9f72010-05-10 22:49:55 +00001944 CompileUnit *TheCU = getCompileUnit(N);
1945 if (TheCU->getDIE(N))
Stuart Hastings639336e2010-04-06 21:38:29 +00001946 return;
1947
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001948 if (!SP.isDefinition())
1949 // This is a method declaration which will be handled while constructing
1950 // class type.
Devang Patel13e16b62009-06-26 01:49:18 +00001951 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001952
Stuart Hastings639336e2010-04-06 21:38:29 +00001953 DIE *SubprogramDie = createSubprogramDIE(SP);
1954
1955 // Add to map.
Devang Patel163a9f72010-05-10 22:49:55 +00001956 TheCU->insertDIE(N, SubprogramDie);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001957
1958 // Add to context owner.
Devang Patel6404e4e2009-12-15 19:16:48 +00001959 addToContextOwner(SubprogramDie, SP.getContext());
Devang Patel0000fad2009-12-08 23:21:45 +00001960
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001961 // Expose as global.
Devang Patel163a9f72010-05-10 22:49:55 +00001962 TheCU->addGlobal(SP.getName(), SubprogramDie);
Devang Patel193f7202009-11-24 01:14:22 +00001963
Devang Patel13e16b62009-06-26 01:49:18 +00001964 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001965}
1966
Devang Patel2c4ceb12009-11-21 02:48:08 +00001967/// beginModule - Emit all Dwarf sections that should come prior to the
Daniel Dunbar00564992009-09-19 20:40:14 +00001968/// content. Create global DIEs and emit initial debug info sections.
1969/// This is inovked by the target AsmPrinter.
Chris Lattner75f50722010-04-04 07:48:20 +00001970void DwarfDebug::beginModule(Module *M) {
Devang Pateleac9c072010-04-27 19:46:33 +00001971 if (DisableDebugInfoPrinting)
1972 return;
1973
Devang Patel78ab9e22009-07-30 18:56:46 +00001974 DebugInfoFinder DbgFinder;
1975 DbgFinder.processModule(*M);
Devang Patel13e16b62009-06-26 01:49:18 +00001976
Chris Lattnerd850ac72010-04-05 02:19:28 +00001977 bool HasDebugInfo = false;
Jim Grosbach1e20b962010-07-21 21:21:52 +00001978
Chris Lattnerd850ac72010-04-05 02:19:28 +00001979 // Scan all the compile-units to see if there are any marked as the main unit.
1980 // if not, we do not generate debug info.
1981 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1982 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1983 if (DICompileUnit(*I).isMain()) {
1984 HasDebugInfo = true;
1985 break;
1986 }
1987 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00001988
Chris Lattnerd850ac72010-04-05 02:19:28 +00001989 if (!HasDebugInfo) return;
1990
1991 // Tell MMI that we have debug info.
1992 MMI->setDebugInfoAvailability(true);
Jim Grosbach1e20b962010-07-21 21:21:52 +00001993
Chris Lattnerbe15beb2010-04-04 23:17:54 +00001994 // Emit initial sections.
Chris Lattnerd850ac72010-04-05 02:19:28 +00001995 EmitSectionLabels();
Jim Grosbach1e20b962010-07-21 21:21:52 +00001996
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001997 // Create all the compile unit DIEs.
Devang Patel78ab9e22009-07-30 18:56:46 +00001998 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1999 E = DbgFinder.compile_unit_end(); I != E; ++I)
Devang Patel2c4ceb12009-11-21 02:48:08 +00002000 constructCompileUnit(*I);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002001
Devang Patel53bb5c92009-11-10 23:06:00 +00002002 // Create DIEs for each subprogram.
Devang Patel78ab9e22009-07-30 18:56:46 +00002003 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2004 E = DbgFinder.subprogram_end(); I != E; ++I)
Devang Patel2c4ceb12009-11-21 02:48:08 +00002005 constructSubprogramDIE(*I);
Devang Patel13e16b62009-06-26 01:49:18 +00002006
Devang Patelc366f832009-12-10 19:14:49 +00002007 // Create DIEs for each global variable.
2008 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2009 E = DbgFinder.global_variable_end(); I != E; ++I)
2010 constructGlobalVariableDIE(*I);
2011
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002012 // Prime section data.
Chris Lattnerf0144122009-07-28 03:13:23 +00002013 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002014
2015 // Print out .file directives to specify files for .loc directives. These are
2016 // printed out early so that they precede any .loc directives.
Chris Lattnerd38fee82010-04-05 00:13:49 +00002017 if (Asm->MAI->hasDotLocAndDotFile()) {
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002018 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2019 // Remember source id starts at 1.
2020 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
Chris Lattner0ad9c912010-01-22 22:09:00 +00002021 // FIXME: don't use sys::path for this! This should not depend on the
2022 // host.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002023 sys::Path FullPath(getSourceDirectoryName(Id.first));
2024 bool AppendOk =
2025 FullPath.appendComponent(getSourceFileName(Id.second));
2026 assert(AppendOk && "Could not append filename to directory!");
2027 AppendOk = false;
Chris Lattnera6594fc2010-01-25 18:58:59 +00002028 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002029 }
2030 }
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002031}
2032
Devang Patel2c4ceb12009-11-21 02:48:08 +00002033/// endModule - Emit all Dwarf sections that should come after the content.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002034///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002035void DwarfDebug::endModule() {
Devang Patel163a9f72010-05-10 22:49:55 +00002036 if (!FirstCU) return;
Devang Patel4a1cad62010-06-28 18:25:03 +00002037 const Module *M = MMI->getModule();
2038 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2039 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2040 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2041 DISubprogram SP(AllSPs->getOperand(SI));
2042 if (!SP.Verify()) continue;
2043
2044 // Collect info for variables that were optimized out.
Devang Patel8b3a6b62010-07-19 17:53:55 +00002045 if (!SP.isDefinition()) continue;
Devang Patel4a1cad62010-06-28 18:25:03 +00002046 StringRef FName = SP.getLinkageName();
2047 if (FName.empty())
2048 FName = SP.getName();
Jim Grosbach1e20b962010-07-21 21:21:52 +00002049 NamedMDNode *NMD =
Devang Patel4a1cad62010-06-28 18:25:03 +00002050 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2051 if (!NMD) continue;
2052 unsigned E = NMD->getNumOperands();
2053 if (!E) continue;
2054 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2055 for (unsigned I = 0; I != E; ++I) {
2056 DIVariable DV(NMD->getOperand(I));
2057 if (!DV.Verify()) continue;
2058 Scope->addVariable(new DbgVariable(DV));
2059 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00002060
Devang Patel4a1cad62010-06-28 18:25:03 +00002061 // Construct subprogram DIE and add variables DIEs.
2062 constructSubprogramDIE(SP);
2063 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2064 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
2065 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2066 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2067 if (VariableDIE)
2068 ScopeDIE->addChild(VariableDIE);
2069 }
2070 }
2071 }
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002072
Devang Patel53bb5c92009-11-10 23:06:00 +00002073 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2074 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2075 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2076 DIE *ISP = *AI;
Devang Patel2c4ceb12009-11-21 02:48:08 +00002077 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
Devang Patel53bb5c92009-11-10 23:06:00 +00002078 }
2079
Devang Patele9f8f5e2010-05-07 20:54:48 +00002080 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
Devang Patel5d11eb02009-12-03 19:11:07 +00002081 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2082 DIE *SPDie = CI->first;
Devang Patele9f8f5e2010-05-07 20:54:48 +00002083 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
Devang Patel5d11eb02009-12-03 19:11:07 +00002084 if (!N) continue;
Devang Patel163a9f72010-05-10 22:49:55 +00002085 DIE *NDie = getCompileUnit(N)->getDIE(N);
Devang Patel5d11eb02009-12-03 19:11:07 +00002086 if (!NDie) continue;
2087 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
Devang Patel5d11eb02009-12-03 19:11:07 +00002088 }
2089
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002090 // Standard sections final addresses.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002091 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
Chris Lattnerc0215722010-04-04 19:25:43 +00002092 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002093 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
Chris Lattnerc0215722010-04-04 19:25:43 +00002094 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002095
2096 // End text sections.
2097 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002098 Asm->OutStreamer.SwitchSection(SectionMap[i]);
Chris Lattnerc0215722010-04-04 19:25:43 +00002099 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002100 }
2101
2102 // Emit common frame information.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002103 emitCommonDebugFrame();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002104
2105 // Emit function debug frame information
2106 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2107 E = DebugFrames.end(); I != E; ++I)
Devang Patel2c4ceb12009-11-21 02:48:08 +00002108 emitFunctionDebugFrame(*I);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002109
2110 // Compute DIE offsets and sizes.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002111 computeSizeAndOffsets();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002112
Devang Patel1e4782d2010-06-29 20:17:53 +00002113 // Emit source line correspondence into a debug line section.
2114 emitDebugLines();
2115
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002116 // Emit all the DIEs into a debug info section
Devang Patel2c4ceb12009-11-21 02:48:08 +00002117 emitDebugInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002118
2119 // Corresponding abbreviations into a abbrev section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002120 emitAbbreviations();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002121
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002122 // Emit info into a debug pubnames section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002123 emitDebugPubNames();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002124
Devang Patel193f7202009-11-24 01:14:22 +00002125 // Emit info into a debug pubtypes section.
2126 emitDebugPubTypes();
2127
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002128 // Emit info into a debug loc section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002129 emitDebugLoc();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002130
2131 // Emit info into a debug aranges section.
2132 EmitDebugARanges();
2133
2134 // Emit info into a debug ranges section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002135 emitDebugRanges();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002136
2137 // Emit info into a debug macinfo section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002138 emitDebugMacInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002139
2140 // Emit inline info.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002141 emitDebugInlineInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002142
Chris Lattnerbc733f52010-03-13 02:17:42 +00002143 // Emit info into a debug str section.
2144 emitDebugStr();
Jim Grosbach1e20b962010-07-21 21:21:52 +00002145
Devang Patel163a9f72010-05-10 22:49:55 +00002146 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2147 E = CUMap.end(); I != E; ++I)
2148 delete I->second;
2149 FirstCU = NULL; // Reset for the next Module, if any.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002150}
2151
Devang Patel53bb5c92009-11-10 23:06:00 +00002152/// findAbstractVariable - Find abstract variable, if any, associated with Var.
Jim Grosbach1e20b962010-07-21 21:21:52 +00002153DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
Chris Lattnerde4845c2010-04-02 19:42:39 +00002154 DebugLoc ScopeLoc) {
Devang Patel53bb5c92009-11-10 23:06:00 +00002155
Devang Patel2db49d72010-05-07 18:11:54 +00002156 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
Devang Patel53bb5c92009-11-10 23:06:00 +00002157 if (AbsDbgVariable)
2158 return AbsDbgVariable;
2159
Devang Patel2db49d72010-05-07 18:11:54 +00002160 LLVMContext &Ctx = Var->getContext();
Chris Lattnerde4845c2010-04-02 19:42:39 +00002161 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
Devang Patel53bb5c92009-11-10 23:06:00 +00002162 if (!Scope)
2163 return NULL;
2164
Devang Patel26c1e562010-05-20 16:36:41 +00002165 AbsDbgVariable = new DbgVariable(Var);
Devang Patel2c4ceb12009-11-21 02:48:08 +00002166 Scope->addVariable(AbsDbgVariable);
Devang Patel2db49d72010-05-07 18:11:54 +00002167 AbstractVariables[Var] = AbsDbgVariable;
Devang Patel53bb5c92009-11-10 23:06:00 +00002168 return AbsDbgVariable;
2169}
2170
Devang Patelee432862010-05-20 19:57:06 +00002171/// collectVariableInfoFromMMITable - Collect variable information from
2172/// side table maintained by MMI.
Jim Grosbach1e20b962010-07-21 21:21:52 +00002173void
Devang Patelee432862010-05-20 19:57:06 +00002174DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2175 SmallPtrSet<const MDNode *, 16> &Processed) {
Chris Lattnerd38fee82010-04-05 00:13:49 +00002176 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
Devang Patele717faa2009-10-06 01:26:37 +00002177 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2178 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2179 VE = VMap.end(); VI != VE; ++VI) {
Devang Patele9f8f5e2010-05-07 20:54:48 +00002180 const MDNode *Var = VI->first;
Devang Patel53bb5c92009-11-10 23:06:00 +00002181 if (!Var) continue;
Devang Patel98e1cac2010-05-14 21:01:35 +00002182 Processed.insert(Var);
Chris Lattnerde4845c2010-04-02 19:42:39 +00002183 DIVariable DV(Var);
2184 const std::pair<unsigned, DebugLoc> &VP = VI->second;
Devang Patel53bb5c92009-11-10 23:06:00 +00002185
Chris Lattnerde4845c2010-04-02 19:42:39 +00002186 DbgScope *Scope = 0;
Devang Patele9f8f5e2010-05-07 20:54:48 +00002187 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
Chris Lattnerde4845c2010-04-02 19:42:39 +00002188 Scope = ConcreteScopes.lookup(IA);
2189 if (Scope == 0)
2190 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
Jim Grosbach1e20b962010-07-21 21:21:52 +00002191
Devang Patelfb0ee432009-11-10 23:20:04 +00002192 // If variable scope is not found then skip this variable.
Chris Lattnerde4845c2010-04-02 19:42:39 +00002193 if (Scope == 0)
Devang Patelfb0ee432009-11-10 23:20:04 +00002194 continue;
Devang Patel53bb5c92009-11-10 23:06:00 +00002195
Devang Patel26c1e562010-05-20 16:36:41 +00002196 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2197 DbgVariable *RegVar = new DbgVariable(DV);
2198 recordVariableFrameIndex(RegVar, VP.first);
Devang Patel2c4ceb12009-11-21 02:48:08 +00002199 Scope->addVariable(RegVar);
Devang Patel26c1e562010-05-20 16:36:41 +00002200 if (AbsDbgVariable) {
2201 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2202 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2203 }
Devang Patele717faa2009-10-06 01:26:37 +00002204 }
Devang Patelee432862010-05-20 19:57:06 +00002205}
Devang Patel90a48ad2010-03-15 18:33:46 +00002206
Jim Grosbach1e20b962010-07-21 21:21:52 +00002207/// isDbgValueInUndefinedReg - Return true if debug value, encoded by
Devang Patelc3f5f782010-05-25 23:40:22 +00002208/// DBG_VALUE instruction, is in undefined reg.
2209static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2210 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2211 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2212 return true;
2213 return false;
2214}
2215
Jim Grosbach1e20b962010-07-21 21:21:52 +00002216/// isDbgValueInDefinedReg - Return true if debug value, encoded by
Devang Patelc3f5f782010-05-25 23:40:22 +00002217/// DBG_VALUE instruction, is in a defined reg.
2218static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2219 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2220 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2221 return true;
2222 return false;
2223}
2224
Devang Patelee432862010-05-20 19:57:06 +00002225/// collectVariableInfo - Populate DbgScope entries with variables' info.
Jim Grosbach1e20b962010-07-21 21:21:52 +00002226void
Devang Patel78e127d2010-06-25 22:07:34 +00002227DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2228 SmallPtrSet<const MDNode *, 16> &Processed) {
Jim Grosbach1e20b962010-07-21 21:21:52 +00002229
Devang Patelee432862010-05-20 19:57:06 +00002230 /// collection info from MMI table.
2231 collectVariableInfoFromMMITable(MF, Processed);
2232
2233 SmallVector<const MachineInstr *, 8> DbgValues;
Devang Patel90a48ad2010-03-15 18:33:46 +00002234 // Collect variable information from DBG_VALUE machine instructions;
Chris Lattnerd38fee82010-04-05 00:13:49 +00002235 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
Devang Patelee432862010-05-20 19:57:06 +00002236 I != E; ++I)
Devang Patel90a48ad2010-03-15 18:33:46 +00002237 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2238 II != IE; ++II) {
2239 const MachineInstr *MInsn = II;
Devang Patelc3f5f782010-05-25 23:40:22 +00002240 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
Devang Patel90a48ad2010-03-15 18:33:46 +00002241 continue;
Devang Patelee432862010-05-20 19:57:06 +00002242 DbgValues.push_back(MInsn);
2243 }
Devang Patel90a48ad2010-03-15 18:33:46 +00002244
Devang Patelc3f5f782010-05-25 23:40:22 +00002245 // This is a collection of DBV_VALUE instructions describing same variable.
2246 SmallVector<const MachineInstr *, 4> MultipleValues;
Devang Patelee432862010-05-20 19:57:06 +00002247 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2248 E = DbgValues.end(); I != E; ++I) {
2249 const MachineInstr *MInsn = *I;
Devang Patelc3f5f782010-05-25 23:40:22 +00002250 MultipleValues.clear();
2251 if (isDbgValueInDefinedReg(MInsn))
2252 MultipleValues.push_back(MInsn);
Devang Patelee432862010-05-20 19:57:06 +00002253 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2254 if (Processed.count(DV) != 0)
2255 continue;
2256
Devang Patel354eb7e2010-06-02 19:05:13 +00002257 const MachineInstr *PrevMI = MInsn;
Jim Grosbach1e20b962010-07-21 21:21:52 +00002258 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
Devang Patelc3f5f782010-05-25 23:40:22 +00002259 ME = DbgValues.end(); MI != ME; ++MI) {
Jim Grosbach1e20b962010-07-21 21:21:52 +00002260 const MDNode *Var =
Devang Patelc3f5f782010-05-25 23:40:22 +00002261 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
Jim Grosbach1e20b962010-07-21 21:21:52 +00002262 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
Devang Patel354eb7e2010-06-02 19:05:13 +00002263 !PrevMI->isIdenticalTo(*MI))
Devang Patelc3f5f782010-05-25 23:40:22 +00002264 MultipleValues.push_back(*MI);
Devang Patel354eb7e2010-06-02 19:05:13 +00002265 PrevMI = *MI;
Devang Patelc3f5f782010-05-25 23:40:22 +00002266 }
2267
Devang Patelee432862010-05-20 19:57:06 +00002268 DbgScope *Scope = findDbgScope(MInsn);
Devang Pateld8720f42010-05-27 20:25:04 +00002269 bool CurFnArg = false;
2270 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2271 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2272 CurFnArg = true;
2273 if (!Scope && CurFnArg)
Devang Patelc0c5a262010-05-21 00:10:20 +00002274 Scope = CurrentFnDbgScope;
Devang Patelee432862010-05-20 19:57:06 +00002275 // If variable scope is not found then skip this variable.
Devang Patelc0c5a262010-05-21 00:10:20 +00002276 if (!Scope)
Devang Patelee432862010-05-20 19:57:06 +00002277 continue;
2278
2279 Processed.insert(DV);
Devang Patelee432862010-05-20 19:57:06 +00002280 DbgVariable *RegVar = new DbgVariable(DV);
Devang Patelee432862010-05-20 19:57:06 +00002281 Scope->addVariable(RegVar);
Devang Pateld8720f42010-05-27 20:25:04 +00002282 if (!CurFnArg)
Jim Grosbach1e20b962010-07-21 21:21:52 +00002283 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
Devang Patelc0c5a262010-05-21 00:10:20 +00002284 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2285 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2286 VarToAbstractVarMap[RegVar] = AbsVar;
Devang Patel90a48ad2010-03-15 18:33:46 +00002287 }
Devang Patelc3f5f782010-05-25 23:40:22 +00002288 if (MultipleValues.size() <= 1) {
2289 DbgVariableToDbgInstMap[RegVar] = MInsn;
2290 continue;
2291 }
2292
2293 // handle multiple DBG_VALUE instructions describing one variable.
Devang Patelc3f5f782010-05-25 23:40:22 +00002294 if (DotDebugLocEntries.empty())
Devang Patel80250682010-05-26 23:55:23 +00002295 RegVar->setDotDebugLocOffset(0);
2296 else
2297 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
Devang Patele2df8422010-05-26 17:29:32 +00002298 const MachineInstr *Begin = NULL;
2299 const MachineInstr *End = NULL;
Jim Grosbach1e20b962010-07-21 21:21:52 +00002300 for (SmallVector<const MachineInstr *, 4>::iterator
2301 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
Devang Patel61409622010-07-07 20:12:52 +00002302 MVI != MVE; ++MVI) {
Devang Patele2df8422010-05-26 17:29:32 +00002303 if (!Begin) {
2304 Begin = *MVI;
2305 continue;
Jim Grosbach1e20b962010-07-21 21:21:52 +00002306 }
Devang Patele2df8422010-05-26 17:29:32 +00002307 End = *MVI;
Devang Patelc3f5f782010-05-25 23:40:22 +00002308 MachineLocation MLoc;
Devang Patele2df8422010-05-26 17:29:32 +00002309 MLoc.set(Begin->getOperand(0).getReg(), 0);
2310 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2311 const MCSymbol *SLabel = getLabelBeforeInsn(End);
Devang Patelc3f5f782010-05-25 23:40:22 +00002312 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
Devang Patele2df8422010-05-26 17:29:32 +00002313 Begin = End;
2314 if (MVI + 1 == MVE) {
2315 // If End is the last instruction then its value is valid
Devang Patelc3f5f782010-05-25 23:40:22 +00002316 // until the end of the funtion.
Devang Patele2df8422010-05-26 17:29:32 +00002317 MLoc.set(End->getOperand(0).getReg(), 0);
Devang Patelc3f5f782010-05-25 23:40:22 +00002318 DotDebugLocEntries.
2319 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2320 }
2321 }
2322 DotDebugLocEntries.push_back(DotDebugLocEntry());
Devang Patel90a48ad2010-03-15 18:33:46 +00002323 }
Devang Patel98e1cac2010-05-14 21:01:35 +00002324
2325 // Collect info for variables that were optimized out.
Devang Pateld1bbc6b2010-06-22 01:01:58 +00002326 const Function *F = MF->getFunction();
2327 const Module *M = F->getParent();
Jim Grosbach1e20b962010-07-21 21:21:52 +00002328 if (NamedMDNode *NMD =
2329 M->getNamedMetadata(Twine("llvm.dbg.lv.",
Devang Patela762b092010-06-22 01:19:38 +00002330 getRealLinkageName(F->getName())))) {
Devang Patel98e1cac2010-05-14 21:01:35 +00002331 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
Dan Gohman872814a2010-07-21 18:54:18 +00002332 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
Devang Patelee432862010-05-20 19:57:06 +00002333 if (!DV || !Processed.insert(DV))
Devang Patel98e1cac2010-05-14 21:01:35 +00002334 continue;
2335 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2336 if (Scope)
Devang Patel26c1e562010-05-20 16:36:41 +00002337 Scope->addVariable(new DbgVariable(DV));
Devang Patel98e1cac2010-05-14 21:01:35 +00002338 }
2339 }
Devang Patelc3f5f782010-05-25 23:40:22 +00002340}
Devang Patel98e1cac2010-05-14 21:01:35 +00002341
Devang Patelc3f5f782010-05-25 23:40:22 +00002342/// getLabelBeforeInsn - Return Label preceding the instruction.
2343const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2344 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2345 LabelsBeforeInsn.find(MI);
2346 if (I == LabelsBeforeInsn.end())
2347 // FunctionBeginSym always preceeds all the instruction in current function.
2348 return FunctionBeginSym;
2349 return I->second;
2350}
2351
2352/// getLabelAfterInsn - Return Label immediately following the instruction.
2353const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2354 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2355 LabelsAfterInsn.find(MI);
2356 if (I == LabelsAfterInsn.end())
2357 return NULL;
2358 return I->second;
Devang Patele717faa2009-10-06 01:26:37 +00002359}
2360
Devang Patel553881b2010-03-29 17:20:31 +00002361/// beginScope - Process beginning of a scope.
2362void DwarfDebug::beginScope(const MachineInstr *MI) {
Devang Patelb2b31a62010-05-26 19:37:24 +00002363 if (InsnNeedsLabel.count(MI) == 0) {
2364 LabelsBeforeInsn[MI] = PrevLabel;
Devang Patel553881b2010-03-29 17:20:31 +00002365 return;
Devang Patelc3f5f782010-05-25 23:40:22 +00002366 }
Devang Patelaead63c2010-03-29 22:59:58 +00002367
Devang Patelb2b31a62010-05-26 19:37:24 +00002368 // Check location.
2369 DebugLoc DL = MI->getDebugLoc();
2370 if (!DL.isUnknown()) {
2371 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2372 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
Devang Pateleac9c072010-04-27 19:46:33 +00002373 PrevInstLoc = DL;
Devang Patelb2b31a62010-05-26 19:37:24 +00002374 LabelsBeforeInsn[MI] = PrevLabel;
2375 return;
Devang Pateleac9c072010-04-27 19:46:33 +00002376 }
Devang Patel553881b2010-03-29 17:20:31 +00002377
Jim Grosbach1e20b962010-07-21 21:21:52 +00002378 // If location is unknown then use temp label for this DBG_VALUE
Devang Patelb2b31a62010-05-26 19:37:24 +00002379 // instruction.
2380 if (MI->isDebugValue()) {
Devang Patel77051f52010-05-26 21:23:46 +00002381 PrevLabel = MMI->getContext().CreateTempSymbol();
2382 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patelb2b31a62010-05-26 19:37:24 +00002383 LabelsBeforeInsn[MI] = PrevLabel;
2384 return;
2385 }
2386
2387 if (UnknownLocations) {
2388 PrevLabel = recordSourceLine(0, 0, 0);
2389 LabelsBeforeInsn[MI] = PrevLabel;
2390 return;
2391 }
2392
2393 assert (0 && "Instruction is not processed!");
Devang Patel0d20ac82009-10-06 01:50:42 +00002394}
2395
Devang Patel2c4ceb12009-11-21 02:48:08 +00002396/// endScope - Process end of a scope.
2397void DwarfDebug::endScope(const MachineInstr *MI) {
Devang Patel1c246352010-04-08 16:50:29 +00002398 if (InsnsEndScopeSet.count(MI) != 0) {
2399 // Emit a label if this instruction ends a scope.
2400 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2401 Asm->OutStreamer.EmitLabel(Label);
Devang Pateleac9c072010-04-27 19:46:33 +00002402 LabelsAfterInsn[MI] = Label;
Devang Patel1c246352010-04-08 16:50:29 +00002403 }
Devang Patel53bb5c92009-11-10 23:06:00 +00002404}
2405
Devang Pateleac9c072010-04-27 19:46:33 +00002406/// getOrCreateDbgScope - Create DbgScope for the scope.
Jim Grosbach1e20b962010-07-21 21:21:52 +00002407DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
Devang Patel61409622010-07-07 20:12:52 +00002408 const MDNode *InlinedAt) {
Devang Patel53bb5c92009-11-10 23:06:00 +00002409 if (!InlinedAt) {
2410 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2411 if (WScope)
Devang Pateleac9c072010-04-27 19:46:33 +00002412 return WScope;
Devang Patel53bb5c92009-11-10 23:06:00 +00002413 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2414 DbgScopeMap.insert(std::make_pair(Scope, WScope));
Devang Pateleac9c072010-04-27 19:46:33 +00002415 if (DIDescriptor(Scope).isLexicalBlock()) {
Jim Grosbach1e20b962010-07-21 21:21:52 +00002416 DbgScope *Parent =
Devang Patel2db49d72010-05-07 18:11:54 +00002417 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
Devang Pateleac9c072010-04-27 19:46:33 +00002418 WScope->setParent(Parent);
2419 Parent->addScope(WScope);
2420 }
2421
2422 if (!WScope->getParent()) {
2423 StringRef SPName = DISubprogram(Scope).getLinkageName();
Stuart Hastingscad22ad2010-06-15 23:06:30 +00002424 // We used to check only for a linkage name, but that fails
2425 // since we began omitting the linkage name for private
2426 // functions. The new way is to check for the name in metadata,
2427 // but that's not supported in old .ll test cases. Ergo, we
2428 // check both.
Stuart Hastings215aa152010-06-11 20:08:44 +00002429 if (SPName == Asm->MF->getFunction()->getName() ||
2430 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
Devang Pateleac9c072010-04-27 19:46:33 +00002431 CurrentFnDbgScope = WScope;
2432 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00002433
Devang Pateleac9c072010-04-27 19:46:33 +00002434 return WScope;
Devang Patel53bb5c92009-11-10 23:06:00 +00002435 }
2436
Devang Patel78e127d2010-06-25 22:07:34 +00002437 getOrCreateAbstractScope(Scope);
Devang Patel53bb5c92009-11-10 23:06:00 +00002438 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2439 if (WScope)
Devang Pateleac9c072010-04-27 19:46:33 +00002440 return WScope;
Devang Patel53bb5c92009-11-10 23:06:00 +00002441
2442 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2443 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2444 DILocation DL(InlinedAt);
Devang Pateleac9c072010-04-27 19:46:33 +00002445 DbgScope *Parent =
Devang Patel2db49d72010-05-07 18:11:54 +00002446 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
Devang Pateleac9c072010-04-27 19:46:33 +00002447 WScope->setParent(Parent);
2448 Parent->addScope(WScope);
2449
2450 ConcreteScopes[InlinedAt] = WScope;
Devang Pateleac9c072010-04-27 19:46:33 +00002451
2452 return WScope;
Devang Patel0d20ac82009-10-06 01:50:42 +00002453}
2454
Devang Pateleac9c072010-04-27 19:46:33 +00002455/// hasValidLocation - Return true if debug location entry attached with
2456/// machine instruction encodes valid location info.
2457static bool hasValidLocation(LLVMContext &Ctx,
2458 const MachineInstr *MInsn,
Devang Patele9f8f5e2010-05-07 20:54:48 +00002459 const MDNode *&Scope, const MDNode *&InlinedAt) {
Devang Pateleac9c072010-04-27 19:46:33 +00002460 DebugLoc DL = MInsn->getDebugLoc();
2461 if (DL.isUnknown()) return false;
Jim Grosbach1e20b962010-07-21 21:21:52 +00002462
Devang Patele9f8f5e2010-05-07 20:54:48 +00002463 const MDNode *S = DL.getScope(Ctx);
Jim Grosbach1e20b962010-07-21 21:21:52 +00002464
Devang Pateleac9c072010-04-27 19:46:33 +00002465 // There is no need to create another DIE for compile unit. For all
2466 // other scopes, create one DbgScope now. This will be translated
2467 // into a scope DIE at the end.
2468 if (DIScope(S).isCompileUnit()) return false;
Jim Grosbach1e20b962010-07-21 21:21:52 +00002469
Devang Pateleac9c072010-04-27 19:46:33 +00002470 Scope = S;
2471 InlinedAt = DL.getInlinedAt(Ctx);
2472 return true;
2473}
2474
2475/// calculateDominanceGraph - Calculate dominance graph for DbgScope
2476/// hierarchy.
2477static void calculateDominanceGraph(DbgScope *Scope) {
2478 assert (Scope && "Unable to calculate scop edominance graph!");
2479 SmallVector<DbgScope *, 4> WorkStack;
2480 WorkStack.push_back(Scope);
2481 unsigned Counter = 0;
2482 while (!WorkStack.empty()) {
2483 DbgScope *WS = WorkStack.back();
2484 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2485 bool visitedChildren = false;
2486 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2487 SE = Children.end(); SI != SE; ++SI) {
2488 DbgScope *ChildScope = *SI;
2489 if (!ChildScope->getDFSOut()) {
2490 WorkStack.push_back(ChildScope);
2491 visitedChildren = true;
2492 ChildScope->setDFSIn(++Counter);
2493 break;
2494 }
2495 }
2496 if (!visitedChildren) {
2497 WorkStack.pop_back();
2498 WS->setDFSOut(++Counter);
2499 }
2500 }
2501}
2502
2503/// printDbgScopeInfo - Print DbgScope info for each machine instruction.
Jim Grosbach1e20b962010-07-21 21:21:52 +00002504static
Devang Pateleac9c072010-04-27 19:46:33 +00002505void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2506 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2507{
2508#ifndef NDEBUG
2509 unsigned PrevDFSIn = 0;
2510 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2511 I != E; ++I) {
2512 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2513 II != IE; ++II) {
2514 const MachineInstr *MInsn = II;
Devang Patele9f8f5e2010-05-07 20:54:48 +00002515 const MDNode *Scope = NULL;
2516 const MDNode *InlinedAt = NULL;
Devang Pateleac9c072010-04-27 19:46:33 +00002517
2518 // Check if instruction has valid location information.
2519 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2520 dbgs() << " [ ";
Jim Grosbach1e20b962010-07-21 21:21:52 +00002521 if (InlinedAt)
Devang Pateleac9c072010-04-27 19:46:33 +00002522 dbgs() << "*";
Jim Grosbach1e20b962010-07-21 21:21:52 +00002523 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
Devang Pateleac9c072010-04-27 19:46:33 +00002524 MI2ScopeMap.find(MInsn);
2525 if (DI != MI2ScopeMap.end()) {
2526 DbgScope *S = DI->second;
2527 dbgs() << S->getDFSIn();
2528 PrevDFSIn = S->getDFSIn();
2529 } else
2530 dbgs() << PrevDFSIn;
Jim Grosbach1e20b962010-07-21 21:21:52 +00002531 } else
Devang Pateleac9c072010-04-27 19:46:33 +00002532 dbgs() << " [ x" << PrevDFSIn;
2533 dbgs() << " ]";
2534 MInsn->dump();
2535 }
2536 dbgs() << "\n";
2537 }
2538#endif
2539}
Devang Patel2c4ceb12009-11-21 02:48:08 +00002540/// extractScopeInformation - Scan machine instructions in this function
Chris Lattner14d750d2010-03-31 05:39:57 +00002541/// and collect DbgScopes. Return true, if at least one scope was found.
Chris Lattnereec791a2010-01-26 23:18:02 +00002542bool DwarfDebug::extractScopeInformation() {
Devang Patelaf9e8472009-10-01 20:31:14 +00002543 // If scope information was extracted using .dbg intrinsics then there is not
2544 // any need to extract these information by scanning each instruction.
2545 if (!DbgScopeMap.empty())
2546 return false;
2547
Dan Gohman314bf7c2010-04-23 01:18:53 +00002548 // Scan each instruction and create scopes. First build working set of scopes.
Devang Pateleac9c072010-04-27 19:46:33 +00002549 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2550 SmallVector<DbgRange, 4> MIRanges;
2551 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
Devang Patele9f8f5e2010-05-07 20:54:48 +00002552 const MDNode *PrevScope = NULL;
2553 const MDNode *PrevInlinedAt = NULL;
Devang Pateleac9c072010-04-27 19:46:33 +00002554 const MachineInstr *RangeBeginMI = NULL;
2555 const MachineInstr *PrevMI = NULL;
Chris Lattnerd38fee82010-04-05 00:13:49 +00002556 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
Devang Patelaf9e8472009-10-01 20:31:14 +00002557 I != E; ++I) {
2558 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2559 II != IE; ++II) {
2560 const MachineInstr *MInsn = II;
Devang Patele9f8f5e2010-05-07 20:54:48 +00002561 const MDNode *Scope = NULL;
2562 const MDNode *InlinedAt = NULL;
Devang Pateleac9c072010-04-27 19:46:33 +00002563
2564 // Check if instruction has valid location information.
2565 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2566 PrevMI = MInsn;
2567 continue;
2568 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00002569
Devang Pateleac9c072010-04-27 19:46:33 +00002570 // If scope has not changed then skip this instruction.
2571 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2572 PrevMI = MInsn;
2573 continue;
2574 }
2575
Jim Grosbach1e20b962010-07-21 21:21:52 +00002576 if (RangeBeginMI) {
2577 // If we have alread seen a beginning of a instruction range and
Devang Pateleac9c072010-04-27 19:46:33 +00002578 // current instruction scope does not match scope of first instruction
2579 // in this range then create a new instruction range.
2580 DbgRange R(RangeBeginMI, PrevMI);
Jim Grosbach1e20b962010-07-21 21:21:52 +00002581 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
Devang Patel61409622010-07-07 20:12:52 +00002582 PrevInlinedAt);
Devang Pateleac9c072010-04-27 19:46:33 +00002583 MIRanges.push_back(R);
Jim Grosbach1e20b962010-07-21 21:21:52 +00002584 }
Devang Pateleac9c072010-04-27 19:46:33 +00002585
2586 // This is a beginning of a new instruction range.
2587 RangeBeginMI = MInsn;
Jim Grosbach1e20b962010-07-21 21:21:52 +00002588
Devang Pateleac9c072010-04-27 19:46:33 +00002589 // Reset previous markers.
2590 PrevMI = MInsn;
2591 PrevScope = Scope;
2592 PrevInlinedAt = InlinedAt;
Devang Patel53bb5c92009-11-10 23:06:00 +00002593 }
2594 }
2595
Devang Pateleac9c072010-04-27 19:46:33 +00002596 // Create last instruction range.
2597 if (RangeBeginMI && PrevMI && PrevScope) {
2598 DbgRange R(RangeBeginMI, PrevMI);
2599 MIRanges.push_back(R);
2600 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
Devang Patelaf9e8472009-10-01 20:31:14 +00002601 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00002602
Devang Patel344130e2010-01-04 20:44:00 +00002603 if (!CurrentFnDbgScope)
2604 return false;
2605
Devang Pateleac9c072010-04-27 19:46:33 +00002606 calculateDominanceGraph(CurrentFnDbgScope);
2607 if (PrintDbgScope)
2608 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2609
2610 // Find ranges of instructions covered by each DbgScope;
2611 DbgScope *PrevDbgScope = NULL;
2612 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2613 RE = MIRanges.end(); RI != RE; ++RI) {
2614 const DbgRange &R = *RI;
2615 DbgScope *S = MI2ScopeMap.lookup(R.first);
2616 assert (S && "Lost DbgScope for a machine instruction!");
2617 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2618 PrevDbgScope->closeInsnRange(S);
2619 S->openInsnRange(R.first);
2620 S->extendInsnRange(R.second);
2621 PrevDbgScope = S;
2622 }
2623
2624 if (PrevDbgScope)
2625 PrevDbgScope->closeInsnRange();
Devang Patelaf9e8472009-10-01 20:31:14 +00002626
Devang Patele37b0c62010-04-08 18:43:56 +00002627 identifyScopeMarkers();
Devang Patel6122a4d2010-04-08 15:37:09 +00002628
2629 return !DbgScopeMap.empty();
2630}
2631
Jim Grosbach1e20b962010-07-21 21:21:52 +00002632/// identifyScopeMarkers() -
Devang Pateleac9c072010-04-27 19:46:33 +00002633/// Each DbgScope has first instruction and last instruction to mark beginning
2634/// and end of a scope respectively. Create an inverse map that list scopes
2635/// starts (and ends) with an instruction. One instruction may start (or end)
2636/// multiple scopes. Ignore scopes that are not reachable.
Devang Patele37b0c62010-04-08 18:43:56 +00002637void DwarfDebug::identifyScopeMarkers() {
Devang Patel42aafd72010-01-20 02:05:23 +00002638 SmallVector<DbgScope *, 4> WorkList;
2639 WorkList.push_back(CurrentFnDbgScope);
2640 while (!WorkList.empty()) {
Chris Lattner14d750d2010-03-31 05:39:57 +00002641 DbgScope *S = WorkList.pop_back_val();
Jim Grosbach1e20b962010-07-21 21:21:52 +00002642
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002643 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
Jim Grosbach1e20b962010-07-21 21:21:52 +00002644 if (!Children.empty())
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002645 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
Devang Patel42aafd72010-01-20 02:05:23 +00002646 SE = Children.end(); SI != SE; ++SI)
2647 WorkList.push_back(*SI);
2648
Devang Patel53bb5c92009-11-10 23:06:00 +00002649 if (S->isAbstractScope())
2650 continue;
Jim Grosbach1e20b962010-07-21 21:21:52 +00002651
Devang Pateleac9c072010-04-27 19:46:33 +00002652 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2653 if (Ranges.empty())
2654 continue;
2655 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2656 RE = Ranges.end(); RI != RE; ++RI) {
Jim Grosbach1e20b962010-07-21 21:21:52 +00002657 assert(RI->first && "DbgRange does not have first instruction!");
2658 assert(RI->second && "DbgRange does not have second instruction!");
Devang Pateleac9c072010-04-27 19:46:33 +00002659 InsnsEndScopeSet.insert(RI->second);
2660 }
Devang Patelaf9e8472009-10-01 20:31:14 +00002661 }
Devang Patelaf9e8472009-10-01 20:31:14 +00002662}
2663
Dan Gohman084751c2010-04-20 00:37:27 +00002664/// FindFirstDebugLoc - Find the first debug location in the function. This
2665/// is intended to be an approximation for the source position of the
2666/// beginning of the function.
2667static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2668 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2669 I != E; ++I)
2670 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2671 MBBI != MBBE; ++MBBI) {
2672 DebugLoc DL = MBBI->getDebugLoc();
2673 if (!DL.isUnknown())
2674 return DL;
2675 }
2676 return DebugLoc();
2677}
2678
Devang Patel2c4ceb12009-11-21 02:48:08 +00002679/// beginFunction - Gather pre-function debug information. Assumes being
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002680/// emitted immediately after the function entry point.
Chris Lattnereec791a2010-01-26 23:18:02 +00002681void DwarfDebug::beginFunction(const MachineFunction *MF) {
Chris Lattner994cb122010-04-05 03:52:55 +00002682 if (!MMI->hasDebugInfo()) return;
Bill Wendling5f017e82010-04-07 09:28:04 +00002683 if (!extractScopeInformation()) return;
Devang Patel60b35bd2009-10-06 18:37:31 +00002684
Devang Pateleac9c072010-04-27 19:46:33 +00002685 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2686 Asm->getFunctionNumber());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002687 // Assumes in correct section after the entry point.
Devang Pateleac9c072010-04-27 19:46:33 +00002688 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002689
2690 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2691 // function.
Dan Gohman084751c2010-04-20 00:37:27 +00002692 DebugLoc FDL = FindFirstDebugLoc(MF);
Chris Lattnerde4845c2010-04-02 19:42:39 +00002693 if (FDL.isUnknown()) return;
Jim Grosbach1e20b962010-07-21 21:21:52 +00002694
Devang Patele9f8f5e2010-05-07 20:54:48 +00002695 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
Stuart Hastings0db42712010-07-19 23:56:30 +00002696 const MDNode *TheScope = 0;
Jim Grosbach1e20b962010-07-21 21:21:52 +00002697
Chris Lattnerde4845c2010-04-02 19:42:39 +00002698 DISubprogram SP = getDISubprogram(Scope);
2699 unsigned Line, Col;
2700 if (SP.Verify()) {
2701 Line = SP.getLineNumber();
2702 Col = 0;
Stuart Hastings0db42712010-07-19 23:56:30 +00002703 TheScope = SP;
Chris Lattnerde4845c2010-04-02 19:42:39 +00002704 } else {
2705 Line = FDL.getLine();
2706 Col = FDL.getCol();
Stuart Hastings0db42712010-07-19 23:56:30 +00002707 TheScope = Scope;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002708 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00002709
Stuart Hastings0db42712010-07-19 23:56:30 +00002710 recordSourceLine(Line, Col, TheScope);
Devang Patelb2b31a62010-05-26 19:37:24 +00002711
Devang Patelb9abe9f2010-06-02 16:42:51 +00002712 /// ProcessedArgs - Collection of arguments already processed.
2713 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2714
Devang Patelb2b31a62010-05-26 19:37:24 +00002715 DebugLoc PrevLoc;
2716 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2717 I != E; ++I)
2718 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2719 II != IE; ++II) {
2720 const MachineInstr *MI = II;
2721 DebugLoc DL = MI->getDebugLoc();
2722 if (MI->isDebugValue()) {
Devang Patelb2b31a62010-05-26 19:37:24 +00002723 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2724 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2725 if (!DV.Verify()) continue;
Devang Patel55e97172010-05-27 16:47:30 +00002726 // If DBG_VALUE is for a local variable then it needs a label.
Jim Grosbach1e20b962010-07-21 21:21:52 +00002727 if (DV.getTag() != dwarf::DW_TAG_arg_variable
Devang Patel7fb231c2010-07-01 21:38:08 +00002728 && isDbgValueInUndefinedReg(MI) == false)
Devang Patelb2b31a62010-05-26 19:37:24 +00002729 InsnNeedsLabel.insert(MI);
Devang Patel55e97172010-05-27 16:47:30 +00002730 // DBG_VALUE for inlined functions argument needs a label.
Devang Patel7fb231c2010-07-01 21:38:08 +00002731 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2732 describes(MF->getFunction()))
Devang Patel55e97172010-05-27 16:47:30 +00002733 InsnNeedsLabel.insert(MI);
2734 // DBG_VALUE indicating argument location change needs a label.
Jim Grosbach1e20b962010-07-21 21:21:52 +00002735 else if (isDbgValueInUndefinedReg(MI) == false
2736 && !ProcessedArgs.insert(DV))
Devang Patelb2b31a62010-05-26 19:37:24 +00002737 InsnNeedsLabel.insert(MI);
2738 } else {
Jim Grosbach1e20b962010-07-21 21:21:52 +00002739 // If location is unknown then instruction needs a location only if
Devang Patelb2b31a62010-05-26 19:37:24 +00002740 // UnknownLocations flag is set.
2741 if (DL.isUnknown()) {
2742 if (UnknownLocations && !PrevLoc.isUnknown())
2743 InsnNeedsLabel.insert(MI);
2744 } else if (DL != PrevLoc)
2745 // Otherwise, instruction needs a location only if it is new location.
2746 InsnNeedsLabel.insert(MI);
2747 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00002748
Devang Patelb2b31a62010-05-26 19:37:24 +00002749 if (!DL.isUnknown() || UnknownLocations)
2750 PrevLoc = DL;
2751 }
2752
2753 PrevLabel = FunctionBeginSym;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002754}
2755
Devang Patel2c4ceb12009-11-21 02:48:08 +00002756/// endFunction - Gather and emit post-function debug information.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002757///
Chris Lattnereec791a2010-01-26 23:18:02 +00002758void DwarfDebug::endFunction(const MachineFunction *MF) {
Bill Wendling5f017e82010-04-07 09:28:04 +00002759 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
Devang Patel70d75ca2009-11-12 19:02:56 +00002760
Devang Patel344130e2010-01-04 20:44:00 +00002761 if (CurrentFnDbgScope) {
Devang Patel65eb4822010-05-22 00:04:14 +00002762
Devang Patelc3f5f782010-05-25 23:40:22 +00002763 // Define end label for subprogram.
2764 FunctionEndSym = Asm->GetTempSymbol("func_end",
2765 Asm->getFunctionNumber());
2766 // Assumes in correct section after the entry point.
2767 Asm->OutStreamer.EmitLabel(FunctionEndSym);
Jim Grosbach1e20b962010-07-21 21:21:52 +00002768
Devang Patel78e127d2010-06-25 22:07:34 +00002769 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2770 collectVariableInfo(MF, ProcessedVars);
Devang Patel65eb4822010-05-22 00:04:14 +00002771
Devang Patel344130e2010-01-04 20:44:00 +00002772 // Get function line info.
2773 if (!Lines.empty()) {
2774 // Get section line info.
2775 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2776 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2777 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2778 // Append the function info to section info.
2779 SectionLineInfos.insert(SectionLineInfos.end(),
2780 Lines.begin(), Lines.end());
2781 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00002782
Devang Patel344130e2010-01-04 20:44:00 +00002783 // Construct abstract scopes.
2784 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
Devang Patel78e127d2010-06-25 22:07:34 +00002785 AE = AbstractScopesList.end(); AI != AE; ++AI) {
Devang Patel78e127d2010-06-25 22:07:34 +00002786 DISubprogram SP((*AI)->getScopeNode());
2787 if (SP.Verify()) {
2788 // Collect info for variables that were optimized out.
2789 StringRef FName = SP.getLinkageName();
2790 if (FName.empty())
2791 FName = SP.getName();
2792 const Module *M = MF->getFunction()->getParent();
Jim Grosbach1e20b962010-07-21 21:21:52 +00002793 if (NamedMDNode *NMD =
2794 M->getNamedMetadata(Twine("llvm.dbg.lv.",
Devang Patel78e127d2010-06-25 22:07:34 +00002795 getRealLinkageName(FName)))) {
2796 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
Dan Gohman872814a2010-07-21 18:54:18 +00002797 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
Devang Patel78e127d2010-06-25 22:07:34 +00002798 if (!DV || !ProcessedVars.insert(DV))
2799 continue;
Devang Patel1d68d212010-06-30 00:11:08 +00002800 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
Devang Patel78e127d2010-06-25 22:07:34 +00002801 if (Scope)
2802 Scope->addVariable(new DbgVariable(DV));
2803 }
2804 }
2805 }
Devang Patel90e19aa2010-06-30 01:40:11 +00002806 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2807 constructScopeDIE(*AI);
Devang Patel78e127d2010-06-25 22:07:34 +00002808 }
Devang Patel61409622010-07-07 20:12:52 +00002809
Devang Patel9c488372010-05-04 06:15:30 +00002810 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
Jim Grosbach1e20b962010-07-21 21:21:52 +00002811
Devang Patel9c488372010-05-04 06:15:30 +00002812 if (!DisableFramePointerElim(*MF))
Jim Grosbach1e20b962010-07-21 21:21:52 +00002813 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
Devang Patel9c488372010-05-04 06:15:30 +00002814 dwarf::DW_FORM_flag, 1);
2815
2816
Chris Lattnerd38fee82010-04-05 00:13:49 +00002817 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
Devang Patel344130e2010-01-04 20:44:00 +00002818 MMI->getFrameMoves()));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002819 }
2820
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002821 // Clear debug info
Devang Patelf54b8522010-01-19 01:26:02 +00002822 CurrentFnDbgScope = NULL;
Devang Patelb2b31a62010-05-26 19:37:24 +00002823 InsnNeedsLabel.clear();
Devang Patel26c1e562010-05-20 16:36:41 +00002824 DbgVariableToFrameIndexMap.clear();
2825 VarToAbstractVarMap.clear();
2826 DbgVariableToDbgInstMap.clear();
2827 DbgVariableLabelsMap.clear();
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002828 DeleteContainerSeconds(DbgScopeMap);
Devang Patel51424712010-04-09 16:04:20 +00002829 InsnsEndScopeSet.clear();
Devang Patelf54b8522010-01-19 01:26:02 +00002830 ConcreteScopes.clear();
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002831 DeleteContainerSeconds(AbstractScopes);
Devang Patelf54b8522010-01-19 01:26:02 +00002832 AbstractScopesList.clear();
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002833 AbstractVariables.clear();
Devang Pateleac9c072010-04-27 19:46:33 +00002834 LabelsBeforeInsn.clear();
2835 LabelsAfterInsn.clear();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002836 Lines.clear();
Devang Patelf2548ca2010-04-16 23:33:45 +00002837 PrevLabel = NULL;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002838}
2839
Devang Patel26c1e562010-05-20 16:36:41 +00002840/// recordVariableFrameIndex - Record a variable's index.
2841void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2842 assert (V && "Invalid DbgVariable!");
2843 DbgVariableToFrameIndexMap[V] = Index;
2844}
2845
2846/// findVariableFrameIndex - Return true if frame index for the variable
2847/// is found. Update FI to hold value of the index.
2848bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2849 assert (V && "Invalid DbgVariable!");
2850 DenseMap<const DbgVariable *, int>::iterator I =
2851 DbgVariableToFrameIndexMap.find(V);
2852 if (I == DbgVariableToFrameIndexMap.end())
2853 return false;
2854 *FI = I->second;
2855 return true;
2856}
2857
2858/// findVariableLabel - Find MCSymbol for the variable.
2859const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2860 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2861 = DbgVariableLabelsMap.find(V);
2862 if (I == DbgVariableLabelsMap.end())
2863 return NULL;
2864 else return I->second;
2865}
2866
Jim Grosbach1e20b962010-07-21 21:21:52 +00002867/// findDbgScope - Find DbgScope for the debug loc attached with an
Devang Patelee432862010-05-20 19:57:06 +00002868/// instruction.
2869DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2870 DbgScope *Scope = NULL;
Jim Grosbach1e20b962010-07-21 21:21:52 +00002871 LLVMContext &Ctx =
Devang Patelee432862010-05-20 19:57:06 +00002872 MInsn->getParent()->getParent()->getFunction()->getContext();
2873 DebugLoc DL = MInsn->getDebugLoc();
2874
Jim Grosbach1e20b962010-07-21 21:21:52 +00002875 if (DL.isUnknown())
Devang Patelee432862010-05-20 19:57:06 +00002876 return Scope;
2877
2878 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2879 Scope = ConcreteScopes.lookup(IA);
2880 if (Scope == 0)
2881 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
Jim Grosbach1e20b962010-07-21 21:21:52 +00002882
Devang Patelee432862010-05-20 19:57:06 +00002883 return Scope;
2884}
2885
2886
Chris Lattnerc6087842010-03-09 04:54:43 +00002887/// recordSourceLine - Register a source line with debug info. Returns the
2888/// unique label that was emitted and which provides correspondence to
2889/// the source line list.
Jim Grosbach1e20b962010-07-21 21:21:52 +00002890MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
Devang Patel61409622010-07-07 20:12:52 +00002891 const MDNode *S) {
Devang Patel65dbc902009-11-25 17:36:49 +00002892 StringRef Dir;
2893 StringRef Fn;
Devang Patelf84548d2009-10-05 18:03:19 +00002894
Dan Gohman1cc0d622010-05-05 23:41:32 +00002895 unsigned Src = 1;
2896 if (S) {
2897 DIDescriptor Scope(S);
Devang Patelf84548d2009-10-05 18:03:19 +00002898
Dan Gohman1cc0d622010-05-05 23:41:32 +00002899 if (Scope.isCompileUnit()) {
2900 DICompileUnit CU(S);
2901 Dir = CU.getDirectory();
2902 Fn = CU.getFilename();
2903 } else if (Scope.isSubprogram()) {
2904 DISubprogram SP(S);
2905 Dir = SP.getDirectory();
2906 Fn = SP.getFilename();
2907 } else if (Scope.isLexicalBlock()) {
2908 DILexicalBlock DB(S);
2909 Dir = DB.getDirectory();
2910 Fn = DB.getFilename();
2911 } else
2912 assert(0 && "Unexpected scope info");
2913
2914 Src = GetOrCreateSourceID(Dir, Fn);
2915 }
2916
Chris Lattner63d78362010-03-14 08:36:50 +00002917 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
Chris Lattner25b68c62010-03-14 08:15:55 +00002918 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002919
Chris Lattnerc6087842010-03-09 04:54:43 +00002920 Asm->OutStreamer.EmitLabel(Label);
2921 return Label;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002922}
2923
Bill Wendling829e67b2009-05-20 23:22:40 +00002924//===----------------------------------------------------------------------===//
2925// Emit Methods
2926//===----------------------------------------------------------------------===//
2927
Devang Patel2c4ceb12009-11-21 02:48:08 +00002928/// computeSizeAndOffset - Compute the size and offset of a DIE.
Bill Wendling94d04b82009-05-20 23:21:38 +00002929///
Jim Grosbach7ab38df2009-11-22 19:20:36 +00002930unsigned
2931DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
Bill Wendling94d04b82009-05-20 23:21:38 +00002932 // Get the children.
2933 const std::vector<DIE *> &Children = Die->getChildren();
2934
2935 // If not last sibling and has children then add sibling offset attribute.
Jeffrey Yasskin638fe8d2010-03-22 18:47:14 +00002936 if (!Last && !Children.empty())
Benjamin Kramer345ef342010-03-31 19:34:01 +00002937 Die->addSiblingOffset(DIEValueAllocator);
Bill Wendling94d04b82009-05-20 23:21:38 +00002938
2939 // Record the abbreviation.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002940 assignAbbrevNumber(Die->getAbbrev());
Bill Wendling94d04b82009-05-20 23:21:38 +00002941
2942 // Get the abbreviation for this DIE.
2943 unsigned AbbrevNumber = Die->getAbbrevNumber();
2944 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2945
2946 // Set DIE offset
2947 Die->setOffset(Offset);
2948
2949 // Start the size with the size of abbreviation code.
Chris Lattneraf76e592009-08-22 20:48:53 +00002950 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
Bill Wendling94d04b82009-05-20 23:21:38 +00002951
2952 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2953 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2954
2955 // Size the DIE attribute values.
2956 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2957 // Size attribute value.
Chris Lattnera37d5382010-04-05 00:18:22 +00002958 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
Bill Wendling94d04b82009-05-20 23:21:38 +00002959
2960 // Size the DIE children if any.
2961 if (!Children.empty()) {
2962 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2963 "Children flag not set");
2964
2965 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel2c4ceb12009-11-21 02:48:08 +00002966 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
Bill Wendling94d04b82009-05-20 23:21:38 +00002967
2968 // End of children marker.
2969 Offset += sizeof(int8_t);
2970 }
2971
2972 Die->setSize(Offset - Die->getOffset());
2973 return Offset;
2974}
2975
Devang Patel2c4ceb12009-11-21 02:48:08 +00002976/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
Bill Wendling94d04b82009-05-20 23:21:38 +00002977///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002978void DwarfDebug::computeSizeAndOffsets() {
Devang Patel163a9f72010-05-10 22:49:55 +00002979 unsigned PrevOffset = 0;
2980 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2981 E = CUMap.end(); I != E; ++I) {
2982 // Compute size of compile unit header.
2983 static unsigned Offset = PrevOffset +
2984 sizeof(int32_t) + // Length of Compilation Unit Info
2985 sizeof(int16_t) + // DWARF version number
2986 sizeof(int32_t) + // Offset Into Abbrev. Section
2987 sizeof(int8_t); // Pointer Size (in bytes)
2988 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2989 PrevOffset = Offset;
2990 }
Bill Wendling94d04b82009-05-20 23:21:38 +00002991}
2992
Chris Lattner11b8f302010-04-04 23:02:02 +00002993/// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2994/// temporary label to it if SymbolStem is specified.
Chris Lattner9c69e285532010-04-04 22:59:04 +00002995static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
Chris Lattner11b8f302010-04-04 23:02:02 +00002996 const char *SymbolStem = 0) {
Chris Lattner9c69e285532010-04-04 22:59:04 +00002997 Asm->OutStreamer.SwitchSection(Section);
Chris Lattner11b8f302010-04-04 23:02:02 +00002998 if (!SymbolStem) return 0;
Jim Grosbach1e20b962010-07-21 21:21:52 +00002999
Chris Lattner9c69e285532010-04-04 22:59:04 +00003000 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3001 Asm->OutStreamer.EmitLabel(TmpSym);
3002 return TmpSym;
3003}
3004
3005/// EmitSectionLabels - Emit initial Dwarf sections with a label at
3006/// the start of each one.
Chris Lattnerfa070b02010-04-04 22:33:59 +00003007void DwarfDebug::EmitSectionLabels() {
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003008 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarf612ff62009-09-19 20:40:05 +00003009
Bill Wendling94d04b82009-05-20 23:21:38 +00003010 // Dwarf sections base addresses.
Chris Lattnerd38fee82010-04-05 00:13:49 +00003011 if (Asm->MAI->doesDwarfRequireFrameSection()) {
Chris Lattner9c69e285532010-04-04 22:59:04 +00003012 DwarfFrameSectionSym =
3013 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3014 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003015
Jim Grosbach1e20b962010-07-21 21:21:52 +00003016 DwarfInfoSectionSym =
Chris Lattner9c69e285532010-04-04 22:59:04 +00003017 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
Jim Grosbach1e20b962010-07-21 21:21:52 +00003018 DwarfAbbrevSectionSym =
Chris Lattner9c69e285532010-04-04 22:59:04 +00003019 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
Chris Lattner11b8f302010-04-04 23:02:02 +00003020 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
Jim Grosbach1e20b962010-07-21 21:21:52 +00003021
Chris Lattner9c69e285532010-04-04 22:59:04 +00003022 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
Chris Lattner11b8f302010-04-04 23:02:02 +00003023 EmitSectionSym(Asm, MacroInfo);
Bill Wendling94d04b82009-05-20 23:21:38 +00003024
Jim Grosbach1e20b962010-07-21 21:21:52 +00003025 DwarfDebugLineSectionSym =
Devang Patel1e4782d2010-06-29 20:17:53 +00003026 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
Chris Lattner11b8f302010-04-04 23:02:02 +00003027 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3028 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3029 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
Jim Grosbach1e20b962010-07-21 21:21:52 +00003030 DwarfStrSectionSym =
Chris Lattner9c69e285532010-04-04 22:59:04 +00003031 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
Devang Patelf2548ca2010-04-16 23:33:45 +00003032 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3033 "debug_range");
Bill Wendling94d04b82009-05-20 23:21:38 +00003034
Devang Patelc3f5f782010-05-25 23:40:22 +00003035 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3036 "section_debug_loc");
3037
Chris Lattner9c69e285532010-04-04 22:59:04 +00003038 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
Chris Lattner4ad1efe2010-04-04 23:10:38 +00003039 EmitSectionSym(Asm, TLOF.getDataSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003040}
3041
Devang Patel2c4ceb12009-11-21 02:48:08 +00003042/// emitDIE - Recusively Emits a debug information entry.
Bill Wendling94d04b82009-05-20 23:21:38 +00003043///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003044void DwarfDebug::emitDIE(DIE *Die) {
Bill Wendling94d04b82009-05-20 23:21:38 +00003045 // Get the abbreviation for this DIE.
3046 unsigned AbbrevNumber = Die->getAbbrevNumber();
3047 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3048
Bill Wendling94d04b82009-05-20 23:21:38 +00003049 // Emit the code (index) for the abbreviation.
Chris Lattner3f53c832010-04-04 18:52:31 +00003050 if (Asm->isVerbose())
Chris Lattner894d75a2010-01-22 23:18:42 +00003051 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3052 Twine::utohexstr(Die->getOffset()) + ":0x" +
3053 Twine::utohexstr(Die->getSize()) + " " +
3054 dwarf::TagString(Abbrev->getTag()));
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003055 Asm->EmitULEB128(AbbrevNumber);
Bill Wendling94d04b82009-05-20 23:21:38 +00003056
Jeffrey Yasskin638fe8d2010-03-22 18:47:14 +00003057 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
Bill Wendling94d04b82009-05-20 23:21:38 +00003058 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3059
3060 // Emit the DIE attribute values.
3061 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3062 unsigned Attr = AbbrevData[i].getAttribute();
3063 unsigned Form = AbbrevData[i].getForm();
3064 assert(Form && "Too many attributes for DIE (check abbreviation)");
3065
Chris Lattner3f53c832010-04-04 18:52:31 +00003066 if (Asm->isVerbose())
Chris Lattnera8013622010-01-24 18:54:17 +00003067 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
Jim Grosbach1e20b962010-07-21 21:21:52 +00003068
Bill Wendling94d04b82009-05-20 23:21:38 +00003069 switch (Attr) {
3070 case dwarf::DW_AT_sibling:
Devang Patel2c4ceb12009-11-21 02:48:08 +00003071 Asm->EmitInt32(Die->getSiblingOffset());
Bill Wendling94d04b82009-05-20 23:21:38 +00003072 break;
3073 case dwarf::DW_AT_abstract_origin: {
3074 DIEEntry *E = cast<DIEEntry>(Values[i]);
3075 DIE *Origin = E->getEntry();
Devang Patel53bb5c92009-11-10 23:06:00 +00003076 unsigned Addr = Origin->getOffset();
Bill Wendling94d04b82009-05-20 23:21:38 +00003077 Asm->EmitInt32(Addr);
3078 break;
3079 }
Devang Patelf2548ca2010-04-16 23:33:45 +00003080 case dwarf::DW_AT_ranges: {
3081 // DW_AT_range Value encodes offset in debug_range section.
3082 DIEInteger *V = cast<DIEInteger>(Values[i]);
3083 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3084 V->getValue(),
3085 DwarfDebugRangeSectionSym,
3086 4);
3087 break;
3088 }
Devang Patel1e4782d2010-06-29 20:17:53 +00003089 case dwarf::DW_AT_stmt_list: {
Jim Grosbach1e20b962010-07-21 21:21:52 +00003090 Asm->EmitLabelDifference(CurrentLineSectionSym,
Devang Patel1e4782d2010-06-29 20:17:53 +00003091 DwarfDebugLineSectionSym, 4);
3092 break;
3093 }
Devang Patelc3f5f782010-05-25 23:40:22 +00003094 case dwarf::DW_AT_location: {
3095 if (UseDotDebugLocEntry.count(Die) != 0) {
3096 DIELabel *L = cast<DIELabel>(Values[i]);
3097 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3098 } else
3099 Values[i]->EmitValue(Asm, Form);
3100 break;
3101 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003102 default:
3103 // Emit an attribute using the defined form.
Chris Lattnerd38fee82010-04-05 00:13:49 +00003104 Values[i]->EmitValue(Asm, Form);
Bill Wendling94d04b82009-05-20 23:21:38 +00003105 break;
3106 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003107 }
3108
3109 // Emit the DIE children if any.
3110 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3111 const std::vector<DIE *> &Children = Die->getChildren();
3112
3113 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel2c4ceb12009-11-21 02:48:08 +00003114 emitDIE(Children[j]);
Bill Wendling94d04b82009-05-20 23:21:38 +00003115
Chris Lattner3f53c832010-04-04 18:52:31 +00003116 if (Asm->isVerbose())
Chris Lattner233f52b2010-03-09 23:52:58 +00003117 Asm->OutStreamer.AddComment("End Of Children Mark");
3118 Asm->EmitInt8(0);
Bill Wendling94d04b82009-05-20 23:21:38 +00003119 }
3120}
3121
Devang Patel8a241142009-12-09 18:24:21 +00003122/// emitDebugInfo - Emit the debug info section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003123///
Devang Patel8a241142009-12-09 18:24:21 +00003124void DwarfDebug::emitDebugInfo() {
3125 // Start debug info section.
3126 Asm->OutStreamer.SwitchSection(
3127 Asm->getObjFileLowering().getDwarfInfoSection());
Devang Patel163a9f72010-05-10 22:49:55 +00003128 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3129 E = CUMap.end(); I != E; ++I) {
3130 CompileUnit *TheCU = I->second;
3131 DIE *Die = TheCU->getCUDie();
Jim Grosbach1e20b962010-07-21 21:21:52 +00003132
Devang Patel163a9f72010-05-10 22:49:55 +00003133 // Emit the compile units header.
3134 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3135 TheCU->getID()));
Jim Grosbach1e20b962010-07-21 21:21:52 +00003136
Devang Patel163a9f72010-05-10 22:49:55 +00003137 // Emit size of content not including length itself
3138 unsigned ContentSize = Die->getSize() +
3139 sizeof(int16_t) + // DWARF version number
3140 sizeof(int32_t) + // Offset Into Abbrev. Section
3141 sizeof(int8_t) + // Pointer Size (in bytes)
3142 sizeof(int32_t); // FIXME - extra pad for gdb bug.
Jim Grosbach1e20b962010-07-21 21:21:52 +00003143
Devang Patel163a9f72010-05-10 22:49:55 +00003144 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3145 Asm->EmitInt32(ContentSize);
3146 Asm->OutStreamer.AddComment("DWARF version number");
3147 Asm->EmitInt16(dwarf::DWARF_VERSION);
3148 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3149 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3150 DwarfAbbrevSectionSym);
3151 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3152 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Jim Grosbach1e20b962010-07-21 21:21:52 +00003153
Devang Patel163a9f72010-05-10 22:49:55 +00003154 emitDIE(Die);
3155 // FIXME - extra padding for gdb bug.
3156 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3157 Asm->EmitInt8(0);
3158 Asm->EmitInt8(0);
3159 Asm->EmitInt8(0);
3160 Asm->EmitInt8(0);
3161 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3162 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003163}
3164
Devang Patel2c4ceb12009-11-21 02:48:08 +00003165/// emitAbbreviations - Emit the abbreviation section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003166///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003167void DwarfDebug::emitAbbreviations() const {
Bill Wendling94d04b82009-05-20 23:21:38 +00003168 // Check to see if it is worth the effort.
3169 if (!Abbreviations.empty()) {
3170 // Start the debug abbrev section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003171 Asm->OutStreamer.SwitchSection(
3172 Asm->getObjFileLowering().getDwarfAbbrevSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003173
Chris Lattnerc0215722010-04-04 19:25:43 +00003174 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003175
3176 // For each abbrevation.
3177 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3178 // Get abbreviation data
3179 const DIEAbbrev *Abbrev = Abbreviations[i];
3180
3181 // Emit the abbrevations code (base 1 index.)
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003182 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
Bill Wendling94d04b82009-05-20 23:21:38 +00003183
3184 // Emit the abbreviations data.
Chris Lattnerd38fee82010-04-05 00:13:49 +00003185 Abbrev->Emit(Asm);
Bill Wendling94d04b82009-05-20 23:21:38 +00003186 }
3187
3188 // Mark end of abbreviations.
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003189 Asm->EmitULEB128(0, "EOM(3)");
Bill Wendling94d04b82009-05-20 23:21:38 +00003190
Chris Lattnerc0215722010-04-04 19:25:43 +00003191 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003192 }
3193}
3194
Devang Patel2c4ceb12009-11-21 02:48:08 +00003195/// emitEndOfLineMatrix - Emit the last address of the section and the end of
Bill Wendling94d04b82009-05-20 23:21:38 +00003196/// the line matrix.
3197///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003198void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling94d04b82009-05-20 23:21:38 +00003199 // Define last address of section.
Chris Lattner233f52b2010-03-09 23:52:58 +00003200 Asm->OutStreamer.AddComment("Extended Op");
3201 Asm->EmitInt8(0);
Jim Grosbach1e20b962010-07-21 21:21:52 +00003202
Chris Lattner233f52b2010-03-09 23:52:58 +00003203 Asm->OutStreamer.AddComment("Op size");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003204 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner233f52b2010-03-09 23:52:58 +00003205 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3206 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3207
3208 Asm->OutStreamer.AddComment("Section end label");
Chris Lattnerd85fc6e2010-03-10 01:17:49 +00003209
Chris Lattnerc0215722010-04-04 19:25:43 +00003210 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
Chris Lattnerd38fee82010-04-05 00:13:49 +00003211 Asm->getTargetData().getPointerSize(),
3212 0/*AddrSpace*/);
Bill Wendling94d04b82009-05-20 23:21:38 +00003213
3214 // Mark end of matrix.
Chris Lattner233f52b2010-03-09 23:52:58 +00003215 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3216 Asm->EmitInt8(0);
Chris Lattner0ad9c912010-01-22 22:09:00 +00003217 Asm->EmitInt8(1);
Chris Lattner894d75a2010-01-22 23:18:42 +00003218 Asm->EmitInt8(1);
Bill Wendling94d04b82009-05-20 23:21:38 +00003219}
3220
Devang Patel2c4ceb12009-11-21 02:48:08 +00003221/// emitDebugLines - Emit source line information.
Bill Wendling94d04b82009-05-20 23:21:38 +00003222///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003223void DwarfDebug::emitDebugLines() {
Bill Wendling94d04b82009-05-20 23:21:38 +00003224 // If the target is using .loc/.file, the assembler will be emitting the
3225 // .debug_line table automatically.
Chris Lattnerd38fee82010-04-05 00:13:49 +00003226 if (Asm->MAI->hasDotLocAndDotFile())
Bill Wendling94d04b82009-05-20 23:21:38 +00003227 return;
3228
3229 // Minimum line delta, thus ranging from -10..(255-10).
3230 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3231 // Maximum line delta, thus ranging from -10..(255-10).
3232 const int MaxLineDelta = 255 + MinLineDelta;
3233
3234 // Start the dwarf line section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003235 Asm->OutStreamer.SwitchSection(
3236 Asm->getObjFileLowering().getDwarfLineSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003237
3238 // Construct the section header.
Devang Patel1e4782d2010-06-29 20:17:53 +00003239 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3240 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
Chris Lattner233f52b2010-03-09 23:52:58 +00003241 Asm->OutStreamer.AddComment("Length of Source Line Info");
Chris Lattnera6437182010-04-04 19:58:12 +00003242 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3243 Asm->GetTempSymbol("line_begin"), 4);
Chris Lattnerc0215722010-04-04 19:25:43 +00003244 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003245
Chris Lattner233f52b2010-03-09 23:52:58 +00003246 Asm->OutStreamer.AddComment("DWARF version number");
Jim Grosbach1e20b962010-07-21 21:21:52 +00003247 Asm->EmitInt16(dwarf::DWARF_VERSION);
Bill Wendling94d04b82009-05-20 23:21:38 +00003248
Chris Lattner233f52b2010-03-09 23:52:58 +00003249 Asm->OutStreamer.AddComment("Prolog Length");
Chris Lattnera6437182010-04-04 19:58:12 +00003250 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3251 Asm->GetTempSymbol("line_prolog_begin"), 4);
Chris Lattnerc0215722010-04-04 19:25:43 +00003252 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003253
Chris Lattner233f52b2010-03-09 23:52:58 +00003254 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3255 Asm->EmitInt8(1);
3256 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3257 Asm->EmitInt8(1);
3258 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3259 Asm->EmitInt8(MinLineDelta);
3260 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3261 Asm->EmitInt8(MaxLineDelta);
3262 Asm->OutStreamer.AddComment("Special Opcode Base");
3263 Asm->EmitInt8(-MinLineDelta);
Bill Wendling94d04b82009-05-20 23:21:38 +00003264
3265 // Line number standard opcode encodings argument count
Chris Lattner233f52b2010-03-09 23:52:58 +00003266 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3267 Asm->EmitInt8(0);
3268 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3269 Asm->EmitInt8(1);
3270 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3271 Asm->EmitInt8(1);
3272 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3273 Asm->EmitInt8(1);
3274 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3275 Asm->EmitInt8(1);
3276 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3277 Asm->EmitInt8(0);
3278 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3279 Asm->EmitInt8(0);
3280 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3281 Asm->EmitInt8(0);
3282 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3283 Asm->EmitInt8(1);
Bill Wendling94d04b82009-05-20 23:21:38 +00003284
3285 // Emit directories.
3286 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
Chris Lattner4cf202b2010-01-23 03:11:46 +00003287 const std::string &Dir = getSourceDirectoryName(DI);
Chris Lattner3f53c832010-04-04 18:52:31 +00003288 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
Chris Lattner4cf202b2010-01-23 03:11:46 +00003289 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
Bill Wendling94d04b82009-05-20 23:21:38 +00003290 }
3291
Chris Lattner233f52b2010-03-09 23:52:58 +00003292 Asm->OutStreamer.AddComment("End of directories");
3293 Asm->EmitInt8(0);
Bill Wendling94d04b82009-05-20 23:21:38 +00003294
3295 // Emit files.
3296 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3297 // Remember source id starts at 1.
3298 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
Chris Lattner4cf202b2010-01-23 03:11:46 +00003299 const std::string &FN = getSourceFileName(Id.second);
Chris Lattner3f53c832010-04-04 18:52:31 +00003300 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
Chris Lattner4cf202b2010-01-23 03:11:46 +00003301 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
Jim Grosbach1e20b962010-07-21 21:21:52 +00003302
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003303 Asm->EmitULEB128(Id.first, "Directory #");
3304 Asm->EmitULEB128(0, "Mod date");
3305 Asm->EmitULEB128(0, "File size");
Bill Wendling94d04b82009-05-20 23:21:38 +00003306 }
3307
Chris Lattner233f52b2010-03-09 23:52:58 +00003308 Asm->OutStreamer.AddComment("End of files");
3309 Asm->EmitInt8(0);
Bill Wendling94d04b82009-05-20 23:21:38 +00003310
Chris Lattnerc0215722010-04-04 19:25:43 +00003311 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003312
3313 // A sequence for each text section.
3314 unsigned SecSrcLinesSize = SectionSourceLines.size();
3315
3316 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3317 // Isolate current sections line info.
3318 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3319
Bill Wendling94d04b82009-05-20 23:21:38 +00003320 // Dwarf assumes we start with first line of first source file.
3321 unsigned Source = 1;
3322 unsigned Line = 1;
3323
3324 // Construct rows of the address, source, line, column matrix.
3325 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3326 const SrcLineInfo &LineInfo = LineInfos[i];
Chris Lattner25b68c62010-03-14 08:15:55 +00003327 MCSymbol *Label = LineInfo.getLabel();
Chris Lattnerb9130602010-03-14 02:20:58 +00003328 if (!Label->isDefined()) continue; // Not emitted, in dead code.
Bill Wendling94d04b82009-05-20 23:21:38 +00003329
Chris Lattner0d9d70f2010-03-09 23:38:23 +00003330 if (Asm->isVerbose()) {
Chris Lattner188a87d2010-03-10 01:04:13 +00003331 std::pair<unsigned, unsigned> SrcID =
Bill Wendling94d04b82009-05-20 23:21:38 +00003332 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
Chris Lattner188a87d2010-03-10 01:04:13 +00003333 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
Chris Lattner49f618a2010-03-10 02:29:31 +00003334 "/" +
3335 Twine(getSourceFileName(SrcID.second)) +
Chris Lattner188a87d2010-03-10 01:04:13 +00003336 ":" + Twine(LineInfo.getLine()));
Bill Wendling94d04b82009-05-20 23:21:38 +00003337 }
3338
3339 // Define the line address.
Chris Lattner233f52b2010-03-09 23:52:58 +00003340 Asm->OutStreamer.AddComment("Extended Op");
3341 Asm->EmitInt8(0);
3342 Asm->OutStreamer.AddComment("Op size");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003343 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner233f52b2010-03-09 23:52:58 +00003344
3345 Asm->OutStreamer.AddComment("DW_LNE_set_address");
Jim Grosbach1e20b962010-07-21 21:21:52 +00003346 Asm->EmitInt8(dwarf::DW_LNE_set_address);
Chris Lattner233f52b2010-03-09 23:52:58 +00003347
3348 Asm->OutStreamer.AddComment("Location label");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003349 Asm->OutStreamer.EmitSymbolValue(Label,
3350 Asm->getTargetData().getPointerSize(),
Chris Lattnerb9130602010-03-14 02:20:58 +00003351 0/*AddrSpace*/);
Jim Grosbach1e20b962010-07-21 21:21:52 +00003352
Bill Wendling94d04b82009-05-20 23:21:38 +00003353 // If change of source, then switch to the new source.
3354 if (Source != LineInfo.getSourceID()) {
3355 Source = LineInfo.getSourceID();
Chris Lattner233f52b2010-03-09 23:52:58 +00003356 Asm->OutStreamer.AddComment("DW_LNS_set_file");
Jim Grosbach1e20b962010-07-21 21:21:52 +00003357 Asm->EmitInt8(dwarf::DW_LNS_set_file);
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003358 Asm->EmitULEB128(Source, "New Source");
Bill Wendling94d04b82009-05-20 23:21:38 +00003359 }
3360
3361 // If change of line.
3362 if (Line != LineInfo.getLine()) {
3363 // Determine offset.
3364 int Offset = LineInfo.getLine() - Line;
3365 int Delta = Offset - MinLineDelta;
3366
3367 // Update line.
3368 Line = LineInfo.getLine();
3369
3370 // If delta is small enough and in range...
3371 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3372 // ... then use fast opcode.
Chris Lattner233f52b2010-03-09 23:52:58 +00003373 Asm->OutStreamer.AddComment("Line Delta");
3374 Asm->EmitInt8(Delta - MinLineDelta);
Bill Wendling94d04b82009-05-20 23:21:38 +00003375 } else {
3376 // ... otherwise use long hand.
Chris Lattner233f52b2010-03-09 23:52:58 +00003377 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
Bill Wendling94d04b82009-05-20 23:21:38 +00003378 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003379 Asm->EmitSLEB128(Offset, "Line Offset");
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 } else {
3384 // Copy the previous row (different address or source)
Chris Lattner233f52b2010-03-09 23:52:58 +00003385 Asm->OutStreamer.AddComment("DW_LNS_copy");
3386 Asm->EmitInt8(dwarf::DW_LNS_copy);
Bill Wendling94d04b82009-05-20 23:21:38 +00003387 }
3388 }
3389
Devang Patel2c4ceb12009-11-21 02:48:08 +00003390 emitEndOfLineMatrix(j + 1);
Bill Wendling94d04b82009-05-20 23:21:38 +00003391 }
3392
3393 if (SecSrcLinesSize == 0)
3394 // Because we're emitting a debug_line section, we still need a line
3395 // table. The linker and friends expect it to exist. If there's nothing to
3396 // put into it, emit an empty table.
Devang Patel2c4ceb12009-11-21 02:48:08 +00003397 emitEndOfLineMatrix(1);
Bill Wendling94d04b82009-05-20 23:21:38 +00003398
Chris Lattnerc0215722010-04-04 19:25:43 +00003399 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003400}
3401
Devang Patel2c4ceb12009-11-21 02:48:08 +00003402/// emitCommonDebugFrame - Emit common frame info into a debug frame section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003403///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003404void DwarfDebug::emitCommonDebugFrame() {
Chris Lattnerd38fee82010-04-05 00:13:49 +00003405 if (!Asm->MAI->doesDwarfRequireFrameSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00003406 return;
3407
Chris Lattnerd38fee82010-04-05 00:13:49 +00003408 int stackGrowth = Asm->getTargetData().getPointerSize();
3409 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3410 TargetFrameInfo::StackGrowsDown)
3411 stackGrowth *= -1;
Bill Wendling94d04b82009-05-20 23:21:38 +00003412
3413 // Start the dwarf frame section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003414 Asm->OutStreamer.SwitchSection(
3415 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003416
Chris Lattnerc0215722010-04-04 19:25:43 +00003417 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
Chris Lattner233f52b2010-03-09 23:52:58 +00003418 Asm->OutStreamer.AddComment("Length of Common Information Entry");
Chris Lattnera6437182010-04-04 19:58:12 +00003419 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3420 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
Bill Wendling94d04b82009-05-20 23:21:38 +00003421
Chris Lattnerc0215722010-04-04 19:25:43 +00003422 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
Chris Lattner233f52b2010-03-09 23:52:58 +00003423 Asm->OutStreamer.AddComment("CIE Identifier Tag");
Bill Wendling94d04b82009-05-20 23:21:38 +00003424 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
Chris Lattner233f52b2010-03-09 23:52:58 +00003425 Asm->OutStreamer.AddComment("CIE Version");
Bill Wendling94d04b82009-05-20 23:21:38 +00003426 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
Chris Lattner233f52b2010-03-09 23:52:58 +00003427 Asm->OutStreamer.AddComment("CIE Augmentation");
Chris Lattner4cf202b2010-01-23 03:11:46 +00003428 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003429 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3430 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
Chris Lattner233f52b2010-03-09 23:52:58 +00003431 Asm->OutStreamer.AddComment("CIE RA Column");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003432 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Bill Wendling94d04b82009-05-20 23:21:38 +00003433 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
Bill Wendling94d04b82009-05-20 23:21:38 +00003434
3435 std::vector<MachineMove> Moves;
3436 RI->getInitialFrameState(Moves);
3437
Chris Lattner02b86b92010-04-04 23:41:46 +00003438 Asm->EmitFrameMoves(Moves, 0, false);
Bill Wendling94d04b82009-05-20 23:21:38 +00003439
Chris Lattner059ea132010-04-28 01:05:45 +00003440 Asm->EmitAlignment(2);
Chris Lattnerc0215722010-04-04 19:25:43 +00003441 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00003442}
3443
Devang Patel2c4ceb12009-11-21 02:48:08 +00003444/// emitFunctionDebugFrame - Emit per function frame info into a debug frame
Bill Wendling94d04b82009-05-20 23:21:38 +00003445/// section.
Chris Lattner206d61e2010-03-13 07:26:18 +00003446void DwarfDebug::
3447emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
Chris Lattnerd38fee82010-04-05 00:13:49 +00003448 if (!Asm->MAI->doesDwarfRequireFrameSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00003449 return;
3450
3451 // Start the dwarf frame section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003452 Asm->OutStreamer.SwitchSection(
3453 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003454
Chris Lattner233f52b2010-03-09 23:52:58 +00003455 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
Chris Lattner206d61e2010-03-13 07:26:18 +00003456 MCSymbol *DebugFrameBegin =
Chris Lattnerc0215722010-04-04 19:25:43 +00003457 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
Chris Lattner206d61e2010-03-13 07:26:18 +00003458 MCSymbol *DebugFrameEnd =
Chris Lattnerc0215722010-04-04 19:25:43 +00003459 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
Chris Lattnera6437182010-04-04 19:58:12 +00003460 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
Bill Wendling94d04b82009-05-20 23:21:38 +00003461
Chris Lattner206d61e2010-03-13 07:26:18 +00003462 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
Bill Wendling94d04b82009-05-20 23:21:38 +00003463
Chris Lattner233f52b2010-03-09 23:52:58 +00003464 Asm->OutStreamer.AddComment("FDE CIE offset");
Jim Grosbach1e20b962010-07-21 21:21:52 +00003465 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
Chris Lattner6189ed12010-04-04 23:25:33 +00003466 DwarfFrameSectionSym);
Bill Wendling94d04b82009-05-20 23:21:38 +00003467
Chris Lattner233f52b2010-03-09 23:52:58 +00003468 Asm->OutStreamer.AddComment("FDE initial location");
Chris Lattnerc0215722010-04-04 19:25:43 +00003469 MCSymbol *FuncBeginSym =
3470 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
Chris Lattnerfb658072010-03-13 07:40:56 +00003471 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
Chris Lattnerd38fee82010-04-05 00:13:49 +00003472 Asm->getTargetData().getPointerSize(),
3473 0/*AddrSpace*/);
Jim Grosbach1e20b962010-07-21 21:21:52 +00003474
3475
Chris Lattner233f52b2010-03-09 23:52:58 +00003476 Asm->OutStreamer.AddComment("FDE address range");
Chris Lattnera6437182010-04-04 19:58:12 +00003477 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
Chris Lattnerd38fee82010-04-05 00:13:49 +00003478 FuncBeginSym, Asm->getTargetData().getPointerSize());
Bill Wendling94d04b82009-05-20 23:21:38 +00003479
Chris Lattner02b86b92010-04-04 23:41:46 +00003480 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
Bill Wendling94d04b82009-05-20 23:21:38 +00003481
Chris Lattner059ea132010-04-28 01:05:45 +00003482 Asm->EmitAlignment(2);
Chris Lattner206d61e2010-03-13 07:26:18 +00003483 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
Bill Wendling94d04b82009-05-20 23:21:38 +00003484}
3485
Devang Patel8a241142009-12-09 18:24:21 +00003486/// emitDebugPubNames - Emit visible names into a debug pubnames section.
3487///
3488void DwarfDebug::emitDebugPubNames() {
Devang Patel163a9f72010-05-10 22:49:55 +00003489 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3490 E = CUMap.end(); I != E; ++I) {
3491 CompileUnit *TheCU = I->second;
3492 // Start the dwarf pubnames section.
3493 Asm->OutStreamer.SwitchSection(
3494 Asm->getObjFileLowering().getDwarfPubNamesSection());
Jim Grosbach1e20b962010-07-21 21:21:52 +00003495
Devang Patel163a9f72010-05-10 22:49:55 +00003496 Asm->OutStreamer.AddComment("Length of Public Names Info");
3497 Asm->EmitLabelDifference(
3498 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3499 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
Jim Grosbach1e20b962010-07-21 21:21:52 +00003500
Devang Patel163a9f72010-05-10 22:49:55 +00003501 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3502 TheCU->getID()));
Jim Grosbach1e20b962010-07-21 21:21:52 +00003503
Devang Patel163a9f72010-05-10 22:49:55 +00003504 Asm->OutStreamer.AddComment("DWARF Version");
Jim Grosbach1e20b962010-07-21 21:21:52 +00003505 Asm->EmitInt16(dwarf::DWARF_VERSION);
3506
Devang Patel163a9f72010-05-10 22:49:55 +00003507 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
Jim Grosbach1e20b962010-07-21 21:21:52 +00003508 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
Devang Patel163a9f72010-05-10 22:49:55 +00003509 DwarfInfoSectionSym);
Jim Grosbach1e20b962010-07-21 21:21:52 +00003510
Devang Patel163a9f72010-05-10 22:49:55 +00003511 Asm->OutStreamer.AddComment("Compilation Unit Length");
3512 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3513 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3514 4);
Jim Grosbach1e20b962010-07-21 21:21:52 +00003515
Devang Patel163a9f72010-05-10 22:49:55 +00003516 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3517 for (StringMap<DIE*>::const_iterator
3518 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3519 const char *Name = GI->getKeyData();
3520 DIE *Entity = GI->second;
Jim Grosbach1e20b962010-07-21 21:21:52 +00003521
Devang Patel163a9f72010-05-10 22:49:55 +00003522 Asm->OutStreamer.AddComment("DIE offset");
3523 Asm->EmitInt32(Entity->getOffset());
Jim Grosbach1e20b962010-07-21 21:21:52 +00003524
Devang Patel163a9f72010-05-10 22:49:55 +00003525 if (Asm->isVerbose())
3526 Asm->OutStreamer.AddComment("External Name");
3527 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3528 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00003529
Devang Patel163a9f72010-05-10 22:49:55 +00003530 Asm->OutStreamer.AddComment("End Mark");
3531 Asm->EmitInt32(0);
3532 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3533 TheCU->getID()));
Bill Wendling94d04b82009-05-20 23:21:38 +00003534 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003535}
3536
Devang Patel193f7202009-11-24 01:14:22 +00003537void DwarfDebug::emitDebugPubTypes() {
Devang Patel163a9f72010-05-10 22:49:55 +00003538 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3539 E = CUMap.end(); I != E; ++I) {
3540 CompileUnit *TheCU = I->second;
3541 // Start the dwarf pubnames section.
3542 Asm->OutStreamer.SwitchSection(
3543 Asm->getObjFileLowering().getDwarfPubTypesSection());
3544 Asm->OutStreamer.AddComment("Length of Public Types Info");
3545 Asm->EmitLabelDifference(
3546 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3547 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
Jim Grosbach1e20b962010-07-21 21:21:52 +00003548
Devang Patel163a9f72010-05-10 22:49:55 +00003549 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3550 TheCU->getID()));
Jim Grosbach1e20b962010-07-21 21:21:52 +00003551
Devang Patel163a9f72010-05-10 22:49:55 +00003552 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3553 Asm->EmitInt16(dwarf::DWARF_VERSION);
Jim Grosbach1e20b962010-07-21 21:21:52 +00003554
Devang Patel163a9f72010-05-10 22:49:55 +00003555 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3556 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3557 DwarfInfoSectionSym);
Jim Grosbach1e20b962010-07-21 21:21:52 +00003558
Devang Patel163a9f72010-05-10 22:49:55 +00003559 Asm->OutStreamer.AddComment("Compilation Unit Length");
3560 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3561 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3562 4);
Jim Grosbach1e20b962010-07-21 21:21:52 +00003563
Devang Patel163a9f72010-05-10 22:49:55 +00003564 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3565 for (StringMap<DIE*>::const_iterator
3566 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3567 const char *Name = GI->getKeyData();
3568 DIE * Entity = GI->second;
Jim Grosbach1e20b962010-07-21 21:21:52 +00003569
Devang Patel163a9f72010-05-10 22:49:55 +00003570 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3571 Asm->EmitInt32(Entity->getOffset());
Jim Grosbach1e20b962010-07-21 21:21:52 +00003572
Devang Patel163a9f72010-05-10 22:49:55 +00003573 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3574 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3575 }
Jim Grosbach1e20b962010-07-21 21:21:52 +00003576
Devang Patel163a9f72010-05-10 22:49:55 +00003577 Asm->OutStreamer.AddComment("End Mark");
Jim Grosbach1e20b962010-07-21 21:21:52 +00003578 Asm->EmitInt32(0);
Devang Patel163a9f72010-05-10 22:49:55 +00003579 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3580 TheCU->getID()));
Devang Patel193f7202009-11-24 01:14:22 +00003581 }
Devang Patel193f7202009-11-24 01:14:22 +00003582}
3583
Devang Patel2c4ceb12009-11-21 02:48:08 +00003584/// emitDebugStr - Emit visible names into a debug str section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003585///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003586void DwarfDebug::emitDebugStr() {
Bill Wendling94d04b82009-05-20 23:21:38 +00003587 // Check to see if it is worth the effort.
Chris Lattner0d9d70f2010-03-09 23:38:23 +00003588 if (StringPool.empty()) return;
Jim Grosbach1e20b962010-07-21 21:21:52 +00003589
Chris Lattner0d9d70f2010-03-09 23:38:23 +00003590 // Start the dwarf str section.
3591 Asm->OutStreamer.SwitchSection(
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003592 Asm->getObjFileLowering().getDwarfStrSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003593
Chris Lattnerbc733f52010-03-13 02:17:42 +00003594 // Get all of the string pool entries and put them in an array by their ID so
3595 // we can sort them.
Jim Grosbach1e20b962010-07-21 21:21:52 +00003596 SmallVector<std::pair<unsigned,
Chris Lattnerbc733f52010-03-13 02:17:42 +00003597 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
Jim Grosbach1e20b962010-07-21 21:21:52 +00003598
Chris Lattnerbc733f52010-03-13 02:17:42 +00003599 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3600 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3601 Entries.push_back(std::make_pair(I->second.second, &*I));
Jim Grosbach1e20b962010-07-21 21:21:52 +00003602
Chris Lattnerbc733f52010-03-13 02:17:42 +00003603 array_pod_sort(Entries.begin(), Entries.end());
Jim Grosbach1e20b962010-07-21 21:21:52 +00003604
Chris Lattnerbc733f52010-03-13 02:17:42 +00003605 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
Chris Lattner0d9d70f2010-03-09 23:38:23 +00003606 // Emit a label for reference from debug information entries.
Chris Lattnerbc733f52010-03-13 02:17:42 +00003607 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
Jim Grosbach1e20b962010-07-21 21:21:52 +00003608
Chris Lattner0d9d70f2010-03-09 23:38:23 +00003609 // Emit the string itself.
Chris Lattnerbc733f52010-03-13 02:17:42 +00003610 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
Bill Wendling94d04b82009-05-20 23:21:38 +00003611 }
3612}
3613
Devang Patel2c4ceb12009-11-21 02:48:08 +00003614/// emitDebugLoc - Emit visible names into a debug loc section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003615///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003616void DwarfDebug::emitDebugLoc() {
Devang Patel80250682010-05-26 23:55:23 +00003617 if (DotDebugLocEntries.empty())
3618 return;
3619
Bill Wendling94d04b82009-05-20 23:21:38 +00003620 // Start the dwarf loc section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003621 Asm->OutStreamer.SwitchSection(
Devang Patelc3f5f782010-05-25 23:40:22 +00003622 Asm->getObjFileLowering().getDwarfLocSection());
3623 unsigned char Size = Asm->getTargetData().getPointerSize();
Devang Patel80250682010-05-26 23:55:23 +00003624 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3625 unsigned index = 1;
Jim Grosbach1e20b962010-07-21 21:21:52 +00003626 for (SmallVector<DotDebugLocEntry, 4>::iterator
3627 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
Devang Patel61409622010-07-07 20:12:52 +00003628 I != E; ++I, ++index) {
Devang Patelc3f5f782010-05-25 23:40:22 +00003629 DotDebugLocEntry Entry = *I;
Devang Patelc3f5f782010-05-25 23:40:22 +00003630 if (Entry.isEmpty()) {
3631 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3632 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patel80250682010-05-26 23:55:23 +00003633 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
Devang Patelc3f5f782010-05-25 23:40:22 +00003634 } else {
3635 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3636 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3637 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3638 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3639 if (Reg < 32) {
3640 Asm->OutStreamer.AddComment("Loc expr size");
3641 Asm->EmitInt16(1);
3642 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3643 } else {
3644 Asm->OutStreamer.AddComment("Loc expr size");
3645 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3646 Asm->EmitInt8(dwarf::DW_OP_regx);
3647 Asm->EmitULEB128(Reg);
3648 }
3649 }
3650 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003651}
3652
3653/// EmitDebugARanges - Emit visible names into a debug aranges section.
3654///
3655void DwarfDebug::EmitDebugARanges() {
3656 // Start the dwarf aranges section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003657 Asm->OutStreamer.SwitchSection(
3658 Asm->getObjFileLowering().getDwarfARangesSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003659}
3660
Devang Patel2c4ceb12009-11-21 02:48:08 +00003661/// emitDebugRanges - Emit visible names into a debug ranges section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003662///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003663void DwarfDebug::emitDebugRanges() {
Bill Wendling94d04b82009-05-20 23:21:38 +00003664 // Start the dwarf ranges section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003665 Asm->OutStreamer.SwitchSection(
Devang Patelf2548ca2010-04-16 23:33:45 +00003666 Asm->getObjFileLowering().getDwarfRangesSection());
Devang Pateleac9c072010-04-27 19:46:33 +00003667 unsigned char Size = Asm->getTargetData().getPointerSize();
3668 for (SmallVector<const MCSymbol *, 8>::iterator
Jim Grosbach1e20b962010-07-21 21:21:52 +00003669 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
Devang Pateleac9c072010-04-27 19:46:33 +00003670 I != E; ++I) {
3671 if (*I)
3672 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
Devang Patelf2548ca2010-04-16 23:33:45 +00003673 else
Devang Pateleac9c072010-04-27 19:46:33 +00003674 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patelf2548ca2010-04-16 23:33:45 +00003675 }
Bill Wendling94d04b82009-05-20 23:21:38 +00003676}
3677
Devang Patel2c4ceb12009-11-21 02:48:08 +00003678/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003679///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003680void DwarfDebug::emitDebugMacInfo() {
Daniel Dunbarf612ff62009-09-19 20:40:05 +00003681 if (const MCSection *LineInfo =
Chris Lattner18a4c162009-08-02 07:24:22 +00003682 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
Bill Wendling94d04b82009-05-20 23:21:38 +00003683 // Start the dwarf macinfo section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003684 Asm->OutStreamer.SwitchSection(LineInfo);
Bill Wendling94d04b82009-05-20 23:21:38 +00003685 }
3686}
3687
Devang Patel2c4ceb12009-11-21 02:48:08 +00003688/// emitDebugInlineInfo - Emit inline info using following format.
Bill Wendling94d04b82009-05-20 23:21:38 +00003689/// Section Header:
3690/// 1. length of section
3691/// 2. Dwarf version number
3692/// 3. address size.
3693///
3694/// Entries (one "entry" for each function that was inlined):
3695///
3696/// 1. offset into __debug_str section for MIPS linkage name, if exists;
3697/// otherwise offset into __debug_str for regular function name.
3698/// 2. offset into __debug_str section for regular function name.
3699/// 3. an unsigned LEB128 number indicating the number of distinct inlining
3700/// instances for the function.
3701///
3702/// The rest of the entry consists of a {die_offset, low_pc} pair for each
3703/// inlined instance; the die_offset points to the inlined_subroutine die in the
3704/// __debug_info section, and the low_pc is the starting address for the
3705/// inlining instance.
Devang Patel2c4ceb12009-11-21 02:48:08 +00003706void DwarfDebug::emitDebugInlineInfo() {
Chris Lattnerd38fee82010-04-05 00:13:49 +00003707 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00003708 return;
3709
Devang Patel163a9f72010-05-10 22:49:55 +00003710 if (!FirstCU)
Bill Wendling94d04b82009-05-20 23:21:38 +00003711 return;
3712
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003713 Asm->OutStreamer.SwitchSection(
3714 Asm->getObjFileLowering().getDwarfDebugInlineSection());
Chris Lattner0ad9c912010-01-22 22:09:00 +00003715
Chris Lattner233f52b2010-03-09 23:52:58 +00003716 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
Chris Lattnera6437182010-04-04 19:58:12 +00003717 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3718 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
Bill Wendling94d04b82009-05-20 23:21:38 +00003719
Chris Lattnerc0215722010-04-04 19:25:43 +00003720 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
Bill Wendling94d04b82009-05-20 23:21:38 +00003721
Chris Lattner233f52b2010-03-09 23:52:58 +00003722 Asm->OutStreamer.AddComment("Dwarf Version");
3723 Asm->EmitInt16(dwarf::DWARF_VERSION);
3724 Asm->OutStreamer.AddComment("Address Size (in bytes)");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003725 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Bill Wendling94d04b82009-05-20 23:21:38 +00003726
Devang Patele9f8f5e2010-05-07 20:54:48 +00003727 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
Devang Patel53bb5c92009-11-10 23:06:00 +00003728 E = InlinedSPNodes.end(); I != E; ++I) {
Jim Grosbach31ef40e2009-11-21 23:12:12 +00003729
Devang Patele9f8f5e2010-05-07 20:54:48 +00003730 const MDNode *Node = *I;
3731 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
Jim Grosbach7ab38df2009-11-22 19:20:36 +00003732 = InlineInfo.find(Node);
Devang Patel53bb5c92009-11-10 23:06:00 +00003733 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
Devang Patele4b27562009-08-28 23:24:31 +00003734 DISubprogram SP(Node);
Devang Patel65dbc902009-11-25 17:36:49 +00003735 StringRef LName = SP.getLinkageName();
3736 StringRef Name = SP.getName();
Bill Wendling94d04b82009-05-20 23:21:38 +00003737
Chris Lattner233f52b2010-03-09 23:52:58 +00003738 Asm->OutStreamer.AddComment("MIPS linkage name");
Chris Lattner4cf202b2010-01-23 03:11:46 +00003739 if (LName.empty()) {
3740 Asm->OutStreamer.EmitBytes(Name, 0);
3741 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
Jim Grosbach1e20b962010-07-21 21:21:52 +00003742 } else
Chris Lattner6189ed12010-04-04 23:25:33 +00003743 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3744 DwarfStrSectionSym);
Devang Patel53bb5c92009-11-10 23:06:00 +00003745
Chris Lattner233f52b2010-03-09 23:52:58 +00003746 Asm->OutStreamer.AddComment("Function name");
Chris Lattner6189ed12010-04-04 23:25:33 +00003747 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003748 Asm->EmitULEB128(Labels.size(), "Inline count");
Bill Wendling94d04b82009-05-20 23:21:38 +00003749
Devang Patel53bb5c92009-11-10 23:06:00 +00003750 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
Bill Wendling94d04b82009-05-20 23:21:38 +00003751 LE = Labels.end(); LI != LE; ++LI) {
Chris Lattner3f53c832010-04-04 18:52:31 +00003752 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
Chris Lattner6ed0f902010-03-09 00:31:02 +00003753 Asm->EmitInt32(LI->second->getOffset());
Bill Wendling94d04b82009-05-20 23:21:38 +00003754
Chris Lattner3f53c832010-04-04 18:52:31 +00003755 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003756 Asm->OutStreamer.EmitSymbolValue(LI->first,
3757 Asm->getTargetData().getPointerSize(),0);
Bill Wendling94d04b82009-05-20 23:21:38 +00003758 }
3759 }
3760
Chris Lattnerc0215722010-04-04 19:25:43 +00003761 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
Bill Wendling94d04b82009-05-20 23:21:38 +00003762}