blob: 490a8662fd2ea5b8ab205091f62e401730a81f0f [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"
16#include "llvm/Module.h"
David Greeneb2c66fc2009-08-19 21:52:55 +000017#include "llvm/CodeGen/MachineFunction.h"
Bill Wendling0310d762009-05-15 09:23:25 +000018#include "llvm/CodeGen/MachineModuleInfo.h"
Chris Lattnerb7db7332010-03-09 01:58:53 +000019#include "llvm/MC/MCAsmInfo.h"
Chris Lattnera87dea42009-07-31 18:48:30 +000020#include "llvm/MC/MCSection.h"
Chris Lattner6c2f9e12009-08-19 05:49:37 +000021#include "llvm/MC/MCStreamer.h"
Chris Lattnerb7db7332010-03-09 01:58:53 +000022#include "llvm/MC/MCSymbol.h"
Chris Lattner45111d12010-01-16 21:57:06 +000023#include "llvm/Target/Mangler.h"
Bill Wendling0310d762009-05-15 09:23:25 +000024#include "llvm/Target/TargetData.h"
25#include "llvm/Target/TargetFrameInfo.h"
Chris Lattnerf0144122009-07-28 03:13:23 +000026#include "llvm/Target/TargetLoweringObjectFile.h"
Chris Lattner9d1c1ad2010-04-04 18:06:11 +000027#include "llvm/Target/TargetMachine.h"
Chris Lattnerf0144122009-07-28 03:13:23 +000028#include "llvm/Target/TargetRegisterInfo.h"
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +000029#include "llvm/ADT/STLExtras.h"
Chris Lattner23132b12009-08-24 03:52:50 +000030#include "llvm/ADT/StringExtras.h"
Daniel Dunbar6e4bdfc2009-10-13 06:47:08 +000031#include "llvm/Support/Debug.h"
32#include "llvm/Support/ErrorHandling.h"
Devang Patel3139fcf2010-01-26 21:39:14 +000033#include "llvm/Support/ValueHandle.h"
Chris Lattner0ad9c912010-01-22 22:09:00 +000034#include "llvm/Support/FormattedStream.h"
Chris Lattnera87dea42009-07-31 18:48:30 +000035#include "llvm/Support/Timer.h"
36#include "llvm/System/Path.h"
Bill Wendling0310d762009-05-15 09:23:25 +000037using namespace llvm;
38
Bill Wendling0310d762009-05-15 09:23:25 +000039//===----------------------------------------------------------------------===//
40
41/// Configuration values for initial hash set sizes (log2).
42///
Bill Wendling0310d762009-05-15 09:23:25 +000043static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
Bill Wendling0310d762009-05-15 09:23:25 +000044
45namespace llvm {
46
47//===----------------------------------------------------------------------===//
48/// CompileUnit - This dwarf writer support class manages information associate
49/// with a source file.
Nick Lewycky5f9843f2009-11-17 08:11:44 +000050class CompileUnit {
Bill Wendling0310d762009-05-15 09:23:25 +000051 /// ID - File identifier for source.
52 ///
53 unsigned ID;
54
55 /// Die - Compile unit debug information entry.
56 ///
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +000057 const OwningPtr<DIE> CUDie;
Bill Wendling0310d762009-05-15 09:23:25 +000058
Jeffrey Yasskind0f393d2010-03-11 18:29:55 +000059 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
Devang Patel6f01d9c2009-11-21 00:31:03 +000060 DIE *IndexTyDie;
61
Bill Wendling0310d762009-05-15 09:23:25 +000062 /// GVToDieMap - Tracks the mapping of unit level debug informaton
63 /// variables to debug information entries.
Devang Patele4b27562009-08-28 23:24:31 +000064 /// FIXME : Rename GVToDieMap -> NodeToDieMap
Devang Patel622b0262010-01-19 06:19:05 +000065 DenseMap<MDNode *, DIE *> GVToDieMap;
Bill Wendling0310d762009-05-15 09:23:25 +000066
67 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
68 /// descriptors to debug information entries using a DIEEntry proxy.
Devang Patele4b27562009-08-28 23:24:31 +000069 /// FIXME : Rename
Devang Patel622b0262010-01-19 06:19:05 +000070 DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
Bill Wendling0310d762009-05-15 09:23:25 +000071
72 /// Globals - A map of globally visible named entities for this unit.
73 ///
74 StringMap<DIE*> Globals;
75
Devang Patel193f7202009-11-24 01:14:22 +000076 /// GlobalTypes - A map of globally visible types for this unit.
77 ///
78 StringMap<DIE*> GlobalTypes;
79
Bill Wendling0310d762009-05-15 09:23:25 +000080public:
81 CompileUnit(unsigned I, DIE *D)
Devang Patel2c4ceb12009-11-21 02:48:08 +000082 : ID(I), CUDie(D), IndexTyDie(0) {}
Bill Wendling0310d762009-05-15 09:23:25 +000083
84 // Accessors.
Devang Patel193f7202009-11-24 01:14:22 +000085 unsigned getID() const { return ID; }
Jeffrey Yasskind0f393d2010-03-11 18:29:55 +000086 DIE* getCUDie() const { return CUDie.get(); }
Devang Patel193f7202009-11-24 01:14:22 +000087 const StringMap<DIE*> &getGlobals() const { return Globals; }
88 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
Bill Wendling0310d762009-05-15 09:23:25 +000089
90 /// hasContent - Return true if this compile unit has something to write out.
91 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +000092 bool hasContent() const { return !CUDie->getChildren().empty(); }
Bill Wendling0310d762009-05-15 09:23:25 +000093
Devang Patel2c4ceb12009-11-21 02:48:08 +000094 /// addGlobal - Add a new global entity to the compile unit.
Bill Wendling0310d762009-05-15 09:23:25 +000095 ///
Benjamin Kramerbbb88db2010-03-31 20:15:45 +000096 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
Bill Wendling0310d762009-05-15 09:23:25 +000097
Devang Patel193f7202009-11-24 01:14:22 +000098 /// addGlobalType - Add a new global type to the compile unit.
99 ///
Benjamin Kramerbbb88db2010-03-31 20:15:45 +0000100 void addGlobalType(StringRef Name, DIE *Die) {
Devang Patel193f7202009-11-24 01:14:22 +0000101 GlobalTypes[Name] = Die;
102 }
103
Devang Patel017d1212009-11-20 21:37:22 +0000104 /// getDIE - Returns the debug information entry map slot for the
Bill Wendling0310d762009-05-15 09:23:25 +0000105 /// specified debug variable.
Devang Patel017d1212009-11-20 21:37:22 +0000106 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000107
Devang Patel017d1212009-11-20 21:37:22 +0000108 /// insertDIE - Insert DIE into the map.
109 void insertDIE(MDNode *N, DIE *D) {
110 GVToDieMap.insert(std::make_pair(N, D));
111 }
Bill Wendling0310d762009-05-15 09:23:25 +0000112
Devang Patel017d1212009-11-20 21:37:22 +0000113 /// getDIEEntry - Returns the debug information entry for the speciefied
114 /// debug variable.
Devang Patel6404e4e2009-12-15 19:16:48 +0000115 DIEEntry *getDIEEntry(MDNode *N) {
Devang Patel622b0262010-01-19 06:19:05 +0000116 DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
Devang Patel6404e4e2009-12-15 19:16:48 +0000117 if (I == GVToDIEEntryMap.end())
118 return NULL;
119 return I->second;
120 }
Devang Patel017d1212009-11-20 21:37:22 +0000121
122 /// insertDIEEntry - Insert debug information entry into the map.
123 void insertDIEEntry(MDNode *N, DIEEntry *E) {
124 GVToDIEEntryMap.insert(std::make_pair(N, E));
Bill Wendling0310d762009-05-15 09:23:25 +0000125 }
126
Devang Patel2c4ceb12009-11-21 02:48:08 +0000127 /// addDie - Adds or interns the DIE to the compile unit.
Bill Wendling0310d762009-05-15 09:23:25 +0000128 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000129 void addDie(DIE *Buffer) {
130 this->CUDie->addChild(Buffer);
Bill Wendling0310d762009-05-15 09:23:25 +0000131 }
Devang Patel6f01d9c2009-11-21 00:31:03 +0000132
133 // getIndexTyDie - Get an anonymous type for index type.
134 DIE *getIndexTyDie() {
135 return IndexTyDie;
136 }
137
Jim Grosbach7ab38df2009-11-22 19:20:36 +0000138 // setIndexTyDie - Set D as anonymous type for index which can be reused
139 // later.
Devang Patel6f01d9c2009-11-21 00:31:03 +0000140 void setIndexTyDie(DIE *D) {
141 IndexTyDie = D;
142 }
143
Bill Wendling0310d762009-05-15 09:23:25 +0000144};
145
146//===----------------------------------------------------------------------===//
147/// DbgVariable - This class is used to track local variable information.
148///
Devang Patelf76a3d62009-11-16 21:53:40 +0000149class DbgVariable {
Bill Wendling0310d762009-05-15 09:23:25 +0000150 DIVariable Var; // Variable Descriptor.
151 unsigned FrameIndex; // Variable frame index.
Devang Patel90a48ad2010-03-15 18:33:46 +0000152 const MachineInstr *DbgValueMInsn; // DBG_VALUE
Devang Patelaead63c2010-03-29 22:59:58 +0000153 // DbgValueLabel - DBG_VALUE is effective from this label.
154 MCSymbol *DbgValueLabel;
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000155 DbgVariable *const AbstractVar; // Abstract variable for this variable.
Devang Patel53bb5c92009-11-10 23:06:00 +0000156 DIE *TheDIE;
Bill Wendling0310d762009-05-15 09:23:25 +0000157public:
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000158 // AbsVar may be NULL.
159 DbgVariable(DIVariable V, unsigned I, DbgVariable *AbsVar)
Devang Patelaead63c2010-03-29 22:59:58 +0000160 : Var(V), FrameIndex(I), DbgValueMInsn(0),
161 DbgValueLabel(0), AbstractVar(AbsVar), TheDIE(0) {}
Devang Patel90a48ad2010-03-15 18:33:46 +0000162 DbgVariable(DIVariable V, const MachineInstr *MI, DbgVariable *AbsVar)
Devang Patelaead63c2010-03-29 22:59:58 +0000163 : Var(V), FrameIndex(0), DbgValueMInsn(MI), DbgValueLabel(0),
164 AbstractVar(AbsVar), TheDIE(0)
Devang Patel90a48ad2010-03-15 18:33:46 +0000165 {}
Bill Wendling0310d762009-05-15 09:23:25 +0000166
167 // Accessors.
Devang Patel53bb5c92009-11-10 23:06:00 +0000168 DIVariable getVariable() const { return Var; }
169 unsigned getFrameIndex() const { return FrameIndex; }
Devang Patel90a48ad2010-03-15 18:33:46 +0000170 const MachineInstr *getDbgValue() const { return DbgValueMInsn; }
Devang Patelaead63c2010-03-29 22:59:58 +0000171 MCSymbol *getDbgValueLabel() const { return DbgValueLabel; }
172 void setDbgValueLabel(MCSymbol *L) { DbgValueLabel = L; }
Devang Patel53bb5c92009-11-10 23:06:00 +0000173 DbgVariable *getAbstractVariable() const { return AbstractVar; }
174 void setDIE(DIE *D) { TheDIE = D; }
175 DIE *getDIE() const { return TheDIE; }
Bill Wendling0310d762009-05-15 09:23:25 +0000176};
177
178//===----------------------------------------------------------------------===//
179/// DbgScope - This class is used to track scope information.
180///
Devang Patelf76a3d62009-11-16 21:53:40 +0000181class DbgScope {
Bill Wendling0310d762009-05-15 09:23:25 +0000182 DbgScope *Parent; // Parent to this scope.
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000183 DIDescriptor Desc; // Debug info descriptor for scope.
Devang Patel3139fcf2010-01-26 21:39:14 +0000184 // Location at which this scope is inlined.
185 AssertingVH<MDNode> InlinedAtLocation;
Devang Patel53bb5c92009-11-10 23:06:00 +0000186 bool AbstractScope; // Abstract Scope
Chris Lattnerb7db7332010-03-09 01:58:53 +0000187 MCSymbol *StartLabel; // Label ID of the beginning of scope.
188 MCSymbol *EndLabel; // Label ID of the end of scope.
Devang Pateld38dd112009-10-01 18:25:23 +0000189 const MachineInstr *LastInsn; // Last instruction of this scope.
190 const MachineInstr *FirstInsn; // First instruction of this scope.
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000191 // Scopes defined in scope. Contents not owned.
192 SmallVector<DbgScope *, 4> Scopes;
193 // Variables declared in scope. Contents owned.
194 SmallVector<DbgVariable *, 8> Variables;
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000195
Owen Anderson04c05f72009-06-24 22:53:20 +0000196 // Private state for dump()
197 mutable unsigned IndentLevel;
Bill Wendling0310d762009-05-15 09:23:25 +0000198public:
Devang Patelc90aefe2009-10-14 21:08:09 +0000199 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
Devang Patel53bb5c92009-11-10 23:06:00 +0000200 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
Chris Lattnerb7db7332010-03-09 01:58:53 +0000201 StartLabel(0), EndLabel(0),
Devang Patelc90aefe2009-10-14 21:08:09 +0000202 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
Bill Wendling0310d762009-05-15 09:23:25 +0000203 virtual ~DbgScope();
204
205 // Accessors.
206 DbgScope *getParent() const { return Parent; }
Devang Patel53bb5c92009-11-10 23:06:00 +0000207 void setParent(DbgScope *P) { Parent = P; }
Bill Wendling0310d762009-05-15 09:23:25 +0000208 DIDescriptor getDesc() const { return Desc; }
Chris Lattnerbc733f52010-03-13 02:17:42 +0000209 MDNode *getInlinedAt() const { return InlinedAtLocation; }
Devang Patel53bb5c92009-11-10 23:06:00 +0000210 MDNode *getScopeNode() const { return Desc.getNode(); }
Chris Lattnerb7db7332010-03-09 01:58:53 +0000211 MCSymbol *getStartLabel() const { return StartLabel; }
212 MCSymbol *getEndLabel() const { return EndLabel; }
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000213 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
214 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
Chris Lattnerb7db7332010-03-09 01:58:53 +0000215 void setStartLabel(MCSymbol *S) { StartLabel = S; }
216 void setEndLabel(MCSymbol *E) { EndLabel = E; }
Devang Pateld38dd112009-10-01 18:25:23 +0000217 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
218 const MachineInstr *getLastInsn() { return LastInsn; }
219 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
Devang Patel53bb5c92009-11-10 23:06:00 +0000220 void setAbstractScope() { AbstractScope = true; }
221 bool isAbstractScope() const { return AbstractScope; }
Devang Pateld38dd112009-10-01 18:25:23 +0000222 const MachineInstr *getFirstInsn() { return FirstInsn; }
Devang Patel53bb5c92009-11-10 23:06:00 +0000223
Devang Patel2c4ceb12009-11-21 02:48:08 +0000224 /// addScope - Add a scope to the scope.
Bill Wendling0310d762009-05-15 09:23:25 +0000225 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000226 void addScope(DbgScope *S) { Scopes.push_back(S); }
Bill Wendling0310d762009-05-15 09:23:25 +0000227
Devang Patel2c4ceb12009-11-21 02:48:08 +0000228 /// addVariable - Add a variable to the scope.
Bill Wendling0310d762009-05-15 09:23:25 +0000229 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000230 void addVariable(DbgVariable *V) { Variables.push_back(V); }
Bill Wendling0310d762009-05-15 09:23:25 +0000231
Devang Patel344130e2010-01-04 20:44:00 +0000232 void fixInstructionMarkers(DenseMap<const MachineInstr *,
233 unsigned> &MIIndexMap) {
Chris Lattnered7a77b2010-03-31 05:36:29 +0000234 assert(getFirstInsn() && "First instruction is missing!");
Devang Patel344130e2010-01-04 20:44:00 +0000235
236 // Use the end of last child scope as end of this scope.
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000237 const SmallVector<DbgScope *, 4> &Scopes = getScopes();
Devang Patelee890ed2010-01-05 16:59:17 +0000238 const MachineInstr *LastInsn = getFirstInsn();
Devang Patel344130e2010-01-04 20:44:00 +0000239 unsigned LIndex = 0;
240 if (Scopes.empty()) {
Chris Lattnered7a77b2010-03-31 05:36:29 +0000241 assert(getLastInsn() && "Inner most scope does not have last insn!");
Devang Patel344130e2010-01-04 20:44:00 +0000242 return;
243 }
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000244 for (SmallVector<DbgScope *, 4>::const_iterator SI = Scopes.begin(),
Devang Patel344130e2010-01-04 20:44:00 +0000245 SE = Scopes.end(); SI != SE; ++SI) {
246 DbgScope *DS = *SI;
247 DS->fixInstructionMarkers(MIIndexMap);
248 const MachineInstr *DSLastInsn = DS->getLastInsn();
249 unsigned DSI = MIIndexMap[DSLastInsn];
250 if (DSI > LIndex) {
251 LastInsn = DSLastInsn;
252 LIndex = DSI;
253 }
254 }
Devang Patel22fb4b22010-02-17 02:20:34 +0000255
256 unsigned CurrentLastInsnIndex = 0;
257 if (const MachineInstr *CL = getLastInsn())
258 CurrentLastInsnIndex = MIIndexMap[CL];
259 unsigned FIndex = MIIndexMap[getFirstInsn()];
260
261 // Set LastInsn as the last instruction for this scope only if
262 // it follows
263 // 1) this scope's first instruction and
264 // 2) current last instruction for this scope, if any.
265 if (LIndex >= CurrentLastInsnIndex && LIndex >= FIndex)
266 setLastInsn(LastInsn);
Devang Patelaf9e8472009-10-01 20:31:14 +0000267 }
268
Bill Wendling0310d762009-05-15 09:23:25 +0000269#ifndef NDEBUG
270 void dump() const;
271#endif
272};
273
274#ifndef NDEBUG
275void DbgScope::dump() const {
David Greenef83adbc2009-12-24 00:31:35 +0000276 raw_ostream &err = dbgs();
Chris Lattnerc281de12009-08-23 00:51:00 +0000277 err.indent(IndentLevel);
Devang Patel53bb5c92009-11-10 23:06:00 +0000278 MDNode *N = Desc.getNode();
279 N->dump();
Chris Lattnerb7db7332010-03-09 01:58:53 +0000280 err << " [" << StartLabel << ", " << EndLabel << "]\n";
Devang Patel53bb5c92009-11-10 23:06:00 +0000281 if (AbstractScope)
282 err << "Abstract Scope\n";
Bill Wendling0310d762009-05-15 09:23:25 +0000283
284 IndentLevel += 2;
Devang Patel53bb5c92009-11-10 23:06:00 +0000285 if (!Scopes.empty())
286 err << "Children ...\n";
Bill Wendling0310d762009-05-15 09:23:25 +0000287 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
288 if (Scopes[i] != this)
289 Scopes[i]->dump();
290
291 IndentLevel -= 2;
292}
293#endif
294
Bill Wendling0310d762009-05-15 09:23:25 +0000295DbgScope::~DbgScope() {
Bill Wendling0310d762009-05-15 09:23:25 +0000296 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
297 delete Variables[j];
Bill Wendling0310d762009-05-15 09:23:25 +0000298}
299
300} // end llvm namespace
301
Chris Lattner75f50722010-04-04 07:48:20 +0000302DwarfDebug::DwarfDebug(AsmPrinter *A)
Chris Lattnerd38fee82010-04-05 00:13:49 +0000303 : Asm(A), MMI(Asm->MMI), ModuleCU(0),
Chris Lattnerfa070b02010-04-04 22:33:59 +0000304 AbbreviationsSet(InitAbbreviationsSetSize), shouldEmit(false),
Chris Lattnerde4845c2010-04-02 19:42:39 +0000305 CurrentFnDbgScope(0), DebugTimer(0) {
Chris Lattnerbc733f52010-03-13 02:17:42 +0000306 NextStringPoolNumber = 0;
Chris Lattner9c69e285532010-04-04 22:59:04 +0000307
Chris Lattner4ad1efe2010-04-04 23:10:38 +0000308 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
309 DwarfStrSectionSym = TextSectionSym = 0;
Chris Lattner9c69e285532010-04-04 22:59:04 +0000310
Bill Wendling0310d762009-05-15 09:23:25 +0000311 if (TimePassesIsEnabled)
Chris Lattner0b86a6f2009-12-28 07:41:18 +0000312 DebugTimer = new Timer("Dwarf Debug Writer");
Bill Wendling0310d762009-05-15 09:23:25 +0000313}
314DwarfDebug::~DwarfDebug() {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000315 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
316 DIEBlocks[j]->~DIEBlock();
Bill Wendling0310d762009-05-15 09:23:25 +0000317
Bill Wendling0310d762009-05-15 09:23:25 +0000318 delete DebugTimer;
319}
320
Chris Lattnerbc733f52010-03-13 02:17:42 +0000321MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
322 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
323 if (Entry.first) return Entry.first;
324
325 Entry.second = NextStringPoolNumber++;
Chris Lattnerc0215722010-04-04 19:25:43 +0000326 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
Chris Lattnerbc733f52010-03-13 02:17:42 +0000327}
328
329
Devang Patel2c4ceb12009-11-21 02:48:08 +0000330/// assignAbbrevNumber - Define a unique number for the abbreviation.
Bill Wendling0310d762009-05-15 09:23:25 +0000331///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000332void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
Bill Wendling0310d762009-05-15 09:23:25 +0000333 // Profile the node so that we can make it unique.
334 FoldingSetNodeID ID;
335 Abbrev.Profile(ID);
336
337 // Check the set for priors.
338 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
339
340 // If it's newly added.
341 if (InSet == &Abbrev) {
342 // Add to abbreviation list.
343 Abbreviations.push_back(&Abbrev);
344
345 // Assign the vector position + 1 as its number.
346 Abbrev.setNumber(Abbreviations.size());
347 } else {
348 // Assign existing abbreviation number.
349 Abbrev.setNumber(InSet->getNumber());
350 }
351}
352
Devang Patel2c4ceb12009-11-21 02:48:08 +0000353/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
Bill Wendling995f80a2009-05-20 23:24:48 +0000354/// information entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000355DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000356 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
Bill Wendling0310d762009-05-15 09:23:25 +0000357 return Value;
358}
359
Devang Patel2c4ceb12009-11-21 02:48:08 +0000360/// addUInt - Add an unsigned integer attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000361///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000362void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
Bill Wendling0310d762009-05-15 09:23:25 +0000363 unsigned Form, uint64_t Integer) {
364 if (!Form) Form = DIEInteger::BestForm(false, Integer);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000365 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000366 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000367}
368
Devang Patel2c4ceb12009-11-21 02:48:08 +0000369/// addSInt - Add an signed integer attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000370///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000371void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
Bill Wendling0310d762009-05-15 09:23:25 +0000372 unsigned Form, int64_t Integer) {
373 if (!Form) Form = DIEInteger::BestForm(true, Integer);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000374 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000375 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000376}
377
Devang Patel69f57b12009-12-02 15:25:16 +0000378/// addString - Add a string attribute data and value. DIEString only
379/// keeps string reference.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000380void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattner4cf202b2010-01-23 03:11:46 +0000381 StringRef String) {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000382 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
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/// addLabel - Add a Dwarf label attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000387///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000388void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattnerb98b1bf2010-03-08 22:23:36 +0000389 const MCSymbol *Label) {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000390 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000391 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000392}
393
Devang Patel2c4ceb12009-11-21 02:48:08 +0000394/// addDelta - Add a label delta attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000395///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000396void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattnerb98b1bf2010-03-08 22:23:36 +0000397 const MCSymbol *Hi, const MCSymbol *Lo) {
Benjamin Kramer345ef342010-03-31 19:34:01 +0000398 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000399 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000400}
401
Devang Patel2c4ceb12009-11-21 02:48:08 +0000402/// addBlock - Add block data.
Bill Wendling0310d762009-05-15 09:23:25 +0000403///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000404void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
Bill Wendling0310d762009-05-15 09:23:25 +0000405 DIEBlock *Block) {
Chris Lattnera37d5382010-04-05 00:18:22 +0000406 Block->ComputeSize(Asm);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000407 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000408 Die->addValue(Attribute, Block->BestForm(), Block);
Bill Wendling0310d762009-05-15 09:23:25 +0000409}
410
Devang Patel2c4ceb12009-11-21 02:48:08 +0000411/// addSourceLine - Add location information to specified debug information
Bill Wendling0310d762009-05-15 09:23:25 +0000412/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000413void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
Bill Wendling0310d762009-05-15 09:23:25 +0000414 // If there is no compile unit specified, don't add a line #.
Devang Patel3c91b052010-03-08 20:52:55 +0000415 if (!V->getCompileUnit().Verify())
Bill Wendling0310d762009-05-15 09:23:25 +0000416 return;
417
418 unsigned Line = V->getLineNumber();
Devang Patel77bf2952010-03-08 22:02:50 +0000419 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
420 V->getContext().getFilename());
Bill Wendling0310d762009-05-15 09:23:25 +0000421 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000422 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
423 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling0310d762009-05-15 09:23:25 +0000424}
425
Devang Patel2c4ceb12009-11-21 02:48:08 +0000426/// addSourceLine - Add location information to specified debug information
Bill Wendling0310d762009-05-15 09:23:25 +0000427/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000428void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
Bill Wendling0310d762009-05-15 09:23:25 +0000429 // If there is no compile unit specified, don't add a line #.
Devang Patel3c91b052010-03-08 20:52:55 +0000430 if (!G->getCompileUnit().Verify())
Bill Wendling0310d762009-05-15 09:23:25 +0000431 return;
432
433 unsigned Line = G->getLineNumber();
Devang Patel77bf2952010-03-08 22:02:50 +0000434 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
435 G->getContext().getFilename());
Bill Wendling0310d762009-05-15 09:23:25 +0000436 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000437 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
438 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling0310d762009-05-15 09:23:25 +0000439}
Devang Patel82dfc0c2009-08-31 22:47:13 +0000440
Devang Patel2c4ceb12009-11-21 02:48:08 +0000441/// addSourceLine - Add location information to specified debug information
Devang Patel82dfc0c2009-08-31 22:47:13 +0000442/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000443void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
Devang Patel82dfc0c2009-08-31 22:47:13 +0000444 // If there is no compile unit specified, don't add a line #.
Devang Patel3c91b052010-03-08 20:52:55 +0000445 if (!SP->getCompileUnit().Verify())
Devang Patel82dfc0c2009-08-31 22:47:13 +0000446 return;
Caroline Ticec6f9d622009-09-11 18:25:54 +0000447 // If the line number is 0, don't add it.
448 if (SP->getLineNumber() == 0)
449 return;
450
Devang Patel82dfc0c2009-08-31 22:47:13 +0000451 unsigned Line = SP->getLineNumber();
Devang Patel77bf2952010-03-08 22:02:50 +0000452 if (!SP->getContext().Verify())
453 return;
Devang Patel9bb59a22010-03-24 21:30:35 +0000454 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
455 SP->getFilename());
Devang Patel82dfc0c2009-08-31 22:47:13 +0000456 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000457 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
458 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Devang Patel82dfc0c2009-08-31 22:47:13 +0000459}
460
Devang Patel2c4ceb12009-11-21 02:48:08 +0000461/// addSourceLine - Add location information to specified debug information
Devang Patel82dfc0c2009-08-31 22:47:13 +0000462/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000463void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
Bill Wendling0310d762009-05-15 09:23:25 +0000464 // If there is no compile unit specified, don't add a line #.
465 DICompileUnit CU = Ty->getCompileUnit();
Devang Patel3c91b052010-03-08 20:52:55 +0000466 if (!CU.Verify())
Bill Wendling0310d762009-05-15 09:23:25 +0000467 return;
468
469 unsigned Line = Ty->getLineNumber();
Devang Patel77bf2952010-03-08 22:02:50 +0000470 if (!Ty->getContext().Verify())
471 return;
472 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
473 Ty->getContext().getFilename());
Bill Wendling0310d762009-05-15 09:23:25 +0000474 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000475 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
476 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling0310d762009-05-15 09:23:25 +0000477}
478
Devang Patel6404e4e2009-12-15 19:16:48 +0000479/// addSourceLine - Add location information to specified debug information
480/// entry.
481void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
482 // If there is no compile unit specified, don't add a line #.
Devang Patel3c91b052010-03-08 20:52:55 +0000483 if (!NS->getCompileUnit().Verify())
Devang Patel6404e4e2009-12-15 19:16:48 +0000484 return;
485
486 unsigned Line = NS->getLineNumber();
487 StringRef FN = NS->getFilename();
488 StringRef Dir = NS->getDirectory();
489
490 unsigned FileID = GetOrCreateSourceID(Dir, FN);
491 assert(FileID && "Invalid file id");
492 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
493 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
494}
495
Caroline Ticedc8f6042009-08-31 21:19:37 +0000496/* Byref variables, in Blocks, are declared by the programmer as
497 "SomeType VarName;", but the compiler creates a
498 __Block_byref_x_VarName struct, and gives the variable VarName
499 either the struct, or a pointer to the struct, as its type. This
500 is necessary for various behind-the-scenes things the compiler
501 needs to do with by-reference variables in blocks.
502
503 However, as far as the original *programmer* is concerned, the
504 variable should still have type 'SomeType', as originally declared.
505
506 The following function dives into the __Block_byref_x_VarName
507 struct to find the original type of the variable. This will be
508 passed back to the code generating the type for the Debug
509 Information Entry for the variable 'VarName'. 'VarName' will then
510 have the original type 'SomeType' in its debug information.
511
512 The original type 'SomeType' will be the type of the field named
513 'VarName' inside the __Block_byref_x_VarName struct.
514
515 NOTE: In order for this to not completely fail on the debugger
516 side, the Debug Information Entry for the variable VarName needs to
517 have a DW_AT_location that tells the debugger how to unwind through
518 the pointers and __Block_byref_x_VarName struct to find the actual
Devang Patel2c4ceb12009-11-21 02:48:08 +0000519 value of the variable. The function addBlockByrefType does this. */
Caroline Ticedc8f6042009-08-31 21:19:37 +0000520
521/// Find the type the programmer originally declared the variable to be
522/// and return that type.
523///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000524DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
Caroline Ticedc8f6042009-08-31 21:19:37 +0000525
526 DIType subType = Ty;
527 unsigned tag = Ty.getTag();
528
529 if (tag == dwarf::DW_TAG_pointer_type) {
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000530 DIDerivedType DTy = DIDerivedType(Ty.getNode());
Caroline Ticedc8f6042009-08-31 21:19:37 +0000531 subType = DTy.getTypeDerivedFrom();
532 }
533
534 DICompositeType blockStruct = DICompositeType(subType.getNode());
Caroline Ticedc8f6042009-08-31 21:19:37 +0000535 DIArray Elements = blockStruct.getTypeArray();
536
Caroline Ticedc8f6042009-08-31 21:19:37 +0000537 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
538 DIDescriptor Element = Elements.getElement(i);
539 DIDerivedType DT = DIDerivedType(Element.getNode());
Devang Patel65dbc902009-11-25 17:36:49 +0000540 if (Name == DT.getName())
Caroline Ticedc8f6042009-08-31 21:19:37 +0000541 return (DT.getTypeDerivedFrom());
542 }
543
544 return Ty;
545}
546
Devang Patel2c4ceb12009-11-21 02:48:08 +0000547/// addComplexAddress - Start with the address based on the location provided,
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000548/// and generate the DWARF information necessary to find the actual variable
549/// given the extra address information encoded in the DIVariable, starting from
550/// the starting location. Add the DWARF information to the die.
551///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000552void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000553 unsigned Attribute,
554 const MachineLocation &Location) {
555 const DIVariable &VD = DV->getVariable();
556 DIType Ty = VD.getType();
557
558 // Decode the original location, and use that as the start of the byref
559 // variable's location.
Chris Lattnerd38fee82010-04-05 00:13:49 +0000560 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000561 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000562 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000563
564 if (Location.isReg()) {
565 if (Reg < 32) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000566 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000567 } else {
568 Reg = Reg - dwarf::DW_OP_reg0;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000569 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
570 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000571 }
572 } else {
573 if (Reg < 32)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000574 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000575 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000576 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
577 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000578 }
579
Devang Patel2c4ceb12009-11-21 02:48:08 +0000580 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000581 }
582
583 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
584 uint64_t Element = VD.getAddrElement(i);
585
586 if (Element == DIFactory::OpPlus) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000587 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
588 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000589 } else if (Element == DIFactory::OpDeref) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000590 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000591 } else llvm_unreachable("unknown DIFactory Opcode");
592 }
593
594 // Now attach the location information to the DIE.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000595 addBlock(Die, Attribute, 0, Block);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000596}
597
Caroline Ticedc8f6042009-08-31 21:19:37 +0000598/* Byref variables, in Blocks, are declared by the programmer as "SomeType
599 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
600 gives the variable VarName either the struct, or a pointer to the struct, as
601 its type. This is necessary for various behind-the-scenes things the
602 compiler needs to do with by-reference variables in Blocks.
603
604 However, as far as the original *programmer* is concerned, the variable
605 should still have type 'SomeType', as originally declared.
606
Devang Patel2c4ceb12009-11-21 02:48:08 +0000607 The function getBlockByrefType dives into the __Block_byref_x_VarName
Caroline Ticedc8f6042009-08-31 21:19:37 +0000608 struct to find the original type of the variable, which is then assigned to
609 the variable's Debug Information Entry as its real type. So far, so good.
610 However now the debugger will expect the variable VarName to have the type
611 SomeType. So we need the location attribute for the variable to be an
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000612 expression that explains to the debugger how to navigate through the
Caroline Ticedc8f6042009-08-31 21:19:37 +0000613 pointers and struct to find the actual variable of type SomeType.
614
615 The following function does just that. We start by getting
616 the "normal" location for the variable. This will be the location
617 of either the struct __Block_byref_x_VarName or the pointer to the
618 struct __Block_byref_x_VarName.
619
620 The struct will look something like:
621
622 struct __Block_byref_x_VarName {
623 ... <various fields>
624 struct __Block_byref_x_VarName *forwarding;
625 ... <various other fields>
626 SomeType VarName;
627 ... <maybe more fields>
628 };
629
630 If we are given the struct directly (as our starting point) we
631 need to tell the debugger to:
632
633 1). Add the offset of the forwarding field.
634
Dan Gohmanf451cb82010-02-10 16:03:48 +0000635 2). Follow that pointer to get the real __Block_byref_x_VarName
Caroline Ticedc8f6042009-08-31 21:19:37 +0000636 struct to use (the real one may have been copied onto the heap).
637
638 3). Add the offset for the field VarName, to find the actual variable.
639
640 If we started with a pointer to the struct, then we need to
641 dereference that pointer first, before the other steps.
642 Translating this into DWARF ops, we will need to append the following
643 to the current location description for the variable:
644
645 DW_OP_deref -- optional, if we start with a pointer
646 DW_OP_plus_uconst <forward_fld_offset>
647 DW_OP_deref
648 DW_OP_plus_uconst <varName_fld_offset>
649
650 That is what this function does. */
651
Devang Patel2c4ceb12009-11-21 02:48:08 +0000652/// addBlockByrefAddress - Start with the address based on the location
Caroline Ticedc8f6042009-08-31 21:19:37 +0000653/// provided, and generate the DWARF information necessary to find the
654/// actual Block variable (navigating the Block struct) based on the
655/// starting location. Add the DWARF information to the die. For
656/// more information, read large comment just above here.
657///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000658void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
Daniel Dunbar00564992009-09-19 20:40:14 +0000659 unsigned Attribute,
660 const MachineLocation &Location) {
Caroline Ticedc8f6042009-08-31 21:19:37 +0000661 const DIVariable &VD = DV->getVariable();
662 DIType Ty = VD.getType();
663 DIType TmpTy = Ty;
664 unsigned Tag = Ty.getTag();
665 bool isPointer = false;
666
Devang Patel65dbc902009-11-25 17:36:49 +0000667 StringRef varName = VD.getName();
Caroline Ticedc8f6042009-08-31 21:19:37 +0000668
669 if (Tag == dwarf::DW_TAG_pointer_type) {
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000670 DIDerivedType DTy = DIDerivedType(Ty.getNode());
Caroline Ticedc8f6042009-08-31 21:19:37 +0000671 TmpTy = DTy.getTypeDerivedFrom();
672 isPointer = true;
673 }
674
675 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
676
Daniel Dunbar00564992009-09-19 20:40:14 +0000677 // Find the __forwarding field and the variable field in the __Block_byref
678 // struct.
Daniel Dunbar00564992009-09-19 20:40:14 +0000679 DIArray Fields = blockStruct.getTypeArray();
680 DIDescriptor varField = DIDescriptor();
681 DIDescriptor forwardingField = DIDescriptor();
Caroline Ticedc8f6042009-08-31 21:19:37 +0000682
Daniel Dunbar00564992009-09-19 20:40:14 +0000683 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
684 DIDescriptor Element = Fields.getElement(i);
685 DIDerivedType DT = DIDerivedType(Element.getNode());
Devang Patel65dbc902009-11-25 17:36:49 +0000686 StringRef fieldName = DT.getName();
687 if (fieldName == "__forwarding")
Daniel Dunbar00564992009-09-19 20:40:14 +0000688 forwardingField = Element;
Devang Patel65dbc902009-11-25 17:36:49 +0000689 else if (fieldName == varName)
Daniel Dunbar00564992009-09-19 20:40:14 +0000690 varField = Element;
691 }
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000692
Daniel Dunbar00564992009-09-19 20:40:14 +0000693 // Get the offsets for the forwarding field and the variable field.
Chris Lattner1d65ba72010-03-31 06:06:37 +0000694 unsigned forwardingFieldOffset =
Daniel Dunbar00564992009-09-19 20:40:14 +0000695 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
Chris Lattner1d65ba72010-03-31 06:06:37 +0000696 unsigned varFieldOffset =
Daniel Dunbar00564992009-09-19 20:40:14 +0000697 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
Caroline Ticedc8f6042009-08-31 21:19:37 +0000698
Mike Stump7e3720d2009-09-24 23:21:26 +0000699 // Decode the original location, and use that as the start of the byref
700 // variable's location.
Chris Lattnerd38fee82010-04-05 00:13:49 +0000701 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Daniel Dunbar00564992009-09-19 20:40:14 +0000702 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000703 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Caroline Ticedc8f6042009-08-31 21:19:37 +0000704
Daniel Dunbar00564992009-09-19 20:40:14 +0000705 if (Location.isReg()) {
706 if (Reg < 32)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000707 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000708 else {
709 Reg = Reg - dwarf::DW_OP_reg0;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000710 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
711 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000712 }
713 } else {
714 if (Reg < 32)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000715 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000716 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000717 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
718 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000719 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000720
Devang Patel2c4ceb12009-11-21 02:48:08 +0000721 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Daniel Dunbar00564992009-09-19 20:40:14 +0000722 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000723
Mike Stump7e3720d2009-09-24 23:21:26 +0000724 // If we started with a pointer to the __Block_byref... struct, then
Daniel Dunbar00564992009-09-19 20:40:14 +0000725 // the first thing we need to do is dereference the pointer (DW_OP_deref).
Daniel Dunbar00564992009-09-19 20:40:14 +0000726 if (isPointer)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000727 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000728
Daniel Dunbar00564992009-09-19 20:40:14 +0000729 // Next add the offset for the '__forwarding' field:
730 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
731 // adding the offset if it's 0.
Daniel Dunbar00564992009-09-19 20:40:14 +0000732 if (forwardingFieldOffset > 0) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000733 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
734 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
Daniel Dunbar00564992009-09-19 20:40:14 +0000735 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000736
Daniel Dunbar00564992009-09-19 20:40:14 +0000737 // Now dereference the __forwarding field to get to the real __Block_byref
738 // struct: DW_OP_deref.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000739 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000740
Daniel Dunbar00564992009-09-19 20:40:14 +0000741 // Now that we've got the real __Block_byref... struct, add the offset
742 // for the variable's field to get to the location of the actual variable:
743 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
Daniel Dunbar00564992009-09-19 20:40:14 +0000744 if (varFieldOffset > 0) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000745 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
746 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
Daniel Dunbar00564992009-09-19 20:40:14 +0000747 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000748
Daniel Dunbar00564992009-09-19 20:40:14 +0000749 // Now attach the location information to the DIE.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000750 addBlock(Die, Attribute, 0, Block);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000751}
752
Devang Patel2c4ceb12009-11-21 02:48:08 +0000753/// addAddress - Add an address attribute to a die based on the location
Bill Wendling0310d762009-05-15 09:23:25 +0000754/// provided.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000755void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
Bill Wendling0310d762009-05-15 09:23:25 +0000756 const MachineLocation &Location) {
Chris Lattnerd38fee82010-04-05 00:13:49 +0000757 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Bill Wendling0310d762009-05-15 09:23:25 +0000758 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer345ef342010-03-31 19:34:01 +0000759 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Bill Wendling0310d762009-05-15 09:23:25 +0000760
761 if (Location.isReg()) {
762 if (Reg < 32) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000763 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000764 } else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000765 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
766 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000767 }
768 } else {
769 if (Reg < 32) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000770 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000771 } else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000772 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
773 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000774 }
775
Devang Patel2c4ceb12009-11-21 02:48:08 +0000776 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Bill Wendling0310d762009-05-15 09:23:25 +0000777 }
778
Devang Patel2c4ceb12009-11-21 02:48:08 +0000779 addBlock(Die, Attribute, 0, Block);
Bill Wendling0310d762009-05-15 09:23:25 +0000780}
781
Devang Patelc366f832009-12-10 19:14:49 +0000782/// addToContextOwner - Add Die into the list of its context owner's children.
783void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
Devang Patel3c91b052010-03-08 20:52:55 +0000784 if (Context.isType()) {
Devang Patelc366f832009-12-10 19:14:49 +0000785 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
786 ContextDIE->addChild(Die);
Devang Patel6404e4e2009-12-15 19:16:48 +0000787 } else if (Context.isNameSpace()) {
788 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
789 ContextDIE->addChild(Die);
Devang Patelc366f832009-12-10 19:14:49 +0000790 } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
791 ContextDIE->addChild(Die);
792 else
793 ModuleCU->addDie(Die);
794}
795
Devang Patel16ced732009-12-10 18:05:33 +0000796/// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
797/// given DIType.
798DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
799 DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
800 if (TyDIE)
801 return TyDIE;
802
803 // Create new type.
804 TyDIE = new DIE(dwarf::DW_TAG_base_type);
805 ModuleCU->insertDIE(Ty.getNode(), TyDIE);
806 if (Ty.isBasicType())
807 constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
808 else if (Ty.isCompositeType())
809 constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
810 else {
811 assert(Ty.isDerivedType() && "Unknown kind of DIType");
812 constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
813 }
814
Devang Patelc366f832009-12-10 19:14:49 +0000815 addToContextOwner(TyDIE, Ty.getContext());
Devang Patel16ced732009-12-10 18:05:33 +0000816 return TyDIE;
817}
818
Devang Patel2c4ceb12009-11-21 02:48:08 +0000819/// addType - Add a new type attribute to the specified entity.
Devang Patel8a241142009-12-09 18:24:21 +0000820void DwarfDebug::addType(DIE *Entity, DIType Ty) {
Devang Patel3c91b052010-03-08 20:52:55 +0000821 if (!Ty.isValid())
Bill Wendling0310d762009-05-15 09:23:25 +0000822 return;
823
824 // Check for pre-existence.
Devang Patel8a241142009-12-09 18:24:21 +0000825 DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
Bill Wendling0310d762009-05-15 09:23:25 +0000826 // If it exists then use the existing value.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000827 if (Entry) {
828 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
Bill Wendling0310d762009-05-15 09:23:25 +0000829 return;
830 }
831
Bill Wendling0310d762009-05-15 09:23:25 +0000832 // Construct type.
Devang Patel16ced732009-12-10 18:05:33 +0000833 DIE *Buffer = getOrCreateTypeDIE(Ty);
Bill Wendling0310d762009-05-15 09:23:25 +0000834
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +0000835 // Set up proxy.
836 Entry = createDIEEntry(Buffer);
837 ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
838
Devang Patel2c4ceb12009-11-21 02:48:08 +0000839 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
Bill Wendling0310d762009-05-15 09:23:25 +0000840}
841
Devang Patel2c4ceb12009-11-21 02:48:08 +0000842/// constructTypeDIE - Construct basic type die from DIBasicType.
Devang Patel8a241142009-12-09 18:24:21 +0000843void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
Bill Wendling0310d762009-05-15 09:23:25 +0000844 // Get core information.
Devang Patel65dbc902009-11-25 17:36:49 +0000845 StringRef Name = BTy.getName();
Bill Wendling0310d762009-05-15 09:23:25 +0000846 Buffer.setTag(dwarf::DW_TAG_base_type);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000847 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Bill Wendling0310d762009-05-15 09:23:25 +0000848 BTy.getEncoding());
849
850 // Add name if not anonymous or intermediate type.
Devang Patel65dbc902009-11-25 17:36:49 +0000851 if (!Name.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000852 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +0000853 uint64_t Size = BTy.getSizeInBits() >> 3;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000854 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling0310d762009-05-15 09:23:25 +0000855}
856
Devang Patel2c4ceb12009-11-21 02:48:08 +0000857/// constructTypeDIE - Construct derived type die from DIDerivedType.
Devang Patel8a241142009-12-09 18:24:21 +0000858void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
Bill Wendling0310d762009-05-15 09:23:25 +0000859 // Get core information.
Devang Patel65dbc902009-11-25 17:36:49 +0000860 StringRef Name = DTy.getName();
Bill Wendling0310d762009-05-15 09:23:25 +0000861 uint64_t Size = DTy.getSizeInBits() >> 3;
862 unsigned Tag = DTy.getTag();
863
864 // FIXME - Workaround for templates.
865 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
866
867 Buffer.setTag(Tag);
868
869 // Map to main type, void will not have a type.
870 DIType FromTy = DTy.getTypeDerivedFrom();
Devang Patel8a241142009-12-09 18:24:21 +0000871 addType(&Buffer, FromTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000872
873 // Add name if not anonymous or intermediate type.
Devang Pateldeea5642009-11-30 23:56:56 +0000874 if (!Name.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000875 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +0000876
877 // Add size if non-zero (derived types might be zero-sized.)
878 if (Size)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000879 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling0310d762009-05-15 09:23:25 +0000880
881 // Add source line info if available and TyDesc is not a forward declaration.
Devang Patel05f6fa82009-11-23 18:43:37 +0000882 if (!DTy.isForwardDecl())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000883 addSourceLine(&Buffer, &DTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000884}
885
Devang Patel2c4ceb12009-11-21 02:48:08 +0000886/// constructTypeDIE - Construct type DIE from DICompositeType.
Devang Patel8a241142009-12-09 18:24:21 +0000887void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
Bill Wendling0310d762009-05-15 09:23:25 +0000888 // Get core information.
Devang Patel65dbc902009-11-25 17:36:49 +0000889 StringRef Name = CTy.getName();
Bill Wendling0310d762009-05-15 09:23:25 +0000890
891 uint64_t Size = CTy.getSizeInBits() >> 3;
892 unsigned Tag = CTy.getTag();
893 Buffer.setTag(Tag);
894
895 switch (Tag) {
896 case dwarf::DW_TAG_vector_type:
897 case dwarf::DW_TAG_array_type:
Devang Patel8a241142009-12-09 18:24:21 +0000898 constructArrayTypeDIE(Buffer, &CTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000899 break;
900 case dwarf::DW_TAG_enumeration_type: {
901 DIArray Elements = CTy.getTypeArray();
902
903 // Add enumerators to enumeration type.
904 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
905 DIE *ElemDie = NULL;
Devang Patel3c91b052010-03-08 20:52:55 +0000906 DIDescriptor Enum(Elements.getElement(i).getNode());
907 if (Enum.isEnumerator()) {
908 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum.getNode()));
Devang Patel2c4ceb12009-11-21 02:48:08 +0000909 Buffer.addChild(ElemDie);
Devang Patelc5254722009-10-09 17:51:49 +0000910 }
Bill Wendling0310d762009-05-15 09:23:25 +0000911 }
912 }
913 break;
914 case dwarf::DW_TAG_subroutine_type: {
915 // Add return type.
916 DIArray Elements = CTy.getTypeArray();
917 DIDescriptor RTy = Elements.getElement(0);
Devang Patel8a241142009-12-09 18:24:21 +0000918 addType(&Buffer, DIType(RTy.getNode()));
Bill Wendling0310d762009-05-15 09:23:25 +0000919
920 // Add prototype flag.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000921 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +0000922
923 // Add arguments.
924 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
925 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
926 DIDescriptor Ty = Elements.getElement(i);
Devang Patel8a241142009-12-09 18:24:21 +0000927 addType(Arg, DIType(Ty.getNode()));
Devang Patel2c4ceb12009-11-21 02:48:08 +0000928 Buffer.addChild(Arg);
Bill Wendling0310d762009-05-15 09:23:25 +0000929 }
930 }
931 break;
932 case dwarf::DW_TAG_structure_type:
933 case dwarf::DW_TAG_union_type:
934 case dwarf::DW_TAG_class_type: {
935 // Add elements to structure type.
936 DIArray Elements = CTy.getTypeArray();
937
938 // A forward struct declared type may not have elements available.
Devang Patel3c91b052010-03-08 20:52:55 +0000939 unsigned N = Elements.getNumElements();
940 if (N == 0)
Bill Wendling0310d762009-05-15 09:23:25 +0000941 break;
942
943 // Add elements to structure type.
Devang Patel3c91b052010-03-08 20:52:55 +0000944 for (unsigned i = 0; i < N; ++i) {
Bill Wendling0310d762009-05-15 09:23:25 +0000945 DIDescriptor Element = Elements.getElement(i);
946 DIE *ElemDie = NULL;
Devang Patel3c91b052010-03-08 20:52:55 +0000947 if (Element.isSubprogram())
Devang Patelffe966c2009-12-14 16:18:45 +0000948 ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
Devang Patel3c91b052010-03-08 20:52:55 +0000949 else if (Element.isVariable()) {
Devang Patel1ee0cb92010-01-30 01:08:30 +0000950 DIVariable DV(Element.getNode());
951 ElemDie = new DIE(dwarf::DW_TAG_variable);
952 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
953 DV.getName());
954 addType(ElemDie, DV.getType());
955 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
956 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
957 addSourceLine(ElemDie, &DV);
Devang Patel3c91b052010-03-08 20:52:55 +0000958 } else if (Element.isDerivedType())
Devang Patel8a241142009-12-09 18:24:21 +0000959 ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
Devang Patel3c91b052010-03-08 20:52:55 +0000960 else
961 continue;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000962 Buffer.addChild(ElemDie);
Bill Wendling0310d762009-05-15 09:23:25 +0000963 }
964
Devang Patela1ba2692009-08-27 23:51:51 +0000965 if (CTy.isAppleBlockExtension())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000966 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +0000967
968 unsigned RLang = CTy.getRunTimeLang();
969 if (RLang)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000970 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
Bill Wendling0310d762009-05-15 09:23:25 +0000971 dwarf::DW_FORM_data1, RLang);
Devang Patelb5544992010-01-26 21:16:06 +0000972
973 DICompositeType ContainingType = CTy.getContainingType();
Devang Patel3c91b052010-03-08 20:52:55 +0000974 if (DIDescriptor(ContainingType.getNode()).isCompositeType())
Devang Patelb5544992010-01-26 21:16:06 +0000975 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
976 getOrCreateTypeDIE(DIType(ContainingType.getNode())));
Bill Wendling0310d762009-05-15 09:23:25 +0000977 break;
978 }
979 default:
980 break;
981 }
982
983 // Add name if not anonymous or intermediate type.
Devang Patel65dbc902009-11-25 17:36:49 +0000984 if (!Name.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000985 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +0000986
Devang Patel8cbb6122010-01-29 18:34:58 +0000987 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type ||
Bill Wendling0310d762009-05-15 09:23:25 +0000988 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
989 // Add size if non-zero (derived types might be zero-sized.)
990 if (Size)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000991 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling0310d762009-05-15 09:23:25 +0000992 else {
993 // Add zero size if it is not a forward declaration.
994 if (CTy.isForwardDecl())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000995 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +0000996 else
Devang Patel2c4ceb12009-11-21 02:48:08 +0000997 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
Bill Wendling0310d762009-05-15 09:23:25 +0000998 }
999
1000 // Add source line info if available.
1001 if (!CTy.isForwardDecl())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001002 addSourceLine(&Buffer, &CTy);
Bill Wendling0310d762009-05-15 09:23:25 +00001003 }
1004}
1005
Devang Patel2c4ceb12009-11-21 02:48:08 +00001006/// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1007void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
Bill Wendling0310d762009-05-15 09:23:25 +00001008 int64_t L = SR.getLo();
1009 int64_t H = SR.getHi();
1010 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1011
Devang Patel2c4ceb12009-11-21 02:48:08 +00001012 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
Devang Patel6325a532009-08-14 20:59:16 +00001013 if (L)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001014 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
Devang Pateld55224c2009-12-04 23:10:24 +00001015 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
Bill Wendling0310d762009-05-15 09:23:25 +00001016
Devang Patel2c4ceb12009-11-21 02:48:08 +00001017 Buffer.addChild(DW_Subrange);
Bill Wendling0310d762009-05-15 09:23:25 +00001018}
1019
Devang Patel2c4ceb12009-11-21 02:48:08 +00001020/// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
Devang Patel8a241142009-12-09 18:24:21 +00001021void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
Bill Wendling0310d762009-05-15 09:23:25 +00001022 DICompositeType *CTy) {
1023 Buffer.setTag(dwarf::DW_TAG_array_type);
1024 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001025 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001026
1027 // Emit derived type.
Devang Patel8a241142009-12-09 18:24:21 +00001028 addType(&Buffer, CTy->getTypeDerivedFrom());
Bill Wendling0310d762009-05-15 09:23:25 +00001029 DIArray Elements = CTy->getTypeArray();
1030
Devang Patel6f01d9c2009-11-21 00:31:03 +00001031 // Get an anonymous type for index type.
Devang Patel8a241142009-12-09 18:24:21 +00001032 DIE *IdxTy = ModuleCU->getIndexTyDie();
Devang Patel6f01d9c2009-11-21 00:31:03 +00001033 if (!IdxTy) {
1034 // Construct an anonymous type for index type.
1035 IdxTy = new DIE(dwarf::DW_TAG_base_type);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001036 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1037 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Devang Patel6f01d9c2009-11-21 00:31:03 +00001038 dwarf::DW_ATE_signed);
Devang Patel8a241142009-12-09 18:24:21 +00001039 ModuleCU->addDie(IdxTy);
1040 ModuleCU->setIndexTyDie(IdxTy);
Devang Patel6f01d9c2009-11-21 00:31:03 +00001041 }
Bill Wendling0310d762009-05-15 09:23:25 +00001042
1043 // Add subranges to array type.
1044 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1045 DIDescriptor Element = Elements.getElement(i);
1046 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001047 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
Bill Wendling0310d762009-05-15 09:23:25 +00001048 }
1049}
1050
Devang Patel2c4ceb12009-11-21 02:48:08 +00001051/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
Devang Patel3c91b052010-03-08 20:52:55 +00001052DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
Bill Wendling0310d762009-05-15 09:23:25 +00001053 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
Devang Patel3c91b052010-03-08 20:52:55 +00001054 StringRef Name = ETy.getName();
Devang Patel2c4ceb12009-11-21 02:48:08 +00001055 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Devang Patel3c91b052010-03-08 20:52:55 +00001056 int64_t Value = ETy.getEnumValue();
Devang Patel2c4ceb12009-11-21 02:48:08 +00001057 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
Bill Wendling0310d762009-05-15 09:23:25 +00001058 return Enumerator;
1059}
1060
Devang Patel351ca332010-01-05 01:46:14 +00001061/// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1062/// printer to not emit usual symbol prefix before the symbol name is used then
1063/// return linkage name after skipping this special LLVM prefix.
1064static StringRef getRealLinkageName(StringRef LinkageName) {
1065 char One = '\1';
1066 if (LinkageName.startswith(StringRef(&One, 1)))
1067 return LinkageName.substr(1);
1068 return LinkageName;
1069}
1070
Devang Patel2c4ceb12009-11-21 02:48:08 +00001071/// createGlobalVariableDIE - Create new DIE using GV.
Devang Patel8a241142009-12-09 18:24:21 +00001072DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
Jim Grosbach7ab38df2009-11-22 19:20:36 +00001073 // If the global variable was optmized out then no need to create debug info
1074 // entry.
Devang Patel84c73e92009-11-06 17:58:12 +00001075 if (!GV.getGlobal()) return NULL;
Devang Patel65dbc902009-11-25 17:36:49 +00001076 if (GV.getDisplayName().empty()) return NULL;
Devang Patel465c3be2009-11-06 01:30:04 +00001077
Bill Wendling0310d762009-05-15 09:23:25 +00001078 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001079 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
Devang Patel5ccdd102009-09-29 18:40:58 +00001080 GV.getDisplayName());
1081
Devang Patel65dbc902009-11-25 17:36:49 +00001082 StringRef LinkageName = GV.getLinkageName();
Devang Patel351ca332010-01-05 01:46:14 +00001083 if (!LinkageName.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001084 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
Devang Patel351ca332010-01-05 01:46:14 +00001085 getRealLinkageName(LinkageName));
1086
Devang Patel8a241142009-12-09 18:24:21 +00001087 addType(GVDie, GV.getType());
Bill Wendling0310d762009-05-15 09:23:25 +00001088 if (!GV.isLocalToUnit())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001089 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1090 addSourceLine(GVDie, &GV);
Devang Patelb71a16d2009-10-05 23:22:08 +00001091
Bill Wendling0310d762009-05-15 09:23:25 +00001092 return GVDie;
1093}
1094
Devang Patel2c4ceb12009-11-21 02:48:08 +00001095/// createMemberDIE - Create new member DIE.
Devang Patel8a241142009-12-09 18:24:21 +00001096DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
Bill Wendling0310d762009-05-15 09:23:25 +00001097 DIE *MemberDie = new DIE(DT.getTag());
Devang Patel65dbc902009-11-25 17:36:49 +00001098 StringRef Name = DT.getName();
1099 if (!Name.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001100 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Devang Patel65dbc902009-11-25 17:36:49 +00001101
Devang Patel8a241142009-12-09 18:24:21 +00001102 addType(MemberDie, DT.getTypeDerivedFrom());
Bill Wendling0310d762009-05-15 09:23:25 +00001103
Devang Patel2c4ceb12009-11-21 02:48:08 +00001104 addSourceLine(MemberDie, &DT);
Bill Wendling0310d762009-05-15 09:23:25 +00001105
Benjamin Kramer345ef342010-03-31 19:34:01 +00001106 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
Devang Patel2c4ceb12009-11-21 02:48:08 +00001107 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
Devang Patel33db5082009-11-04 22:06:12 +00001108
Bill Wendling0310d762009-05-15 09:23:25 +00001109 uint64_t Size = DT.getSizeInBits();
Devang Patel61ecbd12009-11-04 23:48:00 +00001110 uint64_t FieldSize = DT.getOriginalTypeSize();
Bill Wendling0310d762009-05-15 09:23:25 +00001111
1112 if (Size != FieldSize) {
1113 // Handle bitfield.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001114 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1115 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
Bill Wendling0310d762009-05-15 09:23:25 +00001116
1117 uint64_t Offset = DT.getOffsetInBits();
Bill Wendling0310d762009-05-15 09:23:25 +00001118 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1119 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
Benjamin Kramer3d594fd2010-01-07 17:50:57 +00001120 uint64_t FieldOffset = (HiMark - FieldSize);
Bill Wendling0310d762009-05-15 09:23:25 +00001121 Offset -= FieldOffset;
1122
1123 // Maybe we need to work from the other end.
Chris Lattnerd38fee82010-04-05 00:13:49 +00001124 if (Asm->getTargetData().isLittleEndian())
1125 Offset = FieldSize - (Offset + Size);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001126 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
Bill Wendling0310d762009-05-15 09:23:25 +00001127
Devang Patel33db5082009-11-04 22:06:12 +00001128 // Here WD_AT_data_member_location points to the anonymous
1129 // field that includes this bit field.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001130 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
Devang Patel33db5082009-11-04 22:06:12 +00001131
1132 } else
1133 // This is not a bitfield.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001134 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
Devang Patel33db5082009-11-04 22:06:12 +00001135
Devang Patelc1dc8ff2010-02-03 20:08:48 +00001136 if (DT.getTag() == dwarf::DW_TAG_inheritance
1137 && DT.isVirtual()) {
1138
1139 // For C++, virtual base classes are not at fixed offset. Use following
1140 // expression to extract appropriate offset from vtable.
1141 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1142
Benjamin Kramer345ef342010-03-31 19:34:01 +00001143 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
Devang Patelc1dc8ff2010-02-03 20:08:48 +00001144 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1145 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1146 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1147 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1148 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1149 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1150 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1151
1152 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1153 VBaseLocationDie);
1154 } else
1155 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
Bill Wendling0310d762009-05-15 09:23:25 +00001156
1157 if (DT.isProtected())
Devang Patel5d11eb02009-12-03 19:11:07 +00001158 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
Bill Wendling0310d762009-05-15 09:23:25 +00001159 dwarf::DW_ACCESS_protected);
1160 else if (DT.isPrivate())
Devang Patel5d11eb02009-12-03 19:11:07 +00001161 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
Bill Wendling0310d762009-05-15 09:23:25 +00001162 dwarf::DW_ACCESS_private);
Devang Patel5d11eb02009-12-03 19:11:07 +00001163 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1164 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1165 dwarf::DW_ACCESS_public);
1166 if (DT.isVirtual())
1167 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1168 dwarf::DW_VIRTUALITY_virtual);
Bill Wendling0310d762009-05-15 09:23:25 +00001169 return MemberDie;
1170}
1171
Devang Patelffe966c2009-12-14 16:18:45 +00001172/// createSubprogramDIE - Create new DIE using SP.
1173DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1174 DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1175 if (SPDie)
1176 return SPDie;
1177
1178 SPDie = new DIE(dwarf::DW_TAG_subprogram);
Devang Patel1eac3e72010-03-02 17:58:15 +00001179 // Constructors and operators for anonymous aggregates do not have names.
Devang Patel6b506cb2010-03-02 01:26:20 +00001180 if (!SP.getName().empty())
1181 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
Bill Wendling0310d762009-05-15 09:23:25 +00001182
Devang Patel65dbc902009-11-25 17:36:49 +00001183 StringRef LinkageName = SP.getLinkageName();
Devang Patel351ca332010-01-05 01:46:14 +00001184 if (!LinkageName.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001185 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
Devang Patel351ca332010-01-05 01:46:14 +00001186 getRealLinkageName(LinkageName));
1187
Devang Patel2c4ceb12009-11-21 02:48:08 +00001188 addSourceLine(SPDie, &SP);
Bill Wendling0310d762009-05-15 09:23:25 +00001189
Bill Wendling0310d762009-05-15 09:23:25 +00001190 // Add prototyped tag, if C or ObjC.
1191 unsigned Lang = SP.getCompileUnit().getLanguage();
1192 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1193 Lang == dwarf::DW_LANG_ObjC)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001194 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001195
1196 // Add Return Type.
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001197 DICompositeType SPTy = SP.getType();
1198 DIArray Args = SPTy.getTypeArray();
Bill Wendling0310d762009-05-15 09:23:25 +00001199 unsigned SPTag = SPTy.getTag();
Devang Patel5d11eb02009-12-03 19:11:07 +00001200
Devang Patel3c91b052010-03-08 20:52:55 +00001201 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
Devang Patel8a241142009-12-09 18:24:21 +00001202 addType(SPDie, SPTy);
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001203 else
Devang Patel8a241142009-12-09 18:24:21 +00001204 addType(SPDie, DIType(Args.getElement(0).getNode()));
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001205
Devang Patel5d11eb02009-12-03 19:11:07 +00001206 unsigned VK = SP.getVirtuality();
1207 if (VK) {
1208 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
Benjamin Kramer345ef342010-03-31 19:34:01 +00001209 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel5d11eb02009-12-03 19:11:07 +00001210 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1211 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1212 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
Devang Patel622b0262010-01-19 06:19:05 +00001213 ContainingTypeMap.insert(std::make_pair(SPDie,
1214 SP.getContainingType().getNode()));
Devang Patel5d11eb02009-12-03 19:11:07 +00001215 }
1216
Devang Patelffe966c2009-12-14 16:18:45 +00001217 if (MakeDecl || !SP.isDefinition()) {
Devang Patel2c4ceb12009-11-21 02:48:08 +00001218 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001219
1220 // Add arguments. Do not add arguments for subprogram definition. They will
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001221 // be handled while processing variables.
1222 DICompositeType SPTy = SP.getType();
1223 DIArray Args = SPTy.getTypeArray();
1224 unsigned SPTag = SPTy.getTag();
1225
Bill Wendling0310d762009-05-15 09:23:25 +00001226 if (SPTag == dwarf::DW_TAG_subroutine_type)
1227 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1228 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
Devang Patelb4645642010-02-06 01:02:37 +00001229 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1230 addType(Arg, ATy);
1231 if (ATy.isArtificial())
1232 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001233 SPDie->addChild(Arg);
Bill Wendling0310d762009-05-15 09:23:25 +00001234 }
1235 }
1236
Devang Patel4e0d19d2010-02-03 19:57:19 +00001237 if (SP.isArtificial())
1238 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1239
Bill Wendling0310d762009-05-15 09:23:25 +00001240 // DW_TAG_inlined_subroutine may refer to this DIE.
Devang Patel8a241142009-12-09 18:24:21 +00001241 ModuleCU->insertDIE(SP.getNode(), SPDie);
Bill Wendling0310d762009-05-15 09:23:25 +00001242 return SPDie;
1243}
1244
Devang Patel8935d902010-04-01 17:16:48 +00001245/// getUpdatedDbgScope - Find DbgScope assicated with the instruction.
1246/// Update scope hierarchy. Create abstract scope if required.
Devang Patel53bb5c92009-11-10 23:06:00 +00001247DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
Chris Lattnered7a77b2010-03-31 05:36:29 +00001248 MDNode *InlinedAt) {
1249 assert(N && "Invalid Scope encoding!");
1250 assert(MI && "Missing machine instruction!");
Devang Patel8935d902010-04-01 17:16:48 +00001251 bool isAConcreteScope = InlinedAt != 0;
Devang Patel53bb5c92009-11-10 23:06:00 +00001252
1253 DbgScope *NScope = NULL;
1254
1255 if (InlinedAt)
1256 NScope = DbgScopeMap.lookup(InlinedAt);
1257 else
1258 NScope = DbgScopeMap.lookup(N);
Chris Lattnered7a77b2010-03-31 05:36:29 +00001259 assert(NScope && "Unable to find working scope!");
Devang Patel53bb5c92009-11-10 23:06:00 +00001260
1261 if (NScope->getFirstInsn())
1262 return NScope;
Devang Patelaf9e8472009-10-01 20:31:14 +00001263
1264 DbgScope *Parent = NULL;
Devang Patel8935d902010-04-01 17:16:48 +00001265 if (isAConcreteScope) {
Devang Patelc90aefe2009-10-14 21:08:09 +00001266 DILocation IL(InlinedAt);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001267 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
Devang Patel53bb5c92009-11-10 23:06:00 +00001268 IL.getOrigLocation().getNode());
Chris Lattnered7a77b2010-03-31 05:36:29 +00001269 assert(Parent && "Unable to find Parent scope!");
Devang Patel53bb5c92009-11-10 23:06:00 +00001270 NScope->setParent(Parent);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001271 Parent->addScope(NScope);
Devang Patel53bb5c92009-11-10 23:06:00 +00001272 } else if (DIDescriptor(N).isLexicalBlock()) {
1273 DILexicalBlock DB(N);
Devang Patel3c91b052010-03-08 20:52:55 +00001274 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1275 NScope->setParent(Parent);
1276 Parent->addScope(NScope);
Devang Patelc90aefe2009-10-14 21:08:09 +00001277 }
Devang Patelaf9e8472009-10-01 20:31:14 +00001278
Devang Patelbdf45cb2009-10-27 20:47:17 +00001279 NScope->setFirstInsn(MI);
Devang Patelaf9e8472009-10-01 20:31:14 +00001280
Devang Patel53bb5c92009-11-10 23:06:00 +00001281 if (!Parent && !InlinedAt) {
Devang Patel39ae3ff2009-11-11 00:31:36 +00001282 StringRef SPName = DISubprogram(N).getLinkageName();
Chris Lattnerd38fee82010-04-05 00:13:49 +00001283 if (SPName == Asm->MF->getFunction()->getName())
Devang Patel39ae3ff2009-11-11 00:31:36 +00001284 CurrentFnDbgScope = NScope;
Devang Patel53bb5c92009-11-10 23:06:00 +00001285 }
Devang Patelaf9e8472009-10-01 20:31:14 +00001286
Devang Patel8935d902010-04-01 17:16:48 +00001287 if (isAConcreteScope) {
Devang Patel53bb5c92009-11-10 23:06:00 +00001288 ConcreteScopes[InlinedAt] = NScope;
1289 getOrCreateAbstractScope(N);
1290 }
1291
Devang Patelbdf45cb2009-10-27 20:47:17 +00001292 return NScope;
Devang Patelaf9e8472009-10-01 20:31:14 +00001293}
1294
Devang Patel53bb5c92009-11-10 23:06:00 +00001295DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
Chris Lattnered7a77b2010-03-31 05:36:29 +00001296 assert(N && "Invalid Scope encoding!");
Devang Patel53bb5c92009-11-10 23:06:00 +00001297
1298 DbgScope *AScope = AbstractScopes.lookup(N);
1299 if (AScope)
1300 return AScope;
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001301
Devang Patel53bb5c92009-11-10 23:06:00 +00001302 DbgScope *Parent = NULL;
1303
1304 DIDescriptor Scope(N);
1305 if (Scope.isLexicalBlock()) {
1306 DILexicalBlock DB(N);
1307 DIDescriptor ParentDesc = DB.getContext();
Devang Patel3c91b052010-03-08 20:52:55 +00001308 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
Devang Patel53bb5c92009-11-10 23:06:00 +00001309 }
1310
1311 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1312
1313 if (Parent)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001314 Parent->addScope(AScope);
Devang Patel53bb5c92009-11-10 23:06:00 +00001315 AScope->setAbstractScope();
1316 AbstractScopes[N] = AScope;
1317 if (DIDescriptor(N).isSubprogram())
1318 AbstractScopesList.push_back(AScope);
1319 return AScope;
1320}
Devang Patelaf9e8472009-10-01 20:31:14 +00001321
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001322/// updateSubprogramScopeDIE - Find DIE for the given subprogram and
Devang Patel2c4ceb12009-11-21 02:48:08 +00001323/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1324/// If there are global variables in this scope then create and insert
1325/// DIEs for these variables.
1326DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
Chris Lattnerd38fee82010-04-05 00:13:49 +00001327 DIE *SPDie = ModuleCU->getDIE(SPNode);
1328 assert(SPDie && "Unable to find subprogram DIE!");
1329 DISubprogram SP(SPNode);
Chris Lattner206d61e2010-03-13 07:26:18 +00001330
Chris Lattnerd38fee82010-04-05 00:13:49 +00001331 // There is not any need to generate specification DIE for a function
1332 // defined at compile unit level. If a function is defined inside another
1333 // function then gdb prefers the definition at top level and but does not
1334 // expect specification DIE in parent function. So avoid creating
1335 // specification DIE for a function defined inside a function.
1336 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1337 !SP.getContext().isFile() && !SP.getContext().isSubprogram()) {
1338 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1339
1340 // Add arguments.
1341 DICompositeType SPTy = SP.getType();
1342 DIArray Args = SPTy.getTypeArray();
1343 unsigned SPTag = SPTy.getTag();
1344 if (SPTag == dwarf::DW_TAG_subroutine_type)
1345 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1346 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1347 DIType ATy = DIType(DIType(Args.getElement(i).getNode()));
1348 addType(Arg, ATy);
1349 if (ATy.isArtificial())
1350 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1351 SPDie->addChild(Arg);
1352 }
1353 DIE *SPDeclDie = SPDie;
1354 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1355 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1356 SPDeclDie);
1357 ModuleCU->addDie(SPDie);
1358 }
1359
1360 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1361 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1362 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1363 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1364 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1365 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1366 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
Devang Patelb4645642010-02-06 01:02:37 +00001367
Chris Lattnerd38fee82010-04-05 00:13:49 +00001368 if (!DISubprogram(SPNode).isLocalToUnit())
1369 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1370
1371 return SPDie;
Devang Patel53bb5c92009-11-10 23:06:00 +00001372}
1373
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001374/// constructLexicalScope - Construct new DW_TAG_lexical_block
Devang Patel2c4ceb12009-11-21 02:48:08 +00001375/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1376DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
Chris Lattnerb7db7332010-03-09 01:58:53 +00001377 MCSymbol *Start = Scope->getStartLabel();
1378 MCSymbol *End = Scope->getEndLabel();
Devang Patelaead63c2010-03-29 22:59:58 +00001379 if (Start == 0 || End == 0) return 0;
Devang Patel53bb5c92009-11-10 23:06:00 +00001380
Chris Lattnerb7db7332010-03-09 01:58:53 +00001381 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1382 assert(End->isDefined() && "Invalid end label for an inlined scope!");
Chris Lattnera34ec2292010-03-09 01:51:43 +00001383
Devang Patel53bb5c92009-11-10 23:06:00 +00001384 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1385 if (Scope->isAbstractScope())
1386 return ScopeDIE;
1387
Devang Patel2c4ceb12009-11-21 02:48:08 +00001388 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
Chris Lattnerd38fee82010-04-05 00:13:49 +00001389 Start ? Start : Asm->GetTempSymbol("func_begin",
1390 Asm->getFunctionNumber()));
Devang Patel2c4ceb12009-11-21 02:48:08 +00001391 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
Chris Lattnerd38fee82010-04-05 00:13:49 +00001392 End ? End : Asm->GetTempSymbol("func_end",Asm->getFunctionNumber()));
Devang Patel53bb5c92009-11-10 23:06:00 +00001393
1394 return ScopeDIE;
1395}
1396
Devang Patel2c4ceb12009-11-21 02:48:08 +00001397/// constructInlinedScopeDIE - This scope represents inlined body of
1398/// a function. Construct DIE to represent this concrete inlined copy
1399/// of the function.
1400DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
Chris Lattnerb7db7332010-03-09 01:58:53 +00001401 MCSymbol *StartLabel = Scope->getStartLabel();
1402 MCSymbol *EndLabel = Scope->getEndLabel();
Devang Patelaead63c2010-03-29 22:59:58 +00001403 if (StartLabel == 0 || EndLabel == 0) return 0;
Chris Lattner6c7dfc02010-03-09 04:48:35 +00001404
Chris Lattnerb7db7332010-03-09 01:58:53 +00001405 assert(StartLabel->isDefined() &&
Chris Lattnera34ec2292010-03-09 01:51:43 +00001406 "Invalid starting label for an inlined scope!");
Chris Lattnerb7db7332010-03-09 01:58:53 +00001407 assert(EndLabel->isDefined() &&
Chris Lattnera34ec2292010-03-09 01:51:43 +00001408 "Invalid end label for an inlined scope!");
Devang Patel3c91b052010-03-08 20:52:55 +00001409 if (!Scope->getScopeNode())
Devang Patel0ef3fa62010-03-08 19:20:38 +00001410 return NULL;
Devang Patel3c91b052010-03-08 20:52:55 +00001411 DIScope DS(Scope->getScopeNode());
Devang Patel53bb5c92009-11-10 23:06:00 +00001412 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1413
1414 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
Devang Patel017d1212009-11-20 21:37:22 +00001415 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
Chris Lattnered7a77b2010-03-31 05:36:29 +00001416 assert(OriginDIE && "Unable to find Origin DIE!");
Devang Patel2c4ceb12009-11-21 02:48:08 +00001417 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
Devang Patel53bb5c92009-11-10 23:06:00 +00001418 dwarf::DW_FORM_ref4, OriginDIE);
1419
Chris Lattner6ed0f902010-03-09 00:31:02 +00001420 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
Chris Lattnerb7db7332010-03-09 01:58:53 +00001421 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
Devang Patel53bb5c92009-11-10 23:06:00 +00001422
1423 InlinedSubprogramDIEs.insert(OriginDIE);
1424
1425 // Track the start label for this inlined function.
Devang Patel622b0262010-01-19 06:19:05 +00001426 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
Devang Patel53bb5c92009-11-10 23:06:00 +00001427 I = InlineInfo.find(InlinedSP.getNode());
1428
1429 if (I == InlineInfo.end()) {
Chris Lattner6ed0f902010-03-09 00:31:02 +00001430 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartLabel,
Jim Grosbach7ab38df2009-11-22 19:20:36 +00001431 ScopeDIE));
Devang Patel53bb5c92009-11-10 23:06:00 +00001432 InlinedSPNodes.push_back(InlinedSP.getNode());
1433 } else
Chris Lattner6ed0f902010-03-09 00:31:02 +00001434 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
Devang Patel53bb5c92009-11-10 23:06:00 +00001435
Devang Patel53bb5c92009-11-10 23:06:00 +00001436 DILocation DL(Scope->getInlinedAt());
Devang Patel2c4ceb12009-11-21 02:48:08 +00001437 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1438 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
Devang Patel53bb5c92009-11-10 23:06:00 +00001439
1440 return ScopeDIE;
1441}
1442
Devang Patel2c4ceb12009-11-21 02:48:08 +00001443
1444/// constructVariableDIE - Construct a DIE for the given DbgVariable.
Devang Patel8a241142009-12-09 18:24:21 +00001445DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
Devang Patel53bb5c92009-11-10 23:06:00 +00001446 // Get the descriptor.
1447 const DIVariable &VD = DV->getVariable();
Devang Patel65dbc902009-11-25 17:36:49 +00001448 StringRef Name = VD.getName();
1449 if (Name.empty())
Devang Patel3fb6bd62009-11-13 02:25:26 +00001450 return NULL;
Devang Patel53bb5c92009-11-10 23:06:00 +00001451
1452 // Translate tag to proper Dwarf tag. The result variable is dropped for
1453 // now.
1454 unsigned Tag;
1455 switch (VD.getTag()) {
1456 case dwarf::DW_TAG_return_variable:
1457 return NULL;
1458 case dwarf::DW_TAG_arg_variable:
1459 Tag = dwarf::DW_TAG_formal_parameter;
1460 break;
1461 case dwarf::DW_TAG_auto_variable: // fall thru
1462 default:
1463 Tag = dwarf::DW_TAG_variable;
1464 break;
1465 }
1466
1467 // Define variable debug information entry.
1468 DIE *VariableDie = new DIE(Tag);
1469
1470
1471 DIE *AbsDIE = NULL;
1472 if (DbgVariable *AV = DV->getAbstractVariable())
1473 AbsDIE = AV->getDIE();
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001474
Devang Patel53bb5c92009-11-10 23:06:00 +00001475 if (AbsDIE) {
1476 DIScope DS(Scope->getScopeNode());
1477 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
Devang Patel017d1212009-11-20 21:37:22 +00001478 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
Daniel Dunbarc0326792009-11-11 03:09:50 +00001479 (void) OriginSPDIE;
Chris Lattnered7a77b2010-03-31 05:36:29 +00001480 assert(OriginSPDIE && "Unable to find Origin DIE for the SP!");
Devang Patel53bb5c92009-11-10 23:06:00 +00001481 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
Chris Lattnered7a77b2010-03-31 05:36:29 +00001482 assert(AbsDIE && "Unable to find Origin DIE for the Variable!");
Devang Patel2c4ceb12009-11-21 02:48:08 +00001483 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
Devang Patel53bb5c92009-11-10 23:06:00 +00001484 dwarf::DW_FORM_ref4, AbsDIE);
1485 }
1486 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +00001487 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1488 addSourceLine(VariableDie, &VD);
Devang Patel53bb5c92009-11-10 23:06:00 +00001489
1490 // Add variable type.
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001491 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
Devang Patel53bb5c92009-11-10 23:06:00 +00001492 // addresses instead.
1493 if (VD.isBlockByrefVariable())
Devang Patel8a241142009-12-09 18:24:21 +00001494 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
Devang Patel53bb5c92009-11-10 23:06:00 +00001495 else
Devang Patel8a241142009-12-09 18:24:21 +00001496 addType(VariableDie, VD.getType());
Devang Patel53bb5c92009-11-10 23:06:00 +00001497 }
1498
1499 // Add variable address.
1500 if (!Scope->isAbstractScope()) {
Devang Patel90a48ad2010-03-15 18:33:46 +00001501 // Check if variable is described by DBG_VALUE instruction.
1502 if (const MachineInstr *DbgValueInsn = DV->getDbgValue()) {
1503 if (DbgValueInsn->getNumOperands() == 3) {
1504 // FIXME : Handle getNumOperands != 3
1505 if (DbgValueInsn->getOperand(0).getType()
1506 == MachineOperand::MO_Register
1507 && DbgValueInsn->getOperand(0).getReg()) {
1508 MachineLocation Location;
1509 Location.set(DbgValueInsn->getOperand(0).getReg());
1510 addAddress(VariableDie, dwarf::DW_AT_location, Location);
Devang Patelaead63c2010-03-29 22:59:58 +00001511 if (MCSymbol *VS = DV->getDbgValueLabel())
1512 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1513 VS);
Devang Patel90a48ad2010-03-15 18:33:46 +00001514 } else if (DbgValueInsn->getOperand(0).getType() ==
1515 MachineOperand::MO_Immediate) {
Benjamin Kramer345ef342010-03-31 19:34:01 +00001516 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel90a48ad2010-03-15 18:33:46 +00001517 unsigned Imm = DbgValueInsn->getOperand(0).getImm();
1518 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
1519 addBlock(VariableDie, dwarf::DW_AT_const_value, 0, Block);
Devang Patelaead63c2010-03-29 22:59:58 +00001520 if (MCSymbol *VS = DV->getDbgValueLabel())
1521 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1522 VS);
Devang Patel90a48ad2010-03-15 18:33:46 +00001523 } else {
1524 //FIXME : Handle other operand types.
1525 delete VariableDie;
1526 return NULL;
1527 }
1528 }
1529 } else {
1530 MachineLocation Location;
1531 unsigned FrameReg;
Chris Lattnerd38fee82010-04-05 00:13:49 +00001532 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1533 int Offset = RI->getFrameIndexReference(*Asm->MF, DV->getFrameIndex(),
Chris Lattner1d65ba72010-03-31 06:06:37 +00001534 FrameReg);
Devang Patel90a48ad2010-03-15 18:33:46 +00001535 Location.set(FrameReg, Offset);
1536
1537 if (VD.hasComplexAddress())
1538 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1539 else if (VD.isBlockByrefVariable())
1540 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1541 else
1542 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1543 }
Devang Patel53bb5c92009-11-10 23:06:00 +00001544 }
Devang Patelb4645642010-02-06 01:02:37 +00001545
1546 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1547 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
Devang Patel53bb5c92009-11-10 23:06:00 +00001548 DV->setDIE(VariableDie);
1549 return VariableDie;
1550
1551}
Devang Patel2c4ceb12009-11-21 02:48:08 +00001552
Devang Patel193f7202009-11-24 01:14:22 +00001553void DwarfDebug::addPubTypes(DISubprogram SP) {
1554 DICompositeType SPTy = SP.getType();
1555 unsigned SPTag = SPTy.getTag();
1556 if (SPTag != dwarf::DW_TAG_subroutine_type)
1557 return;
1558
1559 DIArray Args = SPTy.getTypeArray();
Devang Patel193f7202009-11-24 01:14:22 +00001560 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1561 DIType ATy(Args.getElement(i).getNode());
Devang Patel3c91b052010-03-08 20:52:55 +00001562 if (!ATy.isValid())
Devang Patel193f7202009-11-24 01:14:22 +00001563 continue;
1564 DICompositeType CATy = getDICompositeType(ATy);
Devang Patel3c91b052010-03-08 20:52:55 +00001565 if (DIDescriptor(CATy.getNode()).Verify() && !CATy.getName().empty()) {
Devang Patel193f7202009-11-24 01:14:22 +00001566 if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1567 ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1568 }
1569 }
1570}
1571
Devang Patel2c4ceb12009-11-21 02:48:08 +00001572/// constructScopeDIE - Construct a DIE for this scope.
1573DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
Devang Patel3c91b052010-03-08 20:52:55 +00001574 if (!Scope || !Scope->getScopeNode())
1575 return NULL;
1576
1577 DIScope DS(Scope->getScopeNode());
1578 DIE *ScopeDIE = NULL;
1579 if (Scope->getInlinedAt())
1580 ScopeDIE = constructInlinedScopeDIE(Scope);
1581 else if (DS.isSubprogram()) {
1582 if (Scope->isAbstractScope())
1583 ScopeDIE = ModuleCU->getDIE(DS.getNode());
1584 else
1585 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1586 }
Devang Patelaead63c2010-03-29 22:59:58 +00001587 else
Devang Patel3c91b052010-03-08 20:52:55 +00001588 ScopeDIE = constructLexicalScopeDIE(Scope);
Devang Patelaead63c2010-03-29 22:59:58 +00001589 if (!ScopeDIE) return NULL;
Devang Patel3c91b052010-03-08 20:52:55 +00001590
Devang Patel53bb5c92009-11-10 23:06:00 +00001591 // Add variables to scope.
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00001592 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
Devang Patel53bb5c92009-11-10 23:06:00 +00001593 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
Devang Patel8a241142009-12-09 18:24:21 +00001594 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001595 if (VariableDIE)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001596 ScopeDIE->addChild(VariableDIE);
Devang Patel53bb5c92009-11-10 23:06:00 +00001597 }
1598
1599 // Add nested scopes.
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00001600 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
Devang Patel53bb5c92009-11-10 23:06:00 +00001601 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1602 // Define the Scope debug information entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001603 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001604 if (NestedDIE)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001605 ScopeDIE->addChild(NestedDIE);
Devang Patel53bb5c92009-11-10 23:06:00 +00001606 }
Devang Patel193f7202009-11-24 01:14:22 +00001607
1608 if (DS.isSubprogram())
1609 addPubTypes(DISubprogram(DS.getNode()));
1610
1611 return ScopeDIE;
Devang Patel53bb5c92009-11-10 23:06:00 +00001612}
1613
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001614/// GetOrCreateSourceID - Look up the source id with the given directory and
1615/// source file names. If none currently exists, create a new id and insert it
1616/// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1617/// maps as well.
Chris Lattner1d65ba72010-03-31 06:06:37 +00001618unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001619 unsigned DId;
1620 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1621 if (DI != DirectoryIdMap.end()) {
1622 DId = DI->getValue();
1623 } else {
1624 DId = DirectoryNames.size() + 1;
1625 DirectoryIdMap[DirName] = DId;
1626 DirectoryNames.push_back(DirName);
1627 }
1628
1629 unsigned FId;
1630 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1631 if (FI != SourceFileIdMap.end()) {
1632 FId = FI->getValue();
1633 } else {
1634 FId = SourceFileNames.size() + 1;
1635 SourceFileIdMap[FileName] = FId;
1636 SourceFileNames.push_back(FileName);
1637 }
1638
1639 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1640 SourceIdMap.find(std::make_pair(DId, FId));
1641 if (SI != SourceIdMap.end())
1642 return SI->second;
1643
1644 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1645 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1646 SourceIds.push_back(std::make_pair(DId, FId));
1647
1648 return SrcId;
1649}
1650
Devang Patel6404e4e2009-12-15 19:16:48 +00001651/// getOrCreateNameSpace - Create a DIE for DINameSpace.
1652DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1653 DIE *NDie = ModuleCU->getDIE(NS.getNode());
1654 if (NDie)
1655 return NDie;
1656 NDie = new DIE(dwarf::DW_TAG_namespace);
1657 ModuleCU->insertDIE(NS.getNode(), NDie);
1658 if (!NS.getName().empty())
1659 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1660 addSourceLine(NDie, &NS);
1661 addToContextOwner(NDie, NS.getContext());
1662 return NDie;
1663}
1664
Jeffrey Yasskind0f393d2010-03-11 18:29:55 +00001665void DwarfDebug::constructCompileUnit(MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +00001666 DICompileUnit DIUnit(N);
Jeffrey Yasskind0f393d2010-03-11 18:29:55 +00001667 // Use first compile unit marked as isMain as the compile unit for this
1668 // module.
1669 if (ModuleCU || !DIUnit.isMain())
1670 return;
Devang Patel65dbc902009-11-25 17:36:49 +00001671 StringRef FN = DIUnit.getFilename();
1672 StringRef Dir = DIUnit.getDirectory();
Devang Patel5ccdd102009-09-29 18:40:58 +00001673 unsigned ID = GetOrCreateSourceID(Dir, FN);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001674
1675 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001676 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
Devang Patel5ccdd102009-09-29 18:40:58 +00001677 DIUnit.getProducer());
Devang Patel2c4ceb12009-11-21 02:48:08 +00001678 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001679 DIUnit.getLanguage());
Devang Patel2c4ceb12009-11-21 02:48:08 +00001680 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
Chris Lattner9c69e285532010-04-04 22:59:04 +00001681 addLabel(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, TextSectionSym);
Devang Patel4a602ca2010-03-22 23:11:36 +00001682 addLabel(Die, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
Chris Lattnerc0215722010-04-04 19:25:43 +00001683 Asm->GetTempSymbol("text_end"));
Devang Patel4a602ca2010-03-22 23:11:36 +00001684 // DW_AT_stmt_list is a offset of line number information for this
1685 // compile unit in debug_line section. It is always zero when only one
1686 // compile unit is emitted in one object file.
1687 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001688
Devang Patel65dbc902009-11-25 17:36:49 +00001689 if (!Dir.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001690 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001691 if (DIUnit.isOptimized())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001692 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001693
Devang Patel65dbc902009-11-25 17:36:49 +00001694 StringRef Flags = DIUnit.getFlags();
1695 if (!Flags.empty())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001696 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001697
1698 unsigned RVer = DIUnit.getRunTimeVersion();
1699 if (RVer)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001700 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001701 dwarf::DW_FORM_data1, RVer);
1702
Jeffrey Yasskind0f393d2010-03-11 18:29:55 +00001703 assert(!ModuleCU &&
1704 "ModuleCU assigned since the top of constructCompileUnit");
1705 ModuleCU = new CompileUnit(ID, Die);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001706}
1707
Devang Patel2c4ceb12009-11-21 02:48:08 +00001708void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +00001709 DIGlobalVariable DI_GV(N);
Daniel Dunbarf612ff62009-09-19 20:40:05 +00001710
Devang Patel905cf5e2009-09-04 23:59:07 +00001711 // If debug information is malformed then ignore it.
1712 if (DI_GV.Verify() == false)
1713 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001714
1715 // Check for pre-existence.
Devang Patel017d1212009-11-20 21:37:22 +00001716 if (ModuleCU->getDIE(DI_GV.getNode()))
Devang Patel13e16b62009-06-26 01:49:18 +00001717 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001718
Devang Patel8a241142009-12-09 18:24:21 +00001719 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
Devang Pateledb45632009-12-10 23:25:41 +00001720 if (!VariableDie)
1721 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001722
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001723 // Add to map.
Devang Patel017d1212009-11-20 21:37:22 +00001724 ModuleCU->insertDIE(N, VariableDie);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001725
1726 // Add to context owner.
Devang Patelc9b16cc2010-01-15 01:12:22 +00001727 DIDescriptor GVContext = DI_GV.getContext();
1728 // Do not create specification DIE if context is either compile unit
1729 // or a subprogram.
Chris Lattner1d65ba72010-03-31 06:06:37 +00001730 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1731 !GVContext.isFile() && !GVContext.isSubprogram()) {
Devang Patel6404e4e2009-12-15 19:16:48 +00001732 // Create specification DIE.
1733 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1734 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1735 dwarf::DW_FORM_ref4, VariableDie);
Benjamin Kramer345ef342010-03-31 19:34:01 +00001736 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel6404e4e2009-12-15 19:16:48 +00001737 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
Chris Lattner4faf59a2010-03-08 22:31:46 +00001738 addLabel(Block, 0, dwarf::DW_FORM_udata,
Chris Lattnerdeb0cba2010-03-12 21:09:07 +00001739 Asm->Mang->getSymbol(DI_GV.getGlobal()));
Devang Patel6404e4e2009-12-15 19:16:48 +00001740 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
Devang Patel8581e012010-02-09 01:58:33 +00001741 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Devang Patel6404e4e2009-12-15 19:16:48 +00001742 ModuleCU->addDie(VariableSpecDIE);
1743 } else {
Benjamin Kramer345ef342010-03-31 19:34:01 +00001744 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel6404e4e2009-12-15 19:16:48 +00001745 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
Chris Lattner4faf59a2010-03-08 22:31:46 +00001746 addLabel(Block, 0, dwarf::DW_FORM_udata,
Chris Lattnerdeb0cba2010-03-12 21:09:07 +00001747 Asm->Mang->getSymbol(DI_GV.getGlobal()));
Devang Patel6404e4e2009-12-15 19:16:48 +00001748 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1749 }
Devang Patelc9b16cc2010-01-15 01:12:22 +00001750 addToContextOwner(VariableDie, GVContext);
Devang Patelc366f832009-12-10 19:14:49 +00001751
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001752 // Expose as global. FIXME - need to check external flag.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001753 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
Devang Patel193f7202009-11-24 01:14:22 +00001754
1755 DIType GTy = DI_GV.getType();
Devang Patel65dbc902009-11-25 17:36:49 +00001756 if (GTy.isCompositeType() && !GTy.getName().empty()) {
Devang Patel193f7202009-11-24 01:14:22 +00001757 DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
Chris Lattnered7a77b2010-03-31 05:36:29 +00001758 assert(Entry && "Missing global type!");
Devang Patel193f7202009-11-24 01:14:22 +00001759 ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1760 }
Devang Patel13e16b62009-06-26 01:49:18 +00001761 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001762}
1763
Devang Patel2c4ceb12009-11-21 02:48:08 +00001764void DwarfDebug::constructSubprogramDIE(MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +00001765 DISubprogram SP(N);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001766
Stuart Hastingsf8df8142010-03-31 23:08:46 +00001767 // Check for pre-existence.
1768 if (ModuleCU->getDIE(N))
1769 return;
1770
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001771 if (!SP.isDefinition())
1772 // This is a method declaration which will be handled while constructing
1773 // class type.
Devang Patel13e16b62009-06-26 01:49:18 +00001774 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001775
Stuart Hastingsf8df8142010-03-31 23:08:46 +00001776 DIE *SubprogramDie = createSubprogramDIE(SP);
1777
1778 // Add to map.
1779 ModuleCU->insertDIE(N, SubprogramDie);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001780
1781 // Add to context owner.
Devang Patel6404e4e2009-12-15 19:16:48 +00001782 addToContextOwner(SubprogramDie, SP.getContext());
Devang Patel0000fad2009-12-08 23:21:45 +00001783
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001784 // Expose as global.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001785 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
Devang Patel193f7202009-11-24 01:14:22 +00001786
Devang Patel13e16b62009-06-26 01:49:18 +00001787 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001788}
1789
Devang Patel2c4ceb12009-11-21 02:48:08 +00001790/// beginModule - Emit all Dwarf sections that should come prior to the
Daniel Dunbar00564992009-09-19 20:40:14 +00001791/// content. Create global DIEs and emit initial debug info sections.
1792/// This is inovked by the target AsmPrinter.
Chris Lattner75f50722010-04-04 07:48:20 +00001793void DwarfDebug::beginModule(Module *M) {
Chris Lattnerd38fee82010-04-05 00:13:49 +00001794 if (!Asm->MAI->doesSupportDebugInformation())
Devang Patel3380cc52009-11-11 19:55:08 +00001795 return;
Chris Lattnerd850ac72010-04-05 02:19:28 +00001796
1797 MMI = Asm->MMI;
Devang Patel3380cc52009-11-11 19:55:08 +00001798
Chris Lattnera909d662010-03-29 20:38:20 +00001799 TimeRegion Timer(DebugTimer);
Chris Lattnerd850ac72010-04-05 02:19:28 +00001800
Devang Patel78ab9e22009-07-30 18:56:46 +00001801 DebugInfoFinder DbgFinder;
1802 DbgFinder.processModule(*M);
Devang Patel13e16b62009-06-26 01:49:18 +00001803
Chris Lattnerd850ac72010-04-05 02:19:28 +00001804 bool HasDebugInfo = false;
1805
1806 // Scan all the compile-units to see if there are any marked as the main unit.
1807 // if not, we do not generate debug info.
1808 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1809 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1810 if (DICompileUnit(*I).isMain()) {
1811 HasDebugInfo = true;
1812 break;
1813 }
1814 }
1815
1816 if (!HasDebugInfo) return;
1817
Chris Lattner6342b412010-04-05 03:49:26 +00001818 shouldEmit = true;
1819
Chris Lattnerd850ac72010-04-05 02:19:28 +00001820 // Tell MMI that we have debug info.
1821 MMI->setDebugInfoAvailability(true);
1822
Chris Lattnerbe15beb2010-04-04 23:17:54 +00001823 // Emit initial sections.
Chris Lattnerd850ac72010-04-05 02:19:28 +00001824 EmitSectionLabels();
Chris Lattnerbe15beb2010-04-04 23:17:54 +00001825
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001826 // Create all the compile unit DIEs.
Devang Patel78ab9e22009-07-30 18:56:46 +00001827 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1828 E = DbgFinder.compile_unit_end(); I != E; ++I)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001829 constructCompileUnit(*I);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001830
Devang Patel53bb5c92009-11-10 23:06:00 +00001831 // Create DIEs for each subprogram.
Devang Patel78ab9e22009-07-30 18:56:46 +00001832 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1833 E = DbgFinder.subprogram_end(); I != E; ++I)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001834 constructSubprogramDIE(*I);
Devang Patel13e16b62009-06-26 01:49:18 +00001835
Devang Patelc366f832009-12-10 19:14:49 +00001836 // Create DIEs for each global variable.
1837 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1838 E = DbgFinder.global_variable_end(); I != E; ++I)
1839 constructGlobalVariableDIE(*I);
1840
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001841 // Prime section data.
Chris Lattnerf0144122009-07-28 03:13:23 +00001842 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001843
1844 // Print out .file directives to specify files for .loc directives. These are
1845 // printed out early so that they precede any .loc directives.
Chris Lattnerd38fee82010-04-05 00:13:49 +00001846 if (Asm->MAI->hasDotLocAndDotFile()) {
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001847 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1848 // Remember source id starts at 1.
1849 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
Chris Lattner0ad9c912010-01-22 22:09:00 +00001850 // FIXME: don't use sys::path for this! This should not depend on the
1851 // host.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001852 sys::Path FullPath(getSourceDirectoryName(Id.first));
1853 bool AppendOk =
1854 FullPath.appendComponent(getSourceFileName(Id.second));
1855 assert(AppendOk && "Could not append filename to directory!");
1856 AppendOk = false;
Chris Lattnera6594fc2010-01-25 18:58:59 +00001857 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001858 }
1859 }
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001860}
1861
Devang Patel2c4ceb12009-11-21 02:48:08 +00001862/// endModule - Emit all Dwarf sections that should come after the content.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001863///
Devang Patel2c4ceb12009-11-21 02:48:08 +00001864void DwarfDebug::endModule() {
Devang Patel6f3dc922009-10-06 00:03:14 +00001865 if (!ModuleCU)
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001866 return;
1867
Chris Lattnera909d662010-03-29 20:38:20 +00001868 TimeRegion Timer(DebugTimer);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001869
Devang Patel53bb5c92009-11-10 23:06:00 +00001870 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1871 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1872 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1873 DIE *ISP = *AI;
Devang Patel2c4ceb12009-11-21 02:48:08 +00001874 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
Devang Patel53bb5c92009-11-10 23:06:00 +00001875 }
1876
Devang Patel1d5cc1d2009-12-03 01:25:38 +00001877 // Insert top level DIEs.
1878 for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1879 TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1880 ModuleCU->getCUDie()->addChild(*TI);
1881
Devang Patel622b0262010-01-19 06:19:05 +00001882 for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
Devang Patel5d11eb02009-12-03 19:11:07 +00001883 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1884 DIE *SPDie = CI->first;
1885 MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1886 if (!N) continue;
1887 DIE *NDie = ModuleCU->getDIE(N);
1888 if (!NDie) continue;
1889 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
Devang Patelf8b72ca2010-01-15 00:26:31 +00001890 // FIXME - This is not the correct approach.
Chris Lattner1d65ba72010-03-31 06:06:37 +00001891 //addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie
Devang Patel5d11eb02009-12-03 19:11:07 +00001892 }
1893
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001894 // Standard sections final addresses.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00001895 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
Chris Lattnerc0215722010-04-04 19:25:43 +00001896 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
Chris Lattner6c2f9e12009-08-19 05:49:37 +00001897 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
Chris Lattnerc0215722010-04-04 19:25:43 +00001898 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001899
1900 // End text sections.
1901 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
Chris Lattner6c2f9e12009-08-19 05:49:37 +00001902 Asm->OutStreamer.SwitchSection(SectionMap[i]);
Chris Lattnerc0215722010-04-04 19:25:43 +00001903 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001904 }
1905
1906 // Emit common frame information.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001907 emitCommonDebugFrame();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001908
1909 // Emit function debug frame information
1910 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1911 E = DebugFrames.end(); I != E; ++I)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001912 emitFunctionDebugFrame(*I);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001913
1914 // Compute DIE offsets and sizes.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001915 computeSizeAndOffsets();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001916
1917 // Emit all the DIEs into a debug info section
Devang Patel2c4ceb12009-11-21 02:48:08 +00001918 emitDebugInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001919
1920 // Corresponding abbreviations into a abbrev section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001921 emitAbbreviations();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001922
1923 // Emit source line correspondence into a debug line section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001924 emitDebugLines();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001925
1926 // Emit info into a debug pubnames section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001927 emitDebugPubNames();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001928
Devang Patel193f7202009-11-24 01:14:22 +00001929 // Emit info into a debug pubtypes section.
1930 emitDebugPubTypes();
1931
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001932 // Emit info into a debug loc section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001933 emitDebugLoc();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001934
1935 // Emit info into a debug aranges section.
1936 EmitDebugARanges();
1937
1938 // Emit info into a debug ranges section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001939 emitDebugRanges();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001940
1941 // Emit info into a debug macinfo section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001942 emitDebugMacInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001943
1944 // Emit inline info.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001945 emitDebugInlineInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001946
Chris Lattnerbc733f52010-03-13 02:17:42 +00001947 // Emit info into a debug str section.
1948 emitDebugStr();
1949
Jeffrey Yasskind0f393d2010-03-11 18:29:55 +00001950 delete ModuleCU;
1951 ModuleCU = NULL; // Reset for the next Module, if any.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001952}
1953
Devang Patel53bb5c92009-11-10 23:06:00 +00001954/// findAbstractVariable - Find abstract variable, if any, associated with Var.
Jim Grosbach7ab38df2009-11-22 19:20:36 +00001955DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1956 unsigned FrameIdx,
Chris Lattnerde4845c2010-04-02 19:42:39 +00001957 DebugLoc ScopeLoc) {
Devang Patel53bb5c92009-11-10 23:06:00 +00001958
1959 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1960 if (AbsDbgVariable)
1961 return AbsDbgVariable;
1962
Chris Lattnerde4845c2010-04-02 19:42:39 +00001963 LLVMContext &Ctx = Var.getNode()->getContext();
1964 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
Devang Patel53bb5c92009-11-10 23:06:00 +00001965 if (!Scope)
1966 return NULL;
1967
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00001968 AbsDbgVariable = new DbgVariable(Var, FrameIdx,
1969 NULL /* No more-abstract variable*/);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001970 Scope->addVariable(AbsDbgVariable);
Devang Patel53bb5c92009-11-10 23:06:00 +00001971 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1972 return AbsDbgVariable;
1973}
1974
Devang Patel90a48ad2010-03-15 18:33:46 +00001975/// findAbstractVariable - Find abstract variable, if any, associated with Var.
1976/// FIXME : Refactor findAbstractVariable.
1977DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1978 const MachineInstr *MI,
Chris Lattnerde4845c2010-04-02 19:42:39 +00001979 DebugLoc ScopeLoc) {
Devang Patel90a48ad2010-03-15 18:33:46 +00001980
1981 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1982 if (AbsDbgVariable)
1983 return AbsDbgVariable;
1984
Chris Lattnerde4845c2010-04-02 19:42:39 +00001985 LLVMContext &Ctx = Var.getNode()->getContext();
1986 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
Devang Patel90a48ad2010-03-15 18:33:46 +00001987 if (!Scope)
1988 return NULL;
1989
Devang Patelaead63c2010-03-29 22:59:58 +00001990 AbsDbgVariable = new DbgVariable(Var, MI,
Devang Patel90a48ad2010-03-15 18:33:46 +00001991 NULL /* No more-abstract variable*/);
1992 Scope->addVariable(AbsDbgVariable);
1993 AbstractVariables[Var.getNode()] = AbsDbgVariable;
Devang Patelaead63c2010-03-29 22:59:58 +00001994 DbgValueStartMap[MI] = AbsDbgVariable;
Devang Patel90a48ad2010-03-15 18:33:46 +00001995 return AbsDbgVariable;
1996}
1997
Devang Patel2c4ceb12009-11-21 02:48:08 +00001998/// collectVariableInfo - Populate DbgScope entries with variables' info.
1999void DwarfDebug::collectVariableInfo() {
Devang Patelac1ceb32009-10-09 22:42:28 +00002000 if (!MMI) return;
Devang Patel53bb5c92009-11-10 23:06:00 +00002001
Chris Lattnerd38fee82010-04-05 00:13:49 +00002002 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
Chris Lattnerde4845c2010-04-02 19:42:39 +00002003
Devang Patele717faa2009-10-06 01:26:37 +00002004 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2005 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2006 VE = VMap.end(); VI != VE; ++VI) {
Devang Patelbc5201f2010-01-22 22:52:10 +00002007 MDNode *Var = VI->first;
Devang Patel53bb5c92009-11-10 23:06:00 +00002008 if (!Var) continue;
Chris Lattnerde4845c2010-04-02 19:42:39 +00002009 DIVariable DV(Var);
2010 const std::pair<unsigned, DebugLoc> &VP = VI->second;
Devang Patel53bb5c92009-11-10 23:06:00 +00002011
Chris Lattnerde4845c2010-04-02 19:42:39 +00002012 DbgScope *Scope = 0;
2013 if (MDNode *IA = VP.second.getInlinedAt(Ctx))
2014 Scope = ConcreteScopes.lookup(IA);
2015 if (Scope == 0)
2016 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2017
Devang Patelfb0ee432009-11-10 23:20:04 +00002018 // If variable scope is not found then skip this variable.
Chris Lattnerde4845c2010-04-02 19:42:39 +00002019 if (Scope == 0)
Devang Patelfb0ee432009-11-10 23:20:04 +00002020 continue;
Devang Patel53bb5c92009-11-10 23:06:00 +00002021
Chris Lattnerde4845c2010-04-02 19:42:39 +00002022 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, VP.second);
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002023 DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
Devang Patel2c4ceb12009-11-21 02:48:08 +00002024 Scope->addVariable(RegVar);
Devang Patele717faa2009-10-06 01:26:37 +00002025 }
Devang Patel90a48ad2010-03-15 18:33:46 +00002026
2027 // Collect variable information from DBG_VALUE machine instructions;
Chris Lattnerd38fee82010-04-05 00:13:49 +00002028 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
Devang Patel90a48ad2010-03-15 18:33:46 +00002029 I != E; ++I) {
2030 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2031 II != IE; ++II) {
2032 const MachineInstr *MInsn = II;
Chris Lattner14d750d2010-03-31 05:39:57 +00002033 if (!MInsn->isDebugValue())
Devang Patel90a48ad2010-03-15 18:33:46 +00002034 continue;
Devang Patelaead63c2010-03-29 22:59:58 +00002035
Devang Patel90a48ad2010-03-15 18:33:46 +00002036 // FIXME : Lift this restriction.
2037 if (MInsn->getNumOperands() != 3)
2038 continue;
Chris Lattner870cfcf2010-03-31 03:34:40 +00002039 DIVariable DV((MDNode*)(MInsn->getOperand(MInsn->getNumOperands()
2040 - 1).getMetadata()));
Devang Patel90a48ad2010-03-15 18:33:46 +00002041 if (DV.getTag() == dwarf::DW_TAG_arg_variable) {
2042 // FIXME Handle inlined subroutine arguments.
2043 DbgVariable *ArgVar = new DbgVariable(DV, MInsn, NULL);
2044 CurrentFnDbgScope->addVariable(ArgVar);
Devang Patelaead63c2010-03-29 22:59:58 +00002045 DbgValueStartMap[MInsn] = ArgVar;
Devang Patel90a48ad2010-03-15 18:33:46 +00002046 continue;
2047 }
2048
2049 DebugLoc DL = MInsn->getDebugLoc();
2050 if (DL.isUnknown()) continue;
Chris Lattnerde4845c2010-04-02 19:42:39 +00002051 DbgScope *Scope = 0;
2052 if (MDNode *IA = DL.getInlinedAt(Ctx))
2053 Scope = ConcreteScopes.lookup(IA);
2054 if (Scope == 0)
2055 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2056
Devang Patel90a48ad2010-03-15 18:33:46 +00002057 // If variable scope is not found then skip this variable.
Chris Lattnerde4845c2010-04-02 19:42:39 +00002058 if (Scope == 0)
Devang Patel90a48ad2010-03-15 18:33:46 +00002059 continue;
2060
Chris Lattnerde4845c2010-04-02 19:42:39 +00002061 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL);
Devang Patel90a48ad2010-03-15 18:33:46 +00002062 DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
Devang Patelaead63c2010-03-29 22:59:58 +00002063 DbgValueStartMap[MInsn] = RegVar;
Devang Patel90a48ad2010-03-15 18:33:46 +00002064 Scope->addVariable(RegVar);
2065 }
2066 }
Devang Patele717faa2009-10-06 01:26:37 +00002067}
2068
Devang Patel553881b2010-03-29 17:20:31 +00002069/// beginScope - Process beginning of a scope.
2070void DwarfDebug::beginScope(const MachineInstr *MI) {
Devang Patel553881b2010-03-29 17:20:31 +00002071 // Check location.
2072 DebugLoc DL = MI->getDebugLoc();
2073 if (DL.isUnknown())
2074 return;
Devang Patel553881b2010-03-29 17:20:31 +00002075
2076 // Check and update last known location info.
Chris Lattnerde4845c2010-04-02 19:42:39 +00002077 if (DL == PrevInstLoc)
2078 return;
2079
Chris Lattnerd38fee82010-04-05 00:13:49 +00002080 MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
Chris Lattnerde4845c2010-04-02 19:42:39 +00002081
2082 // FIXME: Should only verify each scope once!
2083 if (!DIScope(Scope).Verify())
Devang Patel553881b2010-03-29 17:20:31 +00002084 return;
Devang Patel553881b2010-03-29 17:20:31 +00002085
Devang Patelaead63c2010-03-29 22:59:58 +00002086 // DBG_VALUE instruction establishes new value.
Chris Lattner14d750d2010-03-31 05:39:57 +00002087 if (MI->isDebugValue()) {
Devang Patelaead63c2010-03-29 22:59:58 +00002088 DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
2089 = DbgValueStartMap.find(MI);
2090 if (DI != DbgValueStartMap.end()) {
Chris Lattnerde4845c2010-04-02 19:42:39 +00002091 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2092 PrevInstLoc = DL;
Devang Patelaead63c2010-03-29 22:59:58 +00002093 DI->second->setDbgValueLabel(Label);
2094 }
Devang Patel7ed63112010-03-30 18:07:00 +00002095 return;
Devang Patelaead63c2010-03-29 22:59:58 +00002096 }
2097
Devang Patel553881b2010-03-29 17:20:31 +00002098 // Emit a label to indicate location change. This is used for line
2099 // table even if this instruction does start a new scope.
Chris Lattnerde4845c2010-04-02 19:42:39 +00002100 MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2101 PrevInstLoc = DL;
Devang Patel553881b2010-03-29 17:20:31 +00002102
2103 // update DbgScope if this instruction starts a new scope.
Devang Patel0d20ac82009-10-06 01:50:42 +00002104 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
2105 if (I == DbgScopeBeginMap.end())
2106 return;
Devang Patel553881b2010-03-29 17:20:31 +00002107
Dan Gohman277207e2009-11-23 21:30:55 +00002108 ScopeVector &SD = I->second;
Devang Patel53bb5c92009-11-10 23:06:00 +00002109 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
Jim Grosbach31ef40e2009-11-21 23:12:12 +00002110 SDI != SDE; ++SDI)
Chris Lattnerc6087842010-03-09 04:54:43 +00002111 (*SDI)->setStartLabel(Label);
Devang Patel0d20ac82009-10-06 01:50:42 +00002112}
2113
Devang Patel2c4ceb12009-11-21 02:48:08 +00002114/// endScope - Process end of a scope.
2115void DwarfDebug::endScope(const MachineInstr *MI) {
Devang Patel553881b2010-03-29 17:20:31 +00002116 // Ignore DBG_VALUE instruction.
Chris Lattner14d750d2010-03-31 05:39:57 +00002117 if (MI->isDebugValue())
Devang Patel553881b2010-03-29 17:20:31 +00002118 return;
2119
2120 // Check location.
2121 DebugLoc DL = MI->getDebugLoc();
2122 if (DL.isUnknown())
2123 return;
Chris Lattnerde4845c2010-04-02 19:42:39 +00002124
Devang Patel553881b2010-03-29 17:20:31 +00002125 // Emit a label and update DbgScope if this instruction ends a scope.
Devang Patel0d20ac82009-10-06 01:50:42 +00002126 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
Devang Patel8a4087d2009-10-06 03:15:38 +00002127 if (I == DbgScopeEndMap.end())
Devang Patel0d20ac82009-10-06 01:50:42 +00002128 return;
Chris Lattnerde4845c2010-04-02 19:42:39 +00002129
Chris Lattner63d78362010-03-14 08:36:50 +00002130 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
Chris Lattnerb7db7332010-03-09 01:58:53 +00002131 Asm->OutStreamer.EmitLabel(Label);
Devang Patel53bb5c92009-11-10 23:06:00 +00002132
Chris Lattnerb7db7332010-03-09 01:58:53 +00002133 SmallVector<DbgScope*, 2> &SD = I->second;
Devang Patel0d20ac82009-10-06 01:50:42 +00002134 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
Jim Grosbach31ef40e2009-11-21 23:12:12 +00002135 SDI != SDE; ++SDI)
Chris Lattnerb7db7332010-03-09 01:58:53 +00002136 (*SDI)->setEndLabel(Label);
Devang Patel53bb5c92009-11-10 23:06:00 +00002137 return;
2138}
2139
2140/// createDbgScope - Create DbgScope for the scope.
2141void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
Devang Patel53bb5c92009-11-10 23:06:00 +00002142 if (!InlinedAt) {
2143 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2144 if (WScope)
2145 return;
2146 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2147 DbgScopeMap.insert(std::make_pair(Scope, WScope));
Jim Grosbach31ef40e2009-11-21 23:12:12 +00002148 if (DIDescriptor(Scope).isLexicalBlock())
Devang Patel2f105c62009-11-11 00:18:40 +00002149 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
Devang Patel53bb5c92009-11-10 23:06:00 +00002150 return;
2151 }
2152
2153 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2154 if (WScope)
2155 return;
2156
2157 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2158 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2159 DILocation DL(InlinedAt);
2160 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
Devang Patel0d20ac82009-10-06 01:50:42 +00002161}
2162
Devang Patel2c4ceb12009-11-21 02:48:08 +00002163/// extractScopeInformation - Scan machine instructions in this function
Chris Lattner14d750d2010-03-31 05:39:57 +00002164/// and collect DbgScopes. Return true, if at least one scope was found.
Chris Lattnereec791a2010-01-26 23:18:02 +00002165bool DwarfDebug::extractScopeInformation() {
Devang Patelaf9e8472009-10-01 20:31:14 +00002166 // If scope information was extracted using .dbg intrinsics then there is not
2167 // any need to extract these information by scanning each instruction.
2168 if (!DbgScopeMap.empty())
2169 return false;
2170
Devang Patel344130e2010-01-04 20:44:00 +00002171 DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2172 unsigned MIIndex = 0;
Chris Lattnerd38fee82010-04-05 00:13:49 +00002173 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
Chris Lattnerde4845c2010-04-02 19:42:39 +00002174
Devang Patel53bb5c92009-11-10 23:06:00 +00002175 // Scan each instruction and create scopes. First build working set of scopes.
Chris Lattnerd38fee82010-04-05 00:13:49 +00002176 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
Devang Patelaf9e8472009-10-01 20:31:14 +00002177 I != E; ++I) {
2178 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2179 II != IE; ++II) {
2180 const MachineInstr *MInsn = II;
Devang Patel90a48ad2010-03-15 18:33:46 +00002181 // FIXME : Remove DBG_VALUE check.
Chris Lattner14d750d2010-03-31 05:39:57 +00002182 if (MInsn->isDebugValue()) continue;
Devang Patel344130e2010-01-04 20:44:00 +00002183 MIIndexMap[MInsn] = MIIndex++;
Chris Lattnerde4845c2010-04-02 19:42:39 +00002184
Devang Patelaf9e8472009-10-01 20:31:14 +00002185 DebugLoc DL = MInsn->getDebugLoc();
Devang Patel53bb5c92009-11-10 23:06:00 +00002186 if (DL.isUnknown()) continue;
Chris Lattnerde4845c2010-04-02 19:42:39 +00002187
2188 MDNode *Scope = DL.getScope(Ctx);
2189
Devang Patelaf9e8472009-10-01 20:31:14 +00002190 // There is no need to create another DIE for compile unit. For all
Jim Grosbach31ef40e2009-11-21 23:12:12 +00002191 // other scopes, create one DbgScope now. This will be translated
Devang Patelaf9e8472009-10-01 20:31:14 +00002192 // into a scope DIE at the end.
Chris Lattnerde4845c2010-04-02 19:42:39 +00002193 if (DIScope(Scope).isCompileUnit()) continue;
2194 createDbgScope(Scope, DL.getInlinedAt(Ctx));
Devang Patel53bb5c92009-11-10 23:06:00 +00002195 }
2196 }
2197
Devang Patelc8e77642010-04-01 22:47:29 +00002198
Devang Patel53bb5c92009-11-10 23:06:00 +00002199 // Build scope hierarchy using working set of scopes.
Chris Lattnerd38fee82010-04-05 00:13:49 +00002200 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
Devang Patel53bb5c92009-11-10 23:06:00 +00002201 I != E; ++I) {
2202 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2203 II != IE; ++II) {
2204 const MachineInstr *MInsn = II;
Devang Patel90a48ad2010-03-15 18:33:46 +00002205 // FIXME : Remove DBG_VALUE check.
Chris Lattner14d750d2010-03-31 05:39:57 +00002206 if (MInsn->isDebugValue()) continue;
Devang Patel53bb5c92009-11-10 23:06:00 +00002207 DebugLoc DL = MInsn->getDebugLoc();
Chris Lattnerde4845c2010-04-02 19:42:39 +00002208 if (DL.isUnknown()) continue;
2209
2210 MDNode *Scope = DL.getScope(Ctx);
2211 if (Scope == 0) continue;
2212
Devang Patel53bb5c92009-11-10 23:06:00 +00002213 // There is no need to create another DIE for compile unit. For all
Jim Grosbach31ef40e2009-11-21 23:12:12 +00002214 // other scopes, create one DbgScope now. This will be translated
Devang Patel53bb5c92009-11-10 23:06:00 +00002215 // into a scope DIE at the end.
Chris Lattnerde4845c2010-04-02 19:42:39 +00002216 if (DIScope(Scope).isCompileUnit()) continue;
2217 DbgScope *DScope = getUpdatedDbgScope(Scope, MInsn, DL.getInlinedAt(Ctx));
2218 DScope->setLastInsn(MInsn);
Devang Patelaf9e8472009-10-01 20:31:14 +00002219 }
2220 }
2221
Devang Patel344130e2010-01-04 20:44:00 +00002222 if (!CurrentFnDbgScope)
2223 return false;
2224
2225 CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
Devang Patelaf9e8472009-10-01 20:31:14 +00002226
2227 // Each scope has first instruction and last instruction to mark beginning
2228 // and end of a scope respectively. Create an inverse map that list scopes
2229 // starts (and ends) with an instruction. One instruction may start (or end)
Devang Patel42aafd72010-01-20 02:05:23 +00002230 // multiple scopes. Ignore scopes that are not reachable.
2231 SmallVector<DbgScope *, 4> WorkList;
2232 WorkList.push_back(CurrentFnDbgScope);
2233 while (!WorkList.empty()) {
Chris Lattner14d750d2010-03-31 05:39:57 +00002234 DbgScope *S = WorkList.pop_back_val();
Devang Patel42aafd72010-01-20 02:05:23 +00002235
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002236 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
Devang Patel42aafd72010-01-20 02:05:23 +00002237 if (!Children.empty())
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002238 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
Devang Patel42aafd72010-01-20 02:05:23 +00002239 SE = Children.end(); SI != SE; ++SI)
2240 WorkList.push_back(*SI);
2241
Devang Patel53bb5c92009-11-10 23:06:00 +00002242 if (S->isAbstractScope())
2243 continue;
Devang Patelaf9e8472009-10-01 20:31:14 +00002244 const MachineInstr *MI = S->getFirstInsn();
Chris Lattnered7a77b2010-03-31 05:36:29 +00002245 assert(MI && "DbgScope does not have first instruction!");
Devang Patelaf9e8472009-10-01 20:31:14 +00002246
2247 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2248 if (IDI != DbgScopeBeginMap.end())
2249 IDI->second.push_back(S);
2250 else
Devang Patel53bb5c92009-11-10 23:06:00 +00002251 DbgScopeBeginMap[MI].push_back(S);
Devang Patelaf9e8472009-10-01 20:31:14 +00002252
2253 MI = S->getLastInsn();
Chris Lattnered7a77b2010-03-31 05:36:29 +00002254 assert(MI && "DbgScope does not have last instruction!");
Devang Patelaf9e8472009-10-01 20:31:14 +00002255 IDI = DbgScopeEndMap.find(MI);
2256 if (IDI != DbgScopeEndMap.end())
2257 IDI->second.push_back(S);
2258 else
Devang Patel53bb5c92009-11-10 23:06:00 +00002259 DbgScopeEndMap[MI].push_back(S);
Devang Patelaf9e8472009-10-01 20:31:14 +00002260 }
2261
2262 return !DbgScopeMap.empty();
2263}
2264
Devang Patel2c4ceb12009-11-21 02:48:08 +00002265/// beginFunction - Gather pre-function debug information. Assumes being
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002266/// emitted immediately after the function entry point.
Chris Lattnereec791a2010-01-26 23:18:02 +00002267void DwarfDebug::beginFunction(const MachineFunction *MF) {
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002268 if (!ShouldEmitDwarfDebug()) return;
Chris Lattnerd38fee82010-04-05 00:13:49 +00002269
2270 TimeRegion Timer(DebugTimer);
Chris Lattnereec791a2010-01-26 23:18:02 +00002271 if (!extractScopeInformation())
Devang Patel60b35bd2009-10-06 18:37:31 +00002272 return;
Chris Lattnera909d662010-03-29 20:38:20 +00002273
Devang Patel2c4ceb12009-11-21 02:48:08 +00002274 collectVariableInfo();
Devang Patel60b35bd2009-10-06 18:37:31 +00002275
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002276 // Assumes in correct section after the entry point.
Chris Lattnerc0215722010-04-04 19:25:43 +00002277 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_begin",
Chris Lattnerd38fee82010-04-05 00:13:49 +00002278 Asm->getFunctionNumber()));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002279
2280 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2281 // function.
Devang Patelac1ceb32009-10-09 22:42:28 +00002282 DebugLoc FDL = MF->getDefaultDebugLoc();
Chris Lattnerde4845c2010-04-02 19:42:39 +00002283 if (FDL.isUnknown()) return;
2284
2285 MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2286
2287 DISubprogram SP = getDISubprogram(Scope);
2288 unsigned Line, Col;
2289 if (SP.Verify()) {
2290 Line = SP.getLineNumber();
2291 Col = 0;
2292 } else {
2293 Line = FDL.getLine();
2294 Col = FDL.getCol();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002295 }
Chris Lattnerde4845c2010-04-02 19:42:39 +00002296
2297 recordSourceLine(Line, Col, Scope);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002298}
2299
Devang Patel2c4ceb12009-11-21 02:48:08 +00002300/// endFunction - Gather and emit post-function debug information.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002301///
Chris Lattnereec791a2010-01-26 23:18:02 +00002302void DwarfDebug::endFunction(const MachineFunction *MF) {
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002303 if (!ShouldEmitDwarfDebug()) return;
Chris Lattnera909d662010-03-29 20:38:20 +00002304 if (DbgScopeMap.empty()) return;
2305
2306 TimeRegion Timer(DebugTimer);
Devang Patel70d75ca2009-11-12 19:02:56 +00002307
Devang Patel344130e2010-01-04 20:44:00 +00002308 if (CurrentFnDbgScope) {
2309 // Define end label for subprogram.
Chris Lattnerd38fee82010-04-05 00:13:49 +00002310 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("func_end",
2311 Asm->getFunctionNumber()));
Devang Patel344130e2010-01-04 20:44:00 +00002312
2313 // Get function line info.
2314 if (!Lines.empty()) {
2315 // Get section line info.
2316 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2317 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2318 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2319 // Append the function info to section info.
2320 SectionLineInfos.insert(SectionLineInfos.end(),
2321 Lines.begin(), Lines.end());
2322 }
2323
2324 // Construct abstract scopes.
2325 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2326 AE = AbstractScopesList.end(); AI != AE; ++AI)
2327 constructScopeDIE(*AI);
2328
2329 constructScopeDIE(CurrentFnDbgScope);
2330
Chris Lattnerd38fee82010-04-05 00:13:49 +00002331 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
Devang Patel344130e2010-01-04 20:44:00 +00002332 MMI->getFrameMoves()));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002333 }
2334
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002335 // Clear debug info
Devang Patelf54b8522010-01-19 01:26:02 +00002336 CurrentFnDbgScope = NULL;
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002337 DeleteContainerSeconds(DbgScopeMap);
Devang Patelf54b8522010-01-19 01:26:02 +00002338 DbgScopeBeginMap.clear();
2339 DbgScopeEndMap.clear();
Devang Patelaead63c2010-03-29 22:59:58 +00002340 DbgValueStartMap.clear();
Devang Patelf54b8522010-01-19 01:26:02 +00002341 ConcreteScopes.clear();
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002342 DeleteContainerSeconds(AbstractScopes);
Devang Patelf54b8522010-01-19 01:26:02 +00002343 AbstractScopesList.clear();
Jeffrey Yasskin5c213dc2010-03-12 17:45:06 +00002344 AbstractVariables.clear();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002345 Lines.clear();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002346}
2347
Chris Lattnerc6087842010-03-09 04:54:43 +00002348/// recordSourceLine - Register a source line with debug info. Returns the
2349/// unique label that was emitted and which provides correspondence to
2350/// the source line list.
2351MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, MDNode *S) {
Devang Patele4b27562009-08-28 23:24:31 +00002352 if (!MMI)
2353 return 0;
2354
Chris Lattnera909d662010-03-29 20:38:20 +00002355 TimeRegion Timer(DebugTimer);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002356
Devang Patel65dbc902009-11-25 17:36:49 +00002357 StringRef Dir;
2358 StringRef Fn;
Devang Patelf84548d2009-10-05 18:03:19 +00002359
2360 DIDescriptor Scope(S);
2361 if (Scope.isCompileUnit()) {
2362 DICompileUnit CU(S);
2363 Dir = CU.getDirectory();
2364 Fn = CU.getFilename();
2365 } else if (Scope.isSubprogram()) {
2366 DISubprogram SP(S);
2367 Dir = SP.getDirectory();
2368 Fn = SP.getFilename();
2369 } else if (Scope.isLexicalBlock()) {
2370 DILexicalBlock DB(S);
2371 Dir = DB.getDirectory();
2372 Fn = DB.getFilename();
2373 } else
Chris Lattner206d61e2010-03-13 07:26:18 +00002374 assert(0 && "Unexpected scope info");
Devang Patelf84548d2009-10-05 18:03:19 +00002375
2376 unsigned Src = GetOrCreateSourceID(Dir, Fn);
Chris Lattner63d78362010-03-14 08:36:50 +00002377 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
Chris Lattner25b68c62010-03-14 08:15:55 +00002378 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002379
Chris Lattnerc6087842010-03-09 04:54:43 +00002380 Asm->OutStreamer.EmitLabel(Label);
2381 return Label;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002382}
2383
2384/// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2385/// timed. Look up the source id with the given directory and source file
2386/// names. If none currently exists, create a new id and insert it in the
2387/// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2388/// well.
2389unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2390 const std::string &FileName) {
Chris Lattnera909d662010-03-29 20:38:20 +00002391 TimeRegion Timer(DebugTimer);
2392 return GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002393}
2394
Bill Wendling829e67b2009-05-20 23:22:40 +00002395//===----------------------------------------------------------------------===//
2396// Emit Methods
2397//===----------------------------------------------------------------------===//
2398
Devang Patel2c4ceb12009-11-21 02:48:08 +00002399/// computeSizeAndOffset - Compute the size and offset of a DIE.
Bill Wendling94d04b82009-05-20 23:21:38 +00002400///
Jim Grosbach7ab38df2009-11-22 19:20:36 +00002401unsigned
2402DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
Bill Wendling94d04b82009-05-20 23:21:38 +00002403 // Get the children.
2404 const std::vector<DIE *> &Children = Die->getChildren();
2405
2406 // If not last sibling and has children then add sibling offset attribute.
Jeffrey Yasskin638fe8d2010-03-22 18:47:14 +00002407 if (!Last && !Children.empty())
Benjamin Kramer345ef342010-03-31 19:34:01 +00002408 Die->addSiblingOffset(DIEValueAllocator);
Bill Wendling94d04b82009-05-20 23:21:38 +00002409
2410 // Record the abbreviation.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002411 assignAbbrevNumber(Die->getAbbrev());
Bill Wendling94d04b82009-05-20 23:21:38 +00002412
2413 // Get the abbreviation for this DIE.
2414 unsigned AbbrevNumber = Die->getAbbrevNumber();
2415 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2416
2417 // Set DIE offset
2418 Die->setOffset(Offset);
2419
2420 // Start the size with the size of abbreviation code.
Chris Lattneraf76e592009-08-22 20:48:53 +00002421 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
Bill Wendling94d04b82009-05-20 23:21:38 +00002422
2423 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2424 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2425
2426 // Size the DIE attribute values.
2427 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2428 // Size attribute value.
Chris Lattnera37d5382010-04-05 00:18:22 +00002429 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
Bill Wendling94d04b82009-05-20 23:21:38 +00002430
2431 // Size the DIE children if any.
2432 if (!Children.empty()) {
2433 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2434 "Children flag not set");
2435
2436 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel2c4ceb12009-11-21 02:48:08 +00002437 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
Bill Wendling94d04b82009-05-20 23:21:38 +00002438
2439 // End of children marker.
2440 Offset += sizeof(int8_t);
2441 }
2442
2443 Die->setSize(Offset - Die->getOffset());
2444 return Offset;
2445}
2446
Devang Patel2c4ceb12009-11-21 02:48:08 +00002447/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
Bill Wendling94d04b82009-05-20 23:21:38 +00002448///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002449void DwarfDebug::computeSizeAndOffsets() {
Bill Wendling94d04b82009-05-20 23:21:38 +00002450 // Compute size of compile unit header.
2451 static unsigned Offset =
2452 sizeof(int32_t) + // Length of Compilation Unit Info
2453 sizeof(int16_t) + // DWARF version number
2454 sizeof(int32_t) + // Offset Into Abbrev. Section
2455 sizeof(int8_t); // Pointer Size (in bytes)
2456
Devang Patel2c4ceb12009-11-21 02:48:08 +00002457 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
Devang Patel1dbc7712009-06-29 20:45:18 +00002458 CompileUnitOffsets[ModuleCU] = 0;
Bill Wendling94d04b82009-05-20 23:21:38 +00002459}
2460
Chris Lattner11b8f302010-04-04 23:02:02 +00002461/// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2462/// temporary label to it if SymbolStem is specified.
Chris Lattner9c69e285532010-04-04 22:59:04 +00002463static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
Chris Lattner11b8f302010-04-04 23:02:02 +00002464 const char *SymbolStem = 0) {
Chris Lattner9c69e285532010-04-04 22:59:04 +00002465 Asm->OutStreamer.SwitchSection(Section);
Chris Lattner11b8f302010-04-04 23:02:02 +00002466 if (!SymbolStem) return 0;
2467
Chris Lattner9c69e285532010-04-04 22:59:04 +00002468 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2469 Asm->OutStreamer.EmitLabel(TmpSym);
2470 return TmpSym;
2471}
2472
2473/// EmitSectionLabels - Emit initial Dwarf sections with a label at
2474/// the start of each one.
Chris Lattnerfa070b02010-04-04 22:33:59 +00002475void DwarfDebug::EmitSectionLabels() {
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002476 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarf612ff62009-09-19 20:40:05 +00002477
Bill Wendling94d04b82009-05-20 23:21:38 +00002478 // Dwarf sections base addresses.
Chris Lattnerd38fee82010-04-05 00:13:49 +00002479 if (Asm->MAI->doesDwarfRequireFrameSection()) {
Chris Lattner9c69e285532010-04-04 22:59:04 +00002480 DwarfFrameSectionSym =
2481 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
2482 }
Bill Wendling94d04b82009-05-20 23:21:38 +00002483
Chris Lattner9c69e285532010-04-04 22:59:04 +00002484 DwarfInfoSectionSym =
2485 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2486 DwarfAbbrevSectionSym =
2487 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
Chris Lattner11b8f302010-04-04 23:02:02 +00002488 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
Chris Lattner9c69e285532010-04-04 22:59:04 +00002489
2490 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
Chris Lattner11b8f302010-04-04 23:02:02 +00002491 EmitSectionSym(Asm, MacroInfo);
Bill Wendling94d04b82009-05-20 23:21:38 +00002492
Chris Lattner11b8f302010-04-04 23:02:02 +00002493 EmitSectionSym(Asm, TLOF.getDwarfLineSection());
2494 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2495 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2496 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
Chris Lattner9c69e285532010-04-04 22:59:04 +00002497 DwarfStrSectionSym =
2498 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
Chris Lattner11b8f302010-04-04 23:02:02 +00002499 EmitSectionSym(Asm, TLOF.getDwarfRangesSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002500
Chris Lattner9c69e285532010-04-04 22:59:04 +00002501 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
Chris Lattner4ad1efe2010-04-04 23:10:38 +00002502 EmitSectionSym(Asm, TLOF.getDataSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002503}
2504
Devang Patel2c4ceb12009-11-21 02:48:08 +00002505/// emitDIE - Recusively Emits a debug information entry.
Bill Wendling94d04b82009-05-20 23:21:38 +00002506///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002507void DwarfDebug::emitDIE(DIE *Die) {
Bill Wendling94d04b82009-05-20 23:21:38 +00002508 // Get the abbreviation for this DIE.
2509 unsigned AbbrevNumber = Die->getAbbrevNumber();
2510 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2511
Bill Wendling94d04b82009-05-20 23:21:38 +00002512 // Emit the code (index) for the abbreviation.
Chris Lattner3f53c832010-04-04 18:52:31 +00002513 if (Asm->isVerbose())
Chris Lattner894d75a2010-01-22 23:18:42 +00002514 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2515 Twine::utohexstr(Die->getOffset()) + ":0x" +
2516 Twine::utohexstr(Die->getSize()) + " " +
2517 dwarf::TagString(Abbrev->getTag()));
Chris Lattner7e1a8f82010-04-04 19:09:29 +00002518 Asm->EmitULEB128(AbbrevNumber);
Bill Wendling94d04b82009-05-20 23:21:38 +00002519
Jeffrey Yasskin638fe8d2010-03-22 18:47:14 +00002520 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
Bill Wendling94d04b82009-05-20 23:21:38 +00002521 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2522
2523 // Emit the DIE attribute values.
2524 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2525 unsigned Attr = AbbrevData[i].getAttribute();
2526 unsigned Form = AbbrevData[i].getForm();
2527 assert(Form && "Too many attributes for DIE (check abbreviation)");
2528
Chris Lattner3f53c832010-04-04 18:52:31 +00002529 if (Asm->isVerbose())
Chris Lattnera8013622010-01-24 18:54:17 +00002530 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2531
Bill Wendling94d04b82009-05-20 23:21:38 +00002532 switch (Attr) {
2533 case dwarf::DW_AT_sibling:
Devang Patel2c4ceb12009-11-21 02:48:08 +00002534 Asm->EmitInt32(Die->getSiblingOffset());
Bill Wendling94d04b82009-05-20 23:21:38 +00002535 break;
2536 case dwarf::DW_AT_abstract_origin: {
2537 DIEEntry *E = cast<DIEEntry>(Values[i]);
2538 DIE *Origin = E->getEntry();
Devang Patel53bb5c92009-11-10 23:06:00 +00002539 unsigned Addr = Origin->getOffset();
Bill Wendling94d04b82009-05-20 23:21:38 +00002540 Asm->EmitInt32(Addr);
2541 break;
2542 }
2543 default:
2544 // Emit an attribute using the defined form.
Chris Lattnerd38fee82010-04-05 00:13:49 +00002545 Values[i]->EmitValue(Asm, Form);
Bill Wendling94d04b82009-05-20 23:21:38 +00002546 break;
2547 }
Bill Wendling94d04b82009-05-20 23:21:38 +00002548 }
2549
2550 // Emit the DIE children if any.
2551 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2552 const std::vector<DIE *> &Children = Die->getChildren();
2553
2554 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel2c4ceb12009-11-21 02:48:08 +00002555 emitDIE(Children[j]);
Bill Wendling94d04b82009-05-20 23:21:38 +00002556
Chris Lattner3f53c832010-04-04 18:52:31 +00002557 if (Asm->isVerbose())
Chris Lattner233f52b2010-03-09 23:52:58 +00002558 Asm->OutStreamer.AddComment("End Of Children Mark");
2559 Asm->EmitInt8(0);
Bill Wendling94d04b82009-05-20 23:21:38 +00002560 }
2561}
2562
Devang Patel8a241142009-12-09 18:24:21 +00002563/// emitDebugInfo - Emit the debug info section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002564///
Devang Patel8a241142009-12-09 18:24:21 +00002565void DwarfDebug::emitDebugInfo() {
2566 // Start debug info section.
2567 Asm->OutStreamer.SwitchSection(
2568 Asm->getObjFileLowering().getDwarfInfoSection());
2569 DIE *Die = ModuleCU->getCUDie();
Bill Wendling94d04b82009-05-20 23:21:38 +00002570
2571 // Emit the compile units header.
Chris Lattnerc0215722010-04-04 19:25:43 +00002572 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2573 ModuleCU->getID()));
Bill Wendling94d04b82009-05-20 23:21:38 +00002574
2575 // Emit size of content not including length itself
2576 unsigned ContentSize = Die->getSize() +
2577 sizeof(int16_t) + // DWARF version number
2578 sizeof(int32_t) + // Offset Into Abbrev. Section
2579 sizeof(int8_t) + // Pointer Size (in bytes)
2580 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2581
Chris Lattner233f52b2010-03-09 23:52:58 +00002582 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2583 Asm->EmitInt32(ContentSize);
2584 Asm->OutStreamer.AddComment("DWARF version number");
2585 Asm->EmitInt16(dwarf::DWARF_VERSION);
2586 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
Chris Lattner6189ed12010-04-04 23:25:33 +00002587 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2588 DwarfAbbrevSectionSym);
Chris Lattner233f52b2010-03-09 23:52:58 +00002589 Asm->OutStreamer.AddComment("Address Size (in bytes)");
Chris Lattnerd38fee82010-04-05 00:13:49 +00002590 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Bill Wendling94d04b82009-05-20 23:21:38 +00002591
Devang Patel2c4ceb12009-11-21 02:48:08 +00002592 emitDIE(Die);
Bill Wendling94d04b82009-05-20 23:21:38 +00002593 // FIXME - extra padding for gdb bug.
Chris Lattner233f52b2010-03-09 23:52:58 +00002594 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
2595 Asm->EmitInt8(0);
2596 Asm->EmitInt8(0);
2597 Asm->EmitInt8(0);
2598 Asm->EmitInt8(0);
Chris Lattnerc0215722010-04-04 19:25:43 +00002599 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", ModuleCU->getID()));
Bill Wendling94d04b82009-05-20 23:21:38 +00002600}
2601
Devang Patel2c4ceb12009-11-21 02:48:08 +00002602/// emitAbbreviations - Emit the abbreviation section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002603///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002604void DwarfDebug::emitAbbreviations() const {
Bill Wendling94d04b82009-05-20 23:21:38 +00002605 // Check to see if it is worth the effort.
2606 if (!Abbreviations.empty()) {
2607 // Start the debug abbrev section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002608 Asm->OutStreamer.SwitchSection(
2609 Asm->getObjFileLowering().getDwarfAbbrevSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002610
Chris Lattnerc0215722010-04-04 19:25:43 +00002611 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
Bill Wendling94d04b82009-05-20 23:21:38 +00002612
2613 // For each abbrevation.
2614 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2615 // Get abbreviation data
2616 const DIEAbbrev *Abbrev = Abbreviations[i];
2617
2618 // Emit the abbrevations code (base 1 index.)
Chris Lattner7e1a8f82010-04-04 19:09:29 +00002619 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
Bill Wendling94d04b82009-05-20 23:21:38 +00002620
2621 // Emit the abbreviations data.
Chris Lattnerd38fee82010-04-05 00:13:49 +00002622 Abbrev->Emit(Asm);
Bill Wendling94d04b82009-05-20 23:21:38 +00002623 }
2624
2625 // Mark end of abbreviations.
Chris Lattner7e1a8f82010-04-04 19:09:29 +00002626 Asm->EmitULEB128(0, "EOM(3)");
Bill Wendling94d04b82009-05-20 23:21:38 +00002627
Chris Lattnerc0215722010-04-04 19:25:43 +00002628 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00002629 }
2630}
2631
Devang Patel2c4ceb12009-11-21 02:48:08 +00002632/// emitEndOfLineMatrix - Emit the last address of the section and the end of
Bill Wendling94d04b82009-05-20 23:21:38 +00002633/// the line matrix.
2634///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002635void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling94d04b82009-05-20 23:21:38 +00002636 // Define last address of section.
Chris Lattner233f52b2010-03-09 23:52:58 +00002637 Asm->OutStreamer.AddComment("Extended Op");
2638 Asm->EmitInt8(0);
2639
2640 Asm->OutStreamer.AddComment("Op size");
Chris Lattnerd38fee82010-04-05 00:13:49 +00002641 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner233f52b2010-03-09 23:52:58 +00002642 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2643 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2644
2645 Asm->OutStreamer.AddComment("Section end label");
Chris Lattnerd85fc6e2010-03-10 01:17:49 +00002646
Chris Lattnerc0215722010-04-04 19:25:43 +00002647 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
Chris Lattnerd38fee82010-04-05 00:13:49 +00002648 Asm->getTargetData().getPointerSize(),
2649 0/*AddrSpace*/);
Bill Wendling94d04b82009-05-20 23:21:38 +00002650
2651 // Mark end of matrix.
Chris Lattner233f52b2010-03-09 23:52:58 +00002652 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2653 Asm->EmitInt8(0);
Chris Lattner0ad9c912010-01-22 22:09:00 +00002654 Asm->EmitInt8(1);
Chris Lattner894d75a2010-01-22 23:18:42 +00002655 Asm->EmitInt8(1);
Bill Wendling94d04b82009-05-20 23:21:38 +00002656}
2657
Devang Patel2c4ceb12009-11-21 02:48:08 +00002658/// emitDebugLines - Emit source line information.
Bill Wendling94d04b82009-05-20 23:21:38 +00002659///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002660void DwarfDebug::emitDebugLines() {
Bill Wendling94d04b82009-05-20 23:21:38 +00002661 // If the target is using .loc/.file, the assembler will be emitting the
2662 // .debug_line table automatically.
Chris Lattnerd38fee82010-04-05 00:13:49 +00002663 if (Asm->MAI->hasDotLocAndDotFile())
Bill Wendling94d04b82009-05-20 23:21:38 +00002664 return;
2665
2666 // Minimum line delta, thus ranging from -10..(255-10).
2667 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2668 // Maximum line delta, thus ranging from -10..(255-10).
2669 const int MaxLineDelta = 255 + MinLineDelta;
2670
2671 // Start the dwarf line section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002672 Asm->OutStreamer.SwitchSection(
2673 Asm->getObjFileLowering().getDwarfLineSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002674
2675 // Construct the section header.
Chris Lattner233f52b2010-03-09 23:52:58 +00002676 Asm->OutStreamer.AddComment("Length of Source Line Info");
Chris Lattnera6437182010-04-04 19:58:12 +00002677 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
2678 Asm->GetTempSymbol("line_begin"), 4);
Chris Lattnerc0215722010-04-04 19:25:43 +00002679 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
Bill Wendling94d04b82009-05-20 23:21:38 +00002680
Chris Lattner233f52b2010-03-09 23:52:58 +00002681 Asm->OutStreamer.AddComment("DWARF version number");
2682 Asm->EmitInt16(dwarf::DWARF_VERSION);
Bill Wendling94d04b82009-05-20 23:21:38 +00002683
Chris Lattner233f52b2010-03-09 23:52:58 +00002684 Asm->OutStreamer.AddComment("Prolog Length");
Chris Lattnera6437182010-04-04 19:58:12 +00002685 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
2686 Asm->GetTempSymbol("line_prolog_begin"), 4);
Chris Lattnerc0215722010-04-04 19:25:43 +00002687 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
Bill Wendling94d04b82009-05-20 23:21:38 +00002688
Chris Lattner233f52b2010-03-09 23:52:58 +00002689 Asm->OutStreamer.AddComment("Minimum Instruction Length");
2690 Asm->EmitInt8(1);
2691 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
2692 Asm->EmitInt8(1);
2693 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
2694 Asm->EmitInt8(MinLineDelta);
2695 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
2696 Asm->EmitInt8(MaxLineDelta);
2697 Asm->OutStreamer.AddComment("Special Opcode Base");
2698 Asm->EmitInt8(-MinLineDelta);
Bill Wendling94d04b82009-05-20 23:21:38 +00002699
2700 // Line number standard opcode encodings argument count
Chris Lattner233f52b2010-03-09 23:52:58 +00002701 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
2702 Asm->EmitInt8(0);
2703 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
2704 Asm->EmitInt8(1);
2705 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
2706 Asm->EmitInt8(1);
2707 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
2708 Asm->EmitInt8(1);
2709 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
2710 Asm->EmitInt8(1);
2711 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
2712 Asm->EmitInt8(0);
2713 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
2714 Asm->EmitInt8(0);
2715 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
2716 Asm->EmitInt8(0);
2717 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
2718 Asm->EmitInt8(1);
Bill Wendling94d04b82009-05-20 23:21:38 +00002719
2720 // Emit directories.
2721 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
Chris Lattner4cf202b2010-01-23 03:11:46 +00002722 const std::string &Dir = getSourceDirectoryName(DI);
Chris Lattner3f53c832010-04-04 18:52:31 +00002723 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
Chris Lattner4cf202b2010-01-23 03:11:46 +00002724 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
Bill Wendling94d04b82009-05-20 23:21:38 +00002725 }
2726
Chris Lattner233f52b2010-03-09 23:52:58 +00002727 Asm->OutStreamer.AddComment("End of directories");
2728 Asm->EmitInt8(0);
Bill Wendling94d04b82009-05-20 23:21:38 +00002729
2730 // Emit files.
2731 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2732 // Remember source id starts at 1.
2733 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
Chris Lattner4cf202b2010-01-23 03:11:46 +00002734 const std::string &FN = getSourceFileName(Id.second);
Chris Lattner3f53c832010-04-04 18:52:31 +00002735 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
Chris Lattner4cf202b2010-01-23 03:11:46 +00002736 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2737
Chris Lattner7e1a8f82010-04-04 19:09:29 +00002738 Asm->EmitULEB128(Id.first, "Directory #");
2739 Asm->EmitULEB128(0, "Mod date");
2740 Asm->EmitULEB128(0, "File size");
Bill Wendling94d04b82009-05-20 23:21:38 +00002741 }
2742
Chris Lattner233f52b2010-03-09 23:52:58 +00002743 Asm->OutStreamer.AddComment("End of files");
2744 Asm->EmitInt8(0);
Bill Wendling94d04b82009-05-20 23:21:38 +00002745
Chris Lattnerc0215722010-04-04 19:25:43 +00002746 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00002747
2748 // A sequence for each text section.
2749 unsigned SecSrcLinesSize = SectionSourceLines.size();
2750
2751 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2752 // Isolate current sections line info.
2753 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2754
Bill Wendling94d04b82009-05-20 23:21:38 +00002755 // Dwarf assumes we start with first line of first source file.
2756 unsigned Source = 1;
2757 unsigned Line = 1;
2758
2759 // Construct rows of the address, source, line, column matrix.
2760 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2761 const SrcLineInfo &LineInfo = LineInfos[i];
Chris Lattner25b68c62010-03-14 08:15:55 +00002762 MCSymbol *Label = LineInfo.getLabel();
Chris Lattnerb9130602010-03-14 02:20:58 +00002763 if (!Label->isDefined()) continue; // Not emitted, in dead code.
Bill Wendling94d04b82009-05-20 23:21:38 +00002764
Caroline Ticec6f9d622009-09-11 18:25:54 +00002765 if (LineInfo.getLine() == 0) continue;
2766
Chris Lattner0d9d70f2010-03-09 23:38:23 +00002767 if (Asm->isVerbose()) {
Chris Lattner188a87d2010-03-10 01:04:13 +00002768 std::pair<unsigned, unsigned> SrcID =
Bill Wendling94d04b82009-05-20 23:21:38 +00002769 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
Chris Lattner188a87d2010-03-10 01:04:13 +00002770 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
Chris Lattner49f618a2010-03-10 02:29:31 +00002771 "/" +
2772 Twine(getSourceFileName(SrcID.second)) +
Chris Lattner188a87d2010-03-10 01:04:13 +00002773 ":" + Twine(LineInfo.getLine()));
Bill Wendling94d04b82009-05-20 23:21:38 +00002774 }
2775
2776 // Define the line address.
Chris Lattner233f52b2010-03-09 23:52:58 +00002777 Asm->OutStreamer.AddComment("Extended Op");
2778 Asm->EmitInt8(0);
2779 Asm->OutStreamer.AddComment("Op size");
Chris Lattnerd38fee82010-04-05 00:13:49 +00002780 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner233f52b2010-03-09 23:52:58 +00002781
2782 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2783 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2784
2785 Asm->OutStreamer.AddComment("Location label");
Chris Lattnerd38fee82010-04-05 00:13:49 +00002786 Asm->OutStreamer.EmitSymbolValue(Label,
2787 Asm->getTargetData().getPointerSize(),
Chris Lattnerb9130602010-03-14 02:20:58 +00002788 0/*AddrSpace*/);
Chris Lattnerd85fc6e2010-03-10 01:17:49 +00002789
Bill Wendling94d04b82009-05-20 23:21:38 +00002790 // If change of source, then switch to the new source.
2791 if (Source != LineInfo.getSourceID()) {
2792 Source = LineInfo.getSourceID();
Chris Lattner233f52b2010-03-09 23:52:58 +00002793 Asm->OutStreamer.AddComment("DW_LNS_set_file");
2794 Asm->EmitInt8(dwarf::DW_LNS_set_file);
Chris Lattner7e1a8f82010-04-04 19:09:29 +00002795 Asm->EmitULEB128(Source, "New Source");
Bill Wendling94d04b82009-05-20 23:21:38 +00002796 }
2797
2798 // If change of line.
2799 if (Line != LineInfo.getLine()) {
2800 // Determine offset.
2801 int Offset = LineInfo.getLine() - Line;
2802 int Delta = Offset - MinLineDelta;
2803
2804 // Update line.
2805 Line = LineInfo.getLine();
2806
2807 // If delta is small enough and in range...
2808 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2809 // ... then use fast opcode.
Chris Lattner233f52b2010-03-09 23:52:58 +00002810 Asm->OutStreamer.AddComment("Line Delta");
2811 Asm->EmitInt8(Delta - MinLineDelta);
Bill Wendling94d04b82009-05-20 23:21:38 +00002812 } else {
2813 // ... otherwise use long hand.
Chris Lattner233f52b2010-03-09 23:52:58 +00002814 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
Bill Wendling94d04b82009-05-20 23:21:38 +00002815 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
Chris Lattner7e1a8f82010-04-04 19:09:29 +00002816 Asm->EmitSLEB128(Offset, "Line Offset");
Chris Lattner233f52b2010-03-09 23:52:58 +00002817 Asm->OutStreamer.AddComment("DW_LNS_copy");
2818 Asm->EmitInt8(dwarf::DW_LNS_copy);
Bill Wendling94d04b82009-05-20 23:21:38 +00002819 }
2820 } else {
2821 // Copy the previous row (different address or source)
Chris Lattner233f52b2010-03-09 23:52:58 +00002822 Asm->OutStreamer.AddComment("DW_LNS_copy");
2823 Asm->EmitInt8(dwarf::DW_LNS_copy);
Bill Wendling94d04b82009-05-20 23:21:38 +00002824 }
2825 }
2826
Devang Patel2c4ceb12009-11-21 02:48:08 +00002827 emitEndOfLineMatrix(j + 1);
Bill Wendling94d04b82009-05-20 23:21:38 +00002828 }
2829
2830 if (SecSrcLinesSize == 0)
2831 // Because we're emitting a debug_line section, we still need a line
2832 // table. The linker and friends expect it to exist. If there's nothing to
2833 // put into it, emit an empty table.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002834 emitEndOfLineMatrix(1);
Bill Wendling94d04b82009-05-20 23:21:38 +00002835
Chris Lattnerc0215722010-04-04 19:25:43 +00002836 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00002837}
2838
Devang Patel2c4ceb12009-11-21 02:48:08 +00002839/// emitCommonDebugFrame - Emit common frame info into a debug frame section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002840///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002841void DwarfDebug::emitCommonDebugFrame() {
Chris Lattnerd38fee82010-04-05 00:13:49 +00002842 if (!Asm->MAI->doesDwarfRequireFrameSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00002843 return;
2844
Chris Lattnerd38fee82010-04-05 00:13:49 +00002845 int stackGrowth = Asm->getTargetData().getPointerSize();
2846 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2847 TargetFrameInfo::StackGrowsDown)
2848 stackGrowth *= -1;
Bill Wendling94d04b82009-05-20 23:21:38 +00002849
2850 // Start the dwarf frame section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002851 Asm->OutStreamer.SwitchSection(
2852 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002853
Chris Lattnerc0215722010-04-04 19:25:43 +00002854 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
Chris Lattner233f52b2010-03-09 23:52:58 +00002855 Asm->OutStreamer.AddComment("Length of Common Information Entry");
Chris Lattnera6437182010-04-04 19:58:12 +00002856 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
2857 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
Bill Wendling94d04b82009-05-20 23:21:38 +00002858
Chris Lattnerc0215722010-04-04 19:25:43 +00002859 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
Chris Lattner233f52b2010-03-09 23:52:58 +00002860 Asm->OutStreamer.AddComment("CIE Identifier Tag");
Bill Wendling94d04b82009-05-20 23:21:38 +00002861 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
Chris Lattner233f52b2010-03-09 23:52:58 +00002862 Asm->OutStreamer.AddComment("CIE Version");
Bill Wendling94d04b82009-05-20 23:21:38 +00002863 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
Chris Lattner233f52b2010-03-09 23:52:58 +00002864 Asm->OutStreamer.AddComment("CIE Augmentation");
Chris Lattner4cf202b2010-01-23 03:11:46 +00002865 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
Chris Lattner7e1a8f82010-04-04 19:09:29 +00002866 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
2867 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
Chris Lattner233f52b2010-03-09 23:52:58 +00002868 Asm->OutStreamer.AddComment("CIE RA Column");
Chris Lattnerd38fee82010-04-05 00:13:49 +00002869 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Bill Wendling94d04b82009-05-20 23:21:38 +00002870 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
Bill Wendling94d04b82009-05-20 23:21:38 +00002871
2872 std::vector<MachineMove> Moves;
2873 RI->getInitialFrameState(Moves);
2874
Chris Lattner02b86b92010-04-04 23:41:46 +00002875 Asm->EmitFrameMoves(Moves, 0, false);
Bill Wendling94d04b82009-05-20 23:21:38 +00002876
2877 Asm->EmitAlignment(2, 0, 0, false);
Chris Lattnerc0215722010-04-04 19:25:43 +00002878 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
Bill Wendling94d04b82009-05-20 23:21:38 +00002879}
2880
Devang Patel2c4ceb12009-11-21 02:48:08 +00002881/// emitFunctionDebugFrame - Emit per function frame info into a debug frame
Bill Wendling94d04b82009-05-20 23:21:38 +00002882/// section.
Chris Lattner206d61e2010-03-13 07:26:18 +00002883void DwarfDebug::
2884emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
Chris Lattnerd38fee82010-04-05 00:13:49 +00002885 if (!Asm->MAI->doesDwarfRequireFrameSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00002886 return;
2887
2888 // Start the dwarf frame section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002889 Asm->OutStreamer.SwitchSection(
2890 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002891
Chris Lattner233f52b2010-03-09 23:52:58 +00002892 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
Chris Lattner206d61e2010-03-13 07:26:18 +00002893 MCSymbol *DebugFrameBegin =
Chris Lattnerc0215722010-04-04 19:25:43 +00002894 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
Chris Lattner206d61e2010-03-13 07:26:18 +00002895 MCSymbol *DebugFrameEnd =
Chris Lattnerc0215722010-04-04 19:25:43 +00002896 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
Chris Lattnera6437182010-04-04 19:58:12 +00002897 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
Bill Wendling94d04b82009-05-20 23:21:38 +00002898
Chris Lattner206d61e2010-03-13 07:26:18 +00002899 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
Bill Wendling94d04b82009-05-20 23:21:38 +00002900
Chris Lattner233f52b2010-03-09 23:52:58 +00002901 Asm->OutStreamer.AddComment("FDE CIE offset");
Chris Lattner6189ed12010-04-04 23:25:33 +00002902 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
2903 DwarfFrameSectionSym);
Bill Wendling94d04b82009-05-20 23:21:38 +00002904
Chris Lattner233f52b2010-03-09 23:52:58 +00002905 Asm->OutStreamer.AddComment("FDE initial location");
Chris Lattnerc0215722010-04-04 19:25:43 +00002906 MCSymbol *FuncBeginSym =
2907 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
Chris Lattnerfb658072010-03-13 07:40:56 +00002908 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
Chris Lattnerd38fee82010-04-05 00:13:49 +00002909 Asm->getTargetData().getPointerSize(),
2910 0/*AddrSpace*/);
Chris Lattnerd85fc6e2010-03-10 01:17:49 +00002911
2912
Chris Lattner233f52b2010-03-09 23:52:58 +00002913 Asm->OutStreamer.AddComment("FDE address range");
Chris Lattnera6437182010-04-04 19:58:12 +00002914 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
Chris Lattnerd38fee82010-04-05 00:13:49 +00002915 FuncBeginSym, Asm->getTargetData().getPointerSize());
Bill Wendling94d04b82009-05-20 23:21:38 +00002916
Chris Lattner02b86b92010-04-04 23:41:46 +00002917 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
Bill Wendling94d04b82009-05-20 23:21:38 +00002918
2919 Asm->EmitAlignment(2, 0, 0, false);
Chris Lattner206d61e2010-03-13 07:26:18 +00002920 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
Bill Wendling94d04b82009-05-20 23:21:38 +00002921}
2922
Devang Patel8a241142009-12-09 18:24:21 +00002923/// emitDebugPubNames - Emit visible names into a debug pubnames section.
2924///
2925void DwarfDebug::emitDebugPubNames() {
2926 // Start the dwarf pubnames section.
2927 Asm->OutStreamer.SwitchSection(
2928 Asm->getObjFileLowering().getDwarfPubNamesSection());
2929
Chris Lattner233f52b2010-03-09 23:52:58 +00002930 Asm->OutStreamer.AddComment("Length of Public Names Info");
Chris Lattnera6437182010-04-04 19:58:12 +00002931 Asm->EmitLabelDifference(
2932 Asm->GetTempSymbol("pubnames_end", ModuleCU->getID()),
2933 Asm->GetTempSymbol("pubnames_begin", ModuleCU->getID()), 4);
Bill Wendling94d04b82009-05-20 23:21:38 +00002934
Chris Lattnerc0215722010-04-04 19:25:43 +00002935 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2936 ModuleCU->getID()));
Bill Wendling94d04b82009-05-20 23:21:38 +00002937
Chris Lattner233f52b2010-03-09 23:52:58 +00002938 Asm->OutStreamer.AddComment("DWARF Version");
2939 Asm->EmitInt16(dwarf::DWARF_VERSION);
Bill Wendling94d04b82009-05-20 23:21:38 +00002940
Chris Lattner233f52b2010-03-09 23:52:58 +00002941 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
Chris Lattner6189ed12010-04-04 23:25:33 +00002942 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2943 DwarfInfoSectionSym);
Bill Wendling94d04b82009-05-20 23:21:38 +00002944
Chris Lattner233f52b2010-03-09 23:52:58 +00002945 Asm->OutStreamer.AddComment("Compilation Unit Length");
Chris Lattnera6437182010-04-04 19:58:12 +00002946 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2947 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2948 4);
Bill Wendling94d04b82009-05-20 23:21:38 +00002949
Devang Patel8a241142009-12-09 18:24:21 +00002950 const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
Bill Wendling94d04b82009-05-20 23:21:38 +00002951 for (StringMap<DIE*>::const_iterator
2952 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2953 const char *Name = GI->getKeyData();
Chris Lattner233f52b2010-03-09 23:52:58 +00002954 DIE *Entity = GI->second;
Bill Wendling94d04b82009-05-20 23:21:38 +00002955
Chris Lattner233f52b2010-03-09 23:52:58 +00002956 Asm->OutStreamer.AddComment("DIE offset");
2957 Asm->EmitInt32(Entity->getOffset());
Chris Lattner4cf202b2010-01-23 03:11:46 +00002958
Chris Lattner3f53c832010-04-04 18:52:31 +00002959 if (Asm->isVerbose())
Chris Lattner4cf202b2010-01-23 03:11:46 +00002960 Asm->OutStreamer.AddComment("External Name");
2961 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
Bill Wendling94d04b82009-05-20 23:21:38 +00002962 }
2963
Chris Lattner233f52b2010-03-09 23:52:58 +00002964 Asm->OutStreamer.AddComment("End Mark");
2965 Asm->EmitInt32(0);
Chris Lattnerc0215722010-04-04 19:25:43 +00002966 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2967 ModuleCU->getID()));
Bill Wendling94d04b82009-05-20 23:21:38 +00002968}
2969
Devang Patel193f7202009-11-24 01:14:22 +00002970void DwarfDebug::emitDebugPubTypes() {
Devang Patelf3a03762009-11-24 19:18:41 +00002971 // Start the dwarf pubnames section.
2972 Asm->OutStreamer.SwitchSection(
2973 Asm->getObjFileLowering().getDwarfPubTypesSection());
Chris Lattner233f52b2010-03-09 23:52:58 +00002974 Asm->OutStreamer.AddComment("Length of Public Types Info");
Chris Lattnera6437182010-04-04 19:58:12 +00002975 Asm->EmitLabelDifference(
2976 Asm->GetTempSymbol("pubtypes_end", ModuleCU->getID()),
2977 Asm->GetTempSymbol("pubtypes_begin", ModuleCU->getID()), 4);
Devang Patel193f7202009-11-24 01:14:22 +00002978
Chris Lattnerc0215722010-04-04 19:25:43 +00002979 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2980 ModuleCU->getID()));
Devang Patel193f7202009-11-24 01:14:22 +00002981
Chris Lattner3f53c832010-04-04 18:52:31 +00002982 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
Devang Patele3d6d222010-02-02 03:47:27 +00002983 Asm->EmitInt16(dwarf::DWARF_VERSION);
Devang Patel193f7202009-11-24 01:14:22 +00002984
Chris Lattner233f52b2010-03-09 23:52:58 +00002985 Asm->OutStreamer.AddComment("Offset of Compilation ModuleCU Info");
Chris Lattner6189ed12010-04-04 23:25:33 +00002986 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2987 DwarfInfoSectionSym);
Devang Patel193f7202009-11-24 01:14:22 +00002988
Chris Lattner233f52b2010-03-09 23:52:58 +00002989 Asm->OutStreamer.AddComment("Compilation ModuleCU Length");
Chris Lattnera6437182010-04-04 19:58:12 +00002990 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", ModuleCU->getID()),
2991 Asm->GetTempSymbol("info_begin", ModuleCU->getID()),
2992 4);
Devang Patel193f7202009-11-24 01:14:22 +00002993
2994 const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2995 for (StringMap<DIE*>::const_iterator
2996 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2997 const char *Name = GI->getKeyData();
2998 DIE * Entity = GI->second;
2999
Chris Lattner3f53c832010-04-04 18:52:31 +00003000 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
Devang Patele3d6d222010-02-02 03:47:27 +00003001 Asm->EmitInt32(Entity->getOffset());
Chris Lattner4cf202b2010-01-23 03:11:46 +00003002
Chris Lattner3f53c832010-04-04 18:52:31 +00003003 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
Devang Patel31acb892010-02-02 03:37:03 +00003004 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
Devang Patel193f7202009-11-24 01:14:22 +00003005 }
3006
Chris Lattner233f52b2010-03-09 23:52:58 +00003007 Asm->OutStreamer.AddComment("End Mark");
3008 Asm->EmitInt32(0);
Chris Lattnerc0215722010-04-04 19:25:43 +00003009 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3010 ModuleCU->getID()));
Devang Patel193f7202009-11-24 01:14:22 +00003011}
3012
Devang Patel2c4ceb12009-11-21 02:48:08 +00003013/// emitDebugStr - Emit visible names into a debug str section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003014///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003015void DwarfDebug::emitDebugStr() {
Bill Wendling94d04b82009-05-20 23:21:38 +00003016 // Check to see if it is worth the effort.
Chris Lattner0d9d70f2010-03-09 23:38:23 +00003017 if (StringPool.empty()) return;
3018
3019 // Start the dwarf str section.
3020 Asm->OutStreamer.SwitchSection(
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003021 Asm->getObjFileLowering().getDwarfStrSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003022
Chris Lattnerbc733f52010-03-13 02:17:42 +00003023 // Get all of the string pool entries and put them in an array by their ID so
3024 // we can sort them.
3025 SmallVector<std::pair<unsigned,
3026 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3027
3028 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3029 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3030 Entries.push_back(std::make_pair(I->second.second, &*I));
3031
3032 array_pod_sort(Entries.begin(), Entries.end());
3033
3034 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
Chris Lattner0d9d70f2010-03-09 23:38:23 +00003035 // Emit a label for reference from debug information entries.
Chris Lattnerbc733f52010-03-13 02:17:42 +00003036 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
Chris Lattner0d9d70f2010-03-09 23:38:23 +00003037
3038 // Emit the string itself.
Chris Lattnerbc733f52010-03-13 02:17:42 +00003039 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
Bill Wendling94d04b82009-05-20 23:21:38 +00003040 }
3041}
3042
Devang Patel2c4ceb12009-11-21 02:48:08 +00003043/// emitDebugLoc - Emit visible names into a debug loc section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003044///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003045void DwarfDebug::emitDebugLoc() {
Bill Wendling94d04b82009-05-20 23:21:38 +00003046 // Start the dwarf loc section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003047 Asm->OutStreamer.SwitchSection(
3048 Asm->getObjFileLowering().getDwarfLocSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003049}
3050
3051/// EmitDebugARanges - Emit visible names into a debug aranges section.
3052///
3053void DwarfDebug::EmitDebugARanges() {
3054 // Start the dwarf aranges section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003055 Asm->OutStreamer.SwitchSection(
3056 Asm->getObjFileLowering().getDwarfARangesSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003057}
3058
Devang Patel2c4ceb12009-11-21 02:48:08 +00003059/// emitDebugRanges - Emit visible names into a debug ranges section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003060///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003061void DwarfDebug::emitDebugRanges() {
Bill Wendling94d04b82009-05-20 23:21:38 +00003062 // Start the dwarf ranges section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003063 Asm->OutStreamer.SwitchSection(
3064 Asm->getObjFileLowering().getDwarfRangesSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00003065}
3066
Devang Patel2c4ceb12009-11-21 02:48:08 +00003067/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
Bill Wendling94d04b82009-05-20 23:21:38 +00003068///
Devang Patel2c4ceb12009-11-21 02:48:08 +00003069void DwarfDebug::emitDebugMacInfo() {
Daniel Dunbarf612ff62009-09-19 20:40:05 +00003070 if (const MCSection *LineInfo =
Chris Lattner18a4c162009-08-02 07:24:22 +00003071 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
Bill Wendling94d04b82009-05-20 23:21:38 +00003072 // Start the dwarf macinfo section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003073 Asm->OutStreamer.SwitchSection(LineInfo);
Bill Wendling94d04b82009-05-20 23:21:38 +00003074 }
3075}
3076
Devang Patel2c4ceb12009-11-21 02:48:08 +00003077/// emitDebugInlineInfo - Emit inline info using following format.
Bill Wendling94d04b82009-05-20 23:21:38 +00003078/// Section Header:
3079/// 1. length of section
3080/// 2. Dwarf version number
3081/// 3. address size.
3082///
3083/// Entries (one "entry" for each function that was inlined):
3084///
3085/// 1. offset into __debug_str section for MIPS linkage name, if exists;
3086/// otherwise offset into __debug_str for regular function name.
3087/// 2. offset into __debug_str section for regular function name.
3088/// 3. an unsigned LEB128 number indicating the number of distinct inlining
3089/// instances for the function.
3090///
3091/// The rest of the entry consists of a {die_offset, low_pc} pair for each
3092/// inlined instance; the die_offset points to the inlined_subroutine die in the
3093/// __debug_info section, and the low_pc is the starting address for the
3094/// inlining instance.
Devang Patel2c4ceb12009-11-21 02:48:08 +00003095void DwarfDebug::emitDebugInlineInfo() {
Chris Lattnerd38fee82010-04-05 00:13:49 +00003096 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00003097 return;
3098
Devang Patel1dbc7712009-06-29 20:45:18 +00003099 if (!ModuleCU)
Bill Wendling94d04b82009-05-20 23:21:38 +00003100 return;
3101
Chris Lattner6c2f9e12009-08-19 05:49:37 +00003102 Asm->OutStreamer.SwitchSection(
3103 Asm->getObjFileLowering().getDwarfDebugInlineSection());
Chris Lattner0ad9c912010-01-22 22:09:00 +00003104
Chris Lattner233f52b2010-03-09 23:52:58 +00003105 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
Chris Lattnera6437182010-04-04 19:58:12 +00003106 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3107 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
Bill Wendling94d04b82009-05-20 23:21:38 +00003108
Chris Lattnerc0215722010-04-04 19:25:43 +00003109 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
Bill Wendling94d04b82009-05-20 23:21:38 +00003110
Chris Lattner233f52b2010-03-09 23:52:58 +00003111 Asm->OutStreamer.AddComment("Dwarf Version");
3112 Asm->EmitInt16(dwarf::DWARF_VERSION);
3113 Asm->OutStreamer.AddComment("Address Size (in bytes)");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003114 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Bill Wendling94d04b82009-05-20 23:21:38 +00003115
Devang Patel53bb5c92009-11-10 23:06:00 +00003116 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3117 E = InlinedSPNodes.end(); I != E; ++I) {
Jim Grosbach31ef40e2009-11-21 23:12:12 +00003118
Devang Patel53bb5c92009-11-10 23:06:00 +00003119 MDNode *Node = *I;
Devang Patel622b0262010-01-19 06:19:05 +00003120 DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
Jim Grosbach7ab38df2009-11-22 19:20:36 +00003121 = InlineInfo.find(Node);
Devang Patel53bb5c92009-11-10 23:06:00 +00003122 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
Devang Patele4b27562009-08-28 23:24:31 +00003123 DISubprogram SP(Node);
Devang Patel65dbc902009-11-25 17:36:49 +00003124 StringRef LName = SP.getLinkageName();
3125 StringRef Name = SP.getName();
Bill Wendling94d04b82009-05-20 23:21:38 +00003126
Chris Lattner233f52b2010-03-09 23:52:58 +00003127 Asm->OutStreamer.AddComment("MIPS linkage name");
Chris Lattner4cf202b2010-01-23 03:11:46 +00003128 if (LName.empty()) {
3129 Asm->OutStreamer.EmitBytes(Name, 0);
3130 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3131 } else
Chris Lattner6189ed12010-04-04 23:25:33 +00003132 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3133 DwarfStrSectionSym);
Devang Patel53bb5c92009-11-10 23:06:00 +00003134
Chris Lattner233f52b2010-03-09 23:52:58 +00003135 Asm->OutStreamer.AddComment("Function name");
Chris Lattner6189ed12010-04-04 23:25:33 +00003136 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
Chris Lattner7e1a8f82010-04-04 19:09:29 +00003137 Asm->EmitULEB128(Labels.size(), "Inline count");
Bill Wendling94d04b82009-05-20 23:21:38 +00003138
Devang Patel53bb5c92009-11-10 23:06:00 +00003139 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
Bill Wendling94d04b82009-05-20 23:21:38 +00003140 LE = Labels.end(); LI != LE; ++LI) {
Chris Lattner3f53c832010-04-04 18:52:31 +00003141 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
Chris Lattner6ed0f902010-03-09 00:31:02 +00003142 Asm->EmitInt32(LI->second->getOffset());
Bill Wendling94d04b82009-05-20 23:21:38 +00003143
Chris Lattner3f53c832010-04-04 18:52:31 +00003144 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
Chris Lattnerd38fee82010-04-05 00:13:49 +00003145 Asm->OutStreamer.EmitSymbolValue(LI->first,
3146 Asm->getTargetData().getPointerSize(),0);
Bill Wendling94d04b82009-05-20 23:21:38 +00003147 }
3148 }
3149
Chris Lattnerc0215722010-04-04 19:25:43 +00003150 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
Bill Wendling94d04b82009-05-20 23:21:38 +00003151}