blob: a1f646a425387d00cff743a459a7f9b409738739 [file] [log] [blame]
Bill Wendling2f921f82009-05-15 09:23:25 +00001//===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains support for writing dwarf debug info into asm files.
11//
12//===----------------------------------------------------------------------===//
Chris Lattnerb14490d2010-03-09 00:39:24 +000013
Devang Patel80ae3492009-08-28 23:24:31 +000014#define DEBUG_TYPE "dwarfdebug"
Bill Wendling2f921f82009-05-15 09:23:25 +000015#include "DwarfDebug.h"
Chris Lattner3f3fb972010-04-05 05:24:55 +000016#include "DIE.h"
Bill Wendling30346342010-04-05 22:59:21 +000017#include "llvm/Constants.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000018#include "llvm/Module.h"
David Greene829b3e82009-08-19 21:52:55 +000019#include "llvm/CodeGen/MachineFunction.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000020#include "llvm/CodeGen/MachineModuleInfo.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000021#include "llvm/MC/MCAsmInfo.h"
Chris Lattner4d2c0f92009-07-31 18:48:30 +000022#include "llvm/MC/MCSection.h"
Chris Lattner4b7dadb2009-08-19 05:49:37 +000023#include "llvm/MC/MCStreamer.h"
Chris Lattnere13c3722010-03-09 01:58:53 +000024#include "llvm/MC/MCSymbol.h"
Chris Lattnerf62e3ee2010-01-16 21:57:06 +000025#include "llvm/Target/Mangler.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000026#include "llvm/Target/TargetData.h"
27#include "llvm/Target/TargetFrameInfo.h"
Chris Lattner5e693ed2009-07-28 03:13:23 +000028#include "llvm/Target/TargetLoweringObjectFile.h"
Chris Lattner21dc46e2010-04-04 18:06:11 +000029#include "llvm/Target/TargetMachine.h"
Chris Lattner5e693ed2009-07-28 03:13:23 +000030#include "llvm/Target/TargetRegisterInfo.h"
Devang Patel61880932010-04-19 19:14:02 +000031#include "llvm/Target/TargetOptions.h"
Chris Lattner3f3fb972010-04-05 05:24:55 +000032#include "llvm/Analysis/DebugInfo.h"
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +000033#include "llvm/ADT/STLExtras.h"
Chris Lattner06fa1762009-08-24 03:52:50 +000034#include "llvm/ADT/StringExtras.h"
Devang Patel6c74a872010-04-27 19:46:33 +000035#include "llvm/Support/CommandLine.h"
Daniel Dunbarcdf01b52009-10-13 06:47:08 +000036#include "llvm/Support/Debug.h"
37#include "llvm/Support/ErrorHandling.h"
Devang Patel1973df22010-01-26 21:39:14 +000038#include "llvm/Support/ValueHandle.h"
Chris Lattnerf5c834f2010-01-22 22:09:00 +000039#include "llvm/Support/FormattedStream.h"
Chris Lattner4d2c0f92009-07-31 18:48:30 +000040#include "llvm/Support/Timer.h"
41#include "llvm/System/Path.h"
Bill Wendling2f921f82009-05-15 09:23:25 +000042using namespace llvm;
43
Devang Patel6c74a872010-04-27 19:46:33 +000044static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
45 cl::desc("Print DbgScope information for each machine instruction"));
46
Devang Patel30265c42010-07-07 20:12:52 +000047static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
48 cl::Hidden,
Devang Patel6c74a872010-04-27 19:46:33 +000049 cl::desc("Disable debug info printing"));
50
Dan Gohman7421ae42010-05-07 01:08:53 +000051static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
52 cl::desc("Make an absense of debug location information explicit."),
53 cl::init(false));
54
Bill Wendlingfcc14142010-04-07 09:28:04 +000055namespace {
56 const char *DWARFGroupName = "DWARF Emission";
57 const char *DbgTimerName = "DWARF Debug Writer";
58} // end anonymous namespace
59
Bill Wendling2f921f82009-05-15 09:23:25 +000060//===----------------------------------------------------------------------===//
61
62/// Configuration values for initial hash set sizes (log2).
63///
Bill Wendling2f921f82009-05-15 09:23:25 +000064static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
Bill Wendling2f921f82009-05-15 09:23:25 +000065
66namespace llvm {
67
68//===----------------------------------------------------------------------===//
69/// CompileUnit - This dwarf writer support class manages information associate
70/// with a source file.
Nick Lewyckyb7993d62009-11-17 08:11:44 +000071class CompileUnit {
Bill Wendling2f921f82009-05-15 09:23:25 +000072 /// ID - File identifier for source.
73 ///
74 unsigned ID;
75
76 /// Die - Compile unit debug information entry.
77 ///
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +000078 const OwningPtr<DIE> CUDie;
Bill Wendling2f921f82009-05-15 09:23:25 +000079
Jeffrey Yasskin0708de12010-03-11 18:29:55 +000080 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
Devang Patel92e8c652009-11-21 00:31:03 +000081 DIE *IndexTyDie;
82
Devang Patel9a0339f2010-07-07 20:49:57 +000083 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
Bill Wendling2f921f82009-05-15 09:23:25 +000084 /// variables to debug information entries.
Devang Patel9a0339f2010-07-07 20:49:57 +000085 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
Bill Wendling2f921f82009-05-15 09:23:25 +000086
Devang Patel9a0339f2010-07-07 20:49:57 +000087 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
Bill Wendling2f921f82009-05-15 09:23:25 +000088 /// descriptors to debug information entries using a DIEEntry proxy.
Devang Patel9a0339f2010-07-07 20:49:57 +000089 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
Bill Wendling2f921f82009-05-15 09:23:25 +000090
91 /// Globals - A map of globally visible named entities for this unit.
92 ///
93 StringMap<DIE*> Globals;
94
Devang Patel04d2f2d2009-11-24 01:14:22 +000095 /// GlobalTypes - A map of globally visible types for this unit.
96 ///
97 StringMap<DIE*> GlobalTypes;
98
Bill Wendling2f921f82009-05-15 09:23:25 +000099public:
100 CompileUnit(unsigned I, DIE *D)
Devang Patel930143b2009-11-21 02:48:08 +0000101 : ID(I), CUDie(D), IndexTyDie(0) {}
Bill Wendling2f921f82009-05-15 09:23:25 +0000102
103 // Accessors.
Devang Patel04d2f2d2009-11-24 01:14:22 +0000104 unsigned getID() const { return ID; }
Jeffrey Yasskin0708de12010-03-11 18:29:55 +0000105 DIE* getCUDie() const { return CUDie.get(); }
Devang Patel04d2f2d2009-11-24 01:14:22 +0000106 const StringMap<DIE*> &getGlobals() const { return Globals; }
107 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
Bill Wendling2f921f82009-05-15 09:23:25 +0000108
109 /// hasContent - Return true if this compile unit has something to write out.
110 ///
Devang Patel930143b2009-11-21 02:48:08 +0000111 bool hasContent() const { return !CUDie->getChildren().empty(); }
Bill Wendling2f921f82009-05-15 09:23:25 +0000112
Devang Patel930143b2009-11-21 02:48:08 +0000113 /// addGlobal - Add a new global entity to the compile unit.
Bill Wendling2f921f82009-05-15 09:23:25 +0000114 ///
Benjamin Kramer96956ed2010-03-31 20:15:45 +0000115 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
Bill Wendling2f921f82009-05-15 09:23:25 +0000116
Devang Patel04d2f2d2009-11-24 01:14:22 +0000117 /// addGlobalType - Add a new global type to the compile unit.
118 ///
Benjamin Kramer96956ed2010-03-31 20:15:45 +0000119 void addGlobalType(StringRef Name, DIE *Die) {
Devang Patel04d2f2d2009-11-24 01:14:22 +0000120 GlobalTypes[Name] = Die;
121 }
122
Devang Patele064ad42009-11-20 21:37:22 +0000123 /// getDIE - Returns the debug information entry map slot for the
Bill Wendling2f921f82009-05-15 09:23:25 +0000124 /// specified debug variable.
Devang Patel9a0339f2010-07-07 20:49:57 +0000125 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
Jim Grosbach042483e2009-11-21 23:12:12 +0000126
Devang Patele064ad42009-11-20 21:37:22 +0000127 /// insertDIE - Insert DIE into the map.
Devang Patel32cc43c2010-05-07 20:54:48 +0000128 void insertDIE(const MDNode *N, DIE *D) {
Devang Patel9a0339f2010-07-07 20:49:57 +0000129 MDNodeToDieMap.insert(std::make_pair(N, D));
Devang Patele064ad42009-11-20 21:37:22 +0000130 }
Bill Wendling2f921f82009-05-15 09:23:25 +0000131
Devang Patele064ad42009-11-20 21:37:22 +0000132 /// getDIEEntry - Returns the debug information entry for the speciefied
133 /// debug variable.
Devang Patel32cc43c2010-05-07 20:54:48 +0000134 DIEEntry *getDIEEntry(const MDNode *N) {
Devang Patel9a0339f2010-07-07 20:49:57 +0000135 DenseMap<const MDNode *, DIEEntry *>::iterator I = MDNodeToDIEEntryMap.find(N);
136 if (I == MDNodeToDIEEntryMap.end())
Devang Patel1f4690c2009-12-15 19:16:48 +0000137 return NULL;
138 return I->second;
139 }
Devang Patele064ad42009-11-20 21:37:22 +0000140
141 /// insertDIEEntry - Insert debug information entry into the map.
Devang Patel32cc43c2010-05-07 20:54:48 +0000142 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
Devang Patel9a0339f2010-07-07 20:49:57 +0000143 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
Bill Wendling2f921f82009-05-15 09:23:25 +0000144 }
145
Devang Patel930143b2009-11-21 02:48:08 +0000146 /// addDie - Adds or interns the DIE to the compile unit.
Bill Wendling2f921f82009-05-15 09:23:25 +0000147 ///
Devang Patel930143b2009-11-21 02:48:08 +0000148 void addDie(DIE *Buffer) {
149 this->CUDie->addChild(Buffer);
Bill Wendling2f921f82009-05-15 09:23:25 +0000150 }
Devang Patel92e8c652009-11-21 00:31:03 +0000151
152 // getIndexTyDie - Get an anonymous type for index type.
153 DIE *getIndexTyDie() {
154 return IndexTyDie;
155 }
156
Jim Grosbach00e9c612009-11-22 19:20:36 +0000157 // setIndexTyDie - Set D as anonymous type for index which can be reused
158 // later.
Devang Patel92e8c652009-11-21 00:31:03 +0000159 void setIndexTyDie(DIE *D) {
160 IndexTyDie = D;
161 }
162
Bill Wendling2f921f82009-05-15 09:23:25 +0000163};
164
165//===----------------------------------------------------------------------===//
166/// DbgVariable - This class is used to track local variable information.
167///
Devang Patelf3d7c082009-11-16 21:53:40 +0000168class DbgVariable {
Bill Wendling2f921f82009-05-15 09:23:25 +0000169 DIVariable Var; // Variable Descriptor.
Devang Patel9fc11702010-05-25 23:40:22 +0000170 DIE *TheDIE; // Variable DIE.
171 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
Bill Wendling2f921f82009-05-15 09:23:25 +0000172public:
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +0000173 // AbsVar may be NULL.
Devang Patel9fc11702010-05-25 23:40:22 +0000174 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
Bill Wendling2f921f82009-05-15 09:23:25 +0000175
176 // Accessors.
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000177 DIVariable getVariable() const { return Var; }
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000178 void setDIE(DIE *D) { TheDIE = D; }
179 DIE *getDIE() const { return TheDIE; }
Devang Patel9fc11702010-05-25 23:40:22 +0000180 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
181 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
Bill Wendling2f921f82009-05-15 09:23:25 +0000182};
183
184//===----------------------------------------------------------------------===//
Devang Patel6c74a872010-04-27 19:46:33 +0000185/// DbgRange - This is used to track range of instructions with identical
186/// debug info scope.
187///
188typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
189
190//===----------------------------------------------------------------------===//
Bill Wendling2f921f82009-05-15 09:23:25 +0000191/// DbgScope - This class is used to track scope information.
192///
Devang Patelf3d7c082009-11-16 21:53:40 +0000193class DbgScope {
Bill Wendling2f921f82009-05-15 09:23:25 +0000194 DbgScope *Parent; // Parent to this scope.
Jim Grosbach042483e2009-11-21 23:12:12 +0000195 DIDescriptor Desc; // Debug info descriptor for scope.
Devang Patel1973df22010-01-26 21:39:14 +0000196 // Location at which this scope is inlined.
Devang Patel32cc43c2010-05-07 20:54:48 +0000197 AssertingVH<const MDNode> InlinedAtLocation;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000198 bool AbstractScope; // Abstract Scope
Devang Patel787f94c2009-10-01 18:25:23 +0000199 const MachineInstr *LastInsn; // Last instruction of this scope.
200 const MachineInstr *FirstInsn; // First instruction of this scope.
Devang Patel6c74a872010-04-27 19:46:33 +0000201 unsigned DFSIn, DFSOut;
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +0000202 // Scopes defined in scope. Contents not owned.
203 SmallVector<DbgScope *, 4> Scopes;
204 // Variables declared in scope. Contents owned.
205 SmallVector<DbgVariable *, 8> Variables;
Devang Patel6c74a872010-04-27 19:46:33 +0000206 SmallVector<DbgRange, 4> Ranges;
Owen Anderson9becc182009-06-24 22:53:20 +0000207 // Private state for dump()
208 mutable unsigned IndentLevel;
Bill Wendling2f921f82009-05-15 09:23:25 +0000209public:
Devang Patel32cc43c2010-05-07 20:54:48 +0000210 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000211 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
Devang Patel6c74a872010-04-27 19:46:33 +0000212 LastInsn(0), FirstInsn(0),
213 DFSIn(0), DFSOut(0), IndentLevel(0) {}
Bill Wendling2f921f82009-05-15 09:23:25 +0000214 virtual ~DbgScope();
215
216 // Accessors.
217 DbgScope *getParent() const { return Parent; }
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000218 void setParent(DbgScope *P) { Parent = P; }
Bill Wendling2f921f82009-05-15 09:23:25 +0000219 DIDescriptor getDesc() const { return Desc; }
Devang Patel32cc43c2010-05-07 20:54:48 +0000220 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
221 const MDNode *getScopeNode() const { return Desc; }
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +0000222 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
223 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
Devang Patel6c74a872010-04-27 19:46:33 +0000224 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
225
226 /// openInsnRange - This scope covers instruction range starting from MI.
227 void openInsnRange(const MachineInstr *MI) {
228 if (!FirstInsn)
229 FirstInsn = MI;
230
231 if (Parent)
232 Parent->openInsnRange(MI);
233 }
234
235 /// extendInsnRange - Extend the current instruction range covered by
236 /// this scope.
237 void extendInsnRange(const MachineInstr *MI) {
238 assert (FirstInsn && "MI Range is not open!");
239 LastInsn = MI;
240 if (Parent)
241 Parent->extendInsnRange(MI);
242 }
243
244 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
245 /// until now. This is used when a new scope is encountered while walking
246 /// machine instructions.
247 void closeInsnRange(DbgScope *NewScope = NULL) {
248 assert (LastInsn && "Last insn missing!");
249 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
250 FirstInsn = NULL;
251 LastInsn = NULL;
252 // If Parent dominates NewScope then do not close Parent's instruction
253 // range.
254 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
255 Parent->closeInsnRange(NewScope);
256 }
257
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000258 void setAbstractScope() { AbstractScope = true; }
259 bool isAbstractScope() const { return AbstractScope; }
Devang Patel6c74a872010-04-27 19:46:33 +0000260
261 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
262 unsigned getDFSOut() const { return DFSOut; }
263 void setDFSOut(unsigned O) { DFSOut = O; }
264 unsigned getDFSIn() const { return DFSIn; }
265 void setDFSIn(unsigned I) { DFSIn = I; }
266 bool dominates(const DbgScope *S) {
267 if (S == this)
268 return true;
269 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
270 return true;
271 return false;
272 }
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000273
Devang Patel930143b2009-11-21 02:48:08 +0000274 /// addScope - Add a scope to the scope.
Bill Wendling2f921f82009-05-15 09:23:25 +0000275 ///
Devang Patel930143b2009-11-21 02:48:08 +0000276 void addScope(DbgScope *S) { Scopes.push_back(S); }
Bill Wendling2f921f82009-05-15 09:23:25 +0000277
Devang Patel930143b2009-11-21 02:48:08 +0000278 /// addVariable - Add a variable to the scope.
Bill Wendling2f921f82009-05-15 09:23:25 +0000279 ///
Devang Patel930143b2009-11-21 02:48:08 +0000280 void addVariable(DbgVariable *V) { Variables.push_back(V); }
Bill Wendling2f921f82009-05-15 09:23:25 +0000281
Bill Wendling2f921f82009-05-15 09:23:25 +0000282#ifndef NDEBUG
283 void dump() const;
284#endif
285};
Devang Patel6c74a872010-04-27 19:46:33 +0000286
Chris Lattnerf5d06362010-04-05 04:09:20 +0000287} // end llvm namespace
Bill Wendling2f921f82009-05-15 09:23:25 +0000288
289#ifndef NDEBUG
290void DbgScope::dump() const {
David Greenec230cb92009-12-24 00:31:35 +0000291 raw_ostream &err = dbgs();
Chris Lattner81e8e022009-08-23 00:51:00 +0000292 err.indent(IndentLevel);
Devang Patel32cc43c2010-05-07 20:54:48 +0000293 const MDNode *N = Desc;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000294 N->dump();
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000295 if (AbstractScope)
296 err << "Abstract Scope\n";
Bill Wendling2f921f82009-05-15 09:23:25 +0000297
298 IndentLevel += 2;
Devang Patelf6eeaeb2009-11-10 23:06:00 +0000299 if (!Scopes.empty())
300 err << "Children ...\n";
Bill Wendling2f921f82009-05-15 09:23:25 +0000301 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
302 if (Scopes[i] != this)
303 Scopes[i]->dump();
304
305 IndentLevel -= 2;
306}
307#endif
308
Bill Wendling2f921f82009-05-15 09:23:25 +0000309DbgScope::~DbgScope() {
Bill Wendling2f921f82009-05-15 09:23:25 +0000310 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
311 delete Variables[j];
Bill Wendling2f921f82009-05-15 09:23:25 +0000312}
313
Chris Lattnerf0d6bd32010-04-05 05:11:15 +0000314DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
Devang Patel1a0df9a2010-05-10 22:49:55 +0000315 : Asm(A), MMI(Asm->MMI), FirstCU(0),
Chris Lattner196dbdc2010-04-05 03:52:55 +0000316 AbbreviationsSet(InitAbbreviationsSetSize),
Devang Patel12563b32010-04-16 23:33:45 +0000317 CurrentFnDbgScope(0), PrevLabel(NULL) {
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000318 NextStringPoolNumber = 0;
Chris Lattner6629ca92010-04-04 22:59:04 +0000319
Chris Lattnere58b5472010-04-04 23:10:38 +0000320 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
321 DwarfStrSectionSym = TextSectionSym = 0;
Devang Patel9fc11702010-05-25 23:40:22 +0000322 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
Devang Patel24bc1b52010-06-29 20:17:53 +0000323 DwarfDebugLineSectionSym = CurrentLineSectionSym = 0;
Devang Patel9fc11702010-05-25 23:40:22 +0000324 FunctionBeginSym = FunctionEndSym = 0;
Devang Patel9c160e12010-07-08 20:10:35 +0000325 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
Dan Gohman6e681a52010-06-18 15:56:31 +0000326 {
327 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
328 beginModule(M);
Torok Edwinf8dba242010-04-07 10:44:46 +0000329 }
Bill Wendling2f921f82009-05-15 09:23:25 +0000330}
331DwarfDebug::~DwarfDebug() {
Benjamin Kramer74729ae2010-03-31 19:34:01 +0000332 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
333 DIEBlocks[j]->~DIEBlock();
Bill Wendling2f921f82009-05-15 09:23:25 +0000334}
335
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000336MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
337 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
338 if (Entry.first) return Entry.first;
339
340 Entry.second = NextStringPoolNumber++;
Chris Lattnera179b522010-04-04 19:25:43 +0000341 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
Chris Lattnerb7aa9522010-03-13 02:17:42 +0000342}
343
344
Devang Patel930143b2009-11-21 02:48:08 +0000345/// assignAbbrevNumber - Define a unique number for the abbreviation.
Bill Wendling2f921f82009-05-15 09:23:25 +0000346///
Devang Patel930143b2009-11-21 02:48:08 +0000347void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
Bill Wendling2f921f82009-05-15 09:23:25 +0000348 // Profile the node so that we can make it unique.
349 FoldingSetNodeID ID;
350 Abbrev.Profile(ID);
351
352 // Check the set for priors.
353 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
354
355 // If it's newly added.
356 if (InSet == &Abbrev) {
357 // Add to abbreviation list.
358 Abbreviations.push_back(&Abbrev);
359
360 // Assign the vector position + 1 as its number.
361 Abbrev.setNumber(Abbreviations.size());
362 } else {
363 // Assign existing abbreviation number.
364 Abbrev.setNumber(InSet->getNumber());
365 }
366}
367
Devang Patel930143b2009-11-21 02:48:08 +0000368/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
Bill Wendlingbcad77a2009-05-20 23:24:48 +0000369/// information entry.
Devang Patel930143b2009-11-21 02:48:08 +0000370DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
Benjamin Kramer74729ae2010-03-31 19:34:01 +0000371 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
Bill Wendling2f921f82009-05-15 09:23:25 +0000372 return Value;
373}
374
Devang Patel930143b2009-11-21 02:48:08 +0000375/// addUInt - Add an unsigned integer attribute data and value.
Bill Wendling2f921f82009-05-15 09:23:25 +0000376///
Devang Patel930143b2009-11-21 02:48:08 +0000377void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
Bill Wendling2f921f82009-05-15 09:23:25 +0000378 unsigned Form, uint64_t Integer) {
379 if (!Form) Form = DIEInteger::BestForm(false, Integer);
Devang Patel9c160e12010-07-08 20:10:35 +0000380 DIEValue *Value = Integer == 1 ?
381 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
Devang Patel930143b2009-11-21 02:48:08 +0000382 Die->addValue(Attribute, Form, Value);
Bill Wendling2f921f82009-05-15 09:23:25 +0000383}
384
Devang Patel930143b2009-11-21 02:48:08 +0000385/// addSInt - Add an signed integer attribute data and value.
Bill Wendling2f921f82009-05-15 09:23:25 +0000386///
Devang Patel930143b2009-11-21 02:48:08 +0000387void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
Bill Wendling2f921f82009-05-15 09:23:25 +0000388 unsigned Form, int64_t Integer) {
389 if (!Form) Form = DIEInteger::BestForm(true, Integer);
Benjamin Kramer74729ae2010-03-31 19:34:01 +0000390 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
Devang Patel930143b2009-11-21 02:48:08 +0000391 Die->addValue(Attribute, Form, Value);
Bill Wendling2f921f82009-05-15 09:23:25 +0000392}
393
Devang Patel8c339592009-12-02 15:25:16 +0000394/// addString - Add a string attribute data and value. DIEString only
395/// keeps string reference.
Devang Patel930143b2009-11-21 02:48:08 +0000396void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattnerc3f23b82010-01-23 03:11:46 +0000397 StringRef String) {
Benjamin Kramer74729ae2010-03-31 19:34:01 +0000398 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
Devang Patel930143b2009-11-21 02:48:08 +0000399 Die->addValue(Attribute, Form, Value);
Bill Wendling2f921f82009-05-15 09:23:25 +0000400}
401
Devang Patel930143b2009-11-21 02:48:08 +0000402/// addLabel - Add a Dwarf label attribute data and value.
Bill Wendling2f921f82009-05-15 09:23:25 +0000403///
Devang Patel930143b2009-11-21 02:48:08 +0000404void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattnerbc9210c2010-03-08 22:23:36 +0000405 const MCSymbol *Label) {
Benjamin Kramer74729ae2010-03-31 19:34:01 +0000406 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
Devang Patel930143b2009-11-21 02:48:08 +0000407 Die->addValue(Attribute, Form, Value);
Bill Wendling2f921f82009-05-15 09:23:25 +0000408}
409
Devang Patel930143b2009-11-21 02:48:08 +0000410/// addDelta - Add a label delta attribute data and value.
Bill Wendling2f921f82009-05-15 09:23:25 +0000411///
Devang Patel930143b2009-11-21 02:48:08 +0000412void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattnerbc9210c2010-03-08 22:23:36 +0000413 const MCSymbol *Hi, const MCSymbol *Lo) {
Benjamin Kramer74729ae2010-03-31 19:34:01 +0000414 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
Devang Patel930143b2009-11-21 02:48:08 +0000415 Die->addValue(Attribute, Form, Value);
Bill Wendling2f921f82009-05-15 09:23:25 +0000416}
417
Chris Lattner3f3fb972010-04-05 05:24:55 +0000418/// addDIEEntry - Add a DIE attribute data and value.
419///
420void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
421 DIE *Entry) {
422 Die->addValue(Attribute, Form, createDIEEntry(Entry));
423}
424
425
Devang Patel930143b2009-11-21 02:48:08 +0000426/// addBlock - Add block data.
Bill Wendling2f921f82009-05-15 09:23:25 +0000427///
Devang Patel930143b2009-11-21 02:48:08 +0000428void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
Bill Wendling2f921f82009-05-15 09:23:25 +0000429 DIEBlock *Block) {
Chris Lattner5a00dea2010-04-05 00:18:22 +0000430 Block->ComputeSize(Asm);
Benjamin Kramer74729ae2010-03-31 19:34:01 +0000431 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
Devang Patel930143b2009-11-21 02:48:08 +0000432 Die->addValue(Attribute, Block->BestForm(), Block);
Bill Wendling2f921f82009-05-15 09:23:25 +0000433}
434
Devang Patel930143b2009-11-21 02:48:08 +0000435/// addSourceLine - Add location information to specified debug information
Bill Wendling2f921f82009-05-15 09:23:25 +0000436/// entry.
Devang Patel930143b2009-11-21 02:48:08 +0000437void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
Devang Patel0625af22010-05-07 23:33:41 +0000438 // Verify variable.
439 if (!V->Verify())
Bill Wendling2f921f82009-05-15 09:23:25 +0000440 return;
441
442 unsigned Line = V->getLineNumber();
Devang Patel8119fe872010-03-08 22:02:50 +0000443 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
444 V->getContext().getFilename());
Bill Wendling2f921f82009-05-15 09:23:25 +0000445 assert(FileID && "Invalid file id");
Devang Patel930143b2009-11-21 02:48:08 +0000446 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
447 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling2f921f82009-05-15 09:23:25 +0000448}
449
Devang Patel930143b2009-11-21 02:48:08 +0000450/// addSourceLine - Add location information to specified debug information
Bill Wendling2f921f82009-05-15 09:23:25 +0000451/// entry.
Devang Patelcbe7a852010-05-07 23:19:07 +0000452void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
Devang Patel0625af22010-05-07 23:33:41 +0000453 // Verify global variable.
454 if (!G->Verify())
Bill Wendling2f921f82009-05-15 09:23:25 +0000455 return;
456
457 unsigned Line = G->getLineNumber();
Devang Patel8119fe872010-03-08 22:02:50 +0000458 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
459 G->getContext().getFilename());
Bill Wendling2f921f82009-05-15 09:23:25 +0000460 assert(FileID && "Invalid file id");
Devang Patel930143b2009-11-21 02:48:08 +0000461 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
462 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling2f921f82009-05-15 09:23:25 +0000463}
Devang Patelb2de5fa2009-08-31 22:47:13 +0000464
Devang Patel930143b2009-11-21 02:48:08 +0000465/// addSourceLine - Add location information to specified debug information
Devang Patelb2de5fa2009-08-31 22:47:13 +0000466/// entry.
Devang Patel930143b2009-11-21 02:48:08 +0000467void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
Devang Patel0625af22010-05-07 23:33:41 +0000468 // Verify subprogram.
469 if (!SP->Verify())
Devang Patelb2de5fa2009-08-31 22:47:13 +0000470 return;
Caroline Tice183a5192009-09-11 18:25:54 +0000471 // If the line number is 0, don't add it.
472 if (SP->getLineNumber() == 0)
473 return;
474
Devang Patelb2de5fa2009-08-31 22:47:13 +0000475 unsigned Line = SP->getLineNumber();
Devang Patel8119fe872010-03-08 22:02:50 +0000476 if (!SP->getContext().Verify())
477 return;
Devang Patel834392f2010-03-24 21:30:35 +0000478 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
479 SP->getFilename());
Devang Patelb2de5fa2009-08-31 22:47:13 +0000480 assert(FileID && "Invalid file id");
Devang Patel930143b2009-11-21 02:48:08 +0000481 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
482 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Devang Patelb2de5fa2009-08-31 22:47:13 +0000483}
484
Devang Patel930143b2009-11-21 02:48:08 +0000485/// addSourceLine - Add location information to specified debug information
Devang Patelb2de5fa2009-08-31 22:47:13 +0000486/// entry.
Devang Patel930143b2009-11-21 02:48:08 +0000487void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
Devang Patel0625af22010-05-07 23:33:41 +0000488 // Verify type.
489 if (!Ty->Verify())
Bill Wendling2f921f82009-05-15 09:23:25 +0000490 return;
491
492 unsigned Line = Ty->getLineNumber();
Devang Patel8119fe872010-03-08 22:02:50 +0000493 if (!Ty->getContext().Verify())
494 return;
495 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
496 Ty->getContext().getFilename());
Bill Wendling2f921f82009-05-15 09:23:25 +0000497 assert(FileID && "Invalid file id");
Devang Patel930143b2009-11-21 02:48:08 +0000498 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
499 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
Bill Wendling2f921f82009-05-15 09:23:25 +0000500}
501
Devang Patel1f4690c2009-12-15 19:16:48 +0000502/// addSourceLine - Add location information to specified debug information
503/// entry.
504void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
Devang Patel0625af22010-05-07 23:33:41 +0000505 // Verify namespace.
506 if (!NS->Verify())
Devang Patel1f4690c2009-12-15 19:16:48 +0000507 return;
508
509 unsigned Line = NS->getLineNumber();
510 StringRef FN = NS->getFilename();
511 StringRef Dir = NS->getDirectory();
512
513 unsigned FileID = GetOrCreateSourceID(Dir, FN);
514 assert(FileID && "Invalid file id");
515 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
516 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
517}
518
Caroline Ticec87c1e22009-08-31 21:19:37 +0000519/* Byref variables, in Blocks, are declared by the programmer as
520 "SomeType VarName;", but the compiler creates a
521 __Block_byref_x_VarName struct, and gives the variable VarName
522 either the struct, or a pointer to the struct, as its type. This
523 is necessary for various behind-the-scenes things the compiler
524 needs to do with by-reference variables in blocks.
525
526 However, as far as the original *programmer* is concerned, the
527 variable should still have type 'SomeType', as originally declared.
528
529 The following function dives into the __Block_byref_x_VarName
530 struct to find the original type of the variable. This will be
531 passed back to the code generating the type for the Debug
532 Information Entry for the variable 'VarName'. 'VarName' will then
533 have the original type 'SomeType' in its debug information.
534
535 The original type 'SomeType' will be the type of the field named
536 'VarName' inside the __Block_byref_x_VarName struct.
537
538 NOTE: In order for this to not completely fail on the debugger
539 side, the Debug Information Entry for the variable VarName needs to
540 have a DW_AT_location that tells the debugger how to unwind through
541 the pointers and __Block_byref_x_VarName struct to find the actual
Devang Patel930143b2009-11-21 02:48:08 +0000542 value of the variable. The function addBlockByrefType does this. */
Caroline Ticec87c1e22009-08-31 21:19:37 +0000543
544/// Find the type the programmer originally declared the variable to be
545/// and return that type.
546///
Devang Patel930143b2009-11-21 02:48:08 +0000547DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
Caroline Ticec87c1e22009-08-31 21:19:37 +0000548
549 DIType subType = Ty;
550 unsigned tag = Ty.getTag();
551
552 if (tag == dwarf::DW_TAG_pointer_type) {
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000553 DIDerivedType DTy = DIDerivedType(Ty);
Caroline Ticec87c1e22009-08-31 21:19:37 +0000554 subType = DTy.getTypeDerivedFrom();
555 }
556
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000557 DICompositeType blockStruct = DICompositeType(subType);
Caroline Ticec87c1e22009-08-31 21:19:37 +0000558 DIArray Elements = blockStruct.getTypeArray();
559
Caroline Ticec87c1e22009-08-31 21:19:37 +0000560 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
561 DIDescriptor Element = Elements.getElement(i);
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000562 DIDerivedType DT = DIDerivedType(Element);
Devang Patel2d9caf92009-11-25 17:36:49 +0000563 if (Name == DT.getName())
Caroline Ticec87c1e22009-08-31 21:19:37 +0000564 return (DT.getTypeDerivedFrom());
565 }
566
567 return Ty;
568}
569
Devang Patel930143b2009-11-21 02:48:08 +0000570/// addComplexAddress - Start with the address based on the location provided,
Mike Stump14cf8ec2009-09-30 00:08:22 +0000571/// and generate the DWARF information necessary to find the actual variable
572/// given the extra address information encoded in the DIVariable, starting from
573/// the starting location. Add the DWARF information to the die.
574///
Devang Patel930143b2009-11-21 02:48:08 +0000575void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
Mike Stump14cf8ec2009-09-30 00:08:22 +0000576 unsigned Attribute,
577 const MachineLocation &Location) {
578 const DIVariable &VD = DV->getVariable();
579 DIType Ty = VD.getType();
580
581 // Decode the original location, and use that as the start of the byref
582 // variable's location.
Chris Lattner3a383cb2010-04-05 00:13:49 +0000583 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Mike Stump14cf8ec2009-09-30 00:08:22 +0000584 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer74729ae2010-03-31 19:34:01 +0000585 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Mike Stump14cf8ec2009-09-30 00:08:22 +0000586
587 if (Location.isReg()) {
588 if (Reg < 32) {
Devang Patel930143b2009-11-21 02:48:08 +0000589 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Mike Stump14cf8ec2009-09-30 00:08:22 +0000590 } else {
591 Reg = Reg - dwarf::DW_OP_reg0;
Devang Patel930143b2009-11-21 02:48:08 +0000592 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
593 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Mike Stump14cf8ec2009-09-30 00:08:22 +0000594 }
595 } else {
596 if (Reg < 32)
Devang Patel930143b2009-11-21 02:48:08 +0000597 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Mike Stump14cf8ec2009-09-30 00:08:22 +0000598 else {
Devang Patel930143b2009-11-21 02:48:08 +0000599 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
600 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Mike Stump14cf8ec2009-09-30 00:08:22 +0000601 }
602
Devang Patel930143b2009-11-21 02:48:08 +0000603 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Mike Stump14cf8ec2009-09-30 00:08:22 +0000604 }
605
606 for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
607 uint64_t Element = VD.getAddrElement(i);
608
609 if (Element == DIFactory::OpPlus) {
Devang Patel930143b2009-11-21 02:48:08 +0000610 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
611 addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
Mike Stump14cf8ec2009-09-30 00:08:22 +0000612 } else if (Element == DIFactory::OpDeref) {
Devang Patel930143b2009-11-21 02:48:08 +0000613 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Mike Stump14cf8ec2009-09-30 00:08:22 +0000614 } else llvm_unreachable("unknown DIFactory Opcode");
615 }
616
617 // Now attach the location information to the DIE.
Devang Patel930143b2009-11-21 02:48:08 +0000618 addBlock(Die, Attribute, 0, Block);
Mike Stump14cf8ec2009-09-30 00:08:22 +0000619}
620
Caroline Ticec87c1e22009-08-31 21:19:37 +0000621/* Byref variables, in Blocks, are declared by the programmer as "SomeType
622 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
623 gives the variable VarName either the struct, or a pointer to the struct, as
624 its type. This is necessary for various behind-the-scenes things the
625 compiler needs to do with by-reference variables in Blocks.
626
627 However, as far as the original *programmer* is concerned, the variable
628 should still have type 'SomeType', as originally declared.
629
Devang Patel930143b2009-11-21 02:48:08 +0000630 The function getBlockByrefType dives into the __Block_byref_x_VarName
Caroline Ticec87c1e22009-08-31 21:19:37 +0000631 struct to find the original type of the variable, which is then assigned to
632 the variable's Debug Information Entry as its real type. So far, so good.
633 However now the debugger will expect the variable VarName to have the type
634 SomeType. So we need the location attribute for the variable to be an
Daniel Dunbarc418d6b2009-09-19 20:40:05 +0000635 expression that explains to the debugger how to navigate through the
Caroline Ticec87c1e22009-08-31 21:19:37 +0000636 pointers and struct to find the actual variable of type SomeType.
637
638 The following function does just that. We start by getting
639 the "normal" location for the variable. This will be the location
640 of either the struct __Block_byref_x_VarName or the pointer to the
641 struct __Block_byref_x_VarName.
642
643 The struct will look something like:
644
645 struct __Block_byref_x_VarName {
646 ... <various fields>
647 struct __Block_byref_x_VarName *forwarding;
648 ... <various other fields>
649 SomeType VarName;
650 ... <maybe more fields>
651 };
652
653 If we are given the struct directly (as our starting point) we
654 need to tell the debugger to:
655
656 1). Add the offset of the forwarding field.
657
Dan Gohman4a618822010-02-10 16:03:48 +0000658 2). Follow that pointer to get the real __Block_byref_x_VarName
Caroline Ticec87c1e22009-08-31 21:19:37 +0000659 struct to use (the real one may have been copied onto the heap).
660
661 3). Add the offset for the field VarName, to find the actual variable.
662
663 If we started with a pointer to the struct, then we need to
664 dereference that pointer first, before the other steps.
665 Translating this into DWARF ops, we will need to append the following
666 to the current location description for the variable:
667
668 DW_OP_deref -- optional, if we start with a pointer
669 DW_OP_plus_uconst <forward_fld_offset>
670 DW_OP_deref
671 DW_OP_plus_uconst <varName_fld_offset>
672
673 That is what this function does. */
674
Devang Patel930143b2009-11-21 02:48:08 +0000675/// addBlockByrefAddress - Start with the address based on the location
Caroline Ticec87c1e22009-08-31 21:19:37 +0000676/// provided, and generate the DWARF information necessary to find the
677/// actual Block variable (navigating the Block struct) based on the
678/// starting location. Add the DWARF information to the die. For
679/// more information, read large comment just above here.
680///
Devang Patel930143b2009-11-21 02:48:08 +0000681void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000682 unsigned Attribute,
683 const MachineLocation &Location) {
Caroline Ticec87c1e22009-08-31 21:19:37 +0000684 const DIVariable &VD = DV->getVariable();
685 DIType Ty = VD.getType();
686 DIType TmpTy = Ty;
687 unsigned Tag = Ty.getTag();
688 bool isPointer = false;
689
Devang Patel2d9caf92009-11-25 17:36:49 +0000690 StringRef varName = VD.getName();
Caroline Ticec87c1e22009-08-31 21:19:37 +0000691
692 if (Tag == dwarf::DW_TAG_pointer_type) {
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000693 DIDerivedType DTy = DIDerivedType(Ty);
Caroline Ticec87c1e22009-08-31 21:19:37 +0000694 TmpTy = DTy.getTypeDerivedFrom();
695 isPointer = true;
696 }
697
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000698 DICompositeType blockStruct = DICompositeType(TmpTy);
Caroline Ticec87c1e22009-08-31 21:19:37 +0000699
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000700 // Find the __forwarding field and the variable field in the __Block_byref
701 // struct.
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000702 DIArray Fields = blockStruct.getTypeArray();
703 DIDescriptor varField = DIDescriptor();
704 DIDescriptor forwardingField = DIDescriptor();
Caroline Ticec87c1e22009-08-31 21:19:37 +0000705
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000706 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
707 DIDescriptor Element = Fields.getElement(i);
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000708 DIDerivedType DT = DIDerivedType(Element);
Devang Patel2d9caf92009-11-25 17:36:49 +0000709 StringRef fieldName = DT.getName();
710 if (fieldName == "__forwarding")
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000711 forwardingField = Element;
Devang Patel2d9caf92009-11-25 17:36:49 +0000712 else if (fieldName == varName)
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000713 varField = Element;
714 }
Daniel Dunbarc418d6b2009-09-19 20:40:05 +0000715
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000716 // Get the offsets for the forwarding field and the variable field.
Chris Lattner71696ef2010-03-31 06:06:37 +0000717 unsigned forwardingFieldOffset =
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000718 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
Chris Lattner71696ef2010-03-31 06:06:37 +0000719 unsigned varFieldOffset =
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000720 DIDerivedType(varField).getOffsetInBits() >> 3;
Caroline Ticec87c1e22009-08-31 21:19:37 +0000721
Mike Stump944fa252009-09-24 23:21:26 +0000722 // Decode the original location, and use that as the start of the byref
723 // variable's location.
Chris Lattner3a383cb2010-04-05 00:13:49 +0000724 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000725 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer74729ae2010-03-31 19:34:01 +0000726 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Caroline Ticec87c1e22009-08-31 21:19:37 +0000727
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000728 if (Location.isReg()) {
729 if (Reg < 32)
Devang Patel930143b2009-11-21 02:48:08 +0000730 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000731 else {
732 Reg = Reg - dwarf::DW_OP_reg0;
Devang Patel930143b2009-11-21 02:48:08 +0000733 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
734 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000735 }
736 } else {
737 if (Reg < 32)
Devang Patel930143b2009-11-21 02:48:08 +0000738 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000739 else {
Devang Patel930143b2009-11-21 02:48:08 +0000740 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
741 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000742 }
Caroline Ticec87c1e22009-08-31 21:19:37 +0000743
Devang Patel930143b2009-11-21 02:48:08 +0000744 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000745 }
Caroline Ticec87c1e22009-08-31 21:19:37 +0000746
Mike Stump944fa252009-09-24 23:21:26 +0000747 // If we started with a pointer to the __Block_byref... struct, then
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000748 // the first thing we need to do is dereference the pointer (DW_OP_deref).
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000749 if (isPointer)
Devang Patel930143b2009-11-21 02:48:08 +0000750 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Caroline Ticec87c1e22009-08-31 21:19:37 +0000751
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000752 // Next add the offset for the '__forwarding' field:
753 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
754 // adding the offset if it's 0.
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000755 if (forwardingFieldOffset > 0) {
Devang Patel930143b2009-11-21 02:48:08 +0000756 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
757 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000758 }
Caroline Ticec87c1e22009-08-31 21:19:37 +0000759
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000760 // Now dereference the __forwarding field to get to the real __Block_byref
761 // struct: DW_OP_deref.
Devang Patel930143b2009-11-21 02:48:08 +0000762 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Caroline Ticec87c1e22009-08-31 21:19:37 +0000763
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000764 // Now that we've got the real __Block_byref... struct, add the offset
765 // for the variable's field to get to the location of the actual variable:
766 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000767 if (varFieldOffset > 0) {
Devang Patel930143b2009-11-21 02:48:08 +0000768 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
769 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000770 }
Caroline Ticec87c1e22009-08-31 21:19:37 +0000771
Daniel Dunbarbe22ec42009-09-19 20:40:14 +0000772 // Now attach the location information to the DIE.
Devang Patel930143b2009-11-21 02:48:08 +0000773 addBlock(Die, Attribute, 0, Block);
Caroline Ticec87c1e22009-08-31 21:19:37 +0000774}
775
Devang Patel930143b2009-11-21 02:48:08 +0000776/// addAddress - Add an address attribute to a die based on the location
Bill Wendling2f921f82009-05-15 09:23:25 +0000777/// provided.
Devang Patel930143b2009-11-21 02:48:08 +0000778void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
Bill Wendling2f921f82009-05-15 09:23:25 +0000779 const MachineLocation &Location) {
Chris Lattner3a383cb2010-04-05 00:13:49 +0000780 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Bill Wendling2f921f82009-05-15 09:23:25 +0000781 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer74729ae2010-03-31 19:34:01 +0000782 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Bill Wendling2f921f82009-05-15 09:23:25 +0000783
784 if (Location.isReg()) {
785 if (Reg < 32) {
Devang Patel930143b2009-11-21 02:48:08 +0000786 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Bill Wendling2f921f82009-05-15 09:23:25 +0000787 } else {
Devang Patel930143b2009-11-21 02:48:08 +0000788 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
789 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Bill Wendling2f921f82009-05-15 09:23:25 +0000790 }
791 } else {
792 if (Reg < 32) {
Devang Patel930143b2009-11-21 02:48:08 +0000793 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Bill Wendling2f921f82009-05-15 09:23:25 +0000794 } else {
Devang Patel930143b2009-11-21 02:48:08 +0000795 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
796 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
Bill Wendling2f921f82009-05-15 09:23:25 +0000797 }
798
Devang Patel930143b2009-11-21 02:48:08 +0000799 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Bill Wendling2f921f82009-05-15 09:23:25 +0000800 }
801
Devang Patel930143b2009-11-21 02:48:08 +0000802 addBlock(Die, Attribute, 0, Block);
Bill Wendling2f921f82009-05-15 09:23:25 +0000803}
804
Devang Patel173b2b92010-04-28 01:03:09 +0000805/// addRegisterAddress - Add register location entry in variable DIE.
Devang Patele1c53f22010-05-20 16:36:41 +0000806bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
Devang Patel173b2b92010-04-28 01:03:09 +0000807 const MachineOperand &MO) {
808 assert (MO.isReg() && "Invalid machine operand!");
809 if (!MO.getReg())
810 return false;
811 MachineLocation Location;
812 Location.set(MO.getReg());
813 addAddress(Die, dwarf::DW_AT_location, Location);
Devang Patele1c53f22010-05-20 16:36:41 +0000814 if (VS)
Devang Patel173b2b92010-04-28 01:03:09 +0000815 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
816 return true;
817}
818
819/// addConstantValue - Add constant value entry in variable DIE.
Devang Patele1c53f22010-05-20 16:36:41 +0000820bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
Devang Patel173b2b92010-04-28 01:03:09 +0000821 const MachineOperand &MO) {
822 assert (MO.isImm() && "Invalid machine operand!");
823 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
824 unsigned Imm = MO.getImm();
825 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
826 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
Devang Patele1c53f22010-05-20 16:36:41 +0000827 if (VS)
Devang Patel173b2b92010-04-28 01:03:09 +0000828 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
829 return true;
830}
831
832/// addConstantFPValue - Add constant value entry in variable DIE.
Devang Patele1c53f22010-05-20 16:36:41 +0000833bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
Devang Patel173b2b92010-04-28 01:03:09 +0000834 const MachineOperand &MO) {
835 assert (MO.isFPImm() && "Invalid machine operand!");
836 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
837 APFloat FPImm = MO.getFPImm()->getValueAPF();
838
839 // Get the raw data form of the floating point.
840 const APInt FltVal = FPImm.bitcastToAPInt();
841 const char *FltPtr = (const char*)FltVal.getRawData();
842
843 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
844 bool LittleEndian = Asm->getTargetData().isLittleEndian();
845 int Incr = (LittleEndian ? 1 : -1);
846 int Start = (LittleEndian ? 0 : NumBytes - 1);
847 int Stop = (LittleEndian ? NumBytes : -1);
848
849 // Output the constant to DWARF one byte at a time.
850 for (; Start != Stop; Start += Incr)
851 addUInt(Block, 0, dwarf::DW_FORM_data1,
852 (unsigned char)0xFF & FltPtr[Start]);
853
854 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
Devang Patele1c53f22010-05-20 16:36:41 +0000855 if (VS)
856 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
Devang Patel173b2b92010-04-28 01:03:09 +0000857 return true;
858}
859
860
Devang Patel2b75ed22009-12-10 19:14:49 +0000861/// addToContextOwner - Add Die into the list of its context owner's children.
862void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
Devang Patel3b548aa2010-03-08 20:52:55 +0000863 if (Context.isType()) {
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000864 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
Devang Patel2b75ed22009-12-10 19:14:49 +0000865 ContextDIE->addChild(Die);
Devang Patel1f4690c2009-12-15 19:16:48 +0000866 } else if (Context.isNameSpace()) {
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000867 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
Devang Patel1f4690c2009-12-15 19:16:48 +0000868 ContextDIE->addChild(Die);
Stuart Hastingsafe54f12010-06-11 20:08:44 +0000869 } else if (Context.isSubprogram()) {
870 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
871 /*MakeDecl=*/false);
872 ContextDIE->addChild(Die);
Devang Patel1a0df9a2010-05-10 22:49:55 +0000873 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
Devang Patel2b75ed22009-12-10 19:14:49 +0000874 ContextDIE->addChild(Die);
875 else
Devang Patel1a0df9a2010-05-10 22:49:55 +0000876 getCompileUnit(Context)->addDie(Die);
Devang Patel2b75ed22009-12-10 19:14:49 +0000877}
878
Devang Patelb5b60ea2009-12-10 18:05:33 +0000879/// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
880/// given DIType.
881DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
Devang Patel1a0df9a2010-05-10 22:49:55 +0000882 CompileUnit *TypeCU = getCompileUnit(Ty);
883 DIE *TyDIE = TypeCU->getDIE(Ty);
Devang Patelb5b60ea2009-12-10 18:05:33 +0000884 if (TyDIE)
885 return TyDIE;
886
887 // Create new type.
888 TyDIE = new DIE(dwarf::DW_TAG_base_type);
Devang Patel1a0df9a2010-05-10 22:49:55 +0000889 TypeCU->insertDIE(Ty, TyDIE);
Devang Patelb5b60ea2009-12-10 18:05:33 +0000890 if (Ty.isBasicType())
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000891 constructTypeDIE(*TyDIE, DIBasicType(Ty));
Devang Patelb5b60ea2009-12-10 18:05:33 +0000892 else if (Ty.isCompositeType())
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000893 constructTypeDIE(*TyDIE, DICompositeType(Ty));
Devang Patelb5b60ea2009-12-10 18:05:33 +0000894 else {
895 assert(Ty.isDerivedType() && "Unknown kind of DIType");
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000896 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
Devang Patelb5b60ea2009-12-10 18:05:33 +0000897 }
898
Devang Patel2b75ed22009-12-10 19:14:49 +0000899 addToContextOwner(TyDIE, Ty.getContext());
Devang Patelb5b60ea2009-12-10 18:05:33 +0000900 return TyDIE;
901}
902
Devang Patel930143b2009-11-21 02:48:08 +0000903/// addType - Add a new type attribute to the specified entity.
Devang Patel9ccfb642009-12-09 18:24:21 +0000904void DwarfDebug::addType(DIE *Entity, DIType Ty) {
Devang Patel8d6a2b72010-05-07 21:45:47 +0000905 if (!Ty.Verify())
Bill Wendling2f921f82009-05-15 09:23:25 +0000906 return;
907
908 // Check for pre-existence.
Devang Patel1a0df9a2010-05-10 22:49:55 +0000909 CompileUnit *TypeCU = getCompileUnit(Ty);
910 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
Bill Wendling2f921f82009-05-15 09:23:25 +0000911 // If it exists then use the existing value.
Devang Patel930143b2009-11-21 02:48:08 +0000912 if (Entry) {
913 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
Bill Wendling2f921f82009-05-15 09:23:25 +0000914 return;
915 }
916
Bill Wendling2f921f82009-05-15 09:23:25 +0000917 // Construct type.
Devang Patelb5b60ea2009-12-10 18:05:33 +0000918 DIE *Buffer = getOrCreateTypeDIE(Ty);
Bill Wendling2f921f82009-05-15 09:23:25 +0000919
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +0000920 // Set up proxy.
921 Entry = createDIEEntry(Buffer);
Devang Patel1a0df9a2010-05-10 22:49:55 +0000922 TypeCU->insertDIEEntry(Ty, Entry);
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +0000923
Devang Patel930143b2009-11-21 02:48:08 +0000924 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
Bill Wendling2f921f82009-05-15 09:23:25 +0000925}
926
Devang Patel930143b2009-11-21 02:48:08 +0000927/// constructTypeDIE - Construct basic type die from DIBasicType.
Devang Patel9ccfb642009-12-09 18:24:21 +0000928void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
Bill Wendling2f921f82009-05-15 09:23:25 +0000929 // Get core information.
Devang Patel2d9caf92009-11-25 17:36:49 +0000930 StringRef Name = BTy.getName();
Bill Wendling2f921f82009-05-15 09:23:25 +0000931 Buffer.setTag(dwarf::DW_TAG_base_type);
Devang Patel930143b2009-11-21 02:48:08 +0000932 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Bill Wendling2f921f82009-05-15 09:23:25 +0000933 BTy.getEncoding());
934
935 // Add name if not anonymous or intermediate type.
Devang Patel2d9caf92009-11-25 17:36:49 +0000936 if (!Name.empty())
Devang Patel930143b2009-11-21 02:48:08 +0000937 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling2f921f82009-05-15 09:23:25 +0000938 uint64_t Size = BTy.getSizeInBits() >> 3;
Devang Patel930143b2009-11-21 02:48:08 +0000939 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling2f921f82009-05-15 09:23:25 +0000940}
941
Devang Patel930143b2009-11-21 02:48:08 +0000942/// constructTypeDIE - Construct derived type die from DIDerivedType.
Devang Patel9ccfb642009-12-09 18:24:21 +0000943void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
Bill Wendling2f921f82009-05-15 09:23:25 +0000944 // Get core information.
Devang Patel2d9caf92009-11-25 17:36:49 +0000945 StringRef Name = DTy.getName();
Bill Wendling2f921f82009-05-15 09:23:25 +0000946 uint64_t Size = DTy.getSizeInBits() >> 3;
947 unsigned Tag = DTy.getTag();
948
949 // FIXME - Workaround for templates.
950 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
951
952 Buffer.setTag(Tag);
953
954 // Map to main type, void will not have a type.
955 DIType FromTy = DTy.getTypeDerivedFrom();
Devang Patel9ccfb642009-12-09 18:24:21 +0000956 addType(&Buffer, FromTy);
Bill Wendling2f921f82009-05-15 09:23:25 +0000957
958 // Add name if not anonymous or intermediate type.
Devang Patelae466ef2009-11-30 23:56:56 +0000959 if (!Name.empty())
Devang Patel930143b2009-11-21 02:48:08 +0000960 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling2f921f82009-05-15 09:23:25 +0000961
962 // Add size if non-zero (derived types might be zero-sized.)
963 if (Size)
Devang Patel930143b2009-11-21 02:48:08 +0000964 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling2f921f82009-05-15 09:23:25 +0000965
966 // Add source line info if available and TyDesc is not a forward declaration.
Devang Patelb5b51592009-11-23 18:43:37 +0000967 if (!DTy.isForwardDecl())
Devang Patel930143b2009-11-21 02:48:08 +0000968 addSourceLine(&Buffer, &DTy);
Bill Wendling2f921f82009-05-15 09:23:25 +0000969}
970
Devang Patel930143b2009-11-21 02:48:08 +0000971/// constructTypeDIE - Construct type DIE from DICompositeType.
Devang Patel9ccfb642009-12-09 18:24:21 +0000972void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
Bill Wendling2f921f82009-05-15 09:23:25 +0000973 // Get core information.
Devang Patel2d9caf92009-11-25 17:36:49 +0000974 StringRef Name = CTy.getName();
Bill Wendling2f921f82009-05-15 09:23:25 +0000975
976 uint64_t Size = CTy.getSizeInBits() >> 3;
977 unsigned Tag = CTy.getTag();
978 Buffer.setTag(Tag);
979
980 switch (Tag) {
981 case dwarf::DW_TAG_vector_type:
982 case dwarf::DW_TAG_array_type:
Devang Patel9ccfb642009-12-09 18:24:21 +0000983 constructArrayTypeDIE(Buffer, &CTy);
Bill Wendling2f921f82009-05-15 09:23:25 +0000984 break;
985 case dwarf::DW_TAG_enumeration_type: {
986 DIArray Elements = CTy.getTypeArray();
987
988 // Add enumerators to enumeration type.
989 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
990 DIE *ElemDie = NULL;
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000991 DIDescriptor Enum(Elements.getElement(i));
Devang Patel3b548aa2010-03-08 20:52:55 +0000992 if (Enum.isEnumerator()) {
Devang Patelcfa8e9d2010-05-07 18:11:54 +0000993 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
Devang Patel930143b2009-11-21 02:48:08 +0000994 Buffer.addChild(ElemDie);
Devang Patelfafa1fe2009-10-09 17:51:49 +0000995 }
Bill Wendling2f921f82009-05-15 09:23:25 +0000996 }
997 }
998 break;
999 case dwarf::DW_TAG_subroutine_type: {
1000 // Add return type.
1001 DIArray Elements = CTy.getTypeArray();
1002 DIDescriptor RTy = Elements.getElement(0);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001003 addType(&Buffer, DIType(RTy));
Bill Wendling2f921f82009-05-15 09:23:25 +00001004
1005 // Add prototype flag.
Devang Patel930143b2009-11-21 02:48:08 +00001006 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Bill Wendling2f921f82009-05-15 09:23:25 +00001007
1008 // Add arguments.
1009 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1010 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1011 DIDescriptor Ty = Elements.getElement(i);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001012 addType(Arg, DIType(Ty));
Devang Patel930143b2009-11-21 02:48:08 +00001013 Buffer.addChild(Arg);
Bill Wendling2f921f82009-05-15 09:23:25 +00001014 }
1015 }
1016 break;
1017 case dwarf::DW_TAG_structure_type:
1018 case dwarf::DW_TAG_union_type:
1019 case dwarf::DW_TAG_class_type: {
1020 // Add elements to structure type.
1021 DIArray Elements = CTy.getTypeArray();
1022
1023 // A forward struct declared type may not have elements available.
Devang Patel3b548aa2010-03-08 20:52:55 +00001024 unsigned N = Elements.getNumElements();
1025 if (N == 0)
Bill Wendling2f921f82009-05-15 09:23:25 +00001026 break;
1027
1028 // Add elements to structure type.
Devang Patel3b548aa2010-03-08 20:52:55 +00001029 for (unsigned i = 0; i < N; ++i) {
Bill Wendling2f921f82009-05-15 09:23:25 +00001030 DIDescriptor Element = Elements.getElement(i);
1031 DIE *ElemDie = NULL;
Devang Patel3b548aa2010-03-08 20:52:55 +00001032 if (Element.isSubprogram())
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001033 ElemDie = createSubprogramDIE(DISubprogram(Element));
Devang Patel3b548aa2010-03-08 20:52:55 +00001034 else if (Element.isVariable()) {
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001035 DIVariable DV(Element);
Devang Patel160c92d2010-01-30 01:08:30 +00001036 ElemDie = new DIE(dwarf::DW_TAG_variable);
1037 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1038 DV.getName());
1039 addType(ElemDie, DV.getType());
1040 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1041 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1042 addSourceLine(ElemDie, &DV);
Devang Patel3b548aa2010-03-08 20:52:55 +00001043 } else if (Element.isDerivedType())
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001044 ElemDie = createMemberDIE(DIDerivedType(Element));
Devang Patel3b548aa2010-03-08 20:52:55 +00001045 else
1046 continue;
Devang Patel930143b2009-11-21 02:48:08 +00001047 Buffer.addChild(ElemDie);
Bill Wendling2f921f82009-05-15 09:23:25 +00001048 }
1049
Devang Patel3082c012009-08-27 23:51:51 +00001050 if (CTy.isAppleBlockExtension())
Devang Patel930143b2009-11-21 02:48:08 +00001051 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
Bill Wendling2f921f82009-05-15 09:23:25 +00001052
1053 unsigned RLang = CTy.getRunTimeLang();
1054 if (RLang)
Devang Patel930143b2009-11-21 02:48:08 +00001055 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
Bill Wendling2f921f82009-05-15 09:23:25 +00001056 dwarf::DW_FORM_data1, RLang);
Devang Patel303a1be2010-01-26 21:16:06 +00001057
1058 DICompositeType ContainingType = CTy.getContainingType();
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001059 if (DIDescriptor(ContainingType).isCompositeType())
Devang Patel303a1be2010-01-26 21:16:06 +00001060 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001061 getOrCreateTypeDIE(DIType(ContainingType)));
Stuart Hastingsafe54f12010-06-11 20:08:44 +00001062 else {
1063 DIDescriptor Context = CTy.getContext();
1064 addToContextOwner(&Buffer, Context);
1065 }
Bill Wendling2f921f82009-05-15 09:23:25 +00001066 break;
1067 }
1068 default:
1069 break;
1070 }
1071
1072 // Add name if not anonymous or intermediate type.
Devang Patel2d9caf92009-11-25 17:36:49 +00001073 if (!Name.empty())
Devang Patel930143b2009-11-21 02:48:08 +00001074 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendling2f921f82009-05-15 09:23:25 +00001075
Devang Patel30265c42010-07-07 20:12:52 +00001076 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1077 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1078 {
Bill Wendling2f921f82009-05-15 09:23:25 +00001079 // Add size if non-zero (derived types might be zero-sized.)
1080 if (Size)
Devang Patel930143b2009-11-21 02:48:08 +00001081 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendling2f921f82009-05-15 09:23:25 +00001082 else {
1083 // Add zero size if it is not a forward declaration.
1084 if (CTy.isForwardDecl())
Devang Patel930143b2009-11-21 02:48:08 +00001085 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Bill Wendling2f921f82009-05-15 09:23:25 +00001086 else
Devang Patel930143b2009-11-21 02:48:08 +00001087 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
Bill Wendling2f921f82009-05-15 09:23:25 +00001088 }
1089
1090 // Add source line info if available.
1091 if (!CTy.isForwardDecl())
Devang Patel930143b2009-11-21 02:48:08 +00001092 addSourceLine(&Buffer, &CTy);
Bill Wendling2f921f82009-05-15 09:23:25 +00001093 }
1094}
1095
Devang Patel930143b2009-11-21 02:48:08 +00001096/// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1097void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
Bill Wendling2f921f82009-05-15 09:23:25 +00001098 int64_t L = SR.getLo();
1099 int64_t H = SR.getHi();
1100 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1101
Devang Patel930143b2009-11-21 02:48:08 +00001102 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
Devang Patelf691df32009-08-14 20:59:16 +00001103 if (L)
Devang Patel930143b2009-11-21 02:48:08 +00001104 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
Devang Patel8f046022009-12-04 23:10:24 +00001105 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
Bill Wendling2f921f82009-05-15 09:23:25 +00001106
Devang Patel930143b2009-11-21 02:48:08 +00001107 Buffer.addChild(DW_Subrange);
Bill Wendling2f921f82009-05-15 09:23:25 +00001108}
1109
Devang Patel930143b2009-11-21 02:48:08 +00001110/// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
Devang Patel9ccfb642009-12-09 18:24:21 +00001111void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
Bill Wendling2f921f82009-05-15 09:23:25 +00001112 DICompositeType *CTy) {
1113 Buffer.setTag(dwarf::DW_TAG_array_type);
1114 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
Devang Patel930143b2009-11-21 02:48:08 +00001115 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
Bill Wendling2f921f82009-05-15 09:23:25 +00001116
1117 // Emit derived type.
Devang Patel9ccfb642009-12-09 18:24:21 +00001118 addType(&Buffer, CTy->getTypeDerivedFrom());
Bill Wendling2f921f82009-05-15 09:23:25 +00001119 DIArray Elements = CTy->getTypeArray();
1120
Devang Patel92e8c652009-11-21 00:31:03 +00001121 // Get an anonymous type for index type.
Devang Patel1a0df9a2010-05-10 22:49:55 +00001122 CompileUnit *TheCU = getCompileUnit(*CTy);
1123 DIE *IdxTy = TheCU->getIndexTyDie();
Devang Patel92e8c652009-11-21 00:31:03 +00001124 if (!IdxTy) {
1125 // Construct an anonymous type for index type.
1126 IdxTy = new DIE(dwarf::DW_TAG_base_type);
Devang Patel930143b2009-11-21 02:48:08 +00001127 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1128 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Devang Patel92e8c652009-11-21 00:31:03 +00001129 dwarf::DW_ATE_signed);
Devang Patel1a0df9a2010-05-10 22:49:55 +00001130 TheCU->addDie(IdxTy);
1131 TheCU->setIndexTyDie(IdxTy);
Devang Patel92e8c652009-11-21 00:31:03 +00001132 }
Bill Wendling2f921f82009-05-15 09:23:25 +00001133
1134 // Add subranges to array type.
1135 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1136 DIDescriptor Element = Elements.getElement(i);
1137 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001138 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
Bill Wendling2f921f82009-05-15 09:23:25 +00001139 }
1140}
1141
Devang Patel930143b2009-11-21 02:48:08 +00001142/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
Devang Patel3b548aa2010-03-08 20:52:55 +00001143DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
Bill Wendling2f921f82009-05-15 09:23:25 +00001144 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
Devang Patel3b548aa2010-03-08 20:52:55 +00001145 StringRef Name = ETy.getName();
Devang Patel930143b2009-11-21 02:48:08 +00001146 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Devang Patel3b548aa2010-03-08 20:52:55 +00001147 int64_t Value = ETy.getEnumValue();
Devang Patel930143b2009-11-21 02:48:08 +00001148 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
Bill Wendling2f921f82009-05-15 09:23:25 +00001149 return Enumerator;
1150}
1151
Devang Patel43ef34d2010-01-05 01:46:14 +00001152/// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1153/// printer to not emit usual symbol prefix before the symbol name is used then
1154/// return linkage name after skipping this special LLVM prefix.
1155static StringRef getRealLinkageName(StringRef LinkageName) {
1156 char One = '\1';
1157 if (LinkageName.startswith(StringRef(&One, 1)))
1158 return LinkageName.substr(1);
1159 return LinkageName;
1160}
1161
Devang Patel930143b2009-11-21 02:48:08 +00001162/// createGlobalVariableDIE - Create new DIE using GV.
Devang Patel9ccfb642009-12-09 18:24:21 +00001163DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
Jim Grosbach00e9c612009-11-22 19:20:36 +00001164 // If the global variable was optmized out then no need to create debug info
1165 // entry.
Devang Patelcc11371b2009-11-06 17:58:12 +00001166 if (!GV.getGlobal()) return NULL;
Devang Patel2d9caf92009-11-25 17:36:49 +00001167 if (GV.getDisplayName().empty()) return NULL;
Devang Patel06ce6502009-11-06 01:30:04 +00001168
Bill Wendling2f921f82009-05-15 09:23:25 +00001169 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
Jim Grosbach042483e2009-11-21 23:12:12 +00001170 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
Devang Patelb2969422009-09-29 18:40:58 +00001171 GV.getDisplayName());
1172
Devang Patel2d9caf92009-11-25 17:36:49 +00001173 StringRef LinkageName = GV.getLinkageName();
Devang Patel43ef34d2010-01-05 01:46:14 +00001174 if (!LinkageName.empty())
Devang Patel930143b2009-11-21 02:48:08 +00001175 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
Devang Patel43ef34d2010-01-05 01:46:14 +00001176 getRealLinkageName(LinkageName));
1177
Devang Patel9ccfb642009-12-09 18:24:21 +00001178 addType(GVDie, GV.getType());
Bill Wendling2f921f82009-05-15 09:23:25 +00001179 if (!GV.isLocalToUnit())
Devang Patel930143b2009-11-21 02:48:08 +00001180 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1181 addSourceLine(GVDie, &GV);
Devang Patel4144a822009-10-05 23:22:08 +00001182
Bill Wendling2f921f82009-05-15 09:23:25 +00001183 return GVDie;
1184}
1185
Devang Patel930143b2009-11-21 02:48:08 +00001186/// createMemberDIE - Create new member DIE.
Devang Patel9ccfb642009-12-09 18:24:21 +00001187DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
Bill Wendling2f921f82009-05-15 09:23:25 +00001188 DIE *MemberDie = new DIE(DT.getTag());
Devang Patel2d9caf92009-11-25 17:36:49 +00001189 StringRef Name = DT.getName();
1190 if (!Name.empty())
Devang Patel930143b2009-11-21 02:48:08 +00001191 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Devang Patel2d9caf92009-11-25 17:36:49 +00001192
Devang Patel9ccfb642009-12-09 18:24:21 +00001193 addType(MemberDie, DT.getTypeDerivedFrom());
Bill Wendling2f921f82009-05-15 09:23:25 +00001194
Devang Patel930143b2009-11-21 02:48:08 +00001195 addSourceLine(MemberDie, &DT);
Bill Wendling2f921f82009-05-15 09:23:25 +00001196
Benjamin Kramer74729ae2010-03-31 19:34:01 +00001197 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
Devang Patel930143b2009-11-21 02:48:08 +00001198 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
Devang Patel67f56f02009-11-04 22:06:12 +00001199
Bill Wendling2f921f82009-05-15 09:23:25 +00001200 uint64_t Size = DT.getSizeInBits();
Devang Patelf05d5722009-11-04 23:48:00 +00001201 uint64_t FieldSize = DT.getOriginalTypeSize();
Bill Wendling2f921f82009-05-15 09:23:25 +00001202
1203 if (Size != FieldSize) {
1204 // Handle bitfield.
Devang Patel930143b2009-11-21 02:48:08 +00001205 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1206 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
Bill Wendling2f921f82009-05-15 09:23:25 +00001207
1208 uint64_t Offset = DT.getOffsetInBits();
Bill Wendling2f921f82009-05-15 09:23:25 +00001209 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1210 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
Benjamin Kramer2b459982010-01-07 17:50:57 +00001211 uint64_t FieldOffset = (HiMark - FieldSize);
Bill Wendling2f921f82009-05-15 09:23:25 +00001212 Offset -= FieldOffset;
1213
1214 // Maybe we need to work from the other end.
Chris Lattner3a383cb2010-04-05 00:13:49 +00001215 if (Asm->getTargetData().isLittleEndian())
1216 Offset = FieldSize - (Offset + Size);
Devang Patel930143b2009-11-21 02:48:08 +00001217 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
Bill Wendling2f921f82009-05-15 09:23:25 +00001218
Devang Patel67f56f02009-11-04 22:06:12 +00001219 // Here WD_AT_data_member_location points to the anonymous
1220 // field that includes this bit field.
Devang Patel930143b2009-11-21 02:48:08 +00001221 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
Devang Patel67f56f02009-11-04 22:06:12 +00001222
1223 } else
1224 // This is not a bitfield.
Devang Patel930143b2009-11-21 02:48:08 +00001225 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
Devang Patel67f56f02009-11-04 22:06:12 +00001226
Devang Pateld2316892010-02-03 20:08:48 +00001227 if (DT.getTag() == dwarf::DW_TAG_inheritance
1228 && DT.isVirtual()) {
1229
1230 // For C++, virtual base classes are not at fixed offset. Use following
1231 // expression to extract appropriate offset from vtable.
1232 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1233
Benjamin Kramer74729ae2010-03-31 19:34:01 +00001234 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
Devang Pateld2316892010-02-03 20:08:48 +00001235 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1236 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1237 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1239 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1240 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1241 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1242
1243 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1244 VBaseLocationDie);
1245 } else
1246 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
Bill Wendling2f921f82009-05-15 09:23:25 +00001247
1248 if (DT.isProtected())
Devang Pateleb57c592009-12-03 19:11:07 +00001249 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
Bill Wendling2f921f82009-05-15 09:23:25 +00001250 dwarf::DW_ACCESS_protected);
1251 else if (DT.isPrivate())
Devang Pateleb57c592009-12-03 19:11:07 +00001252 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
Bill Wendling2f921f82009-05-15 09:23:25 +00001253 dwarf::DW_ACCESS_private);
Devang Pateleb57c592009-12-03 19:11:07 +00001254 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1255 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1256 dwarf::DW_ACCESS_public);
1257 if (DT.isVirtual())
1258 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1259 dwarf::DW_VIRTUALITY_virtual);
Bill Wendling2f921f82009-05-15 09:23:25 +00001260 return MemberDie;
1261}
1262
Devang Patel525dda02009-12-14 16:18:45 +00001263/// createSubprogramDIE - Create new DIE using SP.
1264DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
Devang Patel1a0df9a2010-05-10 22:49:55 +00001265 CompileUnit *SPCU = getCompileUnit(SP);
1266 DIE *SPDie = SPCU->getDIE(SP);
Devang Patel525dda02009-12-14 16:18:45 +00001267 if (SPDie)
1268 return SPDie;
1269
1270 SPDie = new DIE(dwarf::DW_TAG_subprogram);
Devang Patelf200b392010-03-02 17:58:15 +00001271 // Constructors and operators for anonymous aggregates do not have names.
Devang Pateld0fa3042010-03-02 01:26:20 +00001272 if (!SP.getName().empty())
1273 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
Bill Wendling2f921f82009-05-15 09:23:25 +00001274
Devang Patel2d9caf92009-11-25 17:36:49 +00001275 StringRef LinkageName = SP.getLinkageName();
Devang Patel43ef34d2010-01-05 01:46:14 +00001276 if (!LinkageName.empty())
Devang Patel930143b2009-11-21 02:48:08 +00001277 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
Devang Patel43ef34d2010-01-05 01:46:14 +00001278 getRealLinkageName(LinkageName));
1279
Devang Patel930143b2009-11-21 02:48:08 +00001280 addSourceLine(SPDie, &SP);
Bill Wendling2f921f82009-05-15 09:23:25 +00001281
Bill Wendling2f921f82009-05-15 09:23:25 +00001282 // Add prototyped tag, if C or ObjC.
1283 unsigned Lang = SP.getCompileUnit().getLanguage();
1284 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1285 Lang == dwarf::DW_LANG_ObjC)
Devang Patel930143b2009-11-21 02:48:08 +00001286 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Bill Wendling2f921f82009-05-15 09:23:25 +00001287
1288 // Add Return Type.
Devang Patel236526d2009-12-03 01:25:38 +00001289 DICompositeType SPTy = SP.getType();
1290 DIArray Args = SPTy.getTypeArray();
Bill Wendling2f921f82009-05-15 09:23:25 +00001291 unsigned SPTag = SPTy.getTag();
Devang Pateleb57c592009-12-03 19:11:07 +00001292
Devang Patel3b548aa2010-03-08 20:52:55 +00001293 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
Devang Patel9ccfb642009-12-09 18:24:21 +00001294 addType(SPDie, SPTy);
Devang Patel236526d2009-12-03 01:25:38 +00001295 else
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001296 addType(SPDie, DIType(Args.getElement(0)));
Devang Patel236526d2009-12-03 01:25:38 +00001297
Devang Pateleb57c592009-12-03 19:11:07 +00001298 unsigned VK = SP.getVirtuality();
1299 if (VK) {
1300 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
Benjamin Kramer74729ae2010-03-31 19:34:01 +00001301 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Pateleb57c592009-12-03 19:11:07 +00001302 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1303 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1304 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
Devang Patel018b29b2010-01-19 06:19:05 +00001305 ContainingTypeMap.insert(std::make_pair(SPDie,
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001306 SP.getContainingType()));
Devang Pateleb57c592009-12-03 19:11:07 +00001307 }
1308
Devang Patel525dda02009-12-14 16:18:45 +00001309 if (MakeDecl || !SP.isDefinition()) {
Devang Patel930143b2009-11-21 02:48:08 +00001310 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Bill Wendling2f921f82009-05-15 09:23:25 +00001311
1312 // Add arguments. Do not add arguments for subprogram definition. They will
Devang Patel236526d2009-12-03 01:25:38 +00001313 // be handled while processing variables.
1314 DICompositeType SPTy = SP.getType();
1315 DIArray Args = SPTy.getTypeArray();
1316 unsigned SPTag = SPTy.getTag();
1317
Bill Wendling2f921f82009-05-15 09:23:25 +00001318 if (SPTag == dwarf::DW_TAG_subroutine_type)
1319 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1320 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001321 DIType ATy = DIType(DIType(Args.getElement(i)));
Devang Patel6efc8e52010-02-06 01:02:37 +00001322 addType(Arg, ATy);
1323 if (ATy.isArtificial())
1324 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
Devang Patel930143b2009-11-21 02:48:08 +00001325 SPDie->addChild(Arg);
Bill Wendling2f921f82009-05-15 09:23:25 +00001326 }
1327 }
1328
Devang Patel999b4992010-02-03 19:57:19 +00001329 if (SP.isArtificial())
1330 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1331
Devang Patelb4e3b902010-04-30 19:38:23 +00001332 if (!SP.isLocalToUnit())
1333 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
Devang Patel61880932010-04-19 19:14:02 +00001334
Devang Patelb4e3b902010-04-30 19:38:23 +00001335 if (SP.isOptimized())
1336 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1337
Devang Patelb4e3b902010-04-30 19:38:23 +00001338 // DW_TAG_inlined_subroutine may refer to this DIE.
Devang Patel1a0df9a2010-05-10 22:49:55 +00001339 SPCU->insertDIE(SP, SPDie);
Devang Patelb4e3b902010-04-30 19:38:23 +00001340
Stuart Hastingsafe54f12010-06-11 20:08:44 +00001341 // Add to context owner.
1342 addToContextOwner(SPDie, SP.getContext());
1343
Bill Wendling2f921f82009-05-15 09:23:25 +00001344 return SPDie;
1345}
1346
Devang Patel32cc43c2010-05-07 20:54:48 +00001347DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
Chris Lattner8d2fe282010-03-31 05:36:29 +00001348 assert(N && "Invalid Scope encoding!");
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001349
1350 DbgScope *AScope = AbstractScopes.lookup(N);
1351 if (AScope)
1352 return AScope;
Jim Grosbach042483e2009-11-21 23:12:12 +00001353
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001354 DbgScope *Parent = NULL;
1355
1356 DIDescriptor Scope(N);
1357 if (Scope.isLexicalBlock()) {
1358 DILexicalBlock DB(N);
1359 DIDescriptor ParentDesc = DB.getContext();
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001360 Parent = getOrCreateAbstractScope(ParentDesc);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001361 }
1362
1363 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1364
1365 if (Parent)
Devang Patel930143b2009-11-21 02:48:08 +00001366 Parent->addScope(AScope);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001367 AScope->setAbstractScope();
1368 AbstractScopes[N] = AScope;
1369 if (DIDescriptor(N).isSubprogram())
1370 AbstractScopesList.push_back(AScope);
1371 return AScope;
1372}
Devang Patel75cc16c2009-10-01 20:31:14 +00001373
Devang Patel019922d2010-04-06 23:53:48 +00001374/// isSubprogramContext - Return true if Context is either a subprogram
1375/// or another context nested inside a subprogram.
Devang Patel32cc43c2010-05-07 20:54:48 +00001376static bool isSubprogramContext(const MDNode *Context) {
Devang Patel019922d2010-04-06 23:53:48 +00001377 if (!Context)
1378 return false;
1379 DIDescriptor D(Context);
1380 if (D.isSubprogram())
1381 return true;
1382 if (D.isType())
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001383 return isSubprogramContext(DIType(Context).getContext());
Devang Patel019922d2010-04-06 23:53:48 +00001384 return false;
1385}
1386
Jim Grosbach042483e2009-11-21 23:12:12 +00001387/// updateSubprogramScopeDIE - Find DIE for the given subprogram and
Devang Patel930143b2009-11-21 02:48:08 +00001388/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1389/// If there are global variables in this scope then create and insert
1390/// DIEs for these variables.
Devang Patel32cc43c2010-05-07 20:54:48 +00001391DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
Devang Patel1a0df9a2010-05-10 22:49:55 +00001392 CompileUnit *SPCU = getCompileUnit(SPNode);
1393 DIE *SPDie = SPCU->getDIE(SPNode);
Devang Patela37a95e2010-07-07 22:20:57 +00001394
Chris Lattner3a383cb2010-04-05 00:13:49 +00001395 assert(SPDie && "Unable to find subprogram DIE!");
1396 DISubprogram SP(SPNode);
Chris Lattner2c3f4782010-03-13 07:26:18 +00001397
Chris Lattner3a383cb2010-04-05 00:13:49 +00001398 // There is not any need to generate specification DIE for a function
1399 // defined at compile unit level. If a function is defined inside another
1400 // function then gdb prefers the definition at top level and but does not
1401 // expect specification DIE in parent function. So avoid creating
1402 // specification DIE for a function defined inside a function.
1403 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
Devang Patel019922d2010-04-06 23:53:48 +00001404 !SP.getContext().isFile() &&
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001405 !isSubprogramContext(SP.getContext())) {
Chris Lattner3a383cb2010-04-05 00:13:49 +00001406 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1407
1408 // Add arguments.
1409 DICompositeType SPTy = SP.getType();
1410 DIArray Args = SPTy.getTypeArray();
1411 unsigned SPTag = SPTy.getTag();
1412 if (SPTag == dwarf::DW_TAG_subroutine_type)
1413 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1414 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001415 DIType ATy = DIType(DIType(Args.getElement(i)));
Chris Lattner3a383cb2010-04-05 00:13:49 +00001416 addType(Arg, ATy);
1417 if (ATy.isArtificial())
1418 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1419 SPDie->addChild(Arg);
1420 }
1421 DIE *SPDeclDie = SPDie;
1422 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1423 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1424 SPDeclDie);
Devang Patel1a0df9a2010-05-10 22:49:55 +00001425 SPCU->addDie(SPDie);
Chris Lattner3a383cb2010-04-05 00:13:49 +00001426 }
1427
Devang Patela37a95e2010-07-07 22:20:57 +00001428 // Pick up abstract subprogram DIE.
1429 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1430 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1431 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1432 dwarf::DW_FORM_ref4, AbsSPDIE);
1433 SPCU->addDie(SPDie);
1434 }
1435
Chris Lattner3a383cb2010-04-05 00:13:49 +00001436 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1437 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1438 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1439 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1440 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1441 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1442 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
Devang Patel6efc8e52010-02-06 01:02:37 +00001443
Chris Lattner3a383cb2010-04-05 00:13:49 +00001444 return SPDie;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001445}
1446
Jim Grosbach042483e2009-11-21 23:12:12 +00001447/// constructLexicalScope - Construct new DW_TAG_lexical_block
Devang Patel930143b2009-11-21 02:48:08 +00001448/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1449DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
Devang Patel6c74a872010-04-27 19:46:33 +00001450
1451 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1452 if (Scope->isAbstractScope())
1453 return ScopeDIE;
1454
1455 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1456 if (Ranges.empty())
1457 return 0;
1458
1459 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1460 if (Ranges.size() > 1) {
1461 // .debug_range section has not been laid out yet. Emit offset in
1462 // .debug_range as a uint, size 4, for now. emitDIE will handle
1463 // DW_AT_ranges appropriately.
1464 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1465 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1466 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1467 RE = Ranges.end(); RI != RE; ++RI) {
Devang Patel9fc11702010-05-25 23:40:22 +00001468 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1469 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
Devang Patel6c74a872010-04-27 19:46:33 +00001470 }
1471 DebugRangeSymbols.push_back(NULL);
1472 DebugRangeSymbols.push_back(NULL);
1473 return ScopeDIE;
1474 }
1475
Devang Patel9fc11702010-05-25 23:40:22 +00001476 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1477 const MCSymbol *End = getLabelAfterInsn(RI->second);
Devang Patel6c74a872010-04-27 19:46:33 +00001478
Devang Patel9fc11702010-05-25 23:40:22 +00001479 if (End == 0) return 0;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001480
Chris Lattnere13c3722010-03-09 01:58:53 +00001481 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1482 assert(End->isDefined() && "Invalid end label for an inlined scope!");
Chris Lattnerc3b70f62010-03-09 01:51:43 +00001483
Devang Patel6c74a872010-04-27 19:46:33 +00001484 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1485 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001486
1487 return ScopeDIE;
1488}
1489
Devang Patel930143b2009-11-21 02:48:08 +00001490/// constructInlinedScopeDIE - This scope represents inlined body of
1491/// a function. Construct DIE to represent this concrete inlined copy
1492/// of the function.
1493DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
Devang Patel6c74a872010-04-27 19:46:33 +00001494
1495 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1496 assert (Ranges.empty() == false
1497 && "DbgScope does not have instruction markers!");
1498
1499 // FIXME : .debug_inlined section specification does not clearly state how
1500 // to emit inlined scope that is split into multiple instruction ranges.
1501 // For now, use first instruction range and emit low_pc/high_pc pair and
1502 // corresponding .debug_inlined section entry for this pair.
1503 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
Devang Patel9fc11702010-05-25 23:40:22 +00001504 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1505 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
Devang Patel6c74a872010-04-27 19:46:33 +00001506
Devang Patel4c6bd662010-07-08 22:39:20 +00001507 if (StartLabel == 0 || EndLabel == 0) {
Devang Patel6c74a872010-04-27 19:46:33 +00001508 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1509 return 0;
1510 }
Chris Lattnere13c3722010-03-09 01:58:53 +00001511 assert(StartLabel->isDefined() &&
Chris Lattnerc3b70f62010-03-09 01:51:43 +00001512 "Invalid starting label for an inlined scope!");
Chris Lattnere13c3722010-03-09 01:58:53 +00001513 assert(EndLabel->isDefined() &&
Chris Lattnerc3b70f62010-03-09 01:51:43 +00001514 "Invalid end label for an inlined scope!");
Devang Patel6c74a872010-04-27 19:46:33 +00001515
Devang Patel3b548aa2010-03-08 20:52:55 +00001516 if (!Scope->getScopeNode())
Devang Patelbc97f6b2010-03-08 19:20:38 +00001517 return NULL;
Devang Patel3b548aa2010-03-08 20:52:55 +00001518 DIScope DS(Scope->getScopeNode());
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001519 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1520
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001521 DISubprogram InlinedSP = getDISubprogram(DS);
Devang Patel1a0df9a2010-05-10 22:49:55 +00001522 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1523 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
Chris Lattner8d2fe282010-03-31 05:36:29 +00001524 assert(OriginDIE && "Unable to find Origin DIE!");
Devang Patel930143b2009-11-21 02:48:08 +00001525 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001526 dwarf::DW_FORM_ref4, OriginDIE);
1527
Chris Lattner085b6522010-03-09 00:31:02 +00001528 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
Chris Lattnere13c3722010-03-09 01:58:53 +00001529 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001530
1531 InlinedSubprogramDIEs.insert(OriginDIE);
1532
1533 // Track the start label for this inlined function.
Devang Patel32cc43c2010-05-07 20:54:48 +00001534 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001535 I = InlineInfo.find(InlinedSP);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001536
1537 if (I == InlineInfo.end()) {
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001538 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
Jim Grosbach00e9c612009-11-22 19:20:36 +00001539 ScopeDIE));
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001540 InlinedSPNodes.push_back(InlinedSP);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001541 } else
Chris Lattner085b6522010-03-09 00:31:02 +00001542 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001543
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001544 DILocation DL(Scope->getInlinedAt());
Devang Patel1a0df9a2010-05-10 22:49:55 +00001545 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
Devang Patel930143b2009-11-21 02:48:08 +00001546 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001547
1548 return ScopeDIE;
1549}
1550
Devang Patel930143b2009-11-21 02:48:08 +00001551
1552/// constructVariableDIE - Construct a DIE for the given DbgVariable.
Devang Patel9ccfb642009-12-09 18:24:21 +00001553DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001554 // Get the descriptor.
1555 const DIVariable &VD = DV->getVariable();
Devang Patel2d9caf92009-11-25 17:36:49 +00001556 StringRef Name = VD.getName();
1557 if (Name.empty())
Devang Patel97f99fa2009-11-13 02:25:26 +00001558 return NULL;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001559
1560 // Translate tag to proper Dwarf tag. The result variable is dropped for
1561 // now.
1562 unsigned Tag;
1563 switch (VD.getTag()) {
1564 case dwarf::DW_TAG_return_variable:
1565 return NULL;
1566 case dwarf::DW_TAG_arg_variable:
1567 Tag = dwarf::DW_TAG_formal_parameter;
1568 break;
1569 case dwarf::DW_TAG_auto_variable: // fall thru
1570 default:
1571 Tag = dwarf::DW_TAG_variable;
1572 break;
1573 }
1574
1575 // Define variable debug information entry.
1576 DIE *VariableDie = new DIE(Tag);
1577
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001578 DIE *AbsDIE = NULL;
Devang Patele1c53f22010-05-20 16:36:41 +00001579 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1580 V2AVI = VarToAbstractVarMap.find(DV);
1581 if (V2AVI != VarToAbstractVarMap.end())
1582 AbsDIE = V2AVI->second->getDIE();
Jim Grosbach042483e2009-11-21 23:12:12 +00001583
Devang Patele1c53f22010-05-20 16:36:41 +00001584 if (AbsDIE)
Devang Patel930143b2009-11-21 02:48:08 +00001585 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001586 dwarf::DW_FORM_ref4, AbsDIE);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001587 else {
Devang Patel930143b2009-11-21 02:48:08 +00001588 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1589 addSourceLine(VariableDie, &VD);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001590
1591 // Add variable type.
Jim Grosbach042483e2009-11-21 23:12:12 +00001592 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001593 // addresses instead.
1594 if (VD.isBlockByrefVariable())
Devang Patel9ccfb642009-12-09 18:24:21 +00001595 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001596 else
Devang Patel9ccfb642009-12-09 18:24:21 +00001597 addType(VariableDie, VD.getType());
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001598 }
1599
Devang Patel6efc8e52010-02-06 01:02:37 +00001600 if (Tag == dwarf::DW_TAG_formal_parameter && VD.getType().isArtificial())
1601 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
Devang Patel9fc11702010-05-25 23:40:22 +00001602
1603 if (Scope->isAbstractScope()) {
1604 DV->setDIE(VariableDie);
1605 return VariableDie;
1606 }
1607
1608 // Add variable address.
1609
1610 unsigned Offset = DV->getDotDebugLocOffset();
1611 if (Offset != ~0U) {
1612 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1613 Asm->GetTempSymbol("debug_loc", Offset));
1614 DV->setDIE(VariableDie);
1615 UseDotDebugLocEntry.insert(VariableDie);
1616 return VariableDie;
1617 }
1618
1619 // Check if variable is described by a DBG_VALUE instruction.
1620 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1621 DbgVariableToDbgInstMap.find(DV);
1622 if (DVI != DbgVariableToDbgInstMap.end()) {
1623 const MachineInstr *DVInsn = DVI->second;
1624 const MCSymbol *DVLabel = findVariableLabel(DV);
1625 bool updated = false;
1626 // FIXME : Handle getNumOperands != 3
1627 if (DVInsn->getNumOperands() == 3) {
1628 if (DVInsn->getOperand(0).isReg())
Devang Patel30265c42010-07-07 20:12:52 +00001629 updated =
1630 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
Devang Patel9fc11702010-05-25 23:40:22 +00001631 else if (DVInsn->getOperand(0).isImm())
1632 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1633 else if (DVInsn->getOperand(0).isFPImm())
Devang Patel30265c42010-07-07 20:12:52 +00001634 updated =
1635 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
Devang Patel9fc11702010-05-25 23:40:22 +00001636 } else {
1637 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1638 if (Location.getReg()) {
1639 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1640 if (DVLabel)
1641 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1642 DVLabel);
1643 updated = true;
1644 }
1645 }
1646 if (!updated) {
1647 // If variableDie is not updated then DBG_VALUE instruction does not
1648 // have valid variable info.
1649 delete VariableDie;
1650 return NULL;
1651 }
1652 DV->setDIE(VariableDie);
1653 return VariableDie;
1654 }
1655
1656 // .. else use frame index, if available.
1657 MachineLocation Location;
1658 unsigned FrameReg;
1659 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1660 int FI = 0;
1661 if (findVariableFrameIndex(DV, &FI)) {
1662 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1663 Location.set(FrameReg, Offset);
1664
1665 if (VD.hasComplexAddress())
1666 addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1667 else if (VD.isBlockByrefVariable())
1668 addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1669 else
1670 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1671 }
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001672 DV->setDIE(VariableDie);
1673 return VariableDie;
1674
1675}
Devang Patel930143b2009-11-21 02:48:08 +00001676
Devang Patel04d2f2d2009-11-24 01:14:22 +00001677void DwarfDebug::addPubTypes(DISubprogram SP) {
1678 DICompositeType SPTy = SP.getType();
1679 unsigned SPTag = SPTy.getTag();
1680 if (SPTag != dwarf::DW_TAG_subroutine_type)
1681 return;
1682
1683 DIArray Args = SPTy.getTypeArray();
Devang Patel04d2f2d2009-11-24 01:14:22 +00001684 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001685 DIType ATy(Args.getElement(i));
Devang Patel8d6a2b72010-05-07 21:45:47 +00001686 if (!ATy.Verify())
Devang Patel04d2f2d2009-11-24 01:14:22 +00001687 continue;
1688 DICompositeType CATy = getDICompositeType(ATy);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001689 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
Devang Patel12d150e2010-04-13 20:35:04 +00001690 && !CATy.isForwardDecl()) {
Devang Patel1a0df9a2010-05-10 22:49:55 +00001691 CompileUnit *TheCU = getCompileUnit(CATy);
1692 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1693 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
Devang Patel04d2f2d2009-11-24 01:14:22 +00001694 }
1695 }
1696}
1697
Devang Patel930143b2009-11-21 02:48:08 +00001698/// constructScopeDIE - Construct a DIE for this scope.
1699DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
Devang Patel3b548aa2010-03-08 20:52:55 +00001700 if (!Scope || !Scope->getScopeNode())
1701 return NULL;
1702
1703 DIScope DS(Scope->getScopeNode());
1704 DIE *ScopeDIE = NULL;
1705 if (Scope->getInlinedAt())
1706 ScopeDIE = constructInlinedScopeDIE(Scope);
1707 else if (DS.isSubprogram()) {
Devang Pateld10b2af2010-06-28 20:53:04 +00001708 ProcessedSPNodes.insert(DS);
Devang Patela37a95e2010-07-07 22:20:57 +00001709 if (Scope->isAbstractScope()) {
Devang Patel1a0df9a2010-05-10 22:49:55 +00001710 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
Devang Patela37a95e2010-07-07 22:20:57 +00001711 // Note down abstract DIE.
1712 if (ScopeDIE)
1713 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1714 }
Devang Patel3b548aa2010-03-08 20:52:55 +00001715 else
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001716 ScopeDIE = updateSubprogramScopeDIE(DS);
Devang Patel3b548aa2010-03-08 20:52:55 +00001717 }
Devang Patel23b2ae62010-03-29 22:59:58 +00001718 else
Devang Patel3b548aa2010-03-08 20:52:55 +00001719 ScopeDIE = constructLexicalScopeDIE(Scope);
Devang Patel23b2ae62010-03-29 22:59:58 +00001720 if (!ScopeDIE) return NULL;
Devang Patel3b548aa2010-03-08 20:52:55 +00001721
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001722 // Add variables to scope.
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00001723 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001724 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
Devang Patel9ccfb642009-12-09 18:24:21 +00001725 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
Jim Grosbach042483e2009-11-21 23:12:12 +00001726 if (VariableDIE)
Devang Patel930143b2009-11-21 02:48:08 +00001727 ScopeDIE->addChild(VariableDIE);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001728 }
1729
1730 // Add nested scopes.
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00001731 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001732 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1733 // Define the Scope debug information entry.
Devang Patel930143b2009-11-21 02:48:08 +00001734 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
Jim Grosbach042483e2009-11-21 23:12:12 +00001735 if (NestedDIE)
Devang Patel930143b2009-11-21 02:48:08 +00001736 ScopeDIE->addChild(NestedDIE);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001737 }
Devang Patel04d2f2d2009-11-24 01:14:22 +00001738
1739 if (DS.isSubprogram())
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001740 addPubTypes(DISubprogram(DS));
Devang Patel04d2f2d2009-11-24 01:14:22 +00001741
1742 return ScopeDIE;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001743}
1744
Bill Wendling2b128d72009-05-20 23:19:06 +00001745/// GetOrCreateSourceID - Look up the source id with the given directory and
1746/// source file names. If none currently exists, create a new id and insert it
1747/// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1748/// maps as well.
Chris Lattner71696ef2010-03-31 06:06:37 +00001749unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
Bill Wendling2b128d72009-05-20 23:19:06 +00001750 unsigned DId;
1751 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1752 if (DI != DirectoryIdMap.end()) {
1753 DId = DI->getValue();
1754 } else {
1755 DId = DirectoryNames.size() + 1;
1756 DirectoryIdMap[DirName] = DId;
1757 DirectoryNames.push_back(DirName);
1758 }
1759
1760 unsigned FId;
1761 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1762 if (FI != SourceFileIdMap.end()) {
1763 FId = FI->getValue();
1764 } else {
1765 FId = SourceFileNames.size() + 1;
1766 SourceFileIdMap[FileName] = FId;
1767 SourceFileNames.push_back(FileName);
1768 }
1769
1770 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1771 SourceIdMap.find(std::make_pair(DId, FId));
1772 if (SI != SourceIdMap.end())
1773 return SI->second;
1774
1775 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1776 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1777 SourceIds.push_back(std::make_pair(DId, FId));
1778
1779 return SrcId;
1780}
1781
Devang Patel1f4690c2009-12-15 19:16:48 +00001782/// getOrCreateNameSpace - Create a DIE for DINameSpace.
1783DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
Devang Patel1a0df9a2010-05-10 22:49:55 +00001784 CompileUnit *TheCU = getCompileUnit(NS);
1785 DIE *NDie = TheCU->getDIE(NS);
Devang Patel1f4690c2009-12-15 19:16:48 +00001786 if (NDie)
1787 return NDie;
1788 NDie = new DIE(dwarf::DW_TAG_namespace);
Devang Patel1a0df9a2010-05-10 22:49:55 +00001789 TheCU->insertDIE(NS, NDie);
Devang Patel1f4690c2009-12-15 19:16:48 +00001790 if (!NS.getName().empty())
1791 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1792 addSourceLine(NDie, &NS);
1793 addToContextOwner(NDie, NS.getContext());
1794 return NDie;
1795}
1796
Devang Patel1a0df9a2010-05-10 22:49:55 +00001797/// constructCompileUnit - Create new CompileUnit for the given
1798/// metadata node with tag DW_TAG_compile_unit.
Devang Patel32cc43c2010-05-07 20:54:48 +00001799void DwarfDebug::constructCompileUnit(const MDNode *N) {
Devang Patel80ae3492009-08-28 23:24:31 +00001800 DICompileUnit DIUnit(N);
Devang Patel2d9caf92009-11-25 17:36:49 +00001801 StringRef FN = DIUnit.getFilename();
1802 StringRef Dir = DIUnit.getDirectory();
Devang Patelb2969422009-09-29 18:40:58 +00001803 unsigned ID = GetOrCreateSourceID(Dir, FN);
Bill Wendling2b128d72009-05-20 23:19:06 +00001804
1805 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Devang Patel930143b2009-11-21 02:48:08 +00001806 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
Devang Patelb2969422009-09-29 18:40:58 +00001807 DIUnit.getProducer());
Devang Patel930143b2009-11-21 02:48:08 +00001808 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
Bill Wendling2b128d72009-05-20 23:19:06 +00001809 DIUnit.getLanguage());
Devang Patel930143b2009-11-21 02:48:08 +00001810 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
Devang Patelbd798ce2010-04-26 22:54:28 +00001811 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1812 // simplifies debug range entries.
Devang Patel1de21ec2010-06-28 22:22:47 +00001813 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
Devang Pateld22ed622010-03-22 23:11:36 +00001814 // DW_AT_stmt_list is a offset of line number information for this
Devang Patel24bc1b52010-06-29 20:17:53 +00001815 // compile unit in debug_line section. This offset is calculated
1816 // during endMoudle().
1817 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
Bill Wendling2b128d72009-05-20 23:19:06 +00001818
Devang Patel2d9caf92009-11-25 17:36:49 +00001819 if (!Dir.empty())
Devang Patel930143b2009-11-21 02:48:08 +00001820 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
Bill Wendling2b128d72009-05-20 23:19:06 +00001821 if (DIUnit.isOptimized())
Devang Patel930143b2009-11-21 02:48:08 +00001822 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
Bill Wendling2b128d72009-05-20 23:19:06 +00001823
Devang Patel2d9caf92009-11-25 17:36:49 +00001824 StringRef Flags = DIUnit.getFlags();
1825 if (!Flags.empty())
Devang Patel930143b2009-11-21 02:48:08 +00001826 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
Bill Wendling2b128d72009-05-20 23:19:06 +00001827
1828 unsigned RVer = DIUnit.getRunTimeVersion();
1829 if (RVer)
Devang Patel930143b2009-11-21 02:48:08 +00001830 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
Bill Wendling2b128d72009-05-20 23:19:06 +00001831 dwarf::DW_FORM_data1, RVer);
1832
Devang Patel1a0df9a2010-05-10 22:49:55 +00001833 CompileUnit *NewCU = new CompileUnit(ID, Die);
1834 if (!FirstCU)
1835 FirstCU = NewCU;
1836 CUMap.insert(std::make_pair(N, NewCU));
Bill Wendling2b128d72009-05-20 23:19:06 +00001837}
1838
Devang Patel1a0df9a2010-05-10 22:49:55 +00001839/// getCompielUnit - Get CompileUnit DIE.
1840CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1841 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1842 DIDescriptor D(N);
1843 const MDNode *CUNode = NULL;
1844 if (D.isCompileUnit())
1845 CUNode = N;
1846 else if (D.isSubprogram())
1847 CUNode = DISubprogram(N).getCompileUnit();
1848 else if (D.isType())
1849 CUNode = DIType(N).getCompileUnit();
1850 else if (D.isGlobalVariable())
1851 CUNode = DIGlobalVariable(N).getCompileUnit();
1852 else if (D.isVariable())
1853 CUNode = DIVariable(N).getCompileUnit();
1854 else if (D.isNameSpace())
1855 CUNode = DINameSpace(N).getCompileUnit();
1856 else if (D.isFile())
1857 CUNode = DIFile(N).getCompileUnit();
1858 else
1859 return FirstCU;
1860
1861 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1862 = CUMap.find(CUNode);
1863 if (I == CUMap.end())
1864 return FirstCU;
1865 return I->second;
1866}
1867
1868
1869/// constructGlobalVariableDIE - Construct global variable DIE.
Devang Patel32cc43c2010-05-07 20:54:48 +00001870void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
Devang Patel80ae3492009-08-28 23:24:31 +00001871 DIGlobalVariable DI_GV(N);
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00001872
Devang Patelf5d53602009-09-04 23:59:07 +00001873 // If debug information is malformed then ignore it.
1874 if (DI_GV.Verify() == false)
1875 return;
Bill Wendling2b128d72009-05-20 23:19:06 +00001876
1877 // Check for pre-existence.
Devang Patel1a0df9a2010-05-10 22:49:55 +00001878 CompileUnit *TheCU = getCompileUnit(N);
1879 if (TheCU->getDIE(DI_GV))
Devang Patel0751a282009-06-26 01:49:18 +00001880 return;
Bill Wendling2b128d72009-05-20 23:19:06 +00001881
Devang Patel9ccfb642009-12-09 18:24:21 +00001882 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
Devang Patel2eec32d2009-12-10 23:25:41 +00001883 if (!VariableDie)
1884 return;
Bill Wendling2b128d72009-05-20 23:19:06 +00001885
Bill Wendling2b128d72009-05-20 23:19:06 +00001886 // Add to map.
Devang Patel1a0df9a2010-05-10 22:49:55 +00001887 TheCU->insertDIE(N, VariableDie);
Bill Wendling2b128d72009-05-20 23:19:06 +00001888
1889 // Add to context owner.
Devang Patel89880c82010-01-15 01:12:22 +00001890 DIDescriptor GVContext = DI_GV.getContext();
1891 // Do not create specification DIE if context is either compile unit
1892 // or a subprogram.
Chris Lattner71696ef2010-03-31 06:06:37 +00001893 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
Devang Patel019922d2010-04-06 23:53:48 +00001894 !GVContext.isFile() &&
Devang Patelcfa8e9d2010-05-07 18:11:54 +00001895 !isSubprogramContext(GVContext)) {
Devang Patel1f4690c2009-12-15 19:16:48 +00001896 // Create specification DIE.
1897 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1898 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1899 dwarf::DW_FORM_ref4, VariableDie);
Benjamin Kramer74729ae2010-03-31 19:34:01 +00001900 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel1f4690c2009-12-15 19:16:48 +00001901 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
Chris Lattner8dcf41e2010-03-08 22:31:46 +00001902 addLabel(Block, 0, dwarf::DW_FORM_udata,
Chris Lattner9e4cafe2010-03-12 21:09:07 +00001903 Asm->Mang->getSymbol(DI_GV.getGlobal()));
Devang Patel1f4690c2009-12-15 19:16:48 +00001904 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
Devang Patelce25dd72010-02-09 01:58:33 +00001905 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Devang Patel1a0df9a2010-05-10 22:49:55 +00001906 TheCU->addDie(VariableSpecDIE);
Devang Patel1f4690c2009-12-15 19:16:48 +00001907 } else {
Benjamin Kramer74729ae2010-03-31 19:34:01 +00001908 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel1f4690c2009-12-15 19:16:48 +00001909 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
Chris Lattner8dcf41e2010-03-08 22:31:46 +00001910 addLabel(Block, 0, dwarf::DW_FORM_udata,
Chris Lattner9e4cafe2010-03-12 21:09:07 +00001911 Asm->Mang->getSymbol(DI_GV.getGlobal()));
Devang Patel1f4690c2009-12-15 19:16:48 +00001912 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1913 }
Devang Patel89880c82010-01-15 01:12:22 +00001914 addToContextOwner(VariableDie, GVContext);
Devang Patel2b75ed22009-12-10 19:14:49 +00001915
Bill Wendling2b128d72009-05-20 23:19:06 +00001916 // Expose as global. FIXME - need to check external flag.
Devang Patel1a0df9a2010-05-10 22:49:55 +00001917 TheCU->addGlobal(DI_GV.getName(), VariableDie);
Devang Patel04d2f2d2009-11-24 01:14:22 +00001918
1919 DIType GTy = DI_GV.getType();
Devang Patel12d150e2010-04-13 20:35:04 +00001920 if (GTy.isCompositeType() && !GTy.getName().empty()
1921 && !GTy.isForwardDecl()) {
Devang Patel1a0df9a2010-05-10 22:49:55 +00001922 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
Chris Lattner8d2fe282010-03-31 05:36:29 +00001923 assert(Entry && "Missing global type!");
Devang Patel1a0df9a2010-05-10 22:49:55 +00001924 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
Devang Patel04d2f2d2009-11-24 01:14:22 +00001925 }
Devang Patel0751a282009-06-26 01:49:18 +00001926 return;
Bill Wendling2b128d72009-05-20 23:19:06 +00001927}
1928
Devang Patel1a0df9a2010-05-10 22:49:55 +00001929/// construct SubprogramDIE - Construct subprogram DIE.
Devang Patel32cc43c2010-05-07 20:54:48 +00001930void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
Devang Patel80ae3492009-08-28 23:24:31 +00001931 DISubprogram SP(N);
Bill Wendling2b128d72009-05-20 23:19:06 +00001932
Stuart Hastings4bd3dd92010-04-06 21:38:29 +00001933 // Check for pre-existence.
Devang Patel1a0df9a2010-05-10 22:49:55 +00001934 CompileUnit *TheCU = getCompileUnit(N);
1935 if (TheCU->getDIE(N))
Stuart Hastings4bd3dd92010-04-06 21:38:29 +00001936 return;
1937
Bill Wendling2b128d72009-05-20 23:19:06 +00001938 if (!SP.isDefinition())
1939 // This is a method declaration which will be handled while constructing
1940 // class type.
Devang Patel0751a282009-06-26 01:49:18 +00001941 return;
Bill Wendling2b128d72009-05-20 23:19:06 +00001942
Stuart Hastings4bd3dd92010-04-06 21:38:29 +00001943 DIE *SubprogramDie = createSubprogramDIE(SP);
1944
1945 // Add to map.
Devang Patel1a0df9a2010-05-10 22:49:55 +00001946 TheCU->insertDIE(N, SubprogramDie);
Bill Wendling2b128d72009-05-20 23:19:06 +00001947
1948 // Add to context owner.
Devang Patel1f4690c2009-12-15 19:16:48 +00001949 addToContextOwner(SubprogramDie, SP.getContext());
Devang Patel512001a2009-12-08 23:21:45 +00001950
Bill Wendling2b128d72009-05-20 23:19:06 +00001951 // Expose as global.
Devang Patel1a0df9a2010-05-10 22:49:55 +00001952 TheCU->addGlobal(SP.getName(), SubprogramDie);
Devang Patel04d2f2d2009-11-24 01:14:22 +00001953
Devang Patel0751a282009-06-26 01:49:18 +00001954 return;
Bill Wendling2b128d72009-05-20 23:19:06 +00001955}
1956
Devang Patel930143b2009-11-21 02:48:08 +00001957/// beginModule - Emit all Dwarf sections that should come prior to the
Daniel Dunbarbe22ec42009-09-19 20:40:14 +00001958/// content. Create global DIEs and emit initial debug info sections.
1959/// This is inovked by the target AsmPrinter.
Chris Lattner11980022010-04-04 07:48:20 +00001960void DwarfDebug::beginModule(Module *M) {
Devang Patel6c74a872010-04-27 19:46:33 +00001961 if (DisableDebugInfoPrinting)
1962 return;
1963
Devang Patel63524442009-07-30 18:56:46 +00001964 DebugInfoFinder DbgFinder;
1965 DbgFinder.processModule(*M);
Devang Patel0751a282009-06-26 01:49:18 +00001966
Chris Lattner7cfa70e2010-04-05 02:19:28 +00001967 bool HasDebugInfo = false;
1968
1969 // Scan all the compile-units to see if there are any marked as the main unit.
1970 // if not, we do not generate debug info.
1971 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1972 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1973 if (DICompileUnit(*I).isMain()) {
1974 HasDebugInfo = true;
1975 break;
1976 }
1977 }
1978
1979 if (!HasDebugInfo) return;
1980
1981 // Tell MMI that we have debug info.
1982 MMI->setDebugInfoAvailability(true);
1983
Chris Lattnerd442aa32010-04-04 23:17:54 +00001984 // Emit initial sections.
Chris Lattner7cfa70e2010-04-05 02:19:28 +00001985 EmitSectionLabels();
Chris Lattnerd442aa32010-04-04 23:17:54 +00001986
Bill Wendling2b128d72009-05-20 23:19:06 +00001987 // Create all the compile unit DIEs.
Devang Patel63524442009-07-30 18:56:46 +00001988 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1989 E = DbgFinder.compile_unit_end(); I != E; ++I)
Devang Patel930143b2009-11-21 02:48:08 +00001990 constructCompileUnit(*I);
Bill Wendling2b128d72009-05-20 23:19:06 +00001991
Devang Patelf6eeaeb2009-11-10 23:06:00 +00001992 // Create DIEs for each subprogram.
Devang Patel63524442009-07-30 18:56:46 +00001993 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1994 E = DbgFinder.subprogram_end(); I != E; ++I)
Devang Patel930143b2009-11-21 02:48:08 +00001995 constructSubprogramDIE(*I);
Devang Patel0751a282009-06-26 01:49:18 +00001996
Devang Patel2b75ed22009-12-10 19:14:49 +00001997 // Create DIEs for each global variable.
1998 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1999 E = DbgFinder.global_variable_end(); I != E; ++I)
2000 constructGlobalVariableDIE(*I);
2001
Bill Wendling2b128d72009-05-20 23:19:06 +00002002 // Prime section data.
Chris Lattner5e693ed2009-07-28 03:13:23 +00002003 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
Bill Wendling2b128d72009-05-20 23:19:06 +00002004
2005 // Print out .file directives to specify files for .loc directives. These are
2006 // printed out early so that they precede any .loc directives.
Chris Lattner3a383cb2010-04-05 00:13:49 +00002007 if (Asm->MAI->hasDotLocAndDotFile()) {
Bill Wendling2b128d72009-05-20 23:19:06 +00002008 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2009 // Remember source id starts at 1.
2010 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
Chris Lattnerf5c834f2010-01-22 22:09:00 +00002011 // FIXME: don't use sys::path for this! This should not depend on the
2012 // host.
Bill Wendling2b128d72009-05-20 23:19:06 +00002013 sys::Path FullPath(getSourceDirectoryName(Id.first));
2014 bool AppendOk =
2015 FullPath.appendComponent(getSourceFileName(Id.second));
2016 assert(AppendOk && "Could not append filename to directory!");
2017 AppendOk = false;
Chris Lattner601ef332010-01-25 18:58:59 +00002018 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
Bill Wendling2b128d72009-05-20 23:19:06 +00002019 }
2020 }
Bill Wendling2b128d72009-05-20 23:19:06 +00002021}
2022
Devang Patel930143b2009-11-21 02:48:08 +00002023/// endModule - Emit all Dwarf sections that should come after the content.
Bill Wendling2b128d72009-05-20 23:19:06 +00002024///
Devang Patel930143b2009-11-21 02:48:08 +00002025void DwarfDebug::endModule() {
Devang Patel1a0df9a2010-05-10 22:49:55 +00002026 if (!FirstCU) return;
Devang Patelf3b2db62010-06-28 18:25:03 +00002027 const Module *M = MMI->getModule();
2028 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2029 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2030 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2031 DISubprogram SP(AllSPs->getOperand(SI));
2032 if (!SP.Verify()) continue;
2033
2034 // Collect info for variables that were optimized out.
Devang Patel18efced2010-07-19 17:53:55 +00002035 if (!SP.isDefinition()) continue;
Devang Patelf3b2db62010-06-28 18:25:03 +00002036 StringRef FName = SP.getLinkageName();
2037 if (FName.empty())
2038 FName = SP.getName();
2039 NamedMDNode *NMD =
2040 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2041 if (!NMD) continue;
2042 unsigned E = NMD->getNumOperands();
2043 if (!E) continue;
2044 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2045 for (unsigned I = 0; I != E; ++I) {
2046 DIVariable DV(NMD->getOperand(I));
2047 if (!DV.Verify()) continue;
2048 Scope->addVariable(new DbgVariable(DV));
2049 }
2050
2051 // Construct subprogram DIE and add variables DIEs.
2052 constructSubprogramDIE(SP);
2053 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2054 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
2055 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2056 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2057 if (VariableDIE)
2058 ScopeDIE->addChild(VariableDIE);
2059 }
2060 }
2061 }
Bill Wendling2b128d72009-05-20 23:19:06 +00002062
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002063 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2064 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2065 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2066 DIE *ISP = *AI;
Devang Patel930143b2009-11-21 02:48:08 +00002067 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002068 }
2069
Devang Patel32cc43c2010-05-07 20:54:48 +00002070 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
Devang Pateleb57c592009-12-03 19:11:07 +00002071 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2072 DIE *SPDie = CI->first;
Devang Patel32cc43c2010-05-07 20:54:48 +00002073 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
Devang Pateleb57c592009-12-03 19:11:07 +00002074 if (!N) continue;
Devang Patel1a0df9a2010-05-10 22:49:55 +00002075 DIE *NDie = getCompileUnit(N)->getDIE(N);
Devang Pateleb57c592009-12-03 19:11:07 +00002076 if (!NDie) continue;
2077 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
Devang Pateleb57c592009-12-03 19:11:07 +00002078 }
2079
Bill Wendling2b128d72009-05-20 23:19:06 +00002080 // Standard sections final addresses.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002081 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
Chris Lattnera179b522010-04-04 19:25:43 +00002082 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002083 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
Chris Lattnera179b522010-04-04 19:25:43 +00002084 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
Bill Wendling2b128d72009-05-20 23:19:06 +00002085
2086 // End text sections.
2087 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002088 Asm->OutStreamer.SwitchSection(SectionMap[i]);
Chris Lattnera179b522010-04-04 19:25:43 +00002089 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
Bill Wendling2b128d72009-05-20 23:19:06 +00002090 }
2091
2092 // Emit common frame information.
Devang Patel930143b2009-11-21 02:48:08 +00002093 emitCommonDebugFrame();
Bill Wendling2b128d72009-05-20 23:19:06 +00002094
2095 // Emit function debug frame information
2096 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2097 E = DebugFrames.end(); I != E; ++I)
Devang Patel930143b2009-11-21 02:48:08 +00002098 emitFunctionDebugFrame(*I);
Bill Wendling2b128d72009-05-20 23:19:06 +00002099
2100 // Compute DIE offsets and sizes.
Devang Patel930143b2009-11-21 02:48:08 +00002101 computeSizeAndOffsets();
Bill Wendling2b128d72009-05-20 23:19:06 +00002102
Devang Patel24bc1b52010-06-29 20:17:53 +00002103 // Emit source line correspondence into a debug line section.
2104 emitDebugLines();
2105
Bill Wendling2b128d72009-05-20 23:19:06 +00002106 // Emit all the DIEs into a debug info section
Devang Patel930143b2009-11-21 02:48:08 +00002107 emitDebugInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +00002108
2109 // Corresponding abbreviations into a abbrev section.
Devang Patel930143b2009-11-21 02:48:08 +00002110 emitAbbreviations();
Bill Wendling2b128d72009-05-20 23:19:06 +00002111
Bill Wendling2b128d72009-05-20 23:19:06 +00002112 // Emit info into a debug pubnames section.
Devang Patel930143b2009-11-21 02:48:08 +00002113 emitDebugPubNames();
Bill Wendling2b128d72009-05-20 23:19:06 +00002114
Devang Patel04d2f2d2009-11-24 01:14:22 +00002115 // Emit info into a debug pubtypes section.
2116 emitDebugPubTypes();
2117
Bill Wendling2b128d72009-05-20 23:19:06 +00002118 // Emit info into a debug loc section.
Devang Patel930143b2009-11-21 02:48:08 +00002119 emitDebugLoc();
Bill Wendling2b128d72009-05-20 23:19:06 +00002120
2121 // Emit info into a debug aranges section.
2122 EmitDebugARanges();
2123
2124 // Emit info into a debug ranges section.
Devang Patel930143b2009-11-21 02:48:08 +00002125 emitDebugRanges();
Bill Wendling2b128d72009-05-20 23:19:06 +00002126
2127 // Emit info into a debug macinfo section.
Devang Patel930143b2009-11-21 02:48:08 +00002128 emitDebugMacInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +00002129
2130 // Emit inline info.
Devang Patel930143b2009-11-21 02:48:08 +00002131 emitDebugInlineInfo();
Bill Wendling2b128d72009-05-20 23:19:06 +00002132
Chris Lattnerb7aa9522010-03-13 02:17:42 +00002133 // Emit info into a debug str section.
2134 emitDebugStr();
2135
Devang Patel1a0df9a2010-05-10 22:49:55 +00002136 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2137 E = CUMap.end(); I != E; ++I)
2138 delete I->second;
2139 FirstCU = NULL; // Reset for the next Module, if any.
Bill Wendling2b128d72009-05-20 23:19:06 +00002140}
2141
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002142/// findAbstractVariable - Find abstract variable, if any, associated with Var.
Devang Patele1c53f22010-05-20 16:36:41 +00002143DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
Chris Lattner915c5f92010-04-02 19:42:39 +00002144 DebugLoc ScopeLoc) {
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002145
Devang Patelcfa8e9d2010-05-07 18:11:54 +00002146 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002147 if (AbsDbgVariable)
2148 return AbsDbgVariable;
2149
Devang Patelcfa8e9d2010-05-07 18:11:54 +00002150 LLVMContext &Ctx = Var->getContext();
Chris Lattner915c5f92010-04-02 19:42:39 +00002151 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002152 if (!Scope)
2153 return NULL;
2154
Devang Patele1c53f22010-05-20 16:36:41 +00002155 AbsDbgVariable = new DbgVariable(Var);
Devang Patel930143b2009-11-21 02:48:08 +00002156 Scope->addVariable(AbsDbgVariable);
Devang Patelcfa8e9d2010-05-07 18:11:54 +00002157 AbstractVariables[Var] = AbsDbgVariable;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002158 return AbsDbgVariable;
2159}
2160
Devang Patel490c8ab2010-05-20 19:57:06 +00002161/// collectVariableInfoFromMMITable - Collect variable information from
2162/// side table maintained by MMI.
2163void
2164DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2165 SmallPtrSet<const MDNode *, 16> &Processed) {
Chris Lattner3a383cb2010-04-05 00:13:49 +00002166 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
Devang Patel475d32a2009-10-06 01:26:37 +00002167 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2168 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2169 VE = VMap.end(); VI != VE; ++VI) {
Devang Patel32cc43c2010-05-07 20:54:48 +00002170 const MDNode *Var = VI->first;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002171 if (!Var) continue;
Devang Patele0a94bf2010-05-14 21:01:35 +00002172 Processed.insert(Var);
Chris Lattner915c5f92010-04-02 19:42:39 +00002173 DIVariable DV(Var);
2174 const std::pair<unsigned, DebugLoc> &VP = VI->second;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002175
Chris Lattner915c5f92010-04-02 19:42:39 +00002176 DbgScope *Scope = 0;
Devang Patel32cc43c2010-05-07 20:54:48 +00002177 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
Chris Lattner915c5f92010-04-02 19:42:39 +00002178 Scope = ConcreteScopes.lookup(IA);
2179 if (Scope == 0)
2180 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2181
Devang Patelcdb7d442009-11-10 23:20:04 +00002182 // If variable scope is not found then skip this variable.
Chris Lattner915c5f92010-04-02 19:42:39 +00002183 if (Scope == 0)
Devang Patelcdb7d442009-11-10 23:20:04 +00002184 continue;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002185
Devang Patele1c53f22010-05-20 16:36:41 +00002186 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2187 DbgVariable *RegVar = new DbgVariable(DV);
2188 recordVariableFrameIndex(RegVar, VP.first);
Devang Patel930143b2009-11-21 02:48:08 +00002189 Scope->addVariable(RegVar);
Devang Patele1c53f22010-05-20 16:36:41 +00002190 if (AbsDbgVariable) {
2191 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2192 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2193 }
Devang Patel475d32a2009-10-06 01:26:37 +00002194 }
Devang Patel490c8ab2010-05-20 19:57:06 +00002195}
Devang Patela3e9c9c2010-03-15 18:33:46 +00002196
Devang Patel9fc11702010-05-25 23:40:22 +00002197/// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2198/// DBG_VALUE instruction, is in undefined reg.
2199static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2200 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2201 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2202 return true;
2203 return false;
2204}
2205
2206/// isDbgValueInDefinedReg - Return true if debug value, encoded by
2207/// DBG_VALUE instruction, is in a defined reg.
2208static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2209 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2210 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2211 return true;
2212 return false;
2213}
2214
Devang Patel490c8ab2010-05-20 19:57:06 +00002215/// collectVariableInfo - Populate DbgScope entries with variables' info.
Devang Patel5c0f85c2010-06-25 22:07:34 +00002216void
2217DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2218 SmallPtrSet<const MDNode *, 16> &Processed) {
Devang Patel490c8ab2010-05-20 19:57:06 +00002219
2220 /// collection info from MMI table.
2221 collectVariableInfoFromMMITable(MF, Processed);
2222
2223 SmallVector<const MachineInstr *, 8> DbgValues;
Devang Patela3e9c9c2010-03-15 18:33:46 +00002224 // Collect variable information from DBG_VALUE machine instructions;
Chris Lattner3a383cb2010-04-05 00:13:49 +00002225 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
Devang Patel490c8ab2010-05-20 19:57:06 +00002226 I != E; ++I)
Devang Patela3e9c9c2010-03-15 18:33:46 +00002227 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2228 II != IE; ++II) {
2229 const MachineInstr *MInsn = II;
Devang Patel9fc11702010-05-25 23:40:22 +00002230 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
Devang Patela3e9c9c2010-03-15 18:33:46 +00002231 continue;
Devang Patel490c8ab2010-05-20 19:57:06 +00002232 DbgValues.push_back(MInsn);
2233 }
Devang Patela3e9c9c2010-03-15 18:33:46 +00002234
Devang Patel9fc11702010-05-25 23:40:22 +00002235 // This is a collection of DBV_VALUE instructions describing same variable.
2236 SmallVector<const MachineInstr *, 4> MultipleValues;
Devang Patel490c8ab2010-05-20 19:57:06 +00002237 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2238 E = DbgValues.end(); I != E; ++I) {
2239 const MachineInstr *MInsn = *I;
Devang Patel9fc11702010-05-25 23:40:22 +00002240 MultipleValues.clear();
2241 if (isDbgValueInDefinedReg(MInsn))
2242 MultipleValues.push_back(MInsn);
Devang Patel490c8ab2010-05-20 19:57:06 +00002243 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2244 if (Processed.count(DV) != 0)
2245 continue;
2246
Devang Patelc2254f62010-06-02 19:05:13 +00002247 const MachineInstr *PrevMI = MInsn;
Devang Patel9fc11702010-05-25 23:40:22 +00002248 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2249 ME = DbgValues.end(); MI != ME; ++MI) {
2250 const MDNode *Var =
2251 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
Devang Patelc2254f62010-06-02 19:05:13 +00002252 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2253 !PrevMI->isIdenticalTo(*MI))
Devang Patel9fc11702010-05-25 23:40:22 +00002254 MultipleValues.push_back(*MI);
Devang Patelc2254f62010-06-02 19:05:13 +00002255 PrevMI = *MI;
Devang Patel9fc11702010-05-25 23:40:22 +00002256 }
2257
Devang Patel490c8ab2010-05-20 19:57:06 +00002258 DbgScope *Scope = findDbgScope(MInsn);
Devang Patel7a9dedf2010-05-27 20:25:04 +00002259 bool CurFnArg = false;
2260 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2261 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2262 CurFnArg = true;
2263 if (!Scope && CurFnArg)
Devang Patelfbd6c452010-05-21 00:10:20 +00002264 Scope = CurrentFnDbgScope;
Devang Patel490c8ab2010-05-20 19:57:06 +00002265 // If variable scope is not found then skip this variable.
Devang Patelfbd6c452010-05-21 00:10:20 +00002266 if (!Scope)
Devang Patel490c8ab2010-05-20 19:57:06 +00002267 continue;
2268
2269 Processed.insert(DV);
Devang Patel490c8ab2010-05-20 19:57:06 +00002270 DbgVariable *RegVar = new DbgVariable(DV);
Devang Patel490c8ab2010-05-20 19:57:06 +00002271 Scope->addVariable(RegVar);
Devang Patel7a9dedf2010-05-27 20:25:04 +00002272 if (!CurFnArg)
Devang Patel9fc11702010-05-25 23:40:22 +00002273 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
Devang Patelfbd6c452010-05-21 00:10:20 +00002274 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2275 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2276 VarToAbstractVarMap[RegVar] = AbsVar;
Devang Patela3e9c9c2010-03-15 18:33:46 +00002277 }
Devang Patel9fc11702010-05-25 23:40:22 +00002278 if (MultipleValues.size() <= 1) {
2279 DbgVariableToDbgInstMap[RegVar] = MInsn;
2280 continue;
2281 }
2282
2283 // handle multiple DBG_VALUE instructions describing one variable.
Devang Patel9fc11702010-05-25 23:40:22 +00002284 if (DotDebugLocEntries.empty())
Devang Patel6b9a9fe2010-05-26 23:55:23 +00002285 RegVar->setDotDebugLocOffset(0);
2286 else
2287 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
Devang Patel5a5e0bc2010-05-26 17:29:32 +00002288 const MachineInstr *Begin = NULL;
2289 const MachineInstr *End = NULL;
2290 for (SmallVector<const MachineInstr *, 4>::iterator
Devang Patel30265c42010-07-07 20:12:52 +00002291 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2292 MVI != MVE; ++MVI) {
Devang Patel5a5e0bc2010-05-26 17:29:32 +00002293 if (!Begin) {
2294 Begin = *MVI;
2295 continue;
2296 }
2297 End = *MVI;
Devang Patel9fc11702010-05-25 23:40:22 +00002298 MachineLocation MLoc;
Devang Patel5a5e0bc2010-05-26 17:29:32 +00002299 MLoc.set(Begin->getOperand(0).getReg(), 0);
2300 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2301 const MCSymbol *SLabel = getLabelBeforeInsn(End);
Devang Patel9fc11702010-05-25 23:40:22 +00002302 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
Devang Patel5a5e0bc2010-05-26 17:29:32 +00002303 Begin = End;
2304 if (MVI + 1 == MVE) {
2305 // If End is the last instruction then its value is valid
Devang Patel9fc11702010-05-25 23:40:22 +00002306 // until the end of the funtion.
Devang Patel5a5e0bc2010-05-26 17:29:32 +00002307 MLoc.set(End->getOperand(0).getReg(), 0);
Devang Patel9fc11702010-05-25 23:40:22 +00002308 DotDebugLocEntries.
2309 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2310 }
2311 }
2312 DotDebugLocEntries.push_back(DotDebugLocEntry());
Devang Patela3e9c9c2010-03-15 18:33:46 +00002313 }
Devang Patele0a94bf2010-05-14 21:01:35 +00002314
2315 // Collect info for variables that were optimized out.
Devang Patelad517352010-06-22 01:01:58 +00002316 const Function *F = MF->getFunction();
2317 const Module *M = F->getParent();
2318 if (NamedMDNode *NMD =
Devang Patelb6e058d2010-06-22 01:19:38 +00002319 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2320 getRealLinkageName(F->getName())))) {
Devang Patele0a94bf2010-05-14 21:01:35 +00002321 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2322 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
Devang Patel490c8ab2010-05-20 19:57:06 +00002323 if (!DV || !Processed.insert(DV))
Devang Patele0a94bf2010-05-14 21:01:35 +00002324 continue;
2325 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2326 if (Scope)
Devang Patele1c53f22010-05-20 16:36:41 +00002327 Scope->addVariable(new DbgVariable(DV));
Devang Patele0a94bf2010-05-14 21:01:35 +00002328 }
2329 }
Devang Patel9fc11702010-05-25 23:40:22 +00002330}
Devang Patele0a94bf2010-05-14 21:01:35 +00002331
Devang Patel9fc11702010-05-25 23:40:22 +00002332/// getLabelBeforeInsn - Return Label preceding the instruction.
2333const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2334 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2335 LabelsBeforeInsn.find(MI);
2336 if (I == LabelsBeforeInsn.end())
2337 // FunctionBeginSym always preceeds all the instruction in current function.
2338 return FunctionBeginSym;
2339 return I->second;
2340}
2341
2342/// getLabelAfterInsn - Return Label immediately following the instruction.
2343const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2344 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2345 LabelsAfterInsn.find(MI);
2346 if (I == LabelsAfterInsn.end())
2347 return NULL;
2348 return I->second;
Devang Patel475d32a2009-10-06 01:26:37 +00002349}
2350
Devang Patelbd477be2010-03-29 17:20:31 +00002351/// beginScope - Process beginning of a scope.
2352void DwarfDebug::beginScope(const MachineInstr *MI) {
Devang Patel002d54d2010-05-26 19:37:24 +00002353 if (InsnNeedsLabel.count(MI) == 0) {
2354 LabelsBeforeInsn[MI] = PrevLabel;
Devang Patelbd477be2010-03-29 17:20:31 +00002355 return;
Devang Patel9fc11702010-05-25 23:40:22 +00002356 }
Devang Patel23b2ae62010-03-29 22:59:58 +00002357
Devang Patel002d54d2010-05-26 19:37:24 +00002358 // Check location.
2359 DebugLoc DL = MI->getDebugLoc();
2360 if (!DL.isUnknown()) {
2361 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2362 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
Devang Patel6c74a872010-04-27 19:46:33 +00002363 PrevInstLoc = DL;
Devang Patel002d54d2010-05-26 19:37:24 +00002364 LabelsBeforeInsn[MI] = PrevLabel;
2365 return;
Devang Patel6c74a872010-04-27 19:46:33 +00002366 }
Devang Patelbd477be2010-03-29 17:20:31 +00002367
Devang Patelacc32a52010-05-26 21:23:46 +00002368 // If location is unknown then use temp label for this DBG_VALUE
Devang Patel002d54d2010-05-26 19:37:24 +00002369 // instruction.
2370 if (MI->isDebugValue()) {
Devang Patelacc32a52010-05-26 21:23:46 +00002371 PrevLabel = MMI->getContext().CreateTempSymbol();
2372 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Patel002d54d2010-05-26 19:37:24 +00002373 LabelsBeforeInsn[MI] = PrevLabel;
2374 return;
2375 }
2376
2377 if (UnknownLocations) {
2378 PrevLabel = recordSourceLine(0, 0, 0);
2379 LabelsBeforeInsn[MI] = PrevLabel;
2380 return;
2381 }
2382
2383 assert (0 && "Instruction is not processed!");
Devang Patel8db360d2009-10-06 01:50:42 +00002384}
2385
Devang Patel930143b2009-11-21 02:48:08 +00002386/// endScope - Process end of a scope.
2387void DwarfDebug::endScope(const MachineInstr *MI) {
Devang Patel3ebd8932010-04-08 16:50:29 +00002388 if (InsnsEndScopeSet.count(MI) != 0) {
2389 // Emit a label if this instruction ends a scope.
2390 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2391 Asm->OutStreamer.EmitLabel(Label);
Devang Patel6c74a872010-04-27 19:46:33 +00002392 LabelsAfterInsn[MI] = Label;
Devang Patel3ebd8932010-04-08 16:50:29 +00002393 }
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002394}
2395
Devang Patel6c74a872010-04-27 19:46:33 +00002396/// getOrCreateDbgScope - Create DbgScope for the scope.
Devang Patel30265c42010-07-07 20:12:52 +00002397DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2398 const MDNode *InlinedAt) {
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002399 if (!InlinedAt) {
2400 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2401 if (WScope)
Devang Patel6c74a872010-04-27 19:46:33 +00002402 return WScope;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002403 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2404 DbgScopeMap.insert(std::make_pair(Scope, WScope));
Devang Patel6c74a872010-04-27 19:46:33 +00002405 if (DIDescriptor(Scope).isLexicalBlock()) {
2406 DbgScope *Parent =
Devang Patelcfa8e9d2010-05-07 18:11:54 +00002407 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
Devang Patel6c74a872010-04-27 19:46:33 +00002408 WScope->setParent(Parent);
2409 Parent->addScope(WScope);
2410 }
2411
2412 if (!WScope->getParent()) {
2413 StringRef SPName = DISubprogram(Scope).getLinkageName();
Stuart Hastings9b5005c2010-06-15 23:06:30 +00002414 // We used to check only for a linkage name, but that fails
2415 // since we began omitting the linkage name for private
2416 // functions. The new way is to check for the name in metadata,
2417 // but that's not supported in old .ll test cases. Ergo, we
2418 // check both.
Stuart Hastingsafe54f12010-06-11 20:08:44 +00002419 if (SPName == Asm->MF->getFunction()->getName() ||
2420 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
Devang Patel6c74a872010-04-27 19:46:33 +00002421 CurrentFnDbgScope = WScope;
2422 }
2423
2424 return WScope;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002425 }
2426
Devang Patel5c0f85c2010-06-25 22:07:34 +00002427 getOrCreateAbstractScope(Scope);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002428 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2429 if (WScope)
Devang Patel6c74a872010-04-27 19:46:33 +00002430 return WScope;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002431
2432 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2433 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2434 DILocation DL(InlinedAt);
Devang Patel6c74a872010-04-27 19:46:33 +00002435 DbgScope *Parent =
Devang Patelcfa8e9d2010-05-07 18:11:54 +00002436 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
Devang Patel6c74a872010-04-27 19:46:33 +00002437 WScope->setParent(Parent);
2438 Parent->addScope(WScope);
2439
2440 ConcreteScopes[InlinedAt] = WScope;
Devang Patel6c74a872010-04-27 19:46:33 +00002441
2442 return WScope;
Devang Patel8db360d2009-10-06 01:50:42 +00002443}
2444
Devang Patel6c74a872010-04-27 19:46:33 +00002445/// hasValidLocation - Return true if debug location entry attached with
2446/// machine instruction encodes valid location info.
2447static bool hasValidLocation(LLVMContext &Ctx,
2448 const MachineInstr *MInsn,
Devang Patel32cc43c2010-05-07 20:54:48 +00002449 const MDNode *&Scope, const MDNode *&InlinedAt) {
Devang Patel6c74a872010-04-27 19:46:33 +00002450 DebugLoc DL = MInsn->getDebugLoc();
2451 if (DL.isUnknown()) return false;
2452
Devang Patel32cc43c2010-05-07 20:54:48 +00002453 const MDNode *S = DL.getScope(Ctx);
Devang Patel6c74a872010-04-27 19:46:33 +00002454
2455 // There is no need to create another DIE for compile unit. For all
2456 // other scopes, create one DbgScope now. This will be translated
2457 // into a scope DIE at the end.
2458 if (DIScope(S).isCompileUnit()) return false;
2459
2460 Scope = S;
2461 InlinedAt = DL.getInlinedAt(Ctx);
2462 return true;
2463}
2464
2465/// calculateDominanceGraph - Calculate dominance graph for DbgScope
2466/// hierarchy.
2467static void calculateDominanceGraph(DbgScope *Scope) {
2468 assert (Scope && "Unable to calculate scop edominance graph!");
2469 SmallVector<DbgScope *, 4> WorkStack;
2470 WorkStack.push_back(Scope);
2471 unsigned Counter = 0;
2472 while (!WorkStack.empty()) {
2473 DbgScope *WS = WorkStack.back();
2474 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2475 bool visitedChildren = false;
2476 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2477 SE = Children.end(); SI != SE; ++SI) {
2478 DbgScope *ChildScope = *SI;
2479 if (!ChildScope->getDFSOut()) {
2480 WorkStack.push_back(ChildScope);
2481 visitedChildren = true;
2482 ChildScope->setDFSIn(++Counter);
2483 break;
2484 }
2485 }
2486 if (!visitedChildren) {
2487 WorkStack.pop_back();
2488 WS->setDFSOut(++Counter);
2489 }
2490 }
2491}
2492
2493/// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2494static
2495void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2496 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2497{
2498#ifndef NDEBUG
2499 unsigned PrevDFSIn = 0;
2500 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2501 I != E; ++I) {
2502 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2503 II != IE; ++II) {
2504 const MachineInstr *MInsn = II;
Devang Patel32cc43c2010-05-07 20:54:48 +00002505 const MDNode *Scope = NULL;
2506 const MDNode *InlinedAt = NULL;
Devang Patel6c74a872010-04-27 19:46:33 +00002507
2508 // Check if instruction has valid location information.
2509 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2510 dbgs() << " [ ";
2511 if (InlinedAt)
2512 dbgs() << "*";
2513 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2514 MI2ScopeMap.find(MInsn);
2515 if (DI != MI2ScopeMap.end()) {
2516 DbgScope *S = DI->second;
2517 dbgs() << S->getDFSIn();
2518 PrevDFSIn = S->getDFSIn();
2519 } else
2520 dbgs() << PrevDFSIn;
2521 } else
2522 dbgs() << " [ x" << PrevDFSIn;
2523 dbgs() << " ]";
2524 MInsn->dump();
2525 }
2526 dbgs() << "\n";
2527 }
2528#endif
2529}
Devang Patel930143b2009-11-21 02:48:08 +00002530/// extractScopeInformation - Scan machine instructions in this function
Chris Lattner848c7d22010-03-31 05:39:57 +00002531/// and collect DbgScopes. Return true, if at least one scope was found.
Chris Lattner76555b52010-01-26 23:18:02 +00002532bool DwarfDebug::extractScopeInformation() {
Devang Patel75cc16c2009-10-01 20:31:14 +00002533 // If scope information was extracted using .dbg intrinsics then there is not
2534 // any need to extract these information by scanning each instruction.
2535 if (!DbgScopeMap.empty())
2536 return false;
2537
Dan Gohmane9135cb2010-04-23 01:18:53 +00002538 // Scan each instruction and create scopes. First build working set of scopes.
Devang Patel6c74a872010-04-27 19:46:33 +00002539 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2540 SmallVector<DbgRange, 4> MIRanges;
2541 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
Devang Patel32cc43c2010-05-07 20:54:48 +00002542 const MDNode *PrevScope = NULL;
2543 const MDNode *PrevInlinedAt = NULL;
Devang Patel6c74a872010-04-27 19:46:33 +00002544 const MachineInstr *RangeBeginMI = NULL;
2545 const MachineInstr *PrevMI = NULL;
Chris Lattner3a383cb2010-04-05 00:13:49 +00002546 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
Devang Patel75cc16c2009-10-01 20:31:14 +00002547 I != E; ++I) {
2548 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2549 II != IE; ++II) {
2550 const MachineInstr *MInsn = II;
Devang Patel32cc43c2010-05-07 20:54:48 +00002551 const MDNode *Scope = NULL;
2552 const MDNode *InlinedAt = NULL;
Devang Patel6c74a872010-04-27 19:46:33 +00002553
2554 // Check if instruction has valid location information.
2555 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2556 PrevMI = MInsn;
2557 continue;
2558 }
Chris Lattner915c5f92010-04-02 19:42:39 +00002559
Devang Patel6c74a872010-04-27 19:46:33 +00002560 // If scope has not changed then skip this instruction.
2561 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2562 PrevMI = MInsn;
2563 continue;
2564 }
2565
2566 if (RangeBeginMI) {
2567 // If we have alread seen a beginning of a instruction range and
2568 // current instruction scope does not match scope of first instruction
2569 // in this range then create a new instruction range.
2570 DbgRange R(RangeBeginMI, PrevMI);
Devang Patel30265c42010-07-07 20:12:52 +00002571 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2572 PrevInlinedAt);
Devang Patel6c74a872010-04-27 19:46:33 +00002573 MIRanges.push_back(R);
2574 }
2575
2576 // This is a beginning of a new instruction range.
2577 RangeBeginMI = MInsn;
Chris Lattner915c5f92010-04-02 19:42:39 +00002578
Devang Patel6c74a872010-04-27 19:46:33 +00002579 // Reset previous markers.
2580 PrevMI = MInsn;
2581 PrevScope = Scope;
2582 PrevInlinedAt = InlinedAt;
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002583 }
2584 }
2585
Devang Patel6c74a872010-04-27 19:46:33 +00002586 // Create last instruction range.
2587 if (RangeBeginMI && PrevMI && PrevScope) {
2588 DbgRange R(RangeBeginMI, PrevMI);
2589 MIRanges.push_back(R);
2590 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
Devang Patel75cc16c2009-10-01 20:31:14 +00002591 }
Devang Patel6c74a872010-04-27 19:46:33 +00002592
Devang Patel530a0752010-01-04 20:44:00 +00002593 if (!CurrentFnDbgScope)
2594 return false;
2595
Devang Patel6c74a872010-04-27 19:46:33 +00002596 calculateDominanceGraph(CurrentFnDbgScope);
2597 if (PrintDbgScope)
2598 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2599
2600 // Find ranges of instructions covered by each DbgScope;
2601 DbgScope *PrevDbgScope = NULL;
2602 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2603 RE = MIRanges.end(); RI != RE; ++RI) {
2604 const DbgRange &R = *RI;
2605 DbgScope *S = MI2ScopeMap.lookup(R.first);
2606 assert (S && "Lost DbgScope for a machine instruction!");
2607 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2608 PrevDbgScope->closeInsnRange(S);
2609 S->openInsnRange(R.first);
2610 S->extendInsnRange(R.second);
2611 PrevDbgScope = S;
2612 }
2613
2614 if (PrevDbgScope)
2615 PrevDbgScope->closeInsnRange();
Devang Patel75cc16c2009-10-01 20:31:14 +00002616
Devang Patel359b0132010-04-08 18:43:56 +00002617 identifyScopeMarkers();
Devang Patelf1d5a1e2010-04-08 15:37:09 +00002618
2619 return !DbgScopeMap.empty();
2620}
2621
Devang Patel6c74a872010-04-27 19:46:33 +00002622/// identifyScopeMarkers() -
2623/// Each DbgScope has first instruction and last instruction to mark beginning
2624/// and end of a scope respectively. Create an inverse map that list scopes
2625/// starts (and ends) with an instruction. One instruction may start (or end)
2626/// multiple scopes. Ignore scopes that are not reachable.
Devang Patel359b0132010-04-08 18:43:56 +00002627void DwarfDebug::identifyScopeMarkers() {
Devang Patel7771b7c2010-01-20 02:05:23 +00002628 SmallVector<DbgScope *, 4> WorkList;
2629 WorkList.push_back(CurrentFnDbgScope);
2630 while (!WorkList.empty()) {
Chris Lattner848c7d22010-03-31 05:39:57 +00002631 DbgScope *S = WorkList.pop_back_val();
Devang Patel6c74a872010-04-27 19:46:33 +00002632
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00002633 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
Devang Patel7771b7c2010-01-20 02:05:23 +00002634 if (!Children.empty())
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00002635 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
Devang Patel7771b7c2010-01-20 02:05:23 +00002636 SE = Children.end(); SI != SE; ++SI)
2637 WorkList.push_back(*SI);
2638
Devang Patelf6eeaeb2009-11-10 23:06:00 +00002639 if (S->isAbstractScope())
2640 continue;
Devang Patel6c74a872010-04-27 19:46:33 +00002641
2642 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2643 if (Ranges.empty())
2644 continue;
2645 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2646 RE = Ranges.end(); RI != RE; ++RI) {
Devang Patela0813082010-05-19 21:58:28 +00002647 assert(RI->first && "DbgRange does not have first instruction!");
2648 assert(RI->second && "DbgRange does not have second instruction!");
Devang Patel6c74a872010-04-27 19:46:33 +00002649 InsnsEndScopeSet.insert(RI->second);
2650 }
Devang Patel75cc16c2009-10-01 20:31:14 +00002651 }
Devang Patel75cc16c2009-10-01 20:31:14 +00002652}
2653
Dan Gohman3df671a2010-04-20 00:37:27 +00002654/// FindFirstDebugLoc - Find the first debug location in the function. This
2655/// is intended to be an approximation for the source position of the
2656/// beginning of the function.
2657static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2658 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2659 I != E; ++I)
2660 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2661 MBBI != MBBE; ++MBBI) {
2662 DebugLoc DL = MBBI->getDebugLoc();
2663 if (!DL.isUnknown())
2664 return DL;
2665 }
2666 return DebugLoc();
2667}
2668
Devang Patel930143b2009-11-21 02:48:08 +00002669/// beginFunction - Gather pre-function debug information. Assumes being
Bill Wendling2b128d72009-05-20 23:19:06 +00002670/// emitted immediately after the function entry point.
Chris Lattner76555b52010-01-26 23:18:02 +00002671void DwarfDebug::beginFunction(const MachineFunction *MF) {
Chris Lattner196dbdc2010-04-05 03:52:55 +00002672 if (!MMI->hasDebugInfo()) return;
Bill Wendlingfcc14142010-04-07 09:28:04 +00002673 if (!extractScopeInformation()) return;
Devang Patel4598eb62009-10-06 18:37:31 +00002674
Devang Patel6c74a872010-04-27 19:46:33 +00002675 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2676 Asm->getFunctionNumber());
Bill Wendling2b128d72009-05-20 23:19:06 +00002677 // Assumes in correct section after the entry point.
Devang Patel6c74a872010-04-27 19:46:33 +00002678 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
Bill Wendling2b128d72009-05-20 23:19:06 +00002679
2680 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2681 // function.
Dan Gohman3df671a2010-04-20 00:37:27 +00002682 DebugLoc FDL = FindFirstDebugLoc(MF);
Chris Lattner915c5f92010-04-02 19:42:39 +00002683 if (FDL.isUnknown()) return;
2684
Devang Patel32cc43c2010-05-07 20:54:48 +00002685 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
Stuart Hastings61475c52010-07-19 23:56:30 +00002686 const MDNode *TheScope = 0;
Chris Lattner915c5f92010-04-02 19:42:39 +00002687
2688 DISubprogram SP = getDISubprogram(Scope);
2689 unsigned Line, Col;
2690 if (SP.Verify()) {
2691 Line = SP.getLineNumber();
2692 Col = 0;
Stuart Hastings61475c52010-07-19 23:56:30 +00002693 TheScope = SP;
Chris Lattner915c5f92010-04-02 19:42:39 +00002694 } else {
2695 Line = FDL.getLine();
2696 Col = FDL.getCol();
Stuart Hastings61475c52010-07-19 23:56:30 +00002697 TheScope = Scope;
Bill Wendling2b128d72009-05-20 23:19:06 +00002698 }
Chris Lattner915c5f92010-04-02 19:42:39 +00002699
Stuart Hastings61475c52010-07-19 23:56:30 +00002700 recordSourceLine(Line, Col, TheScope);
Devang Patel002d54d2010-05-26 19:37:24 +00002701
Devang Patel21ccf052010-06-02 16:42:51 +00002702 /// ProcessedArgs - Collection of arguments already processed.
2703 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2704
Devang Patel002d54d2010-05-26 19:37:24 +00002705 DebugLoc PrevLoc;
2706 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2707 I != E; ++I)
2708 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2709 II != IE; ++II) {
2710 const MachineInstr *MI = II;
2711 DebugLoc DL = MI->getDebugLoc();
2712 if (MI->isDebugValue()) {
Devang Patel002d54d2010-05-26 19:37:24 +00002713 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2714 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2715 if (!DV.Verify()) continue;
Devang Patel5e6b71c2010-05-27 16:47:30 +00002716 // If DBG_VALUE is for a local variable then it needs a label.
Devang Patel42939752010-07-01 21:38:08 +00002717 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2718 && isDbgValueInUndefinedReg(MI) == false)
Devang Patel002d54d2010-05-26 19:37:24 +00002719 InsnNeedsLabel.insert(MI);
Devang Patel5e6b71c2010-05-27 16:47:30 +00002720 // DBG_VALUE for inlined functions argument needs a label.
Devang Patel42939752010-07-01 21:38:08 +00002721 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2722 describes(MF->getFunction()))
Devang Patel5e6b71c2010-05-27 16:47:30 +00002723 InsnNeedsLabel.insert(MI);
2724 // DBG_VALUE indicating argument location change needs a label.
Devang Patelc657c622010-06-24 21:51:19 +00002725 else if (isDbgValueInUndefinedReg(MI) == false && !ProcessedArgs.insert(DV))
Devang Patel002d54d2010-05-26 19:37:24 +00002726 InsnNeedsLabel.insert(MI);
2727 } else {
2728 // If location is unknown then instruction needs a location only if
2729 // UnknownLocations flag is set.
2730 if (DL.isUnknown()) {
2731 if (UnknownLocations && !PrevLoc.isUnknown())
2732 InsnNeedsLabel.insert(MI);
2733 } else if (DL != PrevLoc)
2734 // Otherwise, instruction needs a location only if it is new location.
2735 InsnNeedsLabel.insert(MI);
2736 }
2737
2738 if (!DL.isUnknown() || UnknownLocations)
2739 PrevLoc = DL;
2740 }
2741
2742 PrevLabel = FunctionBeginSym;
Bill Wendling2b128d72009-05-20 23:19:06 +00002743}
2744
Devang Patel930143b2009-11-21 02:48:08 +00002745/// endFunction - Gather and emit post-function debug information.
Bill Wendling2b128d72009-05-20 23:19:06 +00002746///
Chris Lattner76555b52010-01-26 23:18:02 +00002747void DwarfDebug::endFunction(const MachineFunction *MF) {
Bill Wendlingfcc14142010-04-07 09:28:04 +00002748 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
Devang Patel2904aa92009-11-12 19:02:56 +00002749
Devang Patel530a0752010-01-04 20:44:00 +00002750 if (CurrentFnDbgScope) {
Devang Patel4a8e6e82010-05-22 00:04:14 +00002751
Devang Patel9fc11702010-05-25 23:40:22 +00002752 // Define end label for subprogram.
2753 FunctionEndSym = Asm->GetTempSymbol("func_end",
2754 Asm->getFunctionNumber());
2755 // Assumes in correct section after the entry point.
2756 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2757
Devang Patel5c0f85c2010-06-25 22:07:34 +00002758 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2759 collectVariableInfo(MF, ProcessedVars);
Devang Patel4a8e6e82010-05-22 00:04:14 +00002760
Devang Patel530a0752010-01-04 20:44:00 +00002761 // Get function line info.
2762 if (!Lines.empty()) {
2763 // Get section line info.
2764 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2765 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2766 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2767 // Append the function info to section info.
2768 SectionLineInfos.insert(SectionLineInfos.end(),
2769 Lines.begin(), Lines.end());
2770 }
2771
2772 // Construct abstract scopes.
2773 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
Devang Patel5c0f85c2010-06-25 22:07:34 +00002774 AE = AbstractScopesList.end(); AI != AE; ++AI) {
Devang Patel5c0f85c2010-06-25 22:07:34 +00002775 DISubprogram SP((*AI)->getScopeNode());
2776 if (SP.Verify()) {
2777 // Collect info for variables that were optimized out.
2778 StringRef FName = SP.getLinkageName();
2779 if (FName.empty())
2780 FName = SP.getName();
2781 const Module *M = MF->getFunction()->getParent();
2782 if (NamedMDNode *NMD =
2783 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2784 getRealLinkageName(FName)))) {
2785 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2786 DIVariable DV(cast_or_null<MDNode>(NMD->getOperand(i)));
2787 if (!DV || !ProcessedVars.insert(DV))
2788 continue;
Devang Patel648df7b2010-06-30 00:11:08 +00002789 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
Devang Patel5c0f85c2010-06-25 22:07:34 +00002790 if (Scope)
2791 Scope->addVariable(new DbgVariable(DV));
2792 }
2793 }
2794 }
Devang Patelc5b31092010-06-30 01:40:11 +00002795 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2796 constructScopeDIE(*AI);
Devang Patel5c0f85c2010-06-25 22:07:34 +00002797 }
Devang Patel30265c42010-07-07 20:12:52 +00002798
Devang Patel075e9b52010-05-04 06:15:30 +00002799 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
Devang Patel530a0752010-01-04 20:44:00 +00002800
Devang Patel075e9b52010-05-04 06:15:30 +00002801 if (!DisableFramePointerElim(*MF))
2802 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2803 dwarf::DW_FORM_flag, 1);
2804
2805
Chris Lattner3a383cb2010-04-05 00:13:49 +00002806 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
Devang Patel530a0752010-01-04 20:44:00 +00002807 MMI->getFrameMoves()));
Bill Wendling2b128d72009-05-20 23:19:06 +00002808 }
2809
Bill Wendling2b128d72009-05-20 23:19:06 +00002810 // Clear debug info
Devang Patelfe189e62010-01-19 01:26:02 +00002811 CurrentFnDbgScope = NULL;
Devang Patel002d54d2010-05-26 19:37:24 +00002812 InsnNeedsLabel.clear();
Devang Patele1c53f22010-05-20 16:36:41 +00002813 DbgVariableToFrameIndexMap.clear();
2814 VarToAbstractVarMap.clear();
2815 DbgVariableToDbgInstMap.clear();
2816 DbgVariableLabelsMap.clear();
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00002817 DeleteContainerSeconds(DbgScopeMap);
Devang Patel541019d2010-04-09 16:04:20 +00002818 InsnsEndScopeSet.clear();
Devang Patelfe189e62010-01-19 01:26:02 +00002819 ConcreteScopes.clear();
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00002820 DeleteContainerSeconds(AbstractScopes);
Devang Patelfe189e62010-01-19 01:26:02 +00002821 AbstractScopesList.clear();
Jeffrey Yasskin35b4e4f2010-03-12 17:45:06 +00002822 AbstractVariables.clear();
Devang Patel6c74a872010-04-27 19:46:33 +00002823 LabelsBeforeInsn.clear();
2824 LabelsAfterInsn.clear();
Bill Wendling2b128d72009-05-20 23:19:06 +00002825 Lines.clear();
Devang Patel12563b32010-04-16 23:33:45 +00002826 PrevLabel = NULL;
Bill Wendling2b128d72009-05-20 23:19:06 +00002827}
2828
Devang Patele1c53f22010-05-20 16:36:41 +00002829/// recordVariableFrameIndex - Record a variable's index.
2830void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2831 assert (V && "Invalid DbgVariable!");
2832 DbgVariableToFrameIndexMap[V] = Index;
2833}
2834
2835/// findVariableFrameIndex - Return true if frame index for the variable
2836/// is found. Update FI to hold value of the index.
2837bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2838 assert (V && "Invalid DbgVariable!");
2839 DenseMap<const DbgVariable *, int>::iterator I =
2840 DbgVariableToFrameIndexMap.find(V);
2841 if (I == DbgVariableToFrameIndexMap.end())
2842 return false;
2843 *FI = I->second;
2844 return true;
2845}
2846
2847/// findVariableLabel - Find MCSymbol for the variable.
2848const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2849 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2850 = DbgVariableLabelsMap.find(V);
2851 if (I == DbgVariableLabelsMap.end())
2852 return NULL;
2853 else return I->second;
2854}
2855
Devang Patel490c8ab2010-05-20 19:57:06 +00002856/// findDbgScope - Find DbgScope for the debug loc attached with an
2857/// instruction.
2858DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2859 DbgScope *Scope = NULL;
2860 LLVMContext &Ctx =
2861 MInsn->getParent()->getParent()->getFunction()->getContext();
2862 DebugLoc DL = MInsn->getDebugLoc();
2863
2864 if (DL.isUnknown())
2865 return Scope;
2866
2867 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2868 Scope = ConcreteScopes.lookup(IA);
2869 if (Scope == 0)
2870 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2871
2872 return Scope;
2873}
2874
2875
Chris Lattnerba35a672010-03-09 04:54:43 +00002876/// recordSourceLine - Register a source line with debug info. Returns the
2877/// unique label that was emitted and which provides correspondence to
2878/// the source line list.
Devang Patel30265c42010-07-07 20:12:52 +00002879MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2880 const MDNode *S) {
Devang Patel2d9caf92009-11-25 17:36:49 +00002881 StringRef Dir;
2882 StringRef Fn;
Devang Patel2089d162009-10-05 18:03:19 +00002883
Dan Gohman50849c62010-05-05 23:41:32 +00002884 unsigned Src = 1;
2885 if (S) {
2886 DIDescriptor Scope(S);
Devang Patel2089d162009-10-05 18:03:19 +00002887
Dan Gohman50849c62010-05-05 23:41:32 +00002888 if (Scope.isCompileUnit()) {
2889 DICompileUnit CU(S);
2890 Dir = CU.getDirectory();
2891 Fn = CU.getFilename();
2892 } else if (Scope.isSubprogram()) {
2893 DISubprogram SP(S);
2894 Dir = SP.getDirectory();
2895 Fn = SP.getFilename();
2896 } else if (Scope.isLexicalBlock()) {
2897 DILexicalBlock DB(S);
2898 Dir = DB.getDirectory();
2899 Fn = DB.getFilename();
2900 } else
2901 assert(0 && "Unexpected scope info");
2902
2903 Src = GetOrCreateSourceID(Dir, Fn);
2904 }
2905
Chris Lattner6e52e9d2010-03-14 08:36:50 +00002906 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
Chris Lattnerb4666f42010-03-14 08:15:55 +00002907 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
Bill Wendling2b128d72009-05-20 23:19:06 +00002908
Chris Lattnerba35a672010-03-09 04:54:43 +00002909 Asm->OutStreamer.EmitLabel(Label);
2910 return Label;
Bill Wendling2b128d72009-05-20 23:19:06 +00002911}
2912
Bill Wendling806535f2009-05-20 23:22:40 +00002913//===----------------------------------------------------------------------===//
2914// Emit Methods
2915//===----------------------------------------------------------------------===//
2916
Devang Patel930143b2009-11-21 02:48:08 +00002917/// computeSizeAndOffset - Compute the size and offset of a DIE.
Bill Wendling480ff322009-05-20 23:21:38 +00002918///
Jim Grosbach00e9c612009-11-22 19:20:36 +00002919unsigned
2920DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
Bill Wendling480ff322009-05-20 23:21:38 +00002921 // Get the children.
2922 const std::vector<DIE *> &Children = Die->getChildren();
2923
2924 // If not last sibling and has children then add sibling offset attribute.
Jeffrey Yasskin54ebc982010-03-22 18:47:14 +00002925 if (!Last && !Children.empty())
Benjamin Kramer74729ae2010-03-31 19:34:01 +00002926 Die->addSiblingOffset(DIEValueAllocator);
Bill Wendling480ff322009-05-20 23:21:38 +00002927
2928 // Record the abbreviation.
Devang Patel930143b2009-11-21 02:48:08 +00002929 assignAbbrevNumber(Die->getAbbrev());
Bill Wendling480ff322009-05-20 23:21:38 +00002930
2931 // Get the abbreviation for this DIE.
2932 unsigned AbbrevNumber = Die->getAbbrevNumber();
2933 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2934
2935 // Set DIE offset
2936 Die->setOffset(Offset);
2937
2938 // Start the size with the size of abbreviation code.
Chris Lattner7b26fce2009-08-22 20:48:53 +00002939 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
Bill Wendling480ff322009-05-20 23:21:38 +00002940
2941 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2942 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2943
2944 // Size the DIE attribute values.
2945 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2946 // Size attribute value.
Chris Lattner5a00dea2010-04-05 00:18:22 +00002947 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
Bill Wendling480ff322009-05-20 23:21:38 +00002948
2949 // Size the DIE children if any.
2950 if (!Children.empty()) {
2951 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2952 "Children flag not set");
2953
2954 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel930143b2009-11-21 02:48:08 +00002955 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
Bill Wendling480ff322009-05-20 23:21:38 +00002956
2957 // End of children marker.
2958 Offset += sizeof(int8_t);
2959 }
2960
2961 Die->setSize(Offset - Die->getOffset());
2962 return Offset;
2963}
2964
Devang Patel930143b2009-11-21 02:48:08 +00002965/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
Bill Wendling480ff322009-05-20 23:21:38 +00002966///
Devang Patel930143b2009-11-21 02:48:08 +00002967void DwarfDebug::computeSizeAndOffsets() {
Devang Patel1a0df9a2010-05-10 22:49:55 +00002968 unsigned PrevOffset = 0;
2969 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2970 E = CUMap.end(); I != E; ++I) {
2971 // Compute size of compile unit header.
2972 static unsigned Offset = PrevOffset +
2973 sizeof(int32_t) + // Length of Compilation Unit Info
2974 sizeof(int16_t) + // DWARF version number
2975 sizeof(int32_t) + // Offset Into Abbrev. Section
2976 sizeof(int8_t); // Pointer Size (in bytes)
2977 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2978 PrevOffset = Offset;
2979 }
Bill Wendling480ff322009-05-20 23:21:38 +00002980}
2981
Chris Lattner1fbf53b2010-04-04 23:02:02 +00002982/// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2983/// temporary label to it if SymbolStem is specified.
Chris Lattner6629ca92010-04-04 22:59:04 +00002984static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
Chris Lattner1fbf53b2010-04-04 23:02:02 +00002985 const char *SymbolStem = 0) {
Chris Lattner6629ca92010-04-04 22:59:04 +00002986 Asm->OutStreamer.SwitchSection(Section);
Chris Lattner1fbf53b2010-04-04 23:02:02 +00002987 if (!SymbolStem) return 0;
2988
Chris Lattner6629ca92010-04-04 22:59:04 +00002989 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2990 Asm->OutStreamer.EmitLabel(TmpSym);
2991 return TmpSym;
2992}
2993
2994/// EmitSectionLabels - Emit initial Dwarf sections with a label at
2995/// the start of each one.
Chris Lattner46355d82010-04-04 22:33:59 +00002996void DwarfDebug::EmitSectionLabels() {
Chris Lattner4b7dadb2009-08-19 05:49:37 +00002997 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00002998
Bill Wendling480ff322009-05-20 23:21:38 +00002999 // Dwarf sections base addresses.
Chris Lattner3a383cb2010-04-05 00:13:49 +00003000 if (Asm->MAI->doesDwarfRequireFrameSection()) {
Chris Lattner6629ca92010-04-04 22:59:04 +00003001 DwarfFrameSectionSym =
3002 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3003 }
Bill Wendling480ff322009-05-20 23:21:38 +00003004
Chris Lattner6629ca92010-04-04 22:59:04 +00003005 DwarfInfoSectionSym =
3006 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3007 DwarfAbbrevSectionSym =
3008 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
Chris Lattner1fbf53b2010-04-04 23:02:02 +00003009 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
Chris Lattner6629ca92010-04-04 22:59:04 +00003010
3011 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
Chris Lattner1fbf53b2010-04-04 23:02:02 +00003012 EmitSectionSym(Asm, MacroInfo);
Bill Wendling480ff322009-05-20 23:21:38 +00003013
Devang Patel24bc1b52010-06-29 20:17:53 +00003014 DwarfDebugLineSectionSym =
3015 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
Chris Lattner1fbf53b2010-04-04 23:02:02 +00003016 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3017 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3018 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
Chris Lattner6629ca92010-04-04 22:59:04 +00003019 DwarfStrSectionSym =
3020 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
Devang Patel12563b32010-04-16 23:33:45 +00003021 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3022 "debug_range");
Bill Wendling480ff322009-05-20 23:21:38 +00003023
Devang Patel9fc11702010-05-25 23:40:22 +00003024 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3025 "section_debug_loc");
3026
Chris Lattner6629ca92010-04-04 22:59:04 +00003027 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
Chris Lattnere58b5472010-04-04 23:10:38 +00003028 EmitSectionSym(Asm, TLOF.getDataSection());
Bill Wendling480ff322009-05-20 23:21:38 +00003029}
3030
Devang Patel930143b2009-11-21 02:48:08 +00003031/// emitDIE - Recusively Emits a debug information entry.
Bill Wendling480ff322009-05-20 23:21:38 +00003032///
Devang Patel930143b2009-11-21 02:48:08 +00003033void DwarfDebug::emitDIE(DIE *Die) {
Bill Wendling480ff322009-05-20 23:21:38 +00003034 // Get the abbreviation for this DIE.
3035 unsigned AbbrevNumber = Die->getAbbrevNumber();
3036 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3037
Bill Wendling480ff322009-05-20 23:21:38 +00003038 // Emit the code (index) for the abbreviation.
Chris Lattner7bde8c02010-04-04 18:52:31 +00003039 if (Asm->isVerbose())
Chris Lattnerfa823552010-01-22 23:18:42 +00003040 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3041 Twine::utohexstr(Die->getOffset()) + ":0x" +
3042 Twine::utohexstr(Die->getSize()) + " " +
3043 dwarf::TagString(Abbrev->getTag()));
Chris Lattner9efd1182010-04-04 19:09:29 +00003044 Asm->EmitULEB128(AbbrevNumber);
Bill Wendling480ff322009-05-20 23:21:38 +00003045
Jeffrey Yasskin54ebc982010-03-22 18:47:14 +00003046 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
Bill Wendling480ff322009-05-20 23:21:38 +00003047 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3048
3049 // Emit the DIE attribute values.
3050 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3051 unsigned Attr = AbbrevData[i].getAttribute();
3052 unsigned Form = AbbrevData[i].getForm();
3053 assert(Form && "Too many attributes for DIE (check abbreviation)");
3054
Chris Lattner7bde8c02010-04-04 18:52:31 +00003055 if (Asm->isVerbose())
Chris Lattner5adf9872010-01-24 18:54:17 +00003056 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3057
Bill Wendling480ff322009-05-20 23:21:38 +00003058 switch (Attr) {
3059 case dwarf::DW_AT_sibling:
Devang Patel930143b2009-11-21 02:48:08 +00003060 Asm->EmitInt32(Die->getSiblingOffset());
Bill Wendling480ff322009-05-20 23:21:38 +00003061 break;
3062 case dwarf::DW_AT_abstract_origin: {
3063 DIEEntry *E = cast<DIEEntry>(Values[i]);
3064 DIE *Origin = E->getEntry();
Devang Patelf6eeaeb2009-11-10 23:06:00 +00003065 unsigned Addr = Origin->getOffset();
Bill Wendling480ff322009-05-20 23:21:38 +00003066 Asm->EmitInt32(Addr);
3067 break;
3068 }
Devang Patel12563b32010-04-16 23:33:45 +00003069 case dwarf::DW_AT_ranges: {
3070 // DW_AT_range Value encodes offset in debug_range section.
3071 DIEInteger *V = cast<DIEInteger>(Values[i]);
3072 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3073 V->getValue(),
3074 DwarfDebugRangeSectionSym,
3075 4);
3076 break;
3077 }
Devang Patel24bc1b52010-06-29 20:17:53 +00003078 case dwarf::DW_AT_stmt_list: {
3079 Asm->EmitLabelDifference(CurrentLineSectionSym,
3080 DwarfDebugLineSectionSym, 4);
3081 break;
3082 }
Devang Patel9fc11702010-05-25 23:40:22 +00003083 case dwarf::DW_AT_location: {
3084 if (UseDotDebugLocEntry.count(Die) != 0) {
3085 DIELabel *L = cast<DIELabel>(Values[i]);
3086 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3087 } else
3088 Values[i]->EmitValue(Asm, Form);
3089 break;
3090 }
Bill Wendling480ff322009-05-20 23:21:38 +00003091 default:
3092 // Emit an attribute using the defined form.
Chris Lattner3a383cb2010-04-05 00:13:49 +00003093 Values[i]->EmitValue(Asm, Form);
Bill Wendling480ff322009-05-20 23:21:38 +00003094 break;
3095 }
Bill Wendling480ff322009-05-20 23:21:38 +00003096 }
3097
3098 // Emit the DIE children if any.
3099 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3100 const std::vector<DIE *> &Children = Die->getChildren();
3101
3102 for (unsigned j = 0, M = Children.size(); j < M; ++j)
Devang Patel930143b2009-11-21 02:48:08 +00003103 emitDIE(Children[j]);
Bill Wendling480ff322009-05-20 23:21:38 +00003104
Chris Lattner7bde8c02010-04-04 18:52:31 +00003105 if (Asm->isVerbose())
Chris Lattner566cae92010-03-09 23:52:58 +00003106 Asm->OutStreamer.AddComment("End Of Children Mark");
3107 Asm->EmitInt8(0);
Bill Wendling480ff322009-05-20 23:21:38 +00003108 }
3109}
3110
Devang Patel9ccfb642009-12-09 18:24:21 +00003111/// emitDebugInfo - Emit the debug info section.
Bill Wendling480ff322009-05-20 23:21:38 +00003112///
Devang Patel9ccfb642009-12-09 18:24:21 +00003113void DwarfDebug::emitDebugInfo() {
3114 // Start debug info section.
3115 Asm->OutStreamer.SwitchSection(
3116 Asm->getObjFileLowering().getDwarfInfoSection());
Devang Patel1a0df9a2010-05-10 22:49:55 +00003117 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3118 E = CUMap.end(); I != E; ++I) {
3119 CompileUnit *TheCU = I->second;
3120 DIE *Die = TheCU->getCUDie();
3121
3122 // Emit the compile units header.
3123 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3124 TheCU->getID()));
3125
3126 // Emit size of content not including length itself
3127 unsigned ContentSize = Die->getSize() +
3128 sizeof(int16_t) + // DWARF version number
3129 sizeof(int32_t) + // Offset Into Abbrev. Section
3130 sizeof(int8_t) + // Pointer Size (in bytes)
3131 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3132
3133 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3134 Asm->EmitInt32(ContentSize);
3135 Asm->OutStreamer.AddComment("DWARF version number");
3136 Asm->EmitInt16(dwarf::DWARF_VERSION);
3137 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3138 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3139 DwarfAbbrevSectionSym);
3140 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3141 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3142
3143 emitDIE(Die);
3144 // FIXME - extra padding for gdb bug.
3145 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3146 Asm->EmitInt8(0);
3147 Asm->EmitInt8(0);
3148 Asm->EmitInt8(0);
3149 Asm->EmitInt8(0);
3150 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3151 }
Bill Wendling480ff322009-05-20 23:21:38 +00003152}
3153
Devang Patel930143b2009-11-21 02:48:08 +00003154/// emitAbbreviations - Emit the abbreviation section.
Bill Wendling480ff322009-05-20 23:21:38 +00003155///
Devang Patel930143b2009-11-21 02:48:08 +00003156void DwarfDebug::emitAbbreviations() const {
Bill Wendling480ff322009-05-20 23:21:38 +00003157 // Check to see if it is worth the effort.
3158 if (!Abbreviations.empty()) {
3159 // Start the debug abbrev section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00003160 Asm->OutStreamer.SwitchSection(
3161 Asm->getObjFileLowering().getDwarfAbbrevSection());
Bill Wendling480ff322009-05-20 23:21:38 +00003162
Chris Lattnera179b522010-04-04 19:25:43 +00003163 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
Bill Wendling480ff322009-05-20 23:21:38 +00003164
3165 // For each abbrevation.
3166 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3167 // Get abbreviation data
3168 const DIEAbbrev *Abbrev = Abbreviations[i];
3169
3170 // Emit the abbrevations code (base 1 index.)
Chris Lattner9efd1182010-04-04 19:09:29 +00003171 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
Bill Wendling480ff322009-05-20 23:21:38 +00003172
3173 // Emit the abbreviations data.
Chris Lattner3a383cb2010-04-05 00:13:49 +00003174 Abbrev->Emit(Asm);
Bill Wendling480ff322009-05-20 23:21:38 +00003175 }
3176
3177 // Mark end of abbreviations.
Chris Lattner9efd1182010-04-04 19:09:29 +00003178 Asm->EmitULEB128(0, "EOM(3)");
Bill Wendling480ff322009-05-20 23:21:38 +00003179
Chris Lattnera179b522010-04-04 19:25:43 +00003180 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
Bill Wendling480ff322009-05-20 23:21:38 +00003181 }
3182}
3183
Devang Patel930143b2009-11-21 02:48:08 +00003184/// emitEndOfLineMatrix - Emit the last address of the section and the end of
Bill Wendling480ff322009-05-20 23:21:38 +00003185/// the line matrix.
3186///
Devang Patel930143b2009-11-21 02:48:08 +00003187void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling480ff322009-05-20 23:21:38 +00003188 // Define last address of section.
Chris Lattner566cae92010-03-09 23:52:58 +00003189 Asm->OutStreamer.AddComment("Extended Op");
3190 Asm->EmitInt8(0);
3191
3192 Asm->OutStreamer.AddComment("Op size");
Chris Lattner3a383cb2010-04-05 00:13:49 +00003193 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner566cae92010-03-09 23:52:58 +00003194 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3195 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3196
3197 Asm->OutStreamer.AddComment("Section end label");
Chris Lattnerb245dfb2010-03-10 01:17:49 +00003198
Chris Lattnera179b522010-04-04 19:25:43 +00003199 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
Chris Lattner3a383cb2010-04-05 00:13:49 +00003200 Asm->getTargetData().getPointerSize(),
3201 0/*AddrSpace*/);
Bill Wendling480ff322009-05-20 23:21:38 +00003202
3203 // Mark end of matrix.
Chris Lattner566cae92010-03-09 23:52:58 +00003204 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3205 Asm->EmitInt8(0);
Chris Lattnerf5c834f2010-01-22 22:09:00 +00003206 Asm->EmitInt8(1);
Chris Lattnerfa823552010-01-22 23:18:42 +00003207 Asm->EmitInt8(1);
Bill Wendling480ff322009-05-20 23:21:38 +00003208}
3209
Devang Patel930143b2009-11-21 02:48:08 +00003210/// emitDebugLines - Emit source line information.
Bill Wendling480ff322009-05-20 23:21:38 +00003211///
Devang Patel930143b2009-11-21 02:48:08 +00003212void DwarfDebug::emitDebugLines() {
Bill Wendling480ff322009-05-20 23:21:38 +00003213 // If the target is using .loc/.file, the assembler will be emitting the
3214 // .debug_line table automatically.
Chris Lattner3a383cb2010-04-05 00:13:49 +00003215 if (Asm->MAI->hasDotLocAndDotFile())
Bill Wendling480ff322009-05-20 23:21:38 +00003216 return;
3217
3218 // Minimum line delta, thus ranging from -10..(255-10).
3219 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3220 // Maximum line delta, thus ranging from -10..(255-10).
3221 const int MaxLineDelta = 255 + MinLineDelta;
3222
3223 // Start the dwarf line section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00003224 Asm->OutStreamer.SwitchSection(
3225 Asm->getObjFileLowering().getDwarfLineSection());
Bill Wendling480ff322009-05-20 23:21:38 +00003226
3227 // Construct the section header.
Devang Patel24bc1b52010-06-29 20:17:53 +00003228 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3229 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
Chris Lattner566cae92010-03-09 23:52:58 +00003230 Asm->OutStreamer.AddComment("Length of Source Line Info");
Chris Lattnerf1429f12010-04-04 19:58:12 +00003231 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3232 Asm->GetTempSymbol("line_begin"), 4);
Chris Lattnera179b522010-04-04 19:25:43 +00003233 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
Bill Wendling480ff322009-05-20 23:21:38 +00003234
Chris Lattner566cae92010-03-09 23:52:58 +00003235 Asm->OutStreamer.AddComment("DWARF version number");
3236 Asm->EmitInt16(dwarf::DWARF_VERSION);
Bill Wendling480ff322009-05-20 23:21:38 +00003237
Chris Lattner566cae92010-03-09 23:52:58 +00003238 Asm->OutStreamer.AddComment("Prolog Length");
Chris Lattnerf1429f12010-04-04 19:58:12 +00003239 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3240 Asm->GetTempSymbol("line_prolog_begin"), 4);
Chris Lattnera179b522010-04-04 19:25:43 +00003241 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
Bill Wendling480ff322009-05-20 23:21:38 +00003242
Chris Lattner566cae92010-03-09 23:52:58 +00003243 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3244 Asm->EmitInt8(1);
3245 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3246 Asm->EmitInt8(1);
3247 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3248 Asm->EmitInt8(MinLineDelta);
3249 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3250 Asm->EmitInt8(MaxLineDelta);
3251 Asm->OutStreamer.AddComment("Special Opcode Base");
3252 Asm->EmitInt8(-MinLineDelta);
Bill Wendling480ff322009-05-20 23:21:38 +00003253
3254 // Line number standard opcode encodings argument count
Chris Lattner566cae92010-03-09 23:52:58 +00003255 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3256 Asm->EmitInt8(0);
3257 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3258 Asm->EmitInt8(1);
3259 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3260 Asm->EmitInt8(1);
3261 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3262 Asm->EmitInt8(1);
3263 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3264 Asm->EmitInt8(1);
3265 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3266 Asm->EmitInt8(0);
3267 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3268 Asm->EmitInt8(0);
3269 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3270 Asm->EmitInt8(0);
3271 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3272 Asm->EmitInt8(1);
Bill Wendling480ff322009-05-20 23:21:38 +00003273
3274 // Emit directories.
3275 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
Chris Lattnerc3f23b82010-01-23 03:11:46 +00003276 const std::string &Dir = getSourceDirectoryName(DI);
Chris Lattner7bde8c02010-04-04 18:52:31 +00003277 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
Chris Lattnerc3f23b82010-01-23 03:11:46 +00003278 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
Bill Wendling480ff322009-05-20 23:21:38 +00003279 }
3280
Chris Lattner566cae92010-03-09 23:52:58 +00003281 Asm->OutStreamer.AddComment("End of directories");
3282 Asm->EmitInt8(0);
Bill Wendling480ff322009-05-20 23:21:38 +00003283
3284 // Emit files.
3285 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3286 // Remember source id starts at 1.
3287 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
Chris Lattnerc3f23b82010-01-23 03:11:46 +00003288 const std::string &FN = getSourceFileName(Id.second);
Chris Lattner7bde8c02010-04-04 18:52:31 +00003289 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
Chris Lattnerc3f23b82010-01-23 03:11:46 +00003290 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3291
Chris Lattner9efd1182010-04-04 19:09:29 +00003292 Asm->EmitULEB128(Id.first, "Directory #");
3293 Asm->EmitULEB128(0, "Mod date");
3294 Asm->EmitULEB128(0, "File size");
Bill Wendling480ff322009-05-20 23:21:38 +00003295 }
3296
Chris Lattner566cae92010-03-09 23:52:58 +00003297 Asm->OutStreamer.AddComment("End of files");
3298 Asm->EmitInt8(0);
Bill Wendling480ff322009-05-20 23:21:38 +00003299
Chris Lattnera179b522010-04-04 19:25:43 +00003300 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
Bill Wendling480ff322009-05-20 23:21:38 +00003301
3302 // A sequence for each text section.
3303 unsigned SecSrcLinesSize = SectionSourceLines.size();
3304
3305 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3306 // Isolate current sections line info.
3307 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3308
Bill Wendling480ff322009-05-20 23:21:38 +00003309 // Dwarf assumes we start with first line of first source file.
3310 unsigned Source = 1;
3311 unsigned Line = 1;
3312
3313 // Construct rows of the address, source, line, column matrix.
3314 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3315 const SrcLineInfo &LineInfo = LineInfos[i];
Chris Lattnerb4666f42010-03-14 08:15:55 +00003316 MCSymbol *Label = LineInfo.getLabel();
Chris Lattneree95d4c2010-03-14 02:20:58 +00003317 if (!Label->isDefined()) continue; // Not emitted, in dead code.
Bill Wendling480ff322009-05-20 23:21:38 +00003318
Chris Lattner3d72a672010-03-09 23:38:23 +00003319 if (Asm->isVerbose()) {
Chris Lattner7e998b72010-03-10 01:04:13 +00003320 std::pair<unsigned, unsigned> SrcID =
Bill Wendling480ff322009-05-20 23:21:38 +00003321 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
Chris Lattner7e998b72010-03-10 01:04:13 +00003322 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
Chris Lattnera26fbe42010-03-10 02:29:31 +00003323 "/" +
3324 Twine(getSourceFileName(SrcID.second)) +
Chris Lattner7e998b72010-03-10 01:04:13 +00003325 ":" + Twine(LineInfo.getLine()));
Bill Wendling480ff322009-05-20 23:21:38 +00003326 }
3327
3328 // Define the line address.
Chris Lattner566cae92010-03-09 23:52:58 +00003329 Asm->OutStreamer.AddComment("Extended Op");
3330 Asm->EmitInt8(0);
3331 Asm->OutStreamer.AddComment("Op size");
Chris Lattner3a383cb2010-04-05 00:13:49 +00003332 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner566cae92010-03-09 23:52:58 +00003333
3334 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3335 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3336
3337 Asm->OutStreamer.AddComment("Location label");
Chris Lattner3a383cb2010-04-05 00:13:49 +00003338 Asm->OutStreamer.EmitSymbolValue(Label,
3339 Asm->getTargetData().getPointerSize(),
Chris Lattneree95d4c2010-03-14 02:20:58 +00003340 0/*AddrSpace*/);
Chris Lattnerb245dfb2010-03-10 01:17:49 +00003341
Bill Wendling480ff322009-05-20 23:21:38 +00003342 // If change of source, then switch to the new source.
3343 if (Source != LineInfo.getSourceID()) {
3344 Source = LineInfo.getSourceID();
Chris Lattner566cae92010-03-09 23:52:58 +00003345 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3346 Asm->EmitInt8(dwarf::DW_LNS_set_file);
Chris Lattner9efd1182010-04-04 19:09:29 +00003347 Asm->EmitULEB128(Source, "New Source");
Bill Wendling480ff322009-05-20 23:21:38 +00003348 }
3349
3350 // If change of line.
3351 if (Line != LineInfo.getLine()) {
3352 // Determine offset.
3353 int Offset = LineInfo.getLine() - Line;
3354 int Delta = Offset - MinLineDelta;
3355
3356 // Update line.
3357 Line = LineInfo.getLine();
3358
3359 // If delta is small enough and in range...
3360 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3361 // ... then use fast opcode.
Chris Lattner566cae92010-03-09 23:52:58 +00003362 Asm->OutStreamer.AddComment("Line Delta");
3363 Asm->EmitInt8(Delta - MinLineDelta);
Bill Wendling480ff322009-05-20 23:21:38 +00003364 } else {
3365 // ... otherwise use long hand.
Chris Lattner566cae92010-03-09 23:52:58 +00003366 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
Bill Wendling480ff322009-05-20 23:21:38 +00003367 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
Chris Lattner9efd1182010-04-04 19:09:29 +00003368 Asm->EmitSLEB128(Offset, "Line Offset");
Chris Lattner566cae92010-03-09 23:52:58 +00003369 Asm->OutStreamer.AddComment("DW_LNS_copy");
3370 Asm->EmitInt8(dwarf::DW_LNS_copy);
Bill Wendling480ff322009-05-20 23:21:38 +00003371 }
3372 } else {
3373 // Copy the previous row (different address or source)
Chris Lattner566cae92010-03-09 23:52:58 +00003374 Asm->OutStreamer.AddComment("DW_LNS_copy");
3375 Asm->EmitInt8(dwarf::DW_LNS_copy);
Bill Wendling480ff322009-05-20 23:21:38 +00003376 }
3377 }
3378
Devang Patel930143b2009-11-21 02:48:08 +00003379 emitEndOfLineMatrix(j + 1);
Bill Wendling480ff322009-05-20 23:21:38 +00003380 }
3381
3382 if (SecSrcLinesSize == 0)
3383 // Because we're emitting a debug_line section, we still need a line
3384 // table. The linker and friends expect it to exist. If there's nothing to
3385 // put into it, emit an empty table.
Devang Patel930143b2009-11-21 02:48:08 +00003386 emitEndOfLineMatrix(1);
Bill Wendling480ff322009-05-20 23:21:38 +00003387
Chris Lattnera179b522010-04-04 19:25:43 +00003388 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
Bill Wendling480ff322009-05-20 23:21:38 +00003389}
3390
Devang Patel930143b2009-11-21 02:48:08 +00003391/// emitCommonDebugFrame - Emit common frame info into a debug frame section.
Bill Wendling480ff322009-05-20 23:21:38 +00003392///
Devang Patel930143b2009-11-21 02:48:08 +00003393void DwarfDebug::emitCommonDebugFrame() {
Chris Lattner3a383cb2010-04-05 00:13:49 +00003394 if (!Asm->MAI->doesDwarfRequireFrameSection())
Bill Wendling480ff322009-05-20 23:21:38 +00003395 return;
3396
Chris Lattner3a383cb2010-04-05 00:13:49 +00003397 int stackGrowth = Asm->getTargetData().getPointerSize();
3398 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3399 TargetFrameInfo::StackGrowsDown)
3400 stackGrowth *= -1;
Bill Wendling480ff322009-05-20 23:21:38 +00003401
3402 // Start the dwarf frame section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00003403 Asm->OutStreamer.SwitchSection(
3404 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling480ff322009-05-20 23:21:38 +00003405
Chris Lattnera179b522010-04-04 19:25:43 +00003406 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
Chris Lattner566cae92010-03-09 23:52:58 +00003407 Asm->OutStreamer.AddComment("Length of Common Information Entry");
Chris Lattnerf1429f12010-04-04 19:58:12 +00003408 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3409 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
Bill Wendling480ff322009-05-20 23:21:38 +00003410
Chris Lattnera179b522010-04-04 19:25:43 +00003411 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
Chris Lattner566cae92010-03-09 23:52:58 +00003412 Asm->OutStreamer.AddComment("CIE Identifier Tag");
Bill Wendling480ff322009-05-20 23:21:38 +00003413 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
Chris Lattner566cae92010-03-09 23:52:58 +00003414 Asm->OutStreamer.AddComment("CIE Version");
Bill Wendling480ff322009-05-20 23:21:38 +00003415 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
Chris Lattner566cae92010-03-09 23:52:58 +00003416 Asm->OutStreamer.AddComment("CIE Augmentation");
Chris Lattnerc3f23b82010-01-23 03:11:46 +00003417 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
Chris Lattner9efd1182010-04-04 19:09:29 +00003418 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3419 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
Chris Lattner566cae92010-03-09 23:52:58 +00003420 Asm->OutStreamer.AddComment("CIE RA Column");
Chris Lattner3a383cb2010-04-05 00:13:49 +00003421 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Bill Wendling480ff322009-05-20 23:21:38 +00003422 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
Bill Wendling480ff322009-05-20 23:21:38 +00003423
3424 std::vector<MachineMove> Moves;
3425 RI->getInitialFrameState(Moves);
3426
Chris Lattneraabc6042010-04-04 23:41:46 +00003427 Asm->EmitFrameMoves(Moves, 0, false);
Bill Wendling480ff322009-05-20 23:21:38 +00003428
Chris Lattner9e06e532010-04-28 01:05:45 +00003429 Asm->EmitAlignment(2);
Chris Lattnera179b522010-04-04 19:25:43 +00003430 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
Bill Wendling480ff322009-05-20 23:21:38 +00003431}
3432
Devang Patel930143b2009-11-21 02:48:08 +00003433/// emitFunctionDebugFrame - Emit per function frame info into a debug frame
Bill Wendling480ff322009-05-20 23:21:38 +00003434/// section.
Chris Lattner2c3f4782010-03-13 07:26:18 +00003435void DwarfDebug::
3436emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
Chris Lattner3a383cb2010-04-05 00:13:49 +00003437 if (!Asm->MAI->doesDwarfRequireFrameSection())
Bill Wendling480ff322009-05-20 23:21:38 +00003438 return;
3439
3440 // Start the dwarf frame section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00003441 Asm->OutStreamer.SwitchSection(
3442 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling480ff322009-05-20 23:21:38 +00003443
Chris Lattner566cae92010-03-09 23:52:58 +00003444 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
Chris Lattner2c3f4782010-03-13 07:26:18 +00003445 MCSymbol *DebugFrameBegin =
Chris Lattnera179b522010-04-04 19:25:43 +00003446 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
Chris Lattner2c3f4782010-03-13 07:26:18 +00003447 MCSymbol *DebugFrameEnd =
Chris Lattnera179b522010-04-04 19:25:43 +00003448 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
Chris Lattnerf1429f12010-04-04 19:58:12 +00003449 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
Bill Wendling480ff322009-05-20 23:21:38 +00003450
Chris Lattner2c3f4782010-03-13 07:26:18 +00003451 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
Bill Wendling480ff322009-05-20 23:21:38 +00003452
Chris Lattner566cae92010-03-09 23:52:58 +00003453 Asm->OutStreamer.AddComment("FDE CIE offset");
Chris Lattner70a4fce2010-04-04 23:25:33 +00003454 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3455 DwarfFrameSectionSym);
Bill Wendling480ff322009-05-20 23:21:38 +00003456
Chris Lattner566cae92010-03-09 23:52:58 +00003457 Asm->OutStreamer.AddComment("FDE initial location");
Chris Lattnera179b522010-04-04 19:25:43 +00003458 MCSymbol *FuncBeginSym =
3459 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
Chris Lattner8811e122010-03-13 07:40:56 +00003460 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
Chris Lattner3a383cb2010-04-05 00:13:49 +00003461 Asm->getTargetData().getPointerSize(),
3462 0/*AddrSpace*/);
Chris Lattnerb245dfb2010-03-10 01:17:49 +00003463
3464
Chris Lattner566cae92010-03-09 23:52:58 +00003465 Asm->OutStreamer.AddComment("FDE address range");
Chris Lattnerf1429f12010-04-04 19:58:12 +00003466 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
Chris Lattner3a383cb2010-04-05 00:13:49 +00003467 FuncBeginSym, Asm->getTargetData().getPointerSize());
Bill Wendling480ff322009-05-20 23:21:38 +00003468
Chris Lattneraabc6042010-04-04 23:41:46 +00003469 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
Bill Wendling480ff322009-05-20 23:21:38 +00003470
Chris Lattner9e06e532010-04-28 01:05:45 +00003471 Asm->EmitAlignment(2);
Chris Lattner2c3f4782010-03-13 07:26:18 +00003472 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
Bill Wendling480ff322009-05-20 23:21:38 +00003473}
3474
Devang Patel9ccfb642009-12-09 18:24:21 +00003475/// emitDebugPubNames - Emit visible names into a debug pubnames section.
3476///
3477void DwarfDebug::emitDebugPubNames() {
Devang Patel1a0df9a2010-05-10 22:49:55 +00003478 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3479 E = CUMap.end(); I != E; ++I) {
3480 CompileUnit *TheCU = I->second;
3481 // Start the dwarf pubnames section.
3482 Asm->OutStreamer.SwitchSection(
3483 Asm->getObjFileLowering().getDwarfPubNamesSection());
Chris Lattnerc3f23b82010-01-23 03:11:46 +00003484
Devang Patel1a0df9a2010-05-10 22:49:55 +00003485 Asm->OutStreamer.AddComment("Length of Public Names Info");
3486 Asm->EmitLabelDifference(
3487 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3488 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3489
3490 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3491 TheCU->getID()));
3492
3493 Asm->OutStreamer.AddComment("DWARF Version");
3494 Asm->EmitInt16(dwarf::DWARF_VERSION);
3495
3496 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3497 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3498 DwarfInfoSectionSym);
3499
3500 Asm->OutStreamer.AddComment("Compilation Unit Length");
3501 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3502 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3503 4);
3504
3505 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3506 for (StringMap<DIE*>::const_iterator
3507 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3508 const char *Name = GI->getKeyData();
3509 DIE *Entity = GI->second;
3510
3511 Asm->OutStreamer.AddComment("DIE offset");
3512 Asm->EmitInt32(Entity->getOffset());
3513
3514 if (Asm->isVerbose())
3515 Asm->OutStreamer.AddComment("External Name");
3516 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3517 }
3518
3519 Asm->OutStreamer.AddComment("End Mark");
3520 Asm->EmitInt32(0);
3521 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3522 TheCU->getID()));
Bill Wendling480ff322009-05-20 23:21:38 +00003523 }
Bill Wendling480ff322009-05-20 23:21:38 +00003524}
3525
Devang Patel04d2f2d2009-11-24 01:14:22 +00003526void DwarfDebug::emitDebugPubTypes() {
Devang Patel1a0df9a2010-05-10 22:49:55 +00003527 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3528 E = CUMap.end(); I != E; ++I) {
3529 CompileUnit *TheCU = I->second;
3530 // Start the dwarf pubnames section.
3531 Asm->OutStreamer.SwitchSection(
3532 Asm->getObjFileLowering().getDwarfPubTypesSection());
3533 Asm->OutStreamer.AddComment("Length of Public Types Info");
3534 Asm->EmitLabelDifference(
3535 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3536 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
Chris Lattnerc3f23b82010-01-23 03:11:46 +00003537
Devang Patel1a0df9a2010-05-10 22:49:55 +00003538 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3539 TheCU->getID()));
3540
3541 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3542 Asm->EmitInt16(dwarf::DWARF_VERSION);
3543
3544 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3545 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3546 DwarfInfoSectionSym);
3547
3548 Asm->OutStreamer.AddComment("Compilation Unit Length");
3549 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3550 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3551 4);
3552
3553 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3554 for (StringMap<DIE*>::const_iterator
3555 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3556 const char *Name = GI->getKeyData();
3557 DIE * Entity = GI->second;
3558
3559 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3560 Asm->EmitInt32(Entity->getOffset());
3561
3562 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3563 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3564 }
3565
3566 Asm->OutStreamer.AddComment("End Mark");
3567 Asm->EmitInt32(0);
3568 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3569 TheCU->getID()));
Devang Patel04d2f2d2009-11-24 01:14:22 +00003570 }
Devang Patel04d2f2d2009-11-24 01:14:22 +00003571}
3572
Devang Patel930143b2009-11-21 02:48:08 +00003573/// emitDebugStr - Emit visible names into a debug str section.
Bill Wendling480ff322009-05-20 23:21:38 +00003574///
Devang Patel930143b2009-11-21 02:48:08 +00003575void DwarfDebug::emitDebugStr() {
Bill Wendling480ff322009-05-20 23:21:38 +00003576 // Check to see if it is worth the effort.
Chris Lattner3d72a672010-03-09 23:38:23 +00003577 if (StringPool.empty()) return;
3578
3579 // Start the dwarf str section.
3580 Asm->OutStreamer.SwitchSection(
Chris Lattner4b7dadb2009-08-19 05:49:37 +00003581 Asm->getObjFileLowering().getDwarfStrSection());
Bill Wendling480ff322009-05-20 23:21:38 +00003582
Chris Lattnerb7aa9522010-03-13 02:17:42 +00003583 // Get all of the string pool entries and put them in an array by their ID so
3584 // we can sort them.
3585 SmallVector<std::pair<unsigned,
3586 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3587
3588 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3589 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3590 Entries.push_back(std::make_pair(I->second.second, &*I));
3591
3592 array_pod_sort(Entries.begin(), Entries.end());
3593
3594 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
Chris Lattner3d72a672010-03-09 23:38:23 +00003595 // Emit a label for reference from debug information entries.
Chris Lattnerb7aa9522010-03-13 02:17:42 +00003596 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
Chris Lattner3d72a672010-03-09 23:38:23 +00003597
3598 // Emit the string itself.
Chris Lattnerb7aa9522010-03-13 02:17:42 +00003599 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
Bill Wendling480ff322009-05-20 23:21:38 +00003600 }
3601}
3602
Devang Patel930143b2009-11-21 02:48:08 +00003603/// emitDebugLoc - Emit visible names into a debug loc section.
Bill Wendling480ff322009-05-20 23:21:38 +00003604///
Devang Patel930143b2009-11-21 02:48:08 +00003605void DwarfDebug::emitDebugLoc() {
Devang Patel6b9a9fe2010-05-26 23:55:23 +00003606 if (DotDebugLocEntries.empty())
3607 return;
3608
Bill Wendling480ff322009-05-20 23:21:38 +00003609 // Start the dwarf loc section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00003610 Asm->OutStreamer.SwitchSection(
Devang Patel9fc11702010-05-25 23:40:22 +00003611 Asm->getObjFileLowering().getDwarfLocSection());
3612 unsigned char Size = Asm->getTargetData().getPointerSize();
Devang Patel6b9a9fe2010-05-26 23:55:23 +00003613 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3614 unsigned index = 1;
Devang Patel30265c42010-07-07 20:12:52 +00003615 for (SmallVector<DotDebugLocEntry, 4>::iterator
3616 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3617 I != E; ++I, ++index) {
Devang Patel9fc11702010-05-25 23:40:22 +00003618 DotDebugLocEntry Entry = *I;
Devang Patel9fc11702010-05-25 23:40:22 +00003619 if (Entry.isEmpty()) {
3620 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3621 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patel6b9a9fe2010-05-26 23:55:23 +00003622 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
Devang Patel9fc11702010-05-25 23:40:22 +00003623 } else {
3624 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3625 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3626 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3627 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3628 if (Reg < 32) {
3629 Asm->OutStreamer.AddComment("Loc expr size");
3630 Asm->EmitInt16(1);
3631 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3632 } else {
3633 Asm->OutStreamer.AddComment("Loc expr size");
3634 Asm->EmitInt16(1+MCAsmInfo::getULEB128Size(Reg));
3635 Asm->EmitInt8(dwarf::DW_OP_regx);
3636 Asm->EmitULEB128(Reg);
3637 }
3638 }
3639 }
Bill Wendling480ff322009-05-20 23:21:38 +00003640}
3641
3642/// EmitDebugARanges - Emit visible names into a debug aranges section.
3643///
3644void DwarfDebug::EmitDebugARanges() {
3645 // Start the dwarf aranges section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00003646 Asm->OutStreamer.SwitchSection(
3647 Asm->getObjFileLowering().getDwarfARangesSection());
Bill Wendling480ff322009-05-20 23:21:38 +00003648}
3649
Devang Patel930143b2009-11-21 02:48:08 +00003650/// emitDebugRanges - Emit visible names into a debug ranges section.
Bill Wendling480ff322009-05-20 23:21:38 +00003651///
Devang Patel930143b2009-11-21 02:48:08 +00003652void DwarfDebug::emitDebugRanges() {
Bill Wendling480ff322009-05-20 23:21:38 +00003653 // Start the dwarf ranges section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00003654 Asm->OutStreamer.SwitchSection(
Devang Patel12563b32010-04-16 23:33:45 +00003655 Asm->getObjFileLowering().getDwarfRangesSection());
Devang Patel6c74a872010-04-27 19:46:33 +00003656 unsigned char Size = Asm->getTargetData().getPointerSize();
3657 for (SmallVector<const MCSymbol *, 8>::iterator
3658 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3659 I != E; ++I) {
3660 if (*I)
3661 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
Devang Patel12563b32010-04-16 23:33:45 +00003662 else
Devang Patel6c74a872010-04-27 19:46:33 +00003663 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patel12563b32010-04-16 23:33:45 +00003664 }
Bill Wendling480ff322009-05-20 23:21:38 +00003665}
3666
Devang Patel930143b2009-11-21 02:48:08 +00003667/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
Bill Wendling480ff322009-05-20 23:21:38 +00003668///
Devang Patel930143b2009-11-21 02:48:08 +00003669void DwarfDebug::emitDebugMacInfo() {
Daniel Dunbarc418d6b2009-09-19 20:40:05 +00003670 if (const MCSection *LineInfo =
Chris Lattner1472cf52009-08-02 07:24:22 +00003671 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
Bill Wendling480ff322009-05-20 23:21:38 +00003672 // Start the dwarf macinfo section.
Chris Lattner4b7dadb2009-08-19 05:49:37 +00003673 Asm->OutStreamer.SwitchSection(LineInfo);
Bill Wendling480ff322009-05-20 23:21:38 +00003674 }
3675}
3676
Devang Patel930143b2009-11-21 02:48:08 +00003677/// emitDebugInlineInfo - Emit inline info using following format.
Bill Wendling480ff322009-05-20 23:21:38 +00003678/// Section Header:
3679/// 1. length of section
3680/// 2. Dwarf version number
3681/// 3. address size.
3682///
3683/// Entries (one "entry" for each function that was inlined):
3684///
3685/// 1. offset into __debug_str section for MIPS linkage name, if exists;
3686/// otherwise offset into __debug_str for regular function name.
3687/// 2. offset into __debug_str section for regular function name.
3688/// 3. an unsigned LEB128 number indicating the number of distinct inlining
3689/// instances for the function.
3690///
3691/// The rest of the entry consists of a {die_offset, low_pc} pair for each
3692/// inlined instance; the die_offset points to the inlined_subroutine die in the
3693/// __debug_info section, and the low_pc is the starting address for the
3694/// inlining instance.
Devang Patel930143b2009-11-21 02:48:08 +00003695void DwarfDebug::emitDebugInlineInfo() {
Chris Lattner3a383cb2010-04-05 00:13:49 +00003696 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
Bill Wendling480ff322009-05-20 23:21:38 +00003697 return;
3698
Devang Patel1a0df9a2010-05-10 22:49:55 +00003699 if (!FirstCU)
Bill Wendling480ff322009-05-20 23:21:38 +00003700 return;
3701
Chris Lattner4b7dadb2009-08-19 05:49:37 +00003702 Asm->OutStreamer.SwitchSection(
3703 Asm->getObjFileLowering().getDwarfDebugInlineSection());
Chris Lattnerf5c834f2010-01-22 22:09:00 +00003704
Chris Lattner566cae92010-03-09 23:52:58 +00003705 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
Chris Lattnerf1429f12010-04-04 19:58:12 +00003706 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3707 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
Bill Wendling480ff322009-05-20 23:21:38 +00003708
Chris Lattnera179b522010-04-04 19:25:43 +00003709 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
Bill Wendling480ff322009-05-20 23:21:38 +00003710
Chris Lattner566cae92010-03-09 23:52:58 +00003711 Asm->OutStreamer.AddComment("Dwarf Version");
3712 Asm->EmitInt16(dwarf::DWARF_VERSION);
3713 Asm->OutStreamer.AddComment("Address Size (in bytes)");
Chris Lattner3a383cb2010-04-05 00:13:49 +00003714 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Bill Wendling480ff322009-05-20 23:21:38 +00003715
Devang Patel32cc43c2010-05-07 20:54:48 +00003716 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
Devang Patelf6eeaeb2009-11-10 23:06:00 +00003717 E = InlinedSPNodes.end(); I != E; ++I) {
Jim Grosbach042483e2009-11-21 23:12:12 +00003718
Devang Patel32cc43c2010-05-07 20:54:48 +00003719 const MDNode *Node = *I;
3720 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
Jim Grosbach00e9c612009-11-22 19:20:36 +00003721 = InlineInfo.find(Node);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00003722 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
Devang Patel80ae3492009-08-28 23:24:31 +00003723 DISubprogram SP(Node);
Devang Patel2d9caf92009-11-25 17:36:49 +00003724 StringRef LName = SP.getLinkageName();
3725 StringRef Name = SP.getName();
Bill Wendling480ff322009-05-20 23:21:38 +00003726
Chris Lattner566cae92010-03-09 23:52:58 +00003727 Asm->OutStreamer.AddComment("MIPS linkage name");
Chris Lattnerc3f23b82010-01-23 03:11:46 +00003728 if (LName.empty()) {
3729 Asm->OutStreamer.EmitBytes(Name, 0);
3730 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3731 } else
Chris Lattner70a4fce2010-04-04 23:25:33 +00003732 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3733 DwarfStrSectionSym);
Devang Patelf6eeaeb2009-11-10 23:06:00 +00003734
Chris Lattner566cae92010-03-09 23:52:58 +00003735 Asm->OutStreamer.AddComment("Function name");
Chris Lattner70a4fce2010-04-04 23:25:33 +00003736 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
Chris Lattner9efd1182010-04-04 19:09:29 +00003737 Asm->EmitULEB128(Labels.size(), "Inline count");
Bill Wendling480ff322009-05-20 23:21:38 +00003738
Devang Patelf6eeaeb2009-11-10 23:06:00 +00003739 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
Bill Wendling480ff322009-05-20 23:21:38 +00003740 LE = Labels.end(); LI != LE; ++LI) {
Chris Lattner7bde8c02010-04-04 18:52:31 +00003741 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
Chris Lattner085b6522010-03-09 00:31:02 +00003742 Asm->EmitInt32(LI->second->getOffset());
Bill Wendling480ff322009-05-20 23:21:38 +00003743
Chris Lattner7bde8c02010-04-04 18:52:31 +00003744 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
Chris Lattner3a383cb2010-04-05 00:13:49 +00003745 Asm->OutStreamer.EmitSymbolValue(LI->first,
3746 Asm->getTargetData().getPointerSize(),0);
Bill Wendling480ff322009-05-20 23:21:38 +00003747 }
3748 }
3749
Chris Lattnera179b522010-04-04 19:25:43 +00003750 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
Bill Wendling480ff322009-05-20 23:21:38 +00003751}