blob: 8d4783be8d3ed8f748b7267b3176a12c7c4d1608 [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//===----------------------------------------------------------------------===//
Devang Patele4b27562009-08-28 23:24:31 +000013#define DEBUG_TYPE "dwarfdebug"
Bill Wendling0310d762009-05-15 09:23:25 +000014#include "DwarfDebug.h"
15#include "llvm/Module.h"
David Greeneb2c66fc2009-08-19 21:52:55 +000016#include "llvm/CodeGen/MachineFunction.h"
Bill Wendling0310d762009-05-15 09:23:25 +000017#include "llvm/CodeGen/MachineModuleInfo.h"
Chris Lattnera87dea42009-07-31 18:48:30 +000018#include "llvm/MC/MCSection.h"
Chris Lattner6c2f9e12009-08-19 05:49:37 +000019#include "llvm/MC/MCStreamer.h"
Chris Lattneraf76e592009-08-22 20:48:53 +000020#include "llvm/MC/MCAsmInfo.h"
Bill Wendling0310d762009-05-15 09:23:25 +000021#include "llvm/Target/TargetData.h"
22#include "llvm/Target/TargetFrameInfo.h"
Chris Lattnerf0144122009-07-28 03:13:23 +000023#include "llvm/Target/TargetLoweringObjectFile.h"
24#include "llvm/Target/TargetRegisterInfo.h"
Chris Lattner23132b12009-08-24 03:52:50 +000025#include "llvm/ADT/StringExtras.h"
Daniel Dunbar6e4bdfc2009-10-13 06:47:08 +000026#include "llvm/Support/Debug.h"
27#include "llvm/Support/ErrorHandling.h"
Chris Lattner334fd1f2009-09-16 00:08:41 +000028#include "llvm/Support/Mangler.h"
Chris Lattnera87dea42009-07-31 18:48:30 +000029#include "llvm/Support/Timer.h"
30#include "llvm/System/Path.h"
Bill Wendling0310d762009-05-15 09:23:25 +000031using namespace llvm;
32
33static TimerGroup &getDwarfTimerGroup() {
34 static TimerGroup DwarfTimerGroup("Dwarf Debugging");
35 return DwarfTimerGroup;
36}
37
38//===----------------------------------------------------------------------===//
39
40/// Configuration values for initial hash set sizes (log2).
41///
Bill Wendling0310d762009-05-15 09:23:25 +000042static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
Bill Wendling0310d762009-05-15 09:23:25 +000043
44namespace llvm {
45
46//===----------------------------------------------------------------------===//
47/// CompileUnit - This dwarf writer support class manages information associate
48/// with a source file.
Nick Lewycky5f9843f2009-11-17 08:11:44 +000049class CompileUnit {
Bill Wendling0310d762009-05-15 09:23:25 +000050 /// ID - File identifier for source.
51 ///
52 unsigned ID;
53
54 /// Die - Compile unit debug information entry.
55 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +000056 DIE *CUDie;
Bill Wendling0310d762009-05-15 09:23:25 +000057
Devang Patel6f01d9c2009-11-21 00:31:03 +000058 /// IndexTyDie - An anonymous type for index type.
59 DIE *IndexTyDie;
60
Bill Wendling0310d762009-05-15 09:23:25 +000061 /// GVToDieMap - Tracks the mapping of unit level debug informaton
62 /// variables to debug information entries.
Devang Patele4b27562009-08-28 23:24:31 +000063 /// FIXME : Rename GVToDieMap -> NodeToDieMap
Devang Patel017d1212009-11-20 21:37:22 +000064 ValueMap<MDNode *, DIE *> GVToDieMap;
Bill Wendling0310d762009-05-15 09:23:25 +000065
66 /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
67 /// descriptors to debug information entries using a DIEEntry proxy.
Devang Patele4b27562009-08-28 23:24:31 +000068 /// FIXME : Rename
Devang Patel017d1212009-11-20 21:37:22 +000069 ValueMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
Bill Wendling0310d762009-05-15 09:23:25 +000070
71 /// Globals - A map of globally visible named entities for this unit.
72 ///
73 StringMap<DIE*> Globals;
74
Bill Wendling0310d762009-05-15 09:23:25 +000075public:
76 CompileUnit(unsigned I, DIE *D)
Devang Patel2c4ceb12009-11-21 02:48:08 +000077 : ID(I), CUDie(D), IndexTyDie(0) {}
78 ~CompileUnit() { delete CUDie; delete IndexTyDie; }
Bill Wendling0310d762009-05-15 09:23:25 +000079
80 // Accessors.
Bill Wendling39dd6962009-05-20 23:31:45 +000081 unsigned getID() const { return ID; }
Devang Patel2c4ceb12009-11-21 02:48:08 +000082 DIE* getCUDie() const { return CUDie; }
Bill Wendling0310d762009-05-15 09:23:25 +000083 StringMap<DIE*> &getGlobals() { return Globals; }
84
85 /// hasContent - Return true if this compile unit has something to write out.
86 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +000087 bool hasContent() const { return !CUDie->getChildren().empty(); }
Bill Wendling0310d762009-05-15 09:23:25 +000088
Devang Patel2c4ceb12009-11-21 02:48:08 +000089 /// addGlobal - Add a new global entity to the compile unit.
Bill Wendling0310d762009-05-15 09:23:25 +000090 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +000091 void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
Bill Wendling0310d762009-05-15 09:23:25 +000092
Devang Patel017d1212009-11-20 21:37:22 +000093 /// getDIE - Returns the debug information entry map slot for the
Bill Wendling0310d762009-05-15 09:23:25 +000094 /// specified debug variable.
Devang Patel017d1212009-11-20 21:37:22 +000095 DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
Jim Grosbach31ef40e2009-11-21 23:12:12 +000096
Devang Patel017d1212009-11-20 21:37:22 +000097 /// insertDIE - Insert DIE into the map.
98 void insertDIE(MDNode *N, DIE *D) {
99 GVToDieMap.insert(std::make_pair(N, D));
100 }
Bill Wendling0310d762009-05-15 09:23:25 +0000101
Devang Patel017d1212009-11-20 21:37:22 +0000102 /// getDIEEntry - Returns the debug information entry for the speciefied
103 /// debug variable.
104 DIEEntry *getDIEEntry(MDNode *N) { return GVToDIEEntryMap.lookup(N); }
105
106 /// insertDIEEntry - Insert debug information entry into the map.
107 void insertDIEEntry(MDNode *N, DIEEntry *E) {
108 GVToDIEEntryMap.insert(std::make_pair(N, E));
Bill Wendling0310d762009-05-15 09:23:25 +0000109 }
110
Devang Patel2c4ceb12009-11-21 02:48:08 +0000111 /// addDie - Adds or interns the DIE to the compile unit.
Bill Wendling0310d762009-05-15 09:23:25 +0000112 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000113 void addDie(DIE *Buffer) {
114 this->CUDie->addChild(Buffer);
Bill Wendling0310d762009-05-15 09:23:25 +0000115 }
Devang Patel6f01d9c2009-11-21 00:31:03 +0000116
117 // getIndexTyDie - Get an anonymous type for index type.
118 DIE *getIndexTyDie() {
119 return IndexTyDie;
120 }
121
Jim Grosbach7ab38df2009-11-22 19:20:36 +0000122 // setIndexTyDie - Set D as anonymous type for index which can be reused
123 // later.
Devang Patel6f01d9c2009-11-21 00:31:03 +0000124 void setIndexTyDie(DIE *D) {
125 IndexTyDie = D;
126 }
127
Bill Wendling0310d762009-05-15 09:23:25 +0000128};
129
130//===----------------------------------------------------------------------===//
131/// DbgVariable - This class is used to track local variable information.
132///
Devang Patelf76a3d62009-11-16 21:53:40 +0000133class DbgVariable {
Bill Wendling0310d762009-05-15 09:23:25 +0000134 DIVariable Var; // Variable Descriptor.
135 unsigned FrameIndex; // Variable frame index.
Devang Patel53bb5c92009-11-10 23:06:00 +0000136 DbgVariable *AbstractVar; // Abstract variable for this variable.
137 DIE *TheDIE;
Bill Wendling0310d762009-05-15 09:23:25 +0000138public:
Devang Patel53bb5c92009-11-10 23:06:00 +0000139 DbgVariable(DIVariable V, unsigned I)
140 : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0) {}
Bill Wendling0310d762009-05-15 09:23:25 +0000141
142 // Accessors.
Devang Patel53bb5c92009-11-10 23:06:00 +0000143 DIVariable getVariable() const { return Var; }
144 unsigned getFrameIndex() const { return FrameIndex; }
145 void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
146 DbgVariable *getAbstractVariable() const { return AbstractVar; }
147 void setDIE(DIE *D) { TheDIE = D; }
148 DIE *getDIE() const { return TheDIE; }
Bill Wendling0310d762009-05-15 09:23:25 +0000149};
150
151//===----------------------------------------------------------------------===//
152/// DbgScope - This class is used to track scope information.
153///
Devang Patelf76a3d62009-11-16 21:53:40 +0000154class DbgScope {
Bill Wendling0310d762009-05-15 09:23:25 +0000155 DbgScope *Parent; // Parent to this scope.
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000156 DIDescriptor Desc; // Debug info descriptor for scope.
Devang Patel53bb5c92009-11-10 23:06:00 +0000157 WeakVH InlinedAtLocation; // Location at which scope is inlined.
158 bool AbstractScope; // Abstract Scope
Bill Wendling0310d762009-05-15 09:23:25 +0000159 unsigned StartLabelID; // Label ID of the beginning of scope.
160 unsigned EndLabelID; // Label ID of the end of scope.
Devang Pateld38dd112009-10-01 18:25:23 +0000161 const MachineInstr *LastInsn; // Last instruction of this scope.
162 const MachineInstr *FirstInsn; // First instruction of this scope.
Bill Wendling0310d762009-05-15 09:23:25 +0000163 SmallVector<DbgScope *, 4> Scopes; // Scopes defined in scope.
164 SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000165
Owen Anderson04c05f72009-06-24 22:53:20 +0000166 // Private state for dump()
167 mutable unsigned IndentLevel;
Bill Wendling0310d762009-05-15 09:23:25 +0000168public:
Devang Patelc90aefe2009-10-14 21:08:09 +0000169 DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
Devang Patel53bb5c92009-11-10 23:06:00 +0000170 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000171 StartLabelID(0), EndLabelID(0),
Devang Patelc90aefe2009-10-14 21:08:09 +0000172 LastInsn(0), FirstInsn(0), IndentLevel(0) {}
Bill Wendling0310d762009-05-15 09:23:25 +0000173 virtual ~DbgScope();
174
175 // Accessors.
176 DbgScope *getParent() const { return Parent; }
Devang Patel53bb5c92009-11-10 23:06:00 +0000177 void setParent(DbgScope *P) { Parent = P; }
Bill Wendling0310d762009-05-15 09:23:25 +0000178 DIDescriptor getDesc() const { return Desc; }
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000179 MDNode *getInlinedAt() const {
Devang Patel53bb5c92009-11-10 23:06:00 +0000180 return dyn_cast_or_null<MDNode>(InlinedAtLocation);
Devang Patelc90aefe2009-10-14 21:08:09 +0000181 }
Devang Patel53bb5c92009-11-10 23:06:00 +0000182 MDNode *getScopeNode() const { return Desc.getNode(); }
Bill Wendling0310d762009-05-15 09:23:25 +0000183 unsigned getStartLabelID() const { return StartLabelID; }
184 unsigned getEndLabelID() const { return EndLabelID; }
185 SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
186 SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
Bill Wendling0310d762009-05-15 09:23:25 +0000187 void setStartLabelID(unsigned S) { StartLabelID = S; }
188 void setEndLabelID(unsigned E) { EndLabelID = E; }
Devang Pateld38dd112009-10-01 18:25:23 +0000189 void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
190 const MachineInstr *getLastInsn() { return LastInsn; }
191 void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
Devang Patel53bb5c92009-11-10 23:06:00 +0000192 void setAbstractScope() { AbstractScope = true; }
193 bool isAbstractScope() const { return AbstractScope; }
Devang Pateld38dd112009-10-01 18:25:23 +0000194 const MachineInstr *getFirstInsn() { return FirstInsn; }
Devang Patel53bb5c92009-11-10 23:06:00 +0000195
Devang Patel2c4ceb12009-11-21 02:48:08 +0000196 /// addScope - Add a scope to the scope.
Bill Wendling0310d762009-05-15 09:23:25 +0000197 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000198 void addScope(DbgScope *S) { Scopes.push_back(S); }
Bill Wendling0310d762009-05-15 09:23:25 +0000199
Devang Patel2c4ceb12009-11-21 02:48:08 +0000200 /// addVariable - Add a variable to the scope.
Bill Wendling0310d762009-05-15 09:23:25 +0000201 ///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000202 void addVariable(DbgVariable *V) { Variables.push_back(V); }
Bill Wendling0310d762009-05-15 09:23:25 +0000203
Devang Patel2c4ceb12009-11-21 02:48:08 +0000204 void fixInstructionMarkers() {
Devang Patelaf9e8472009-10-01 20:31:14 +0000205 assert (getFirstInsn() && "First instruction is missing!");
206 if (getLastInsn())
207 return;
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000208
Devang Patelaf9e8472009-10-01 20:31:14 +0000209 // If a scope does not have an instruction to mark an end then use
210 // the end of last child scope.
211 SmallVector<DbgScope *, 4> &Scopes = getScopes();
212 assert (!Scopes.empty() && "Inner most scope does not have last insn!");
213 DbgScope *L = Scopes.back();
214 if (!L->getLastInsn())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000215 L->fixInstructionMarkers();
Devang Patelaf9e8472009-10-01 20:31:14 +0000216 setLastInsn(L->getLastInsn());
217 }
218
Bill Wendling0310d762009-05-15 09:23:25 +0000219#ifndef NDEBUG
220 void dump() const;
221#endif
222};
223
224#ifndef NDEBUG
225void DbgScope::dump() const {
Chris Lattnerc281de12009-08-23 00:51:00 +0000226 raw_ostream &err = errs();
227 err.indent(IndentLevel);
Devang Patel53bb5c92009-11-10 23:06:00 +0000228 MDNode *N = Desc.getNode();
229 N->dump();
Chris Lattnerc281de12009-08-23 00:51:00 +0000230 err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
Devang Patel53bb5c92009-11-10 23:06:00 +0000231 if (AbstractScope)
232 err << "Abstract Scope\n";
Bill Wendling0310d762009-05-15 09:23:25 +0000233
234 IndentLevel += 2;
Devang Patel53bb5c92009-11-10 23:06:00 +0000235 if (!Scopes.empty())
236 err << "Children ...\n";
Bill Wendling0310d762009-05-15 09:23:25 +0000237 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
238 if (Scopes[i] != this)
239 Scopes[i]->dump();
240
241 IndentLevel -= 2;
242}
243#endif
244
Bill Wendling0310d762009-05-15 09:23:25 +0000245DbgScope::~DbgScope() {
246 for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
247 delete Scopes[i];
248 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
249 delete Variables[j];
Bill Wendling0310d762009-05-15 09:23:25 +0000250}
251
252} // end llvm namespace
253
Chris Lattneraf76e592009-08-22 20:48:53 +0000254DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
Devang Patel1dbc7712009-06-29 20:45:18 +0000255 : Dwarf(OS, A, T, "dbg"), ModuleCU(0),
Bill Wendling0310d762009-05-15 09:23:25 +0000256 AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
Devang Patel2c4ceb12009-11-21 02:48:08 +0000257 DIEValues(), StringPool(),
Bill Wendling0310d762009-05-15 09:23:25 +0000258 SectionSourceLines(), didInitial(false), shouldEmit(false),
Devang Patel53bb5c92009-11-10 23:06:00 +0000259 CurrentFnDbgScope(0), DebugTimer(0) {
Bill Wendling0310d762009-05-15 09:23:25 +0000260 if (TimePassesIsEnabled)
261 DebugTimer = new Timer("Dwarf Debug Writer",
262 getDwarfTimerGroup());
263}
264DwarfDebug::~DwarfDebug() {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000265 for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
266 delete DIEValues[j];
Bill Wendling0310d762009-05-15 09:23:25 +0000267
Bill Wendling0310d762009-05-15 09:23:25 +0000268 delete DebugTimer;
269}
270
Devang Patel2c4ceb12009-11-21 02:48:08 +0000271/// assignAbbrevNumber - Define a unique number for the abbreviation.
Bill Wendling0310d762009-05-15 09:23:25 +0000272///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000273void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
Bill Wendling0310d762009-05-15 09:23:25 +0000274 // Profile the node so that we can make it unique.
275 FoldingSetNodeID ID;
276 Abbrev.Profile(ID);
277
278 // Check the set for priors.
279 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
280
281 // If it's newly added.
282 if (InSet == &Abbrev) {
283 // Add to abbreviation list.
284 Abbreviations.push_back(&Abbrev);
285
286 // Assign the vector position + 1 as its number.
287 Abbrev.setNumber(Abbreviations.size());
288 } else {
289 // Assign existing abbreviation number.
290 Abbrev.setNumber(InSet->getNumber());
291 }
292}
293
Devang Patel2c4ceb12009-11-21 02:48:08 +0000294/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
Bill Wendling995f80a2009-05-20 23:24:48 +0000295/// information entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000296DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
Devang Patel6f01d9c2009-11-21 00:31:03 +0000297 DIEEntry *Value = new DIEEntry(Entry);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000298 DIEValues.push_back(Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000299 return Value;
300}
301
Devang Patel2c4ceb12009-11-21 02:48:08 +0000302/// addUInt - Add an unsigned integer attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000303///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000304void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
Bill Wendling0310d762009-05-15 09:23:25 +0000305 unsigned Form, uint64_t Integer) {
306 if (!Form) Form = DIEInteger::BestForm(false, Integer);
Devang Patel6f01d9c2009-11-21 00:31:03 +0000307 DIEValue *Value = new DIEInteger(Integer);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000308 DIEValues.push_back(Value);
309 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000310}
311
Devang Patel2c4ceb12009-11-21 02:48:08 +0000312/// addSInt - Add an signed integer attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000313///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000314void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
Bill Wendling0310d762009-05-15 09:23:25 +0000315 unsigned Form, int64_t Integer) {
316 if (!Form) Form = DIEInteger::BestForm(true, Integer);
Devang Patel6f01d9c2009-11-21 00:31:03 +0000317 DIEValue *Value = new DIEInteger(Integer);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000318 DIEValues.push_back(Value);
319 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000320}
321
Devang Patel2c4ceb12009-11-21 02:48:08 +0000322/// addString - Add a string attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000323///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000324void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
Bill Wendling0310d762009-05-15 09:23:25 +0000325 const std::string &String) {
Devang Patel6f01d9c2009-11-21 00:31:03 +0000326 DIEValue *Value = new DIEString(String);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000327 DIEValues.push_back(Value);
328 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000329}
330
Devang Patel2c4ceb12009-11-21 02:48:08 +0000331/// addLabel - Add a Dwarf label attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000332///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000333void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
Bill Wendling0310d762009-05-15 09:23:25 +0000334 const DWLabel &Label) {
Devang Patel6f01d9c2009-11-21 00:31:03 +0000335 DIEValue *Value = new DIEDwarfLabel(Label);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000336 DIEValues.push_back(Value);
337 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000338}
339
Devang Patel2c4ceb12009-11-21 02:48:08 +0000340/// addObjectLabel - Add an non-Dwarf label attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000341///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000342void DwarfDebug::addObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
Bill Wendling0310d762009-05-15 09:23:25 +0000343 const std::string &Label) {
Devang Patel6f01d9c2009-11-21 00:31:03 +0000344 DIEValue *Value = new DIEObjectLabel(Label);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000345 DIEValues.push_back(Value);
346 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000347}
348
Devang Patel2c4ceb12009-11-21 02:48:08 +0000349/// addSectionOffset - Add a section offset label attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000350///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000351void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
Bill Wendling0310d762009-05-15 09:23:25 +0000352 const DWLabel &Label, const DWLabel &Section,
353 bool isEH, bool useSet) {
Devang Patel6f01d9c2009-11-21 00:31:03 +0000354 DIEValue *Value = new DIESectionOffset(Label, Section, isEH, useSet);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000355 DIEValues.push_back(Value);
356 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000357}
358
Devang Patel2c4ceb12009-11-21 02:48:08 +0000359/// addDelta - Add a label delta attribute data and value.
Bill Wendling0310d762009-05-15 09:23:25 +0000360///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000361void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
Bill Wendling0310d762009-05-15 09:23:25 +0000362 const DWLabel &Hi, const DWLabel &Lo) {
Devang Patel6f01d9c2009-11-21 00:31:03 +0000363 DIEValue *Value = new DIEDelta(Hi, Lo);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000364 DIEValues.push_back(Value);
365 Die->addValue(Attribute, Form, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000366}
367
Devang Patel2c4ceb12009-11-21 02:48:08 +0000368/// addBlock - Add block data.
Bill Wendling0310d762009-05-15 09:23:25 +0000369///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000370void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
Bill Wendling0310d762009-05-15 09:23:25 +0000371 DIEBlock *Block) {
372 Block->ComputeSize(TD);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000373 DIEValues.push_back(Block);
374 Die->addValue(Attribute, Block->BestForm(), Block);
Bill Wendling0310d762009-05-15 09:23:25 +0000375}
376
Devang Patel2c4ceb12009-11-21 02:48:08 +0000377/// addSourceLine - Add location information to specified debug information
Bill Wendling0310d762009-05-15 09:23:25 +0000378/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000379void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
Bill Wendling0310d762009-05-15 09:23:25 +0000380 // If there is no compile unit specified, don't add a line #.
381 if (V->getCompileUnit().isNull())
382 return;
383
384 unsigned Line = V->getLineNumber();
Devang Patel2c4ceb12009-11-21 02:48:08 +0000385 unsigned FileID = findCompileUnit(V->getCompileUnit()).getID();
Bill Wendling0310d762009-05-15 09:23:25 +0000386 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000387 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
388 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling0310d762009-05-15 09:23:25 +0000389}
390
Devang Patel2c4ceb12009-11-21 02:48:08 +0000391/// addSourceLine - Add location information to specified debug information
Bill Wendling0310d762009-05-15 09:23:25 +0000392/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000393void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
Bill Wendling0310d762009-05-15 09:23:25 +0000394 // If there is no compile unit specified, don't add a line #.
395 if (G->getCompileUnit().isNull())
396 return;
397
398 unsigned Line = G->getLineNumber();
Devang Patel2c4ceb12009-11-21 02:48:08 +0000399 unsigned FileID = findCompileUnit(G->getCompileUnit()).getID();
Bill Wendling0310d762009-05-15 09:23:25 +0000400 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000401 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
402 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling0310d762009-05-15 09:23:25 +0000403}
Devang Patel82dfc0c2009-08-31 22:47:13 +0000404
Devang Patel2c4ceb12009-11-21 02:48:08 +0000405/// addSourceLine - Add location information to specified debug information
Devang Patel82dfc0c2009-08-31 22:47:13 +0000406/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000407void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
Devang Patel82dfc0c2009-08-31 22:47:13 +0000408 // If there is no compile unit specified, don't add a line #.
409 if (SP->getCompileUnit().isNull())
410 return;
Caroline Ticec6f9d622009-09-11 18:25:54 +0000411 // If the line number is 0, don't add it.
412 if (SP->getLineNumber() == 0)
413 return;
414
Devang Patel82dfc0c2009-08-31 22:47:13 +0000415
416 unsigned Line = SP->getLineNumber();
Devang Patel2c4ceb12009-11-21 02:48:08 +0000417 unsigned FileID = findCompileUnit(SP->getCompileUnit()).getID();
Devang Patel82dfc0c2009-08-31 22:47:13 +0000418 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000419 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
420 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Devang Patel82dfc0c2009-08-31 22:47:13 +0000421}
422
Devang Patel2c4ceb12009-11-21 02:48:08 +0000423/// addSourceLine - Add location information to specified debug information
Devang Patel82dfc0c2009-08-31 22:47:13 +0000424/// entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000425void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
Bill Wendling0310d762009-05-15 09:23:25 +0000426 // If there is no compile unit specified, don't add a line #.
427 DICompileUnit CU = Ty->getCompileUnit();
428 if (CU.isNull())
429 return;
430
431 unsigned Line = Ty->getLineNumber();
Devang Patel2c4ceb12009-11-21 02:48:08 +0000432 unsigned FileID = findCompileUnit(CU).getID();
Bill Wendling0310d762009-05-15 09:23:25 +0000433 assert(FileID && "Invalid file id");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000434 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
435 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling0310d762009-05-15 09:23:25 +0000436}
437
Caroline Ticedc8f6042009-08-31 21:19:37 +0000438/* Byref variables, in Blocks, are declared by the programmer as
439 "SomeType VarName;", but the compiler creates a
440 __Block_byref_x_VarName struct, and gives the variable VarName
441 either the struct, or a pointer to the struct, as its type. This
442 is necessary for various behind-the-scenes things the compiler
443 needs to do with by-reference variables in blocks.
444
445 However, as far as the original *programmer* is concerned, the
446 variable should still have type 'SomeType', as originally declared.
447
448 The following function dives into the __Block_byref_x_VarName
449 struct to find the original type of the variable. This will be
450 passed back to the code generating the type for the Debug
451 Information Entry for the variable 'VarName'. 'VarName' will then
452 have the original type 'SomeType' in its debug information.
453
454 The original type 'SomeType' will be the type of the field named
455 'VarName' inside the __Block_byref_x_VarName struct.
456
457 NOTE: In order for this to not completely fail on the debugger
458 side, the Debug Information Entry for the variable VarName needs to
459 have a DW_AT_location that tells the debugger how to unwind through
460 the pointers and __Block_byref_x_VarName struct to find the actual
Devang Patel2c4ceb12009-11-21 02:48:08 +0000461 value of the variable. The function addBlockByrefType does this. */
Caroline Ticedc8f6042009-08-31 21:19:37 +0000462
463/// Find the type the programmer originally declared the variable to be
464/// and return that type.
465///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000466DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
Caroline Ticedc8f6042009-08-31 21:19:37 +0000467
468 DIType subType = Ty;
469 unsigned tag = Ty.getTag();
470
471 if (tag == dwarf::DW_TAG_pointer_type) {
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000472 DIDerivedType DTy = DIDerivedType(Ty.getNode());
Caroline Ticedc8f6042009-08-31 21:19:37 +0000473 subType = DTy.getTypeDerivedFrom();
474 }
475
476 DICompositeType blockStruct = DICompositeType(subType.getNode());
477
478 DIArray Elements = blockStruct.getTypeArray();
479
480 if (Elements.isNull())
481 return Ty;
482
483 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
484 DIDescriptor Element = Elements.getElement(i);
485 DIDerivedType DT = DIDerivedType(Element.getNode());
Devang Patel5ccdd102009-09-29 18:40:58 +0000486 if (strcmp(Name.c_str(), DT.getName()) == 0)
Caroline Ticedc8f6042009-08-31 21:19:37 +0000487 return (DT.getTypeDerivedFrom());
488 }
489
490 return Ty;
491}
492
Devang Patel2c4ceb12009-11-21 02:48:08 +0000493/// addComplexAddress - Start with the address based on the location provided,
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000494/// and generate the DWARF information necessary to find the actual variable
495/// given the extra address information encoded in the DIVariable, starting from
496/// the starting location. Add the DWARF information to the die.
497///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000498void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000499 unsigned Attribute,
500 const MachineLocation &Location) {
501 const DIVariable &VD = DV->getVariable();
502 DIType Ty = VD.getType();
503
504 // Decode the original location, and use that as the start of the byref
505 // variable's location.
506 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
507 DIEBlock *Block = new DIEBlock();
508
509 if (Location.isReg()) {
510 if (Reg < 32) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000511 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000512 } else {
513 Reg = Reg - dwarf::DW_OP_reg0;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000514 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
515 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000516 }
517 } else {
518 if (Reg < 32)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000519 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000520 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000521 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
522 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000523 }
524
Devang Patel2c4ceb12009-11-21 02:48:08 +0000525 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000526 }
527
528 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
529 uint64_t Element = VD.getAddrElement(i);
530
531 if (Element == DIFactory::OpPlus) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000532 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
533 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000534 } else if (Element == DIFactory::OpDeref) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000535 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000536 } else llvm_unreachable("unknown DIFactory Opcode");
537 }
538
539 // Now attach the location information to the DIE.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000540 addBlock(Die, Attribute, 0, Block);
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000541}
542
Caroline Ticedc8f6042009-08-31 21:19:37 +0000543/* Byref variables, in Blocks, are declared by the programmer as "SomeType
544 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
545 gives the variable VarName either the struct, or a pointer to the struct, as
546 its type. This is necessary for various behind-the-scenes things the
547 compiler needs to do with by-reference variables in Blocks.
548
549 However, as far as the original *programmer* is concerned, the variable
550 should still have type 'SomeType', as originally declared.
551
Devang Patel2c4ceb12009-11-21 02:48:08 +0000552 The function getBlockByrefType dives into the __Block_byref_x_VarName
Caroline Ticedc8f6042009-08-31 21:19:37 +0000553 struct to find the original type of the variable, which is then assigned to
554 the variable's Debug Information Entry as its real type. So far, so good.
555 However now the debugger will expect the variable VarName to have the type
556 SomeType. So we need the location attribute for the variable to be an
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000557 expression that explains to the debugger how to navigate through the
Caroline Ticedc8f6042009-08-31 21:19:37 +0000558 pointers and struct to find the actual variable of type SomeType.
559
560 The following function does just that. We start by getting
561 the "normal" location for the variable. This will be the location
562 of either the struct __Block_byref_x_VarName or the pointer to the
563 struct __Block_byref_x_VarName.
564
565 The struct will look something like:
566
567 struct __Block_byref_x_VarName {
568 ... <various fields>
569 struct __Block_byref_x_VarName *forwarding;
570 ... <various other fields>
571 SomeType VarName;
572 ... <maybe more fields>
573 };
574
575 If we are given the struct directly (as our starting point) we
576 need to tell the debugger to:
577
578 1). Add the offset of the forwarding field.
579
580 2). Follow that pointer to get the the real __Block_byref_x_VarName
581 struct to use (the real one may have been copied onto the heap).
582
583 3). Add the offset for the field VarName, to find the actual variable.
584
585 If we started with a pointer to the struct, then we need to
586 dereference that pointer first, before the other steps.
587 Translating this into DWARF ops, we will need to append the following
588 to the current location description for the variable:
589
590 DW_OP_deref -- optional, if we start with a pointer
591 DW_OP_plus_uconst <forward_fld_offset>
592 DW_OP_deref
593 DW_OP_plus_uconst <varName_fld_offset>
594
595 That is what this function does. */
596
Devang Patel2c4ceb12009-11-21 02:48:08 +0000597/// addBlockByrefAddress - Start with the address based on the location
Caroline Ticedc8f6042009-08-31 21:19:37 +0000598/// provided, and generate the DWARF information necessary to find the
599/// actual Block variable (navigating the Block struct) based on the
600/// starting location. Add the DWARF information to the die. For
601/// more information, read large comment just above here.
602///
Devang Patel2c4ceb12009-11-21 02:48:08 +0000603void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
Daniel Dunbar00564992009-09-19 20:40:14 +0000604 unsigned Attribute,
605 const MachineLocation &Location) {
Caroline Ticedc8f6042009-08-31 21:19:37 +0000606 const DIVariable &VD = DV->getVariable();
607 DIType Ty = VD.getType();
608 DIType TmpTy = Ty;
609 unsigned Tag = Ty.getTag();
610 bool isPointer = false;
611
Devang Patel5ccdd102009-09-29 18:40:58 +0000612 const char *varName = VD.getName();
Caroline Ticedc8f6042009-08-31 21:19:37 +0000613
614 if (Tag == dwarf::DW_TAG_pointer_type) {
Mike Stump3e4c9bd2009-09-30 00:08:22 +0000615 DIDerivedType DTy = DIDerivedType(Ty.getNode());
Caroline Ticedc8f6042009-08-31 21:19:37 +0000616 TmpTy = DTy.getTypeDerivedFrom();
617 isPointer = true;
618 }
619
620 DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
621
Daniel Dunbar00564992009-09-19 20:40:14 +0000622 // Find the __forwarding field and the variable field in the __Block_byref
623 // struct.
Daniel Dunbar00564992009-09-19 20:40:14 +0000624 DIArray Fields = blockStruct.getTypeArray();
625 DIDescriptor varField = DIDescriptor();
626 DIDescriptor forwardingField = DIDescriptor();
Caroline Ticedc8f6042009-08-31 21:19:37 +0000627
628
Daniel Dunbar00564992009-09-19 20:40:14 +0000629 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
630 DIDescriptor Element = Fields.getElement(i);
631 DIDerivedType DT = DIDerivedType(Element.getNode());
Devang Patel5ccdd102009-09-29 18:40:58 +0000632 const char *fieldName = DT.getName();
633 if (strcmp(fieldName, "__forwarding") == 0)
Daniel Dunbar00564992009-09-19 20:40:14 +0000634 forwardingField = Element;
Devang Patel5ccdd102009-09-29 18:40:58 +0000635 else if (strcmp(fieldName, varName) == 0)
Daniel Dunbar00564992009-09-19 20:40:14 +0000636 varField = Element;
637 }
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000638
Mike Stump7e3720d2009-09-24 23:21:26 +0000639 assert(!varField.isNull() && "Can't find byref variable in Block struct");
640 assert(!forwardingField.isNull()
641 && "Can't find forwarding field in Block struct");
Caroline Ticedc8f6042009-08-31 21:19:37 +0000642
Daniel Dunbar00564992009-09-19 20:40:14 +0000643 // Get the offsets for the forwarding field and the variable field.
Daniel Dunbar00564992009-09-19 20:40:14 +0000644 unsigned int forwardingFieldOffset =
645 DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
646 unsigned int varFieldOffset =
647 DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
Caroline Ticedc8f6042009-08-31 21:19:37 +0000648
Mike Stump7e3720d2009-09-24 23:21:26 +0000649 // Decode the original location, and use that as the start of the byref
650 // variable's location.
Daniel Dunbar00564992009-09-19 20:40:14 +0000651 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
652 DIEBlock *Block = new DIEBlock();
Caroline Ticedc8f6042009-08-31 21:19:37 +0000653
Daniel Dunbar00564992009-09-19 20:40:14 +0000654 if (Location.isReg()) {
655 if (Reg < 32)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000656 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000657 else {
658 Reg = Reg - dwarf::DW_OP_reg0;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000659 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
660 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000661 }
662 } else {
663 if (Reg < 32)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000664 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000665 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000666 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
667 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Daniel Dunbar00564992009-09-19 20:40:14 +0000668 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000669
Devang Patel2c4ceb12009-11-21 02:48:08 +0000670 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Daniel Dunbar00564992009-09-19 20:40:14 +0000671 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000672
Mike Stump7e3720d2009-09-24 23:21:26 +0000673 // If we started with a pointer to the __Block_byref... struct, then
Daniel Dunbar00564992009-09-19 20:40:14 +0000674 // the first thing we need to do is dereference the pointer (DW_OP_deref).
Daniel Dunbar00564992009-09-19 20:40:14 +0000675 if (isPointer)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000676 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000677
Daniel Dunbar00564992009-09-19 20:40:14 +0000678 // Next add the offset for the '__forwarding' field:
679 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
680 // adding the offset if it's 0.
Daniel Dunbar00564992009-09-19 20:40:14 +0000681 if (forwardingFieldOffset > 0) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000682 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
683 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
Daniel Dunbar00564992009-09-19 20:40:14 +0000684 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000685
Daniel Dunbar00564992009-09-19 20:40:14 +0000686 // Now dereference the __forwarding field to get to the real __Block_byref
687 // struct: DW_OP_deref.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000688 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000689
Daniel Dunbar00564992009-09-19 20:40:14 +0000690 // Now that we've got the real __Block_byref... struct, add the offset
691 // for the variable's field to get to the location of the actual variable:
692 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
Daniel Dunbar00564992009-09-19 20:40:14 +0000693 if (varFieldOffset > 0) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000694 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
695 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
Daniel Dunbar00564992009-09-19 20:40:14 +0000696 }
Caroline Ticedc8f6042009-08-31 21:19:37 +0000697
Daniel Dunbar00564992009-09-19 20:40:14 +0000698 // Now attach the location information to the DIE.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000699 addBlock(Die, Attribute, 0, Block);
Caroline Ticedc8f6042009-08-31 21:19:37 +0000700}
701
Devang Patel2c4ceb12009-11-21 02:48:08 +0000702/// addAddress - Add an address attribute to a die based on the location
Bill Wendling0310d762009-05-15 09:23:25 +0000703/// provided.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000704void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
Bill Wendling0310d762009-05-15 09:23:25 +0000705 const MachineLocation &Location) {
706 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
707 DIEBlock *Block = new DIEBlock();
708
709 if (Location.isReg()) {
710 if (Reg < 32) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000711 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000712 } else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000713 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
714 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000715 }
716 } else {
717 if (Reg < 32) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000718 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000719 } else {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000720 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
721 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Bill Wendling0310d762009-05-15 09:23:25 +0000722 }
723
Devang Patel2c4ceb12009-11-21 02:48:08 +0000724 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Bill Wendling0310d762009-05-15 09:23:25 +0000725 }
726
Devang Patel2c4ceb12009-11-21 02:48:08 +0000727 addBlock(Die, Attribute, 0, Block);
Bill Wendling0310d762009-05-15 09:23:25 +0000728}
729
Devang Patel2c4ceb12009-11-21 02:48:08 +0000730/// addType - Add a new type attribute to the specified entity.
731void DwarfDebug::addType(CompileUnit *DW_Unit, DIE *Entity, DIType Ty) {
Bill Wendling0310d762009-05-15 09:23:25 +0000732 if (Ty.isNull())
733 return;
734
735 // Check for pre-existence.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000736 DIEEntry *Entry = DW_Unit->getDIEEntry(Ty.getNode());
Bill Wendling0310d762009-05-15 09:23:25 +0000737
738 // If it exists then use the existing value.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000739 if (Entry) {
740 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
Bill Wendling0310d762009-05-15 09:23:25 +0000741 return;
742 }
743
744 // Set up proxy.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000745 Entry = createDIEEntry();
746 DW_Unit->insertDIEEntry(Ty.getNode(), Entry);
Bill Wendling0310d762009-05-15 09:23:25 +0000747
748 // Construct type.
Devang Patel6f01d9c2009-11-21 00:31:03 +0000749 DIE *Buffer = new DIE(dwarf::DW_TAG_base_type);
Devang Patel6ceea332009-08-31 18:49:10 +0000750 if (Ty.isBasicType())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000751 constructTypeDIE(DW_Unit, *Buffer, DIBasicType(Ty.getNode()));
Devang Patel6ceea332009-08-31 18:49:10 +0000752 else if (Ty.isCompositeType())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000753 constructTypeDIE(DW_Unit, *Buffer, DICompositeType(Ty.getNode()));
Bill Wendling0310d762009-05-15 09:23:25 +0000754 else {
Devang Patel6ceea332009-08-31 18:49:10 +0000755 assert(Ty.isDerivedType() && "Unknown kind of DIType");
Devang Patel2c4ceb12009-11-21 02:48:08 +0000756 constructTypeDIE(DW_Unit, *Buffer, DIDerivedType(Ty.getNode()));
Bill Wendling0310d762009-05-15 09:23:25 +0000757 }
758
759 // Add debug information entry to entity and appropriate context.
760 DIE *Die = NULL;
761 DIDescriptor Context = Ty.getContext();
762 if (!Context.isNull())
Devang Patel017d1212009-11-20 21:37:22 +0000763 Die = DW_Unit->getDIE(Context.getNode());
Bill Wendling0310d762009-05-15 09:23:25 +0000764
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000765 if (Die)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000766 Die->addChild(Buffer);
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000767 else
Devang Patel2c4ceb12009-11-21 02:48:08 +0000768 DW_Unit->addDie(Buffer);
769 Entry->setEntry(Buffer);
770 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
Bill Wendling0310d762009-05-15 09:23:25 +0000771}
772
Devang Patel2c4ceb12009-11-21 02:48:08 +0000773/// constructTypeDIE - Construct basic type die from DIBasicType.
774void DwarfDebug::constructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
Bill Wendling0310d762009-05-15 09:23:25 +0000775 DIBasicType BTy) {
776 // Get core information.
Devang Patel5ccdd102009-09-29 18:40:58 +0000777 const char *Name = BTy.getName();
Bill Wendling0310d762009-05-15 09:23:25 +0000778 Buffer.setTag(dwarf::DW_TAG_base_type);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000779 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Bill Wendling0310d762009-05-15 09:23:25 +0000780 BTy.getEncoding());
781
782 // Add name if not anonymous or intermediate type.
Devang Patel5ccdd102009-09-29 18:40:58 +0000783 if (Name)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000784 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +0000785 uint64_t Size = BTy.getSizeInBits() >> 3;
Devang Patel2c4ceb12009-11-21 02:48:08 +0000786 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling0310d762009-05-15 09:23:25 +0000787}
788
Devang Patel2c4ceb12009-11-21 02:48:08 +0000789/// constructTypeDIE - Construct derived type die from DIDerivedType.
790void DwarfDebug::constructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
Bill Wendling0310d762009-05-15 09:23:25 +0000791 DIDerivedType DTy) {
792 // Get core information.
Devang Patel5ccdd102009-09-29 18:40:58 +0000793 const char *Name = DTy.getName();
Bill Wendling0310d762009-05-15 09:23:25 +0000794 uint64_t Size = DTy.getSizeInBits() >> 3;
795 unsigned Tag = DTy.getTag();
796
797 // FIXME - Workaround for templates.
798 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
799
800 Buffer.setTag(Tag);
801
802 // Map to main type, void will not have a type.
803 DIType FromTy = DTy.getTypeDerivedFrom();
Devang Patel2c4ceb12009-11-21 02:48:08 +0000804 addType(DW_Unit, &Buffer, FromTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000805
806 // Add name if not anonymous or intermediate type.
Devang Patel808b8262009-10-16 21:27:43 +0000807 if (Name && Tag != dwarf::DW_TAG_pointer_type)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000808 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +0000809
810 // Add size if non-zero (derived types might be zero-sized.)
811 if (Size)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000812 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling0310d762009-05-15 09:23:25 +0000813
814 // Add source line info if available and TyDesc is not a forward declaration.
Devang Patel1f37b5b2009-11-20 21:05:37 +0000815 if (!DTy.isForwardDecl() && Tag != dwarf::DW_TAG_pointer_type)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000816 addSourceLine(&Buffer, &DTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000817}
818
Devang Patel2c4ceb12009-11-21 02:48:08 +0000819/// constructTypeDIE - Construct type DIE from DICompositeType.
820void DwarfDebug::constructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
Bill Wendling0310d762009-05-15 09:23:25 +0000821 DICompositeType CTy) {
822 // Get core information.
Devang Patel5ccdd102009-09-29 18:40:58 +0000823 const char *Name = CTy.getName();
Bill Wendling0310d762009-05-15 09:23:25 +0000824
825 uint64_t Size = CTy.getSizeInBits() >> 3;
826 unsigned Tag = CTy.getTag();
827 Buffer.setTag(Tag);
828
829 switch (Tag) {
830 case dwarf::DW_TAG_vector_type:
831 case dwarf::DW_TAG_array_type:
Devang Patel2c4ceb12009-11-21 02:48:08 +0000832 constructArrayTypeDIE(DW_Unit, Buffer, &CTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000833 break;
834 case dwarf::DW_TAG_enumeration_type: {
835 DIArray Elements = CTy.getTypeArray();
836
837 // Add enumerators to enumeration type.
838 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
839 DIE *ElemDie = NULL;
Devang Patele4b27562009-08-28 23:24:31 +0000840 DIEnumerator Enum(Elements.getElement(i).getNode());
Devang Patelc5254722009-10-09 17:51:49 +0000841 if (!Enum.isNull()) {
Devang Patel2c4ceb12009-11-21 02:48:08 +0000842 ElemDie = constructEnumTypeDIE(DW_Unit, &Enum);
843 Buffer.addChild(ElemDie);
Devang Patelc5254722009-10-09 17:51:49 +0000844 }
Bill Wendling0310d762009-05-15 09:23:25 +0000845 }
846 }
847 break;
848 case dwarf::DW_TAG_subroutine_type: {
849 // Add return type.
850 DIArray Elements = CTy.getTypeArray();
851 DIDescriptor RTy = Elements.getElement(0);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000852 addType(DW_Unit, &Buffer, DIType(RTy.getNode()));
Bill Wendling0310d762009-05-15 09:23:25 +0000853
854 // Add prototype flag.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000855 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +0000856
857 // Add arguments.
858 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
859 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
860 DIDescriptor Ty = Elements.getElement(i);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000861 addType(DW_Unit, Arg, DIType(Ty.getNode()));
862 Buffer.addChild(Arg);
Bill Wendling0310d762009-05-15 09:23:25 +0000863 }
864 }
865 break;
866 case dwarf::DW_TAG_structure_type:
867 case dwarf::DW_TAG_union_type:
868 case dwarf::DW_TAG_class_type: {
869 // Add elements to structure type.
870 DIArray Elements = CTy.getTypeArray();
871
872 // A forward struct declared type may not have elements available.
873 if (Elements.isNull())
874 break;
875
876 // Add elements to structure type.
877 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
878 DIDescriptor Element = Elements.getElement(i);
Devang Patele4b27562009-08-28 23:24:31 +0000879 if (Element.isNull())
880 continue;
Bill Wendling0310d762009-05-15 09:23:25 +0000881 DIE *ElemDie = NULL;
882 if (Element.getTag() == dwarf::DW_TAG_subprogram)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000883 ElemDie = createSubprogramDIE(DW_Unit,
Devang Patele4b27562009-08-28 23:24:31 +0000884 DISubprogram(Element.getNode()));
Bill Wendling0310d762009-05-15 09:23:25 +0000885 else
Devang Patel2c4ceb12009-11-21 02:48:08 +0000886 ElemDie = createMemberDIE(DW_Unit,
Devang Patele4b27562009-08-28 23:24:31 +0000887 DIDerivedType(Element.getNode()));
Devang Patel2c4ceb12009-11-21 02:48:08 +0000888 Buffer.addChild(ElemDie);
Bill Wendling0310d762009-05-15 09:23:25 +0000889 }
890
Devang Patela1ba2692009-08-27 23:51:51 +0000891 if (CTy.isAppleBlockExtension())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000892 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +0000893
894 unsigned RLang = CTy.getRunTimeLang();
895 if (RLang)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000896 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
Bill Wendling0310d762009-05-15 09:23:25 +0000897 dwarf::DW_FORM_data1, RLang);
898 break;
899 }
900 default:
901 break;
902 }
903
904 // Add name if not anonymous or intermediate type.
Devang Patel5ccdd102009-09-29 18:40:58 +0000905 if (Name)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000906 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +0000907
908 if (Tag == dwarf::DW_TAG_enumeration_type ||
909 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
910 // Add size if non-zero (derived types might be zero-sized.)
911 if (Size)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000912 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling0310d762009-05-15 09:23:25 +0000913 else {
914 // Add zero size if it is not a forward declaration.
915 if (CTy.isForwardDecl())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000916 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +0000917 else
Devang Patel2c4ceb12009-11-21 02:48:08 +0000918 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
Bill Wendling0310d762009-05-15 09:23:25 +0000919 }
920
921 // Add source line info if available.
922 if (!CTy.isForwardDecl())
Devang Patel2c4ceb12009-11-21 02:48:08 +0000923 addSourceLine(&Buffer, &CTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000924 }
925}
926
Devang Patel2c4ceb12009-11-21 02:48:08 +0000927/// constructSubrangeDIE - Construct subrange DIE from DISubrange.
928void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
Bill Wendling0310d762009-05-15 09:23:25 +0000929 int64_t L = SR.getLo();
930 int64_t H = SR.getHi();
931 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
932
Devang Patel2c4ceb12009-11-21 02:48:08 +0000933 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
Devang Patel6325a532009-08-14 20:59:16 +0000934 if (L)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000935 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
Devang Patel6325a532009-08-14 20:59:16 +0000936 if (H)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000937 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
Bill Wendling0310d762009-05-15 09:23:25 +0000938
Devang Patel2c4ceb12009-11-21 02:48:08 +0000939 Buffer.addChild(DW_Subrange);
Bill Wendling0310d762009-05-15 09:23:25 +0000940}
941
Devang Patel2c4ceb12009-11-21 02:48:08 +0000942/// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
943void DwarfDebug::constructArrayTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
Bill Wendling0310d762009-05-15 09:23:25 +0000944 DICompositeType *CTy) {
945 Buffer.setTag(dwarf::DW_TAG_array_type);
946 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000947 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +0000948
949 // Emit derived type.
Devang Patel2c4ceb12009-11-21 02:48:08 +0000950 addType(DW_Unit, &Buffer, CTy->getTypeDerivedFrom());
Bill Wendling0310d762009-05-15 09:23:25 +0000951 DIArray Elements = CTy->getTypeArray();
952
Devang Patel6f01d9c2009-11-21 00:31:03 +0000953 // Get an anonymous type for index type.
954 DIE *IdxTy = DW_Unit->getIndexTyDie();
955 if (!IdxTy) {
956 // Construct an anonymous type for index type.
957 IdxTy = new DIE(dwarf::DW_TAG_base_type);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000958 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
959 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Devang Patel6f01d9c2009-11-21 00:31:03 +0000960 dwarf::DW_ATE_signed);
Devang Patel2c4ceb12009-11-21 02:48:08 +0000961 DW_Unit->addDie(IdxTy);
Devang Patel6f01d9c2009-11-21 00:31:03 +0000962 DW_Unit->setIndexTyDie(IdxTy);
963 }
Bill Wendling0310d762009-05-15 09:23:25 +0000964
965 // Add subranges to array type.
966 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
967 DIDescriptor Element = Elements.getElement(i);
968 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
Devang Patel2c4ceb12009-11-21 02:48:08 +0000969 constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
Bill Wendling0310d762009-05-15 09:23:25 +0000970 }
971}
972
Devang Patel2c4ceb12009-11-21 02:48:08 +0000973/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
974DIE *DwarfDebug::constructEnumTypeDIE(CompileUnit *DW_Unit, DIEnumerator *ETy) {
Bill Wendling0310d762009-05-15 09:23:25 +0000975 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
Devang Patel5ccdd102009-09-29 18:40:58 +0000976 const char *Name = ETy->getName();
Devang Patel2c4ceb12009-11-21 02:48:08 +0000977 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +0000978 int64_t Value = ETy->getEnumValue();
Devang Patel2c4ceb12009-11-21 02:48:08 +0000979 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
Bill Wendling0310d762009-05-15 09:23:25 +0000980 return Enumerator;
981}
982
Devang Patel2c4ceb12009-11-21 02:48:08 +0000983/// createGlobalVariableDIE - Create new DIE using GV.
984DIE *DwarfDebug::createGlobalVariableDIE(CompileUnit *DW_Unit,
Bill Wendling0310d762009-05-15 09:23:25 +0000985 const DIGlobalVariable &GV) {
Jim Grosbach7ab38df2009-11-22 19:20:36 +0000986 // If the global variable was optmized out then no need to create debug info
987 // entry.
Devang Patel84c73e92009-11-06 17:58:12 +0000988 if (!GV.getGlobal()) return NULL;
989 if (!GV.getDisplayName()) return NULL;
Devang Patel465c3be2009-11-06 01:30:04 +0000990
Bill Wendling0310d762009-05-15 09:23:25 +0000991 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
Jim Grosbach31ef40e2009-11-21 23:12:12 +0000992 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
Devang Patel5ccdd102009-09-29 18:40:58 +0000993 GV.getDisplayName());
994
995 const char *LinkageName = GV.getLinkageName();
996 if (LinkageName) {
Chris Lattner6c2f9e12009-08-19 05:49:37 +0000997 // Skip special LLVM prefix that is used to inform the asm printer to not
998 // emit usual symbol prefix before the symbol name. This happens for
999 // Objective-C symbol names and symbol whose name is replaced using GCC's
1000 // __asm__ attribute.
Devang Patel53cb17d2009-07-16 01:01:22 +00001001 if (LinkageName[0] == 1)
1002 LinkageName = &LinkageName[1];
Devang Patel2c4ceb12009-11-21 02:48:08 +00001003 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
Devang Patel1a8d2d22009-07-14 00:55:28 +00001004 LinkageName);
Devang Patel53cb17d2009-07-16 01:01:22 +00001005 }
Devang Patel2c4ceb12009-11-21 02:48:08 +00001006 addType(DW_Unit, GVDie, GV.getType());
Bill Wendling0310d762009-05-15 09:23:25 +00001007 if (!GV.isLocalToUnit())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001008 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1009 addSourceLine(GVDie, &GV);
Devang Patelb71a16d2009-10-05 23:22:08 +00001010
1011 // Add address.
1012 DIEBlock *Block = new DIEBlock();
Devang Patel2c4ceb12009-11-21 02:48:08 +00001013 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1014 addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
Devang Patelb71a16d2009-10-05 23:22:08 +00001015 Asm->Mang->getMangledName(GV.getGlobal()));
Devang Patel2c4ceb12009-11-21 02:48:08 +00001016 addBlock(GVDie, dwarf::DW_AT_location, 0, Block);
Devang Patelb71a16d2009-10-05 23:22:08 +00001017
Bill Wendling0310d762009-05-15 09:23:25 +00001018 return GVDie;
1019}
1020
Devang Patel2c4ceb12009-11-21 02:48:08 +00001021/// createMemberDIE - Create new member DIE.
1022DIE *DwarfDebug::createMemberDIE(CompileUnit *DW_Unit, const DIDerivedType &DT){
Bill Wendling0310d762009-05-15 09:23:25 +00001023 DIE *MemberDie = new DIE(DT.getTag());
Devang Patel5ccdd102009-09-29 18:40:58 +00001024 if (const char *Name = DT.getName())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001025 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +00001026
Devang Patel2c4ceb12009-11-21 02:48:08 +00001027 addType(DW_Unit, MemberDie, DT.getTypeDerivedFrom());
Bill Wendling0310d762009-05-15 09:23:25 +00001028
Devang Patel2c4ceb12009-11-21 02:48:08 +00001029 addSourceLine(MemberDie, &DT);
Bill Wendling0310d762009-05-15 09:23:25 +00001030
Devang Patel33db5082009-11-04 22:06:12 +00001031 DIEBlock *MemLocationDie = new DIEBlock();
Devang Patel2c4ceb12009-11-21 02:48:08 +00001032 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
Devang Patel33db5082009-11-04 22:06:12 +00001033
Bill Wendling0310d762009-05-15 09:23:25 +00001034 uint64_t Size = DT.getSizeInBits();
Devang Patel61ecbd12009-11-04 23:48:00 +00001035 uint64_t FieldSize = DT.getOriginalTypeSize();
Bill Wendling0310d762009-05-15 09:23:25 +00001036
1037 if (Size != FieldSize) {
1038 // Handle bitfield.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001039 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1040 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
Bill Wendling0310d762009-05-15 09:23:25 +00001041
1042 uint64_t Offset = DT.getOffsetInBits();
1043 uint64_t FieldOffset = Offset;
1044 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1045 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1046 FieldOffset = (HiMark - FieldSize);
1047 Offset -= FieldOffset;
1048
1049 // Maybe we need to work from the other end.
1050 if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001051 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
Bill Wendling0310d762009-05-15 09:23:25 +00001052
Devang Patel33db5082009-11-04 22:06:12 +00001053 // Here WD_AT_data_member_location points to the anonymous
1054 // field that includes this bit field.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001055 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
Devang Patel33db5082009-11-04 22:06:12 +00001056
1057 } else
1058 // This is not a bitfield.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001059 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
Devang Patel33db5082009-11-04 22:06:12 +00001060
Devang Patel2c4ceb12009-11-21 02:48:08 +00001061 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
Bill Wendling0310d762009-05-15 09:23:25 +00001062
1063 if (DT.isProtected())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001064 addUInt(MemberDie, dwarf::DW_AT_accessibility, 0,
Bill Wendling0310d762009-05-15 09:23:25 +00001065 dwarf::DW_ACCESS_protected);
1066 else if (DT.isPrivate())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001067 addUInt(MemberDie, dwarf::DW_AT_accessibility, 0,
Bill Wendling0310d762009-05-15 09:23:25 +00001068 dwarf::DW_ACCESS_private);
1069
1070 return MemberDie;
1071}
1072
Devang Patel2c4ceb12009-11-21 02:48:08 +00001073/// createSubprogramDIE - Create new DIE using SP.
1074DIE *DwarfDebug::createSubprogramDIE(CompileUnit *DW_Unit,
Bill Wendling0310d762009-05-15 09:23:25 +00001075 const DISubprogram &SP,
Bill Wendling6679ee42009-05-18 22:02:36 +00001076 bool IsConstructor,
1077 bool IsInlined) {
Bill Wendling0310d762009-05-15 09:23:25 +00001078 DIE *SPDie = new DIE(dwarf::DW_TAG_subprogram);
1079
Devang Patel5ccdd102009-09-29 18:40:58 +00001080 const char * Name = SP.getName();
Devang Patel2c4ceb12009-11-21 02:48:08 +00001081 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +00001082
Devang Patel5ccdd102009-09-29 18:40:58 +00001083 const char *LinkageName = SP.getLinkageName();
1084 if (LinkageName) {
Jim Grosbach7ab38df2009-11-22 19:20:36 +00001085 // Skip special LLVM prefix that is used to inform the asm printer to not
1086 // emit usual symbol prefix before the symbol name. This happens for
1087 // Objective-C symbol names and symbol whose name is replaced using GCC's
1088 // __asm__ attribute.
Devang Patel53cb17d2009-07-16 01:01:22 +00001089 if (LinkageName[0] == 1)
1090 LinkageName = &LinkageName[1];
Devang Patel2c4ceb12009-11-21 02:48:08 +00001091 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
Devang Patel1a8d2d22009-07-14 00:55:28 +00001092 LinkageName);
Devang Patel53cb17d2009-07-16 01:01:22 +00001093 }
Devang Patel2c4ceb12009-11-21 02:48:08 +00001094 addSourceLine(SPDie, &SP);
Bill Wendling0310d762009-05-15 09:23:25 +00001095
1096 DICompositeType SPTy = SP.getType();
1097 DIArray Args = SPTy.getTypeArray();
1098
1099 // Add prototyped tag, if C or ObjC.
1100 unsigned Lang = SP.getCompileUnit().getLanguage();
1101 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1102 Lang == dwarf::DW_LANG_ObjC)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001103 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001104
1105 // Add Return Type.
1106 unsigned SPTag = SPTy.getTag();
1107 if (!IsConstructor) {
1108 if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001109 addType(DW_Unit, SPDie, SPTy);
Bill Wendling0310d762009-05-15 09:23:25 +00001110 else
Devang Patel2c4ceb12009-11-21 02:48:08 +00001111 addType(DW_Unit, SPDie, DIType(Args.getElement(0).getNode()));
Bill Wendling0310d762009-05-15 09:23:25 +00001112 }
1113
1114 if (!SP.isDefinition()) {
Devang Patel2c4ceb12009-11-21 02:48:08 +00001115 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Bill Wendling0310d762009-05-15 09:23:25 +00001116
1117 // Add arguments. Do not add arguments for subprogram definition. They will
1118 // be handled through RecordVariable.
1119 if (SPTag == dwarf::DW_TAG_subroutine_type)
1120 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1121 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001122 addType(DW_Unit, Arg, DIType(Args.getElement(i).getNode()));
1123 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1124 SPDie->addChild(Arg);
Bill Wendling0310d762009-05-15 09:23:25 +00001125 }
1126 }
1127
Bill Wendling0310d762009-05-15 09:23:25 +00001128 // DW_TAG_inlined_subroutine may refer to this DIE.
Devang Patel017d1212009-11-20 21:37:22 +00001129 DW_Unit->insertDIE(SP.getNode(), SPDie);
Bill Wendling0310d762009-05-15 09:23:25 +00001130 return SPDie;
1131}
1132
Devang Patel2c4ceb12009-11-21 02:48:08 +00001133/// findCompileUnit - Get the compile unit for the given descriptor.
Bill Wendling0310d762009-05-15 09:23:25 +00001134///
Devang Patel2c4ceb12009-11-21 02:48:08 +00001135CompileUnit &DwarfDebug::findCompileUnit(DICompileUnit Unit) const {
Bill Wendling0310d762009-05-15 09:23:25 +00001136 DenseMap<Value *, CompileUnit *>::const_iterator I =
Devang Patele4b27562009-08-28 23:24:31 +00001137 CompileUnitMap.find(Unit.getNode());
Bill Wendling0310d762009-05-15 09:23:25 +00001138 assert(I != CompileUnitMap.end() && "Missing compile unit.");
1139 return *I->second;
1140}
1141
Devang Patel2c4ceb12009-11-21 02:48:08 +00001142/// createDbgScopeVariable - Create a new scope variable.
Bill Wendling0310d762009-05-15 09:23:25 +00001143///
Devang Patel2c4ceb12009-11-21 02:48:08 +00001144DIE *DwarfDebug::createDbgScopeVariable(DbgVariable *DV, CompileUnit *Unit) {
Bill Wendling0310d762009-05-15 09:23:25 +00001145 // Get the descriptor.
1146 const DIVariable &VD = DV->getVariable();
Devang Patel1b845972009-11-03 18:30:27 +00001147 const char *Name = VD.getName();
1148 if (!Name)
1149 return NULL;
Bill Wendling0310d762009-05-15 09:23:25 +00001150
1151 // Translate tag to proper Dwarf tag. The result variable is dropped for
1152 // now.
1153 unsigned Tag;
1154 switch (VD.getTag()) {
1155 case dwarf::DW_TAG_return_variable:
1156 return NULL;
1157 case dwarf::DW_TAG_arg_variable:
1158 Tag = dwarf::DW_TAG_formal_parameter;
1159 break;
1160 case dwarf::DW_TAG_auto_variable: // fall thru
1161 default:
1162 Tag = dwarf::DW_TAG_variable;
1163 break;
1164 }
1165
1166 // Define variable debug information entry.
1167 DIE *VariableDie = new DIE(Tag);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001168 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling0310d762009-05-15 09:23:25 +00001169
1170 // Add source line info if available.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001171 addSourceLine(VariableDie, &VD);
Bill Wendling0310d762009-05-15 09:23:25 +00001172
1173 // Add variable type.
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001174 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
Devang Patel53bb5c92009-11-10 23:06:00 +00001175 // addresses instead.
Caroline Ticedc8f6042009-08-31 21:19:37 +00001176 if (VD.isBlockByrefVariable())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001177 addType(Unit, VariableDie, getBlockByrefType(VD.getType(), Name));
Caroline Ticedc8f6042009-08-31 21:19:37 +00001178 else
Devang Patel2c4ceb12009-11-21 02:48:08 +00001179 addType(Unit, VariableDie, VD.getType());
Bill Wendling0310d762009-05-15 09:23:25 +00001180
1181 // Add variable address.
Devang Patel53bb5c92009-11-10 23:06:00 +00001182 // Variables for abstract instances of inlined functions don't get a
1183 // location.
1184 MachineLocation Location;
1185 Location.set(RI->getFrameRegister(*MF),
1186 RI->getFrameIndexOffset(*MF, DV->getFrameIndex()));
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001187
1188
Devang Patel53bb5c92009-11-10 23:06:00 +00001189 if (VD.hasComplexAddress())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001190 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
Devang Patel53bb5c92009-11-10 23:06:00 +00001191 else if (VD.isBlockByrefVariable())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001192 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
Devang Patel53bb5c92009-11-10 23:06:00 +00001193 else
Devang Patel2c4ceb12009-11-21 02:48:08 +00001194 addAddress(VariableDie, dwarf::DW_AT_location, Location);
Bill Wendling0310d762009-05-15 09:23:25 +00001195
1196 return VariableDie;
1197}
1198
Devang Patel53bb5c92009-11-10 23:06:00 +00001199/// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1200/// Initialize scope and update scope hierarchy.
1201DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1202 MDNode *InlinedAt) {
1203 assert (N && "Invalid Scope encoding!");
1204 assert (MI && "Missing machine instruction!");
1205 bool GetConcreteScope = (MI && InlinedAt);
1206
1207 DbgScope *NScope = NULL;
1208
1209 if (InlinedAt)
1210 NScope = DbgScopeMap.lookup(InlinedAt);
1211 else
1212 NScope = DbgScopeMap.lookup(N);
1213 assert (NScope && "Unable to find working scope!");
1214
1215 if (NScope->getFirstInsn())
1216 return NScope;
Devang Patelaf9e8472009-10-01 20:31:14 +00001217
1218 DbgScope *Parent = NULL;
Devang Patel53bb5c92009-11-10 23:06:00 +00001219 if (GetConcreteScope) {
Devang Patelc90aefe2009-10-14 21:08:09 +00001220 DILocation IL(InlinedAt);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001221 Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
Devang Patel53bb5c92009-11-10 23:06:00 +00001222 IL.getOrigLocation().getNode());
1223 assert (Parent && "Unable to find Parent scope!");
1224 NScope->setParent(Parent);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001225 Parent->addScope(NScope);
Devang Patel53bb5c92009-11-10 23:06:00 +00001226 } else if (DIDescriptor(N).isLexicalBlock()) {
1227 DILexicalBlock DB(N);
1228 if (!DB.getContext().isNull()) {
1229 Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1230 NScope->setParent(Parent);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001231 Parent->addScope(NScope);
Devang Patel53bb5c92009-11-10 23:06:00 +00001232 }
Devang Patelc90aefe2009-10-14 21:08:09 +00001233 }
Devang Patelaf9e8472009-10-01 20:31:14 +00001234
Devang Patelbdf45cb2009-10-27 20:47:17 +00001235 NScope->setFirstInsn(MI);
Devang Patelaf9e8472009-10-01 20:31:14 +00001236
Devang Patel53bb5c92009-11-10 23:06:00 +00001237 if (!Parent && !InlinedAt) {
Devang Patel39ae3ff2009-11-11 00:31:36 +00001238 StringRef SPName = DISubprogram(N).getLinkageName();
1239 if (SPName == MF->getFunction()->getName())
1240 CurrentFnDbgScope = NScope;
Devang Patel53bb5c92009-11-10 23:06:00 +00001241 }
Devang Patelaf9e8472009-10-01 20:31:14 +00001242
Devang Patel53bb5c92009-11-10 23:06:00 +00001243 if (GetConcreteScope) {
1244 ConcreteScopes[InlinedAt] = NScope;
1245 getOrCreateAbstractScope(N);
1246 }
1247
Devang Patelbdf45cb2009-10-27 20:47:17 +00001248 return NScope;
Devang Patelaf9e8472009-10-01 20:31:14 +00001249}
1250
Devang Patel53bb5c92009-11-10 23:06:00 +00001251DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1252 assert (N && "Invalid Scope encoding!");
1253
1254 DbgScope *AScope = AbstractScopes.lookup(N);
1255 if (AScope)
1256 return AScope;
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001257
Devang Patel53bb5c92009-11-10 23:06:00 +00001258 DbgScope *Parent = NULL;
1259
1260 DIDescriptor Scope(N);
1261 if (Scope.isLexicalBlock()) {
1262 DILexicalBlock DB(N);
1263 DIDescriptor ParentDesc = DB.getContext();
1264 if (!ParentDesc.isNull())
1265 Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1266 }
1267
1268 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1269
1270 if (Parent)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001271 Parent->addScope(AScope);
Devang Patel53bb5c92009-11-10 23:06:00 +00001272 AScope->setAbstractScope();
1273 AbstractScopes[N] = AScope;
1274 if (DIDescriptor(N).isSubprogram())
1275 AbstractScopesList.push_back(AScope);
1276 return AScope;
1277}
Devang Patelaf9e8472009-10-01 20:31:14 +00001278
Devang Patel53bb5c92009-11-10 23:06:00 +00001279static DISubprogram getDISubprogram(MDNode *N) {
1280
1281 DIDescriptor D(N);
1282 if (D.isNull())
1283 return DISubprogram();
1284
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001285 if (D.isCompileUnit())
Devang Patel53bb5c92009-11-10 23:06:00 +00001286 return DISubprogram();
1287
1288 if (D.isSubprogram())
1289 return DISubprogram(N);
1290
1291 if (D.isLexicalBlock())
1292 return getDISubprogram(DILexicalBlock(N).getContext().getNode());
1293
1294 llvm_unreachable("Unexpected Descriptor!");
1295}
1296
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001297/// updateSubprogramScopeDIE - Find DIE for the given subprogram and
Devang Patel2c4ceb12009-11-21 02:48:08 +00001298/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1299/// If there are global variables in this scope then create and insert
1300/// DIEs for these variables.
1301DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
Devang Patel53bb5c92009-11-10 23:06:00 +00001302
Devang Patel017d1212009-11-20 21:37:22 +00001303 DIE *SPDie = ModuleCU->getDIE(SPNode);
Devang Patel53bb5c92009-11-10 23:06:00 +00001304 assert (SPDie && "Unable to find subprogram DIE!");
Devang Patel2c4ceb12009-11-21 02:48:08 +00001305 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
Devang Patel53bb5c92009-11-10 23:06:00 +00001306 DWLabel("func_begin", SubprogramCount));
Devang Patel2c4ceb12009-11-21 02:48:08 +00001307 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
Devang Patel53bb5c92009-11-10 23:06:00 +00001308 DWLabel("func_end", SubprogramCount));
1309 MachineLocation Location(RI->getFrameRegister(*MF));
Devang Patel2c4ceb12009-11-21 02:48:08 +00001310 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001311
Devang Patel53bb5c92009-11-10 23:06:00 +00001312 if (!DISubprogram(SPNode).isLocalToUnit())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001313 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
Devang Patel53bb5c92009-11-10 23:06:00 +00001314
1315 // If there are global variables at this scope then add their dies.
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001316 for (SmallVector<WeakVH, 4>::iterator SGI = ScopedGVs.begin(),
Devang Patel53bb5c92009-11-10 23:06:00 +00001317 SGE = ScopedGVs.end(); SGI != SGE; ++SGI) {
1318 MDNode *N = dyn_cast_or_null<MDNode>(*SGI);
1319 if (!N) continue;
1320 DIGlobalVariable GV(N);
1321 if (GV.getContext().getNode() == SPNode) {
Devang Patel2c4ceb12009-11-21 02:48:08 +00001322 DIE *ScopedGVDie = createGlobalVariableDIE(ModuleCU, GV);
Devang Patelfb0ee432009-11-10 23:20:04 +00001323 if (ScopedGVDie)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001324 SPDie->addChild(ScopedGVDie);
Devang Patel53bb5c92009-11-10 23:06:00 +00001325 }
1326 }
1327 return SPDie;
1328}
1329
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001330/// constructLexicalScope - Construct new DW_TAG_lexical_block
Devang Patel2c4ceb12009-11-21 02:48:08 +00001331/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1332DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
Devang Patel53bb5c92009-11-10 23:06:00 +00001333 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1334 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1335
1336 // Ignore empty scopes.
1337 if (StartID == EndID && StartID != 0)
1338 return NULL;
1339
1340 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1341 if (Scope->isAbstractScope())
1342 return ScopeDIE;
1343
Devang Patel2c4ceb12009-11-21 02:48:08 +00001344 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001345 StartID ?
1346 DWLabel("label", StartID)
Devang Patel53bb5c92009-11-10 23:06:00 +00001347 : DWLabel("func_begin", SubprogramCount));
Devang Patel2c4ceb12009-11-21 02:48:08 +00001348 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001349 EndID ?
1350 DWLabel("label", EndID)
Devang Patel53bb5c92009-11-10 23:06:00 +00001351 : DWLabel("func_end", SubprogramCount));
1352
1353
1354
1355 return ScopeDIE;
1356}
1357
Devang Patel2c4ceb12009-11-21 02:48:08 +00001358/// constructInlinedScopeDIE - This scope represents inlined body of
1359/// a function. Construct DIE to represent this concrete inlined copy
1360/// of the function.
1361DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
Devang Patel53bb5c92009-11-10 23:06:00 +00001362 unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1363 unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1364 assert (StartID && "Invalid starting label for an inlined scope!");
1365 assert (EndID && "Invalid end label for an inlined scope!");
1366 // Ignore empty scopes.
1367 if (StartID == EndID && StartID != 0)
1368 return NULL;
1369
1370 DIScope DS(Scope->getScopeNode());
1371 if (DS.isNull())
1372 return NULL;
1373 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1374
1375 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
Devang Patel017d1212009-11-20 21:37:22 +00001376 DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
Devang Patel53bb5c92009-11-10 23:06:00 +00001377 assert (OriginDIE && "Unable to find Origin DIE!");
Devang Patel2c4ceb12009-11-21 02:48:08 +00001378 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
Devang Patel53bb5c92009-11-10 23:06:00 +00001379 dwarf::DW_FORM_ref4, OriginDIE);
1380
Devang Patel2c4ceb12009-11-21 02:48:08 +00001381 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
Devang Patel53bb5c92009-11-10 23:06:00 +00001382 DWLabel("label", StartID));
Devang Patel2c4ceb12009-11-21 02:48:08 +00001383 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
Devang Patel53bb5c92009-11-10 23:06:00 +00001384 DWLabel("label", EndID));
1385
1386 InlinedSubprogramDIEs.insert(OriginDIE);
1387
1388 // Track the start label for this inlined function.
1389 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1390 I = InlineInfo.find(InlinedSP.getNode());
1391
1392 if (I == InlineInfo.end()) {
Jim Grosbach7ab38df2009-11-22 19:20:36 +00001393 InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1394 ScopeDIE));
Devang Patel53bb5c92009-11-10 23:06:00 +00001395 InlinedSPNodes.push_back(InlinedSP.getNode());
1396 } else
1397 I->second.push_back(std::make_pair(StartID, ScopeDIE));
1398
1399 StringPool.insert(InlinedSP.getName());
1400 StringPool.insert(InlinedSP.getLinkageName());
1401 DILocation DL(Scope->getInlinedAt());
Devang Patel2c4ceb12009-11-21 02:48:08 +00001402 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1403 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
Devang Patel53bb5c92009-11-10 23:06:00 +00001404
1405 return ScopeDIE;
1406}
1407
Devang Patel2c4ceb12009-11-21 02:48:08 +00001408
1409/// constructVariableDIE - Construct a DIE for the given DbgVariable.
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001410DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV,
Devang Patel53bb5c92009-11-10 23:06:00 +00001411 DbgScope *Scope, CompileUnit *Unit) {
1412 // Get the descriptor.
1413 const DIVariable &VD = DV->getVariable();
Devang Patel3fb6bd62009-11-13 02:25:26 +00001414 const char *Name = VD.getName();
1415 if (!Name)
1416 return NULL;
Devang Patel53bb5c92009-11-10 23:06:00 +00001417
1418 // Translate tag to proper Dwarf tag. The result variable is dropped for
1419 // now.
1420 unsigned Tag;
1421 switch (VD.getTag()) {
1422 case dwarf::DW_TAG_return_variable:
1423 return NULL;
1424 case dwarf::DW_TAG_arg_variable:
1425 Tag = dwarf::DW_TAG_formal_parameter;
1426 break;
1427 case dwarf::DW_TAG_auto_variable: // fall thru
1428 default:
1429 Tag = dwarf::DW_TAG_variable;
1430 break;
1431 }
1432
1433 // Define variable debug information entry.
1434 DIE *VariableDie = new DIE(Tag);
1435
1436
1437 DIE *AbsDIE = NULL;
1438 if (DbgVariable *AV = DV->getAbstractVariable())
1439 AbsDIE = AV->getDIE();
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001440
Devang Patel53bb5c92009-11-10 23:06:00 +00001441 if (AbsDIE) {
1442 DIScope DS(Scope->getScopeNode());
1443 DISubprogram InlinedSP = getDISubprogram(DS.getNode());
Devang Patel017d1212009-11-20 21:37:22 +00001444 DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
Daniel Dunbarc0326792009-11-11 03:09:50 +00001445 (void) OriginSPDIE;
Devang Patel53bb5c92009-11-10 23:06:00 +00001446 assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1447 DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1448 assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
Devang Patel2c4ceb12009-11-21 02:48:08 +00001449 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
Devang Patel53bb5c92009-11-10 23:06:00 +00001450 dwarf::DW_FORM_ref4, AbsDIE);
1451 }
1452 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +00001453 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1454 addSourceLine(VariableDie, &VD);
Devang Patel53bb5c92009-11-10 23:06:00 +00001455
1456 // Add variable type.
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001457 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
Devang Patel53bb5c92009-11-10 23:06:00 +00001458 // addresses instead.
1459 if (VD.isBlockByrefVariable())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001460 addType(Unit, VariableDie, getBlockByrefType(VD.getType(), Name));
Devang Patel53bb5c92009-11-10 23:06:00 +00001461 else
Devang Patel2c4ceb12009-11-21 02:48:08 +00001462 addType(Unit, VariableDie, VD.getType());
Devang Patel53bb5c92009-11-10 23:06:00 +00001463 }
1464
1465 // Add variable address.
1466 if (!Scope->isAbstractScope()) {
1467 MachineLocation Location;
1468 Location.set(RI->getFrameRegister(*MF),
1469 RI->getFrameIndexOffset(*MF, DV->getFrameIndex()));
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001470
1471
Devang Patel53bb5c92009-11-10 23:06:00 +00001472 if (VD.hasComplexAddress())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001473 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
Devang Patel53bb5c92009-11-10 23:06:00 +00001474 else if (VD.isBlockByrefVariable())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001475 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
Devang Patel53bb5c92009-11-10 23:06:00 +00001476 else
Devang Patel2c4ceb12009-11-21 02:48:08 +00001477 addAddress(VariableDie, dwarf::DW_AT_location, Location);
Devang Patel53bb5c92009-11-10 23:06:00 +00001478 }
1479 DV->setDIE(VariableDie);
1480 return VariableDie;
1481
1482}
Devang Patel2c4ceb12009-11-21 02:48:08 +00001483
1484/// constructScopeDIE - Construct a DIE for this scope.
1485DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
Devang Patel53bb5c92009-11-10 23:06:00 +00001486 if (!Scope)
1487 return NULL;
1488 DIScope DS(Scope->getScopeNode());
1489 if (DS.isNull())
1490 return NULL;
1491
1492 DIE *ScopeDIE = NULL;
1493 if (Scope->getInlinedAt())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001494 ScopeDIE = constructInlinedScopeDIE(Scope);
Devang Patel53bb5c92009-11-10 23:06:00 +00001495 else if (DS.isSubprogram()) {
1496 if (Scope->isAbstractScope())
Devang Patel017d1212009-11-20 21:37:22 +00001497 ScopeDIE = ModuleCU->getDIE(DS.getNode());
Devang Patel53bb5c92009-11-10 23:06:00 +00001498 else
Devang Patel2c4ceb12009-11-21 02:48:08 +00001499 ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
Devang Patel53bb5c92009-11-10 23:06:00 +00001500 }
1501 else {
Devang Patel2c4ceb12009-11-21 02:48:08 +00001502 ScopeDIE = constructLexicalScopeDIE(Scope);
Devang Patel53bb5c92009-11-10 23:06:00 +00001503 if (!ScopeDIE) return NULL;
1504 }
1505
1506 // Add variables to scope.
1507 SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1508 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
Devang Patel2c4ceb12009-11-21 02:48:08 +00001509 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope, ModuleCU);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001510 if (VariableDIE)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001511 ScopeDIE->addChild(VariableDIE);
Devang Patel53bb5c92009-11-10 23:06:00 +00001512 }
1513
1514 // Add nested scopes.
1515 SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1516 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1517 // Define the Scope debug information entry.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001518 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001519 if (NestedDIE)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001520 ScopeDIE->addChild(NestedDIE);
Devang Patel53bb5c92009-11-10 23:06:00 +00001521 }
1522 return ScopeDIE;
1523}
1524
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001525/// GetOrCreateSourceID - Look up the source id with the given directory and
1526/// source file names. If none currently exists, create a new id and insert it
1527/// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1528/// maps as well.
Devang Patel5ccdd102009-09-29 18:40:58 +00001529unsigned DwarfDebug::GetOrCreateSourceID(const char *DirName,
1530 const char *FileName) {
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001531 unsigned DId;
1532 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1533 if (DI != DirectoryIdMap.end()) {
1534 DId = DI->getValue();
1535 } else {
1536 DId = DirectoryNames.size() + 1;
1537 DirectoryIdMap[DirName] = DId;
1538 DirectoryNames.push_back(DirName);
1539 }
1540
1541 unsigned FId;
1542 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1543 if (FI != SourceFileIdMap.end()) {
1544 FId = FI->getValue();
1545 } else {
1546 FId = SourceFileNames.size() + 1;
1547 SourceFileIdMap[FileName] = FId;
1548 SourceFileNames.push_back(FileName);
1549 }
1550
1551 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1552 SourceIdMap.find(std::make_pair(DId, FId));
1553 if (SI != SourceIdMap.end())
1554 return SI->second;
1555
1556 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1557 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1558 SourceIds.push_back(std::make_pair(DId, FId));
1559
1560 return SrcId;
1561}
1562
Devang Patel2c4ceb12009-11-21 02:48:08 +00001563void DwarfDebug::constructCompileUnit(MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +00001564 DICompileUnit DIUnit(N);
Devang Patel5ccdd102009-09-29 18:40:58 +00001565 const char *FN = DIUnit.getFilename();
1566 const char *Dir = DIUnit.getDirectory();
1567 unsigned ID = GetOrCreateSourceID(Dir, FN);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001568
1569 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001570 addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001571 DWLabel("section_line", 0), DWLabel("section_line", 0),
1572 false);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001573 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
Devang Patel5ccdd102009-09-29 18:40:58 +00001574 DIUnit.getProducer());
Devang Patel2c4ceb12009-11-21 02:48:08 +00001575 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001576 DIUnit.getLanguage());
Devang Patel2c4ceb12009-11-21 02:48:08 +00001577 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001578
Devang Patel5ccdd102009-09-29 18:40:58 +00001579 if (Dir)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001580 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001581 if (DIUnit.isOptimized())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001582 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001583
Devang Patel5ccdd102009-09-29 18:40:58 +00001584 if (const char *Flags = DIUnit.getFlags())
Devang Patel2c4ceb12009-11-21 02:48:08 +00001585 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001586
1587 unsigned RVer = DIUnit.getRunTimeVersion();
1588 if (RVer)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001589 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001590 dwarf::DW_FORM_data1, RVer);
1591
1592 CompileUnit *Unit = new CompileUnit(ID, Die);
Devang Patel1dbc7712009-06-29 20:45:18 +00001593 if (!ModuleCU && DIUnit.isMain()) {
Devang Patel70f44262009-06-29 20:38:13 +00001594 // Use first compile unit marked as isMain as the compile unit
1595 // for this module.
Devang Patel1dbc7712009-06-29 20:45:18 +00001596 ModuleCU = Unit;
Devang Patel70f44262009-06-29 20:38:13 +00001597 }
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001598
Devang Patele4b27562009-08-28 23:24:31 +00001599 CompileUnitMap[DIUnit.getNode()] = Unit;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001600 CompileUnits.push_back(Unit);
1601}
1602
Devang Patel2c4ceb12009-11-21 02:48:08 +00001603void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +00001604 DIGlobalVariable DI_GV(N);
Daniel Dunbarf612ff62009-09-19 20:40:05 +00001605
Devang Patel905cf5e2009-09-04 23:59:07 +00001606 // If debug information is malformed then ignore it.
1607 if (DI_GV.Verify() == false)
1608 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001609
1610 // Check for pre-existence.
Devang Patel017d1212009-11-20 21:37:22 +00001611 if (ModuleCU->getDIE(DI_GV.getNode()))
Devang Patel13e16b62009-06-26 01:49:18 +00001612 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001613
Devang Patel2c4ceb12009-11-21 02:48:08 +00001614 DIE *VariableDie = createGlobalVariableDIE(ModuleCU, DI_GV);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001615
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001616 // Add to map.
Devang Patel017d1212009-11-20 21:37:22 +00001617 ModuleCU->insertDIE(N, VariableDie);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001618
1619 // Add to context owner.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001620 ModuleCU->getCUDie()->addChild(VariableDie);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001621
1622 // Expose as global. FIXME - need to check external flag.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001623 ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
Devang Patel13e16b62009-06-26 01:49:18 +00001624 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001625}
1626
Devang Patel2c4ceb12009-11-21 02:48:08 +00001627void DwarfDebug::constructSubprogramDIE(MDNode *N) {
Devang Patele4b27562009-08-28 23:24:31 +00001628 DISubprogram SP(N);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001629
1630 // Check for pre-existence.
Devang Patel017d1212009-11-20 21:37:22 +00001631 if (ModuleCU->getDIE(N))
Devang Patel13e16b62009-06-26 01:49:18 +00001632 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001633
1634 if (!SP.isDefinition())
1635 // This is a method declaration which will be handled while constructing
1636 // class type.
Devang Patel13e16b62009-06-26 01:49:18 +00001637 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001638
Devang Patel2c4ceb12009-11-21 02:48:08 +00001639 DIE *SubprogramDie = createSubprogramDIE(ModuleCU, SP);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001640
1641 // Add to map.
Devang Patel017d1212009-11-20 21:37:22 +00001642 ModuleCU->insertDIE(N, SubprogramDie);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001643
1644 // Add to context owner.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001645 ModuleCU->getCUDie()->addChild(SubprogramDie);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001646
1647 // Expose as global.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001648 ModuleCU->addGlobal(SP.getName(), SubprogramDie);
Devang Patel13e16b62009-06-26 01:49:18 +00001649 return;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001650}
1651
Devang Patel2c4ceb12009-11-21 02:48:08 +00001652/// beginModule - Emit all Dwarf sections that should come prior to the
Daniel Dunbar00564992009-09-19 20:40:14 +00001653/// content. Create global DIEs and emit initial debug info sections.
1654/// This is inovked by the target AsmPrinter.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001655void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
Devang Patel208622d2009-06-25 22:36:02 +00001656 this->M = M;
1657
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001658 if (TimePassesIsEnabled)
1659 DebugTimer->startTimer();
1660
Devang Patel3380cc52009-11-11 19:55:08 +00001661 if (!MAI->doesSupportDebugInformation())
1662 return;
1663
Devang Patel78ab9e22009-07-30 18:56:46 +00001664 DebugInfoFinder DbgFinder;
1665 DbgFinder.processModule(*M);
Devang Patel13e16b62009-06-26 01:49:18 +00001666
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001667 // Create all the compile unit DIEs.
Devang Patel78ab9e22009-07-30 18:56:46 +00001668 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1669 E = DbgFinder.compile_unit_end(); I != E; ++I)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001670 constructCompileUnit(*I);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001671
1672 if (CompileUnits.empty()) {
1673 if (TimePassesIsEnabled)
1674 DebugTimer->stopTimer();
1675
1676 return;
1677 }
1678
Devang Patel70f44262009-06-29 20:38:13 +00001679 // If main compile unit for this module is not seen than randomly
1680 // select first compile unit.
Devang Patel1dbc7712009-06-29 20:45:18 +00001681 if (!ModuleCU)
1682 ModuleCU = CompileUnits[0];
Devang Patel70f44262009-06-29 20:38:13 +00001683
Devang Patel13e16b62009-06-26 01:49:18 +00001684 // Create DIEs for each of the externally visible global variables.
Devang Patel78ab9e22009-07-30 18:56:46 +00001685 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
Devang Patelfd07cf52009-10-05 23:40:42 +00001686 E = DbgFinder.global_variable_end(); I != E; ++I) {
1687 DIGlobalVariable GV(*I);
1688 if (GV.getContext().getNode() != GV.getCompileUnit().getNode())
1689 ScopedGVs.push_back(*I);
1690 else
Devang Patel2c4ceb12009-11-21 02:48:08 +00001691 constructGlobalVariableDIE(*I);
Devang Patelfd07cf52009-10-05 23:40:42 +00001692 }
Devang Patel13e16b62009-06-26 01:49:18 +00001693
Devang Patel53bb5c92009-11-10 23:06:00 +00001694 // Create DIEs for each subprogram.
Devang Patel78ab9e22009-07-30 18:56:46 +00001695 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1696 E = DbgFinder.subprogram_end(); I != E; ++I)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001697 constructSubprogramDIE(*I);
Devang Patel13e16b62009-06-26 01:49:18 +00001698
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001699 MMI = mmi;
1700 shouldEmit = true;
1701 MMI->setDebugInfoAvailability(true);
1702
1703 // Prime section data.
Chris Lattnerf0144122009-07-28 03:13:23 +00001704 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001705
1706 // Print out .file directives to specify files for .loc directives. These are
1707 // printed out early so that they precede any .loc directives.
Chris Lattner33adcfb2009-08-22 21:43:10 +00001708 if (MAI->hasDotLocAndDotFile()) {
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001709 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1710 // Remember source id starts at 1.
1711 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1712 sys::Path FullPath(getSourceDirectoryName(Id.first));
1713 bool AppendOk =
1714 FullPath.appendComponent(getSourceFileName(Id.second));
1715 assert(AppendOk && "Could not append filename to directory!");
1716 AppendOk = false;
Chris Lattner74382b72009-08-23 22:45:37 +00001717 Asm->EmitFile(i, FullPath.str());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001718 Asm->EOL();
1719 }
1720 }
1721
1722 // Emit initial sections
Devang Patel2c4ceb12009-11-21 02:48:08 +00001723 emitInitial();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001724
1725 if (TimePassesIsEnabled)
1726 DebugTimer->stopTimer();
1727}
1728
Devang Patel2c4ceb12009-11-21 02:48:08 +00001729/// endModule - Emit all Dwarf sections that should come after the content.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001730///
Devang Patel2c4ceb12009-11-21 02:48:08 +00001731void DwarfDebug::endModule() {
Devang Patel6f3dc922009-10-06 00:03:14 +00001732 if (!ModuleCU)
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001733 return;
1734
1735 if (TimePassesIsEnabled)
1736 DebugTimer->startTimer();
1737
Devang Patel53bb5c92009-11-10 23:06:00 +00001738 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1739 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1740 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1741 DIE *ISP = *AI;
Devang Patel2c4ceb12009-11-21 02:48:08 +00001742 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
Devang Patel53bb5c92009-11-10 23:06:00 +00001743 }
1744
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001745 // Standard sections final addresses.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00001746 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001747 EmitLabel("text_end", 0);
Chris Lattner6c2f9e12009-08-19 05:49:37 +00001748 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001749 EmitLabel("data_end", 0);
1750
1751 // End text sections.
1752 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
Chris Lattner6c2f9e12009-08-19 05:49:37 +00001753 Asm->OutStreamer.SwitchSection(SectionMap[i]);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001754 EmitLabel("section_end", i);
1755 }
1756
1757 // Emit common frame information.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001758 emitCommonDebugFrame();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001759
1760 // Emit function debug frame information
1761 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1762 E = DebugFrames.end(); I != E; ++I)
Devang Patel2c4ceb12009-11-21 02:48:08 +00001763 emitFunctionDebugFrame(*I);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001764
1765 // Compute DIE offsets and sizes.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001766 computeSizeAndOffsets();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001767
1768 // Emit all the DIEs into a debug info section
Devang Patel2c4ceb12009-11-21 02:48:08 +00001769 emitDebugInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001770
1771 // Corresponding abbreviations into a abbrev section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001772 emitAbbreviations();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001773
1774 // Emit source line correspondence into a debug line section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001775 emitDebugLines();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001776
1777 // Emit info into a debug pubnames section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001778 emitDebugPubNames();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001779
1780 // Emit info into a debug str section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001781 emitDebugStr();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001782
1783 // Emit info into a debug loc section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001784 emitDebugLoc();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001785
1786 // Emit info into a debug aranges section.
1787 EmitDebugARanges();
1788
1789 // Emit info into a debug ranges section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001790 emitDebugRanges();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001791
1792 // Emit info into a debug macinfo section.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001793 emitDebugMacInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001794
1795 // Emit inline info.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001796 emitDebugInlineInfo();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001797
1798 if (TimePassesIsEnabled)
1799 DebugTimer->stopTimer();
1800}
1801
Devang Patel53bb5c92009-11-10 23:06:00 +00001802/// findAbstractVariable - Find abstract variable, if any, associated with Var.
Jim Grosbach7ab38df2009-11-22 19:20:36 +00001803DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1804 unsigned FrameIdx,
Devang Patel53bb5c92009-11-10 23:06:00 +00001805 DILocation &ScopeLoc) {
1806
1807 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1808 if (AbsDbgVariable)
1809 return AbsDbgVariable;
1810
1811 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1812 if (!Scope)
1813 return NULL;
1814
1815 AbsDbgVariable = new DbgVariable(Var, FrameIdx);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001816 Scope->addVariable(AbsDbgVariable);
Devang Patel53bb5c92009-11-10 23:06:00 +00001817 AbstractVariables[Var.getNode()] = AbsDbgVariable;
1818 return AbsDbgVariable;
1819}
1820
Devang Patel2c4ceb12009-11-21 02:48:08 +00001821/// collectVariableInfo - Populate DbgScope entries with variables' info.
1822void DwarfDebug::collectVariableInfo() {
Devang Patelac1ceb32009-10-09 22:42:28 +00001823 if (!MMI) return;
Devang Patel53bb5c92009-11-10 23:06:00 +00001824
Devang Patele717faa2009-10-06 01:26:37 +00001825 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1826 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1827 VE = VMap.end(); VI != VE; ++VI) {
Devang Patelac1ceb32009-10-09 22:42:28 +00001828 MetadataBase *MB = VI->first;
1829 MDNode *Var = dyn_cast_or_null<MDNode>(MB);
Devang Patel53bb5c92009-11-10 23:06:00 +00001830 if (!Var) continue;
Devang Pateleda31212009-10-08 18:48:03 +00001831 DIVariable DV (Var);
Devang Patel53bb5c92009-11-10 23:06:00 +00001832 std::pair< unsigned, MDNode *> VP = VI->second;
1833 DILocation ScopeLoc(VP.second);
1834
1835 DbgScope *Scope =
1836 ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1837 if (!Scope)
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001838 Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
Devang Patelfb0ee432009-11-10 23:20:04 +00001839 // If variable scope is not found then skip this variable.
1840 if (!Scope)
1841 continue;
Devang Patel53bb5c92009-11-10 23:06:00 +00001842
1843 DbgVariable *RegVar = new DbgVariable(DV, VP.first);
Devang Patel2c4ceb12009-11-21 02:48:08 +00001844 Scope->addVariable(RegVar);
Jim Grosbach7ab38df2009-11-22 19:20:36 +00001845 if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1846 ScopeLoc))
Devang Patel53bb5c92009-11-10 23:06:00 +00001847 RegVar->setAbstractVariable(AbsDbgVariable);
Devang Patele717faa2009-10-06 01:26:37 +00001848 }
1849}
1850
Devang Patel2c4ceb12009-11-21 02:48:08 +00001851/// beginScope - Process beginning of a scope starting at Label.
1852void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
Devang Patel0d20ac82009-10-06 01:50:42 +00001853 InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1854 if (I == DbgScopeBeginMap.end())
1855 return;
Devang Patel53bb5c92009-11-10 23:06:00 +00001856 ScopeVector &SD = DbgScopeBeginMap[MI];
1857 for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001858 SDI != SDE; ++SDI)
Devang Patel0d20ac82009-10-06 01:50:42 +00001859 (*SDI)->setStartLabelID(Label);
1860}
1861
Devang Patel2c4ceb12009-11-21 02:48:08 +00001862/// endScope - Process end of a scope.
1863void DwarfDebug::endScope(const MachineInstr *MI) {
Devang Patel0d20ac82009-10-06 01:50:42 +00001864 InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
Devang Patel8a4087d2009-10-06 03:15:38 +00001865 if (I == DbgScopeEndMap.end())
Devang Patel0d20ac82009-10-06 01:50:42 +00001866 return;
Devang Patel53bb5c92009-11-10 23:06:00 +00001867
1868 unsigned Label = MMI->NextLabelID();
1869 Asm->printLabel(Label);
1870
Devang Patel0d20ac82009-10-06 01:50:42 +00001871 SmallVector<DbgScope *, 2> &SD = I->second;
1872 for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001873 SDI != SDE; ++SDI)
Devang Patel0d20ac82009-10-06 01:50:42 +00001874 (*SDI)->setEndLabelID(Label);
Devang Patel53bb5c92009-11-10 23:06:00 +00001875 return;
1876}
1877
1878/// createDbgScope - Create DbgScope for the scope.
1879void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1880
1881 if (!InlinedAt) {
1882 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1883 if (WScope)
1884 return;
1885 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1886 DbgScopeMap.insert(std::make_pair(Scope, WScope));
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001887 if (DIDescriptor(Scope).isLexicalBlock())
Devang Patel2f105c62009-11-11 00:18:40 +00001888 createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
Devang Patel53bb5c92009-11-10 23:06:00 +00001889 return;
1890 }
1891
1892 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1893 if (WScope)
1894 return;
1895
1896 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1897 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1898 DILocation DL(InlinedAt);
1899 createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
Devang Patel0d20ac82009-10-06 01:50:42 +00001900}
1901
Devang Patel2c4ceb12009-11-21 02:48:08 +00001902/// extractScopeInformation - Scan machine instructions in this function
Devang Patelaf9e8472009-10-01 20:31:14 +00001903/// and collect DbgScopes. Return true, if atleast one scope was found.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001904bool DwarfDebug::extractScopeInformation(MachineFunction *MF) {
Devang Patelaf9e8472009-10-01 20:31:14 +00001905 // If scope information was extracted using .dbg intrinsics then there is not
1906 // any need to extract these information by scanning each instruction.
1907 if (!DbgScopeMap.empty())
1908 return false;
1909
Devang Patel53bb5c92009-11-10 23:06:00 +00001910 // Scan each instruction and create scopes. First build working set of scopes.
Devang Patelaf9e8472009-10-01 20:31:14 +00001911 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1912 I != E; ++I) {
1913 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1914 II != IE; ++II) {
1915 const MachineInstr *MInsn = II;
1916 DebugLoc DL = MInsn->getDebugLoc();
Devang Patel53bb5c92009-11-10 23:06:00 +00001917 if (DL.isUnknown()) continue;
Devang Patelaf9e8472009-10-01 20:31:14 +00001918 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
Devang Patel53bb5c92009-11-10 23:06:00 +00001919 if (!DLT.Scope) continue;
Devang Patelaf9e8472009-10-01 20:31:14 +00001920 // There is no need to create another DIE for compile unit. For all
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001921 // other scopes, create one DbgScope now. This will be translated
Devang Patelaf9e8472009-10-01 20:31:14 +00001922 // into a scope DIE at the end.
Devang Patel53bb5c92009-11-10 23:06:00 +00001923 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
1924 createDbgScope(DLT.Scope, DLT.InlinedAtLoc);
1925 }
1926 }
1927
1928
1929 // Build scope hierarchy using working set of scopes.
1930 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1931 I != E; ++I) {
1932 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1933 II != IE; ++II) {
1934 const MachineInstr *MInsn = II;
1935 DebugLoc DL = MInsn->getDebugLoc();
1936 if (DL.isUnknown()) continue;
1937 DebugLocTuple DLT = MF->getDebugLocTuple(DL);
1938 if (!DLT.Scope) continue;
1939 // There is no need to create another DIE for compile unit. For all
Jim Grosbach31ef40e2009-11-21 23:12:12 +00001940 // other scopes, create one DbgScope now. This will be translated
Devang Patel53bb5c92009-11-10 23:06:00 +00001941 // into a scope DIE at the end.
1942 if (DIDescriptor(DLT.Scope).isCompileUnit()) continue;
1943 DbgScope *Scope = getUpdatedDbgScope(DLT.Scope, MInsn, DLT.InlinedAtLoc);
1944 Scope->setLastInsn(MInsn);
Devang Patelaf9e8472009-10-01 20:31:14 +00001945 }
1946 }
1947
1948 // If a scope's last instruction is not set then use its child scope's
1949 // last instruction as this scope's last instrunction.
Devang Patelbdf45cb2009-10-27 20:47:17 +00001950 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
Devang Patelaf9e8472009-10-01 20:31:14 +00001951 DE = DbgScopeMap.end(); DI != DE; ++DI) {
Devang Patel53bb5c92009-11-10 23:06:00 +00001952 if (DI->second->isAbstractScope())
1953 continue;
Devang Patelaf9e8472009-10-01 20:31:14 +00001954 assert (DI->second->getFirstInsn() && "Invalid first instruction!");
Devang Patel2c4ceb12009-11-21 02:48:08 +00001955 DI->second->fixInstructionMarkers();
Devang Patelaf9e8472009-10-01 20:31:14 +00001956 assert (DI->second->getLastInsn() && "Invalid last instruction!");
1957 }
1958
1959 // Each scope has first instruction and last instruction to mark beginning
1960 // and end of a scope respectively. Create an inverse map that list scopes
1961 // starts (and ends) with an instruction. One instruction may start (or end)
1962 // multiple scopes.
Devang Patelbdf45cb2009-10-27 20:47:17 +00001963 for (ValueMap<MDNode *, DbgScope *>::iterator DI = DbgScopeMap.begin(),
Devang Patelaf9e8472009-10-01 20:31:14 +00001964 DE = DbgScopeMap.end(); DI != DE; ++DI) {
1965 DbgScope *S = DI->second;
Devang Patel53bb5c92009-11-10 23:06:00 +00001966 if (S->isAbstractScope())
1967 continue;
Devang Patelaf9e8472009-10-01 20:31:14 +00001968 const MachineInstr *MI = S->getFirstInsn();
1969 assert (MI && "DbgScope does not have first instruction!");
1970
1971 InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
1972 if (IDI != DbgScopeBeginMap.end())
1973 IDI->second.push_back(S);
1974 else
Devang Patel53bb5c92009-11-10 23:06:00 +00001975 DbgScopeBeginMap[MI].push_back(S);
Devang Patelaf9e8472009-10-01 20:31:14 +00001976
1977 MI = S->getLastInsn();
1978 assert (MI && "DbgScope does not have last instruction!");
1979 IDI = DbgScopeEndMap.find(MI);
1980 if (IDI != DbgScopeEndMap.end())
1981 IDI->second.push_back(S);
1982 else
Devang Patel53bb5c92009-11-10 23:06:00 +00001983 DbgScopeEndMap[MI].push_back(S);
Devang Patelaf9e8472009-10-01 20:31:14 +00001984 }
1985
1986 return !DbgScopeMap.empty();
1987}
1988
Devang Patel2c4ceb12009-11-21 02:48:08 +00001989/// beginFunction - Gather pre-function debug information. Assumes being
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001990/// emitted immediately after the function entry point.
Devang Patel2c4ceb12009-11-21 02:48:08 +00001991void DwarfDebug::beginFunction(MachineFunction *MF) {
Bill Wendlingf0fb9872009-05-20 23:19:06 +00001992 this->MF = MF;
1993
1994 if (!ShouldEmitDwarfDebug()) return;
1995
1996 if (TimePassesIsEnabled)
1997 DebugTimer->startTimer();
1998
Devang Patel2c4ceb12009-11-21 02:48:08 +00001999 if (!extractScopeInformation(MF))
Devang Patel60b35bd2009-10-06 18:37:31 +00002000 return;
Devang Patel2c4ceb12009-11-21 02:48:08 +00002001
2002 collectVariableInfo();
Devang Patel60b35bd2009-10-06 18:37:31 +00002003
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002004 // Begin accumulating function debug information.
2005 MMI->BeginFunction(MF);
2006
2007 // Assumes in correct section after the entry point.
2008 EmitLabel("func_begin", ++SubprogramCount);
2009
2010 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2011 // function.
Devang Patelac1ceb32009-10-09 22:42:28 +00002012 DebugLoc FDL = MF->getDefaultDebugLoc();
2013 if (!FDL.isUnknown()) {
2014 DebugLocTuple DLT = MF->getDebugLocTuple(FDL);
2015 unsigned LabelID = 0;
Devang Patel1619dc32009-10-13 23:28:53 +00002016 DISubprogram SP = getDISubprogram(DLT.Scope);
Devang Patelac1ceb32009-10-09 22:42:28 +00002017 if (!SP.isNull())
Devang Patel2c4ceb12009-11-21 02:48:08 +00002018 LabelID = recordSourceLine(SP.getLineNumber(), 0, DLT.Scope);
Devang Patelac1ceb32009-10-09 22:42:28 +00002019 else
Devang Patel2c4ceb12009-11-21 02:48:08 +00002020 LabelID = recordSourceLine(DLT.Line, DLT.Col, DLT.Scope);
Devang Patelac1ceb32009-10-09 22:42:28 +00002021 Asm->printLabel(LabelID);
2022 O << '\n';
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002023 }
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002024 if (TimePassesIsEnabled)
2025 DebugTimer->stopTimer();
2026}
2027
Devang Patel2c4ceb12009-11-21 02:48:08 +00002028/// endFunction - Gather and emit post-function debug information.
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002029///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002030void DwarfDebug::endFunction(MachineFunction *MF) {
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002031 if (!ShouldEmitDwarfDebug()) return;
2032
2033 if (TimePassesIsEnabled)
2034 DebugTimer->startTimer();
2035
Devang Patelac1ceb32009-10-09 22:42:28 +00002036 if (DbgScopeMap.empty())
2037 return;
Devang Patel70d75ca2009-11-12 19:02:56 +00002038
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002039 // Define end label for subprogram.
2040 EmitLabel("func_end", SubprogramCount);
2041
2042 // Get function line info.
2043 if (!Lines.empty()) {
2044 // Get section line info.
Chris Lattner290c2f52009-08-03 23:20:21 +00002045 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002046 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2047 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2048 // Append the function info to section info.
2049 SectionLineInfos.insert(SectionLineInfos.end(),
2050 Lines.begin(), Lines.end());
2051 }
2052
Devang Patel53bb5c92009-11-10 23:06:00 +00002053 // Construct abstract scopes.
2054 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
Jim Grosbach31ef40e2009-11-21 23:12:12 +00002055 AE = AbstractScopesList.end(); AI != AE; ++AI)
Devang Patel2c4ceb12009-11-21 02:48:08 +00002056 constructScopeDIE(*AI);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002057
Devang Patel2c4ceb12009-11-21 02:48:08 +00002058 constructScopeDIE(CurrentFnDbgScope);
Devang Patel70d75ca2009-11-12 19:02:56 +00002059
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002060 DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2061 MMI->getFrameMoves()));
2062
2063 // Clear debug info
Devang Patel53bb5c92009-11-10 23:06:00 +00002064 if (CurrentFnDbgScope) {
2065 CurrentFnDbgScope = NULL;
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002066 DbgScopeMap.clear();
Devang Patelaf9e8472009-10-01 20:31:14 +00002067 DbgScopeBeginMap.clear();
2068 DbgScopeEndMap.clear();
Devang Patel53bb5c92009-11-10 23:06:00 +00002069 ConcreteScopes.clear();
2070 AbstractScopesList.clear();
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002071 }
2072
2073 Lines.clear();
2074
2075 if (TimePassesIsEnabled)
2076 DebugTimer->stopTimer();
2077}
2078
Devang Patel2c4ceb12009-11-21 02:48:08 +00002079/// recordSourceLine - Records location information and associates it with a
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002080/// label. Returns a unique label ID used to generate a label and provide
2081/// correspondence to the source line list.
Jim Grosbach31ef40e2009-11-21 23:12:12 +00002082unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
Devang Patelf84548d2009-10-05 18:03:19 +00002083 MDNode *S) {
Devang Patele4b27562009-08-28 23:24:31 +00002084 if (!MMI)
2085 return 0;
2086
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002087 if (TimePassesIsEnabled)
2088 DebugTimer->startTimer();
2089
Devang Patelf84548d2009-10-05 18:03:19 +00002090 const char *Dir = NULL;
2091 const char *Fn = NULL;
2092
2093 DIDescriptor Scope(S);
2094 if (Scope.isCompileUnit()) {
2095 DICompileUnit CU(S);
2096 Dir = CU.getDirectory();
2097 Fn = CU.getFilename();
2098 } else if (Scope.isSubprogram()) {
2099 DISubprogram SP(S);
2100 Dir = SP.getDirectory();
2101 Fn = SP.getFilename();
2102 } else if (Scope.isLexicalBlock()) {
2103 DILexicalBlock DB(S);
2104 Dir = DB.getDirectory();
2105 Fn = DB.getFilename();
2106 } else
2107 assert (0 && "Unexpected scope info");
2108
2109 unsigned Src = GetOrCreateSourceID(Dir, Fn);
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002110 unsigned ID = MMI->NextLabelID();
2111 Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2112
2113 if (TimePassesIsEnabled)
2114 DebugTimer->stopTimer();
2115
2116 return ID;
2117}
2118
2119/// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2120/// timed. Look up the source id with the given directory and source file
2121/// names. If none currently exists, create a new id and insert it in the
2122/// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2123/// well.
2124unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2125 const std::string &FileName) {
2126 if (TimePassesIsEnabled)
2127 DebugTimer->startTimer();
2128
Devang Patel5ccdd102009-09-29 18:40:58 +00002129 unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
Bill Wendlingf0fb9872009-05-20 23:19:06 +00002130
2131 if (TimePassesIsEnabled)
2132 DebugTimer->stopTimer();
2133
2134 return SrcId;
2135}
2136
Bill Wendling829e67b2009-05-20 23:22:40 +00002137//===----------------------------------------------------------------------===//
2138// Emit Methods
2139//===----------------------------------------------------------------------===//
2140
Devang Patel2c4ceb12009-11-21 02:48:08 +00002141/// computeSizeAndOffset - Compute the size and offset of a DIE.
Bill Wendling94d04b82009-05-20 23:21:38 +00002142///
Jim Grosbach7ab38df2009-11-22 19:20:36 +00002143unsigned
2144DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
Bill Wendling94d04b82009-05-20 23:21:38 +00002145 // Get the children.
2146 const std::vector<DIE *> &Children = Die->getChildren();
2147
2148 // If not last sibling and has children then add sibling offset attribute.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002149 if (!Last && !Children.empty()) Die->addSiblingOffset();
Bill Wendling94d04b82009-05-20 23:21:38 +00002150
2151 // Record the abbreviation.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002152 assignAbbrevNumber(Die->getAbbrev());
Bill Wendling94d04b82009-05-20 23:21:38 +00002153
2154 // Get the abbreviation for this DIE.
2155 unsigned AbbrevNumber = Die->getAbbrevNumber();
2156 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2157
2158 // Set DIE offset
2159 Die->setOffset(Offset);
2160
2161 // Start the size with the size of abbreviation code.
Chris Lattneraf76e592009-08-22 20:48:53 +00002162 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
Bill Wendling94d04b82009-05-20 23:21:38 +00002163
2164 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2165 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2166
2167 // Size the DIE attribute values.
2168 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2169 // Size attribute value.
2170 Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2171
2172 // Size the DIE children if any.
2173 if (!Children.empty()) {
2174 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2175 "Children flag not set");
2176
2177 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel2c4ceb12009-11-21 02:48:08 +00002178 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
Bill Wendling94d04b82009-05-20 23:21:38 +00002179
2180 // End of children marker.
2181 Offset += sizeof(int8_t);
2182 }
2183
2184 Die->setSize(Offset - Die->getOffset());
2185 return Offset;
2186}
2187
Devang Patel2c4ceb12009-11-21 02:48:08 +00002188/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
Bill Wendling94d04b82009-05-20 23:21:38 +00002189///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002190void DwarfDebug::computeSizeAndOffsets() {
Bill Wendling94d04b82009-05-20 23:21:38 +00002191 // Compute size of compile unit header.
2192 static unsigned Offset =
2193 sizeof(int32_t) + // Length of Compilation Unit Info
2194 sizeof(int16_t) + // DWARF version number
2195 sizeof(int32_t) + // Offset Into Abbrev. Section
2196 sizeof(int8_t); // Pointer Size (in bytes)
2197
Devang Patel2c4ceb12009-11-21 02:48:08 +00002198 computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
Devang Patel1dbc7712009-06-29 20:45:18 +00002199 CompileUnitOffsets[ModuleCU] = 0;
Bill Wendling94d04b82009-05-20 23:21:38 +00002200}
2201
Devang Patel2c4ceb12009-11-21 02:48:08 +00002202/// emitInitial - Emit initial Dwarf declarations. This is necessary for cc
Bill Wendling94d04b82009-05-20 23:21:38 +00002203/// tools to recognize the object file contains Dwarf information.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002204void DwarfDebug::emitInitial() {
Bill Wendling94d04b82009-05-20 23:21:38 +00002205 // Check to see if we already emitted intial headers.
2206 if (didInitial) return;
2207 didInitial = true;
2208
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002209 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarf612ff62009-09-19 20:40:05 +00002210
Bill Wendling94d04b82009-05-20 23:21:38 +00002211 // Dwarf sections base addresses.
Chris Lattner33adcfb2009-08-22 21:43:10 +00002212 if (MAI->doesDwarfRequireFrameSection()) {
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002213 Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002214 EmitLabel("section_debug_frame", 0);
2215 }
2216
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002217 Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002218 EmitLabel("section_info", 0);
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002219 Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002220 EmitLabel("section_abbrev", 0);
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002221 Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002222 EmitLabel("section_aranges", 0);
2223
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002224 if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2225 Asm->OutStreamer.SwitchSection(LineInfoDirective);
Bill Wendling94d04b82009-05-20 23:21:38 +00002226 EmitLabel("section_macinfo", 0);
2227 }
2228
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002229 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002230 EmitLabel("section_line", 0);
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002231 Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002232 EmitLabel("section_loc", 0);
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002233 Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002234 EmitLabel("section_pubnames", 0);
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002235 Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002236 EmitLabel("section_str", 0);
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002237 Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002238 EmitLabel("section_ranges", 0);
2239
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002240 Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002241 EmitLabel("text_begin", 0);
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002242 Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002243 EmitLabel("data_begin", 0);
2244}
2245
Devang Patel2c4ceb12009-11-21 02:48:08 +00002246/// emitDIE - Recusively Emits a debug information entry.
Bill Wendling94d04b82009-05-20 23:21:38 +00002247///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002248void DwarfDebug::emitDIE(DIE *Die) {
Bill Wendling94d04b82009-05-20 23:21:38 +00002249 // Get the abbreviation for this DIE.
2250 unsigned AbbrevNumber = Die->getAbbrevNumber();
2251 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2252
2253 Asm->EOL();
2254
2255 // Emit the code (index) for the abbreviation.
2256 Asm->EmitULEB128Bytes(AbbrevNumber);
2257
2258 if (Asm->isVerbose())
2259 Asm->EOL(std::string("Abbrev [" +
2260 utostr(AbbrevNumber) +
2261 "] 0x" + utohexstr(Die->getOffset()) +
2262 ":0x" + utohexstr(Die->getSize()) + " " +
2263 dwarf::TagString(Abbrev->getTag())));
2264 else
2265 Asm->EOL();
2266
2267 SmallVector<DIEValue*, 32> &Values = Die->getValues();
2268 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2269
2270 // Emit the DIE attribute values.
2271 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2272 unsigned Attr = AbbrevData[i].getAttribute();
2273 unsigned Form = AbbrevData[i].getForm();
2274 assert(Form && "Too many attributes for DIE (check abbreviation)");
2275
2276 switch (Attr) {
2277 case dwarf::DW_AT_sibling:
Devang Patel2c4ceb12009-11-21 02:48:08 +00002278 Asm->EmitInt32(Die->getSiblingOffset());
Bill Wendling94d04b82009-05-20 23:21:38 +00002279 break;
2280 case dwarf::DW_AT_abstract_origin: {
2281 DIEEntry *E = cast<DIEEntry>(Values[i]);
2282 DIE *Origin = E->getEntry();
Devang Patel53bb5c92009-11-10 23:06:00 +00002283 unsigned Addr = Origin->getOffset();
Bill Wendling94d04b82009-05-20 23:21:38 +00002284 Asm->EmitInt32(Addr);
2285 break;
2286 }
2287 default:
2288 // Emit an attribute using the defined form.
2289 Values[i]->EmitValue(this, Form);
2290 break;
2291 }
2292
2293 Asm->EOL(dwarf::AttributeString(Attr));
2294 }
2295
2296 // Emit the DIE children if any.
2297 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2298 const std::vector<DIE *> &Children = Die->getChildren();
2299
2300 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel2c4ceb12009-11-21 02:48:08 +00002301 emitDIE(Children[j]);
Bill Wendling94d04b82009-05-20 23:21:38 +00002302
2303 Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
2304 }
2305}
2306
Devang Patel2c4ceb12009-11-21 02:48:08 +00002307/// emitDebugInfo / emitDebugInfoPerCU - Emit the debug info section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002308///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002309void DwarfDebug::emitDebugInfoPerCU(CompileUnit *Unit) {
Devang Patel017d1212009-11-20 21:37:22 +00002310 DIE *Die = Unit->getCUDie();
Bill Wendling94d04b82009-05-20 23:21:38 +00002311
2312 // Emit the compile units header.
2313 EmitLabel("info_begin", Unit->getID());
2314
2315 // Emit size of content not including length itself
2316 unsigned ContentSize = Die->getSize() +
2317 sizeof(int16_t) + // DWARF version number
2318 sizeof(int32_t) + // Offset Into Abbrev. Section
2319 sizeof(int8_t) + // Pointer Size (in bytes)
2320 sizeof(int32_t); // FIXME - extra pad for gdb bug.
2321
2322 Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info");
2323 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2324 EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2325 Asm->EOL("Offset Into Abbrev. Section");
2326 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2327
Devang Patel2c4ceb12009-11-21 02:48:08 +00002328 emitDIE(Die);
Bill Wendling94d04b82009-05-20 23:21:38 +00002329 // FIXME - extra padding for gdb bug.
2330 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2331 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2332 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2333 Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
2334 EmitLabel("info_end", Unit->getID());
2335
2336 Asm->EOL();
2337}
2338
Devang Patel2c4ceb12009-11-21 02:48:08 +00002339void DwarfDebug::emitDebugInfo() {
Bill Wendling94d04b82009-05-20 23:21:38 +00002340 // Start debug info section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002341 Asm->OutStreamer.SwitchSection(
2342 Asm->getObjFileLowering().getDwarfInfoSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002343
Devang Patel2c4ceb12009-11-21 02:48:08 +00002344 emitDebugInfoPerCU(ModuleCU);
Bill Wendling94d04b82009-05-20 23:21:38 +00002345}
2346
Devang Patel2c4ceb12009-11-21 02:48:08 +00002347/// emitAbbreviations - Emit the abbreviation section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002348///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002349void DwarfDebug::emitAbbreviations() const {
Bill Wendling94d04b82009-05-20 23:21:38 +00002350 // Check to see if it is worth the effort.
2351 if (!Abbreviations.empty()) {
2352 // Start the debug abbrev section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002353 Asm->OutStreamer.SwitchSection(
2354 Asm->getObjFileLowering().getDwarfAbbrevSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002355
2356 EmitLabel("abbrev_begin", 0);
2357
2358 // For each abbrevation.
2359 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2360 // Get abbreviation data
2361 const DIEAbbrev *Abbrev = Abbreviations[i];
2362
2363 // Emit the abbrevations code (base 1 index.)
2364 Asm->EmitULEB128Bytes(Abbrev->getNumber());
2365 Asm->EOL("Abbreviation Code");
2366
2367 // Emit the abbreviations data.
2368 Abbrev->Emit(Asm);
2369
2370 Asm->EOL();
2371 }
2372
2373 // Mark end of abbreviations.
2374 Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
2375
2376 EmitLabel("abbrev_end", 0);
2377 Asm->EOL();
2378 }
2379}
2380
Devang Patel2c4ceb12009-11-21 02:48:08 +00002381/// emitEndOfLineMatrix - Emit the last address of the section and the end of
Bill Wendling94d04b82009-05-20 23:21:38 +00002382/// the line matrix.
2383///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002384void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling94d04b82009-05-20 23:21:38 +00002385 // Define last address of section.
2386 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2387 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2388 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2389 EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
2390
2391 // Mark end of matrix.
2392 Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
2393 Asm->EmitULEB128Bytes(1); Asm->EOL();
2394 Asm->EmitInt8(1); Asm->EOL();
2395}
2396
Devang Patel2c4ceb12009-11-21 02:48:08 +00002397/// emitDebugLines - Emit source line information.
Bill Wendling94d04b82009-05-20 23:21:38 +00002398///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002399void DwarfDebug::emitDebugLines() {
Bill Wendling94d04b82009-05-20 23:21:38 +00002400 // If the target is using .loc/.file, the assembler will be emitting the
2401 // .debug_line table automatically.
Chris Lattner33adcfb2009-08-22 21:43:10 +00002402 if (MAI->hasDotLocAndDotFile())
Bill Wendling94d04b82009-05-20 23:21:38 +00002403 return;
2404
2405 // Minimum line delta, thus ranging from -10..(255-10).
2406 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2407 // Maximum line delta, thus ranging from -10..(255-10).
2408 const int MaxLineDelta = 255 + MinLineDelta;
2409
2410 // Start the dwarf line section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002411 Asm->OutStreamer.SwitchSection(
2412 Asm->getObjFileLowering().getDwarfLineSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002413
2414 // Construct the section header.
2415 EmitDifference("line_end", 0, "line_begin", 0, true);
2416 Asm->EOL("Length of Source Line Info");
2417 EmitLabel("line_begin", 0);
2418
2419 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF version number");
2420
2421 EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2422 Asm->EOL("Prolog Length");
2423 EmitLabel("line_prolog_begin", 0);
2424
2425 Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
2426
2427 Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
2428
2429 Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
2430
2431 Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
2432
2433 Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
2434
2435 // Line number standard opcode encodings argument count
2436 Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
2437 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
2438 Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
2439 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
2440 Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
2441 Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
2442 Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
2443 Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
2444 Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
2445
2446 // Emit directories.
2447 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2448 Asm->EmitString(getSourceDirectoryName(DI));
2449 Asm->EOL("Directory");
2450 }
2451
2452 Asm->EmitInt8(0); Asm->EOL("End of directories");
2453
2454 // Emit files.
2455 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2456 // Remember source id starts at 1.
2457 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2458 Asm->EmitString(getSourceFileName(Id.second));
2459 Asm->EOL("Source");
2460 Asm->EmitULEB128Bytes(Id.first);
2461 Asm->EOL("Directory #");
2462 Asm->EmitULEB128Bytes(0);
2463 Asm->EOL("Mod date");
2464 Asm->EmitULEB128Bytes(0);
2465 Asm->EOL("File size");
2466 }
2467
2468 Asm->EmitInt8(0); Asm->EOL("End of files");
2469
2470 EmitLabel("line_prolog_end", 0);
2471
2472 // A sequence for each text section.
2473 unsigned SecSrcLinesSize = SectionSourceLines.size();
2474
2475 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2476 // Isolate current sections line info.
2477 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2478
Chris Lattner93b6db32009-08-08 23:39:42 +00002479 /*if (Asm->isVerbose()) {
Chris Lattnera87dea42009-07-31 18:48:30 +00002480 const MCSection *S = SectionMap[j + 1];
Chris Lattner33adcfb2009-08-22 21:43:10 +00002481 O << '\t' << MAI->getCommentString() << " Section"
Bill Wendling94d04b82009-05-20 23:21:38 +00002482 << S->getName() << '\n';
Chris Lattner93b6db32009-08-08 23:39:42 +00002483 }*/
2484 Asm->EOL();
Bill Wendling94d04b82009-05-20 23:21:38 +00002485
2486 // Dwarf assumes we start with first line of first source file.
2487 unsigned Source = 1;
2488 unsigned Line = 1;
2489
2490 // Construct rows of the address, source, line, column matrix.
2491 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2492 const SrcLineInfo &LineInfo = LineInfos[i];
2493 unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2494 if (!LabelID) continue;
2495
Caroline Ticec6f9d622009-09-11 18:25:54 +00002496 if (LineInfo.getLine() == 0) continue;
2497
Bill Wendling94d04b82009-05-20 23:21:38 +00002498 if (!Asm->isVerbose())
2499 Asm->EOL();
2500 else {
2501 std::pair<unsigned, unsigned> SourceID =
2502 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
Chris Lattner33adcfb2009-08-22 21:43:10 +00002503 O << '\t' << MAI->getCommentString() << ' '
Bill Wendling94d04b82009-05-20 23:21:38 +00002504 << getSourceDirectoryName(SourceID.first) << ' '
2505 << getSourceFileName(SourceID.second)
2506 <<" :" << utostr_32(LineInfo.getLine()) << '\n';
2507 }
2508
2509 // Define the line address.
2510 Asm->EmitInt8(0); Asm->EOL("Extended Op");
2511 Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
2512 Asm->EmitInt8(dwarf::DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
2513 EmitReference("label", LabelID); Asm->EOL("Location label");
2514
2515 // If change of source, then switch to the new source.
2516 if (Source != LineInfo.getSourceID()) {
2517 Source = LineInfo.getSourceID();
2518 Asm->EmitInt8(dwarf::DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
2519 Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
2520 }
2521
2522 // If change of line.
2523 if (Line != LineInfo.getLine()) {
2524 // Determine offset.
2525 int Offset = LineInfo.getLine() - Line;
2526 int Delta = Offset - MinLineDelta;
2527
2528 // Update line.
2529 Line = LineInfo.getLine();
2530
2531 // If delta is small enough and in range...
2532 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2533 // ... then use fast opcode.
2534 Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
2535 } else {
2536 // ... otherwise use long hand.
2537 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2538 Asm->EOL("DW_LNS_advance_line");
2539 Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
2540 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2541 }
2542 } else {
2543 // Copy the previous row (different address or source)
2544 Asm->EmitInt8(dwarf::DW_LNS_copy); Asm->EOL("DW_LNS_copy");
2545 }
2546 }
2547
Devang Patel2c4ceb12009-11-21 02:48:08 +00002548 emitEndOfLineMatrix(j + 1);
Bill Wendling94d04b82009-05-20 23:21:38 +00002549 }
2550
2551 if (SecSrcLinesSize == 0)
2552 // Because we're emitting a debug_line section, we still need a line
2553 // table. The linker and friends expect it to exist. If there's nothing to
2554 // put into it, emit an empty table.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002555 emitEndOfLineMatrix(1);
Bill Wendling94d04b82009-05-20 23:21:38 +00002556
2557 EmitLabel("line_end", 0);
2558 Asm->EOL();
2559}
2560
Devang Patel2c4ceb12009-11-21 02:48:08 +00002561/// emitCommonDebugFrame - Emit common frame info into a debug frame section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002562///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002563void DwarfDebug::emitCommonDebugFrame() {
Chris Lattner33adcfb2009-08-22 21:43:10 +00002564 if (!MAI->doesDwarfRequireFrameSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00002565 return;
2566
2567 int stackGrowth =
2568 Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2569 TargetFrameInfo::StackGrowsUp ?
2570 TD->getPointerSize() : -TD->getPointerSize();
2571
2572 // Start the dwarf frame section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002573 Asm->OutStreamer.SwitchSection(
2574 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002575
2576 EmitLabel("debug_frame_common", 0);
2577 EmitDifference("debug_frame_common_end", 0,
2578 "debug_frame_common_begin", 0, true);
2579 Asm->EOL("Length of Common Information Entry");
2580
2581 EmitLabel("debug_frame_common_begin", 0);
2582 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2583 Asm->EOL("CIE Identifier Tag");
2584 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2585 Asm->EOL("CIE Version");
2586 Asm->EmitString("");
2587 Asm->EOL("CIE Augmentation");
2588 Asm->EmitULEB128Bytes(1);
2589 Asm->EOL("CIE Code Alignment Factor");
2590 Asm->EmitSLEB128Bytes(stackGrowth);
2591 Asm->EOL("CIE Data Alignment Factor");
2592 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2593 Asm->EOL("CIE RA Column");
2594
2595 std::vector<MachineMove> Moves;
2596 RI->getInitialFrameState(Moves);
2597
2598 EmitFrameMoves(NULL, 0, Moves, false);
2599
2600 Asm->EmitAlignment(2, 0, 0, false);
2601 EmitLabel("debug_frame_common_end", 0);
2602
2603 Asm->EOL();
2604}
2605
Devang Patel2c4ceb12009-11-21 02:48:08 +00002606/// emitFunctionDebugFrame - Emit per function frame info into a debug frame
Bill Wendling94d04b82009-05-20 23:21:38 +00002607/// section.
2608void
Devang Patel2c4ceb12009-11-21 02:48:08 +00002609DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
Chris Lattner33adcfb2009-08-22 21:43:10 +00002610 if (!MAI->doesDwarfRequireFrameSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00002611 return;
2612
2613 // Start the dwarf frame section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002614 Asm->OutStreamer.SwitchSection(
2615 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002616
2617 EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2618 "debug_frame_begin", DebugFrameInfo.Number, true);
2619 Asm->EOL("Length of Frame Information Entry");
2620
2621 EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2622
2623 EmitSectionOffset("debug_frame_common", "section_debug_frame",
2624 0, 0, true, false);
2625 Asm->EOL("FDE CIE offset");
2626
2627 EmitReference("func_begin", DebugFrameInfo.Number);
2628 Asm->EOL("FDE initial location");
2629 EmitDifference("func_end", DebugFrameInfo.Number,
2630 "func_begin", DebugFrameInfo.Number);
2631 Asm->EOL("FDE address range");
2632
2633 EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2634 false);
2635
2636 Asm->EmitAlignment(2, 0, 0, false);
2637 EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2638
2639 Asm->EOL();
2640}
2641
Devang Patel2c4ceb12009-11-21 02:48:08 +00002642void DwarfDebug::emitDebugPubNamesPerCU(CompileUnit *Unit) {
Bill Wendling94d04b82009-05-20 23:21:38 +00002643 EmitDifference("pubnames_end", Unit->getID(),
2644 "pubnames_begin", Unit->getID(), true);
2645 Asm->EOL("Length of Public Names Info");
2646
2647 EmitLabel("pubnames_begin", Unit->getID());
2648
2649 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("DWARF Version");
2650
2651 EmitSectionOffset("info_begin", "section_info",
2652 Unit->getID(), 0, true, false);
2653 Asm->EOL("Offset of Compilation Unit Info");
2654
2655 EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID(),
2656 true);
2657 Asm->EOL("Compilation Unit Length");
2658
2659 StringMap<DIE*> &Globals = Unit->getGlobals();
2660 for (StringMap<DIE*>::const_iterator
2661 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2662 const char *Name = GI->getKeyData();
2663 DIE * Entity = GI->second;
2664
2665 Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
2666 Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
2667 }
2668
2669 Asm->EmitInt32(0); Asm->EOL("End Mark");
2670 EmitLabel("pubnames_end", Unit->getID());
2671
2672 Asm->EOL();
2673}
2674
Devang Patel2c4ceb12009-11-21 02:48:08 +00002675/// emitDebugPubNames - Emit visible names into a debug pubnames section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002676///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002677void DwarfDebug::emitDebugPubNames() {
Bill Wendling94d04b82009-05-20 23:21:38 +00002678 // Start the dwarf pubnames section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002679 Asm->OutStreamer.SwitchSection(
2680 Asm->getObjFileLowering().getDwarfPubNamesSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002681
Devang Patel2c4ceb12009-11-21 02:48:08 +00002682 emitDebugPubNamesPerCU(ModuleCU);
Bill Wendling94d04b82009-05-20 23:21:38 +00002683}
2684
Devang Patel2c4ceb12009-11-21 02:48:08 +00002685/// emitDebugStr - Emit visible names into a debug str section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002686///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002687void DwarfDebug::emitDebugStr() {
Bill Wendling94d04b82009-05-20 23:21:38 +00002688 // Check to see if it is worth the effort.
2689 if (!StringPool.empty()) {
2690 // Start the dwarf str section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002691 Asm->OutStreamer.SwitchSection(
2692 Asm->getObjFileLowering().getDwarfStrSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002693
2694 // For each of strings in the string pool.
2695 for (unsigned StringID = 1, N = StringPool.size();
2696 StringID <= N; ++StringID) {
2697 // Emit a label for reference from debug information entries.
2698 EmitLabel("string", StringID);
2699
2700 // Emit the string itself.
2701 const std::string &String = StringPool[StringID];
2702 Asm->EmitString(String); Asm->EOL();
2703 }
2704
2705 Asm->EOL();
2706 }
2707}
2708
Devang Patel2c4ceb12009-11-21 02:48:08 +00002709/// emitDebugLoc - Emit visible names into a debug loc section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002710///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002711void DwarfDebug::emitDebugLoc() {
Bill Wendling94d04b82009-05-20 23:21:38 +00002712 // Start the dwarf loc section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002713 Asm->OutStreamer.SwitchSection(
2714 Asm->getObjFileLowering().getDwarfLocSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002715 Asm->EOL();
2716}
2717
2718/// EmitDebugARanges - Emit visible names into a debug aranges section.
2719///
2720void DwarfDebug::EmitDebugARanges() {
2721 // Start the dwarf aranges section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002722 Asm->OutStreamer.SwitchSection(
2723 Asm->getObjFileLowering().getDwarfARangesSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002724
2725 // FIXME - Mock up
2726#if 0
2727 CompileUnit *Unit = GetBaseCompileUnit();
2728
2729 // Don't include size of length
2730 Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
2731
2732 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2733
2734 EmitReference("info_begin", Unit->getID());
2735 Asm->EOL("Offset of Compilation Unit Info");
2736
2737 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
2738
2739 Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
2740
2741 Asm->EmitInt16(0); Asm->EOL("Pad (1)");
2742 Asm->EmitInt16(0); Asm->EOL("Pad (2)");
2743
2744 // Range 1
2745 EmitReference("text_begin", 0); Asm->EOL("Address");
2746 EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
2747
2748 Asm->EmitInt32(0); Asm->EOL("EOM (1)");
2749 Asm->EmitInt32(0); Asm->EOL("EOM (2)");
2750#endif
2751
2752 Asm->EOL();
2753}
2754
Devang Patel2c4ceb12009-11-21 02:48:08 +00002755/// emitDebugRanges - Emit visible names into a debug ranges section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002756///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002757void DwarfDebug::emitDebugRanges() {
Bill Wendling94d04b82009-05-20 23:21:38 +00002758 // Start the dwarf ranges section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002759 Asm->OutStreamer.SwitchSection(
2760 Asm->getObjFileLowering().getDwarfRangesSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002761 Asm->EOL();
2762}
2763
Devang Patel2c4ceb12009-11-21 02:48:08 +00002764/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
Bill Wendling94d04b82009-05-20 23:21:38 +00002765///
Devang Patel2c4ceb12009-11-21 02:48:08 +00002766void DwarfDebug::emitDebugMacInfo() {
Daniel Dunbarf612ff62009-09-19 20:40:05 +00002767 if (const MCSection *LineInfo =
Chris Lattner18a4c162009-08-02 07:24:22 +00002768 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
Bill Wendling94d04b82009-05-20 23:21:38 +00002769 // Start the dwarf macinfo section.
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002770 Asm->OutStreamer.SwitchSection(LineInfo);
Bill Wendling94d04b82009-05-20 23:21:38 +00002771 Asm->EOL();
2772 }
2773}
2774
Devang Patel2c4ceb12009-11-21 02:48:08 +00002775/// emitDebugInlineInfo - Emit inline info using following format.
Bill Wendling94d04b82009-05-20 23:21:38 +00002776/// Section Header:
2777/// 1. length of section
2778/// 2. Dwarf version number
2779/// 3. address size.
2780///
2781/// Entries (one "entry" for each function that was inlined):
2782///
2783/// 1. offset into __debug_str section for MIPS linkage name, if exists;
2784/// otherwise offset into __debug_str for regular function name.
2785/// 2. offset into __debug_str section for regular function name.
2786/// 3. an unsigned LEB128 number indicating the number of distinct inlining
2787/// instances for the function.
2788///
2789/// The rest of the entry consists of a {die_offset, low_pc} pair for each
2790/// inlined instance; the die_offset points to the inlined_subroutine die in the
2791/// __debug_info section, and the low_pc is the starting address for the
2792/// inlining instance.
Devang Patel2c4ceb12009-11-21 02:48:08 +00002793void DwarfDebug::emitDebugInlineInfo() {
Chris Lattner33adcfb2009-08-22 21:43:10 +00002794 if (!MAI->doesDwarfUsesInlineInfoSection())
Bill Wendling94d04b82009-05-20 23:21:38 +00002795 return;
2796
Devang Patel1dbc7712009-06-29 20:45:18 +00002797 if (!ModuleCU)
Bill Wendling94d04b82009-05-20 23:21:38 +00002798 return;
2799
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002800 Asm->OutStreamer.SwitchSection(
2801 Asm->getObjFileLowering().getDwarfDebugInlineSection());
Bill Wendling94d04b82009-05-20 23:21:38 +00002802 Asm->EOL();
2803 EmitDifference("debug_inlined_end", 1,
2804 "debug_inlined_begin", 1, true);
2805 Asm->EOL("Length of Debug Inlined Information Entry");
2806
2807 EmitLabel("debug_inlined_begin", 1);
2808
2809 Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
2810 Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
2811
Devang Patel53bb5c92009-11-10 23:06:00 +00002812 for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2813 E = InlinedSPNodes.end(); I != E; ++I) {
Jim Grosbach31ef40e2009-11-21 23:12:12 +00002814
Devang Patel53bb5c92009-11-10 23:06:00 +00002815// for (ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
2816 // I = InlineInfo.begin(), E = InlineInfo.end(); I != E; ++I) {
2817 MDNode *Node = *I;
Jim Grosbach7ab38df2009-11-22 19:20:36 +00002818 ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2819 = InlineInfo.find(Node);
Devang Patel53bb5c92009-11-10 23:06:00 +00002820 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
Devang Patele4b27562009-08-28 23:24:31 +00002821 DISubprogram SP(Node);
Devang Patel5ccdd102009-09-29 18:40:58 +00002822 const char *LName = SP.getLinkageName();
2823 const char *Name = SP.getName();
Bill Wendling94d04b82009-05-20 23:21:38 +00002824
Devang Patel5ccdd102009-09-29 18:40:58 +00002825 if (!LName)
Devang Patel53cb17d2009-07-16 01:01:22 +00002826 Asm->EmitString(Name);
2827 else {
Chris Lattner6c2f9e12009-08-19 05:49:37 +00002828 // Skip special LLVM prefix that is used to inform the asm printer to not
2829 // emit usual symbol prefix before the symbol name. This happens for
2830 // Objective-C symbol names and symbol whose name is replaced using GCC's
2831 // __asm__ attribute.
Devang Patel53cb17d2009-07-16 01:01:22 +00002832 if (LName[0] == 1)
2833 LName = &LName[1];
Devang Patel53bb5c92009-11-10 23:06:00 +00002834// Asm->EmitString(LName);
2835 EmitSectionOffset("string", "section_str",
2836 StringPool.idFor(LName), false, true);
2837
Devang Patel53cb17d2009-07-16 01:01:22 +00002838 }
Bill Wendling94d04b82009-05-20 23:21:38 +00002839 Asm->EOL("MIPS linkage name");
Jim Grosbach31ef40e2009-11-21 23:12:12 +00002840// Asm->EmitString(Name);
Devang Patel53bb5c92009-11-10 23:06:00 +00002841 EmitSectionOffset("string", "section_str",
2842 StringPool.idFor(Name), false, true);
2843 Asm->EOL("Function name");
Bill Wendling94d04b82009-05-20 23:21:38 +00002844 Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
2845
Devang Patel53bb5c92009-11-10 23:06:00 +00002846 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
Bill Wendling94d04b82009-05-20 23:21:38 +00002847 LE = Labels.end(); LI != LE; ++LI) {
Devang Patel53bb5c92009-11-10 23:06:00 +00002848 DIE *SP = LI->second;
Bill Wendling94d04b82009-05-20 23:21:38 +00002849 Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
2850
2851 if (TD->getPointerSize() == sizeof(int32_t))
Chris Lattner33adcfb2009-08-22 21:43:10 +00002852 O << MAI->getData32bitsDirective();
Bill Wendling94d04b82009-05-20 23:21:38 +00002853 else
Chris Lattner33adcfb2009-08-22 21:43:10 +00002854 O << MAI->getData64bitsDirective();
Bill Wendling94d04b82009-05-20 23:21:38 +00002855
Devang Patel53bb5c92009-11-10 23:06:00 +00002856 PrintLabelName("label", LI->first); Asm->EOL("low_pc");
Bill Wendling94d04b82009-05-20 23:21:38 +00002857 }
2858 }
2859
2860 EmitLabel("debug_inlined_end", 1);
2861 Asm->EOL();
2862}