blob: a1f646a425387d00cff743a459a7f9b409738739 [file] [log] [blame]
Bill Wendlingb12b3d72009-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 Lattner2ab0c442010-03-09 00:39:24 +000013
Devang Patel15e723d2009-08-28 23:24:31 +000014#define DEBUG_TYPE "dwarfdebug"
Bill Wendlingb12b3d72009-05-15 09:23:25 +000015#include "DwarfDebug.h"
Chris Lattner855b6bb2010-04-05 05:24:55 +000016#include "DIE.h"
Bill Wendling989a27e2010-04-05 22:59:21 +000017#include "llvm/Constants.h"
Bill Wendlingb12b3d72009-05-15 09:23:25 +000018#include "llvm/Module.h"
David Greened87baff2009-08-19 21:52:55 +000019#include "llvm/CodeGen/MachineFunction.h"
Bill Wendlingb12b3d72009-05-15 09:23:25 +000020#include "llvm/CodeGen/MachineModuleInfo.h"
Chris Lattner855e8f52010-03-09 01:58:53 +000021#include "llvm/MC/MCAsmInfo.h"
Chris Lattnere6ad12f2009-07-31 18:48:30 +000022#include "llvm/MC/MCSection.h"
Chris Lattner73266f92009-08-19 05:49:37 +000023#include "llvm/MC/MCStreamer.h"
Chris Lattner855e8f52010-03-09 01:58:53 +000024#include "llvm/MC/MCSymbol.h"
Chris Lattner31a54742010-01-16 21:57:06 +000025#include "llvm/Target/Mangler.h"
Bill Wendlingb12b3d72009-05-15 09:23:25 +000026#include "llvm/Target/TargetData.h"
27#include "llvm/Target/TargetFrameInfo.h"
Chris Lattnerc4c40a92009-07-28 03:13:23 +000028#include "llvm/Target/TargetLoweringObjectFile.h"
Chris Lattner017c7f92010-04-04 18:06:11 +000029#include "llvm/Target/TargetMachine.h"
Chris Lattnerc4c40a92009-07-28 03:13:23 +000030#include "llvm/Target/TargetRegisterInfo.h"
Devang Patel91474172010-04-19 19:14:02 +000031#include "llvm/Target/TargetOptions.h"
Chris Lattner855b6bb2010-04-05 05:24:55 +000032#include "llvm/Analysis/DebugInfo.h"
Jeffrey Yasskinecca2e62010-03-12 17:45:06 +000033#include "llvm/ADT/STLExtras.h"
Chris Lattnerf5377682009-08-24 03:52:50 +000034#include "llvm/ADT/StringExtras.h"
Devang Patelce7bf012010-04-27 19:46:33 +000035#include "llvm/Support/CommandLine.h"
Daniel Dunbarc74255d2009-10-13 06:47:08 +000036#include "llvm/Support/Debug.h"
37#include "llvm/Support/ErrorHandling.h"
Devang Patelae89d3b2010-01-26 21:39:14 +000038#include "llvm/Support/ValueHandle.h"
Chris Lattnerad653482010-01-22 22:09:00 +000039#include "llvm/Support/FormattedStream.h"
Chris Lattnere6ad12f2009-07-31 18:48:30 +000040#include "llvm/Support/Timer.h"
41#include "llvm/System/Path.h"
Bill Wendlingb12b3d72009-05-15 09:23:25 +000042using namespace llvm;
43
Devang Patelce7bf012010-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 Patel84afdd52010-07-07 20:12:52 +000047static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
48 cl::Hidden,
Devang Patelce7bf012010-04-27 19:46:33 +000049 cl::desc("Disable debug info printing"));
50
Dan Gohman77c565e2010-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 Wendlingce3c6252010-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 Wendlingb12b3d72009-05-15 09:23:25 +000060//===----------------------------------------------------------------------===//
61
62/// Configuration values for initial hash set sizes (log2).
63///
Bill Wendlingb12b3d72009-05-15 09:23:25 +000064static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
Bill Wendlingb12b3d72009-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 Lewyckyee68f452009-11-17 08:11:44 +000071class CompileUnit {
Bill Wendlingb12b3d72009-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 Yasskinecca2e62010-03-12 17:45:06 +000078 const OwningPtr<DIE> CUDie;
Bill Wendlingb12b3d72009-05-15 09:23:25 +000079
Jeffrey Yasskinc3545712010-03-11 18:29:55 +000080 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
Devang Patel1233f912009-11-21 00:31:03 +000081 DIE *IndexTyDie;
82
Devang Patel0f23f262010-07-07 20:49:57 +000083 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
Bill Wendlingb12b3d72009-05-15 09:23:25 +000084 /// variables to debug information entries.
Devang Patel0f23f262010-07-07 20:49:57 +000085 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
Bill Wendlingb12b3d72009-05-15 09:23:25 +000086
Devang Patel0f23f262010-07-07 20:49:57 +000087 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
Bill Wendlingb12b3d72009-05-15 09:23:25 +000088 /// descriptors to debug information entries using a DIEEntry proxy.
Devang Patel0f23f262010-07-07 20:49:57 +000089 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
Bill Wendlingb12b3d72009-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 Patelec13b4f2009-11-24 01:14:22 +000095 /// GlobalTypes - A map of globally visible types for this unit.
96 ///
97 StringMap<DIE*> GlobalTypes;
98
Bill Wendlingb12b3d72009-05-15 09:23:25 +000099public:
100 CompileUnit(unsigned I, DIE *D)
Devang Patelc50078e2009-11-21 02:48:08 +0000101 : ID(I), CUDie(D), IndexTyDie(0) {}
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000102
103 // Accessors.
Devang Patelec13b4f2009-11-24 01:14:22 +0000104 unsigned getID() const { return ID; }
Jeffrey Yasskinc3545712010-03-11 18:29:55 +0000105 DIE* getCUDie() const { return CUDie.get(); }
Devang Patelec13b4f2009-11-24 01:14:22 +0000106 const StringMap<DIE*> &getGlobals() const { return Globals; }
107 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000108
109 /// hasContent - Return true if this compile unit has something to write out.
110 ///
Devang Patelc50078e2009-11-21 02:48:08 +0000111 bool hasContent() const { return !CUDie->getChildren().empty(); }
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000112
Devang Patelc50078e2009-11-21 02:48:08 +0000113 /// addGlobal - Add a new global entity to the compile unit.
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000114 ///
Benjamin Kramer648940b2010-03-31 20:15:45 +0000115 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000116
Devang Patelec13b4f2009-11-24 01:14:22 +0000117 /// addGlobalType - Add a new global type to the compile unit.
118 ///
Benjamin Kramer648940b2010-03-31 20:15:45 +0000119 void addGlobalType(StringRef Name, DIE *Die) {
Devang Patelec13b4f2009-11-24 01:14:22 +0000120 GlobalTypes[Name] = Die;
121 }
122
Devang Pateld90672c2009-11-20 21:37:22 +0000123 /// getDIE - Returns the debug information entry map slot for the
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000124 /// specified debug variable.
Devang Patel0f23f262010-07-07 20:49:57 +0000125 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
Jim Grosbach652b7432009-11-21 23:12:12 +0000126
Devang Pateld90672c2009-11-20 21:37:22 +0000127 /// insertDIE - Insert DIE into the map.
Devang Patel9c371c62010-05-07 20:54:48 +0000128 void insertDIE(const MDNode *N, DIE *D) {
Devang Patel0f23f262010-07-07 20:49:57 +0000129 MDNodeToDieMap.insert(std::make_pair(N, D));
Devang Pateld90672c2009-11-20 21:37:22 +0000130 }
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000131
Devang Pateld90672c2009-11-20 21:37:22 +0000132 /// getDIEEntry - Returns the debug information entry for the speciefied
133 /// debug variable.
Devang Patel9c371c62010-05-07 20:54:48 +0000134 DIEEntry *getDIEEntry(const MDNode *N) {
Devang Patel0f23f262010-07-07 20:49:57 +0000135 DenseMap<const MDNode *, DIEEntry *>::iterator I = MDNodeToDIEEntryMap.find(N);
136 if (I == MDNodeToDIEEntryMap.end())
Devang Patel8287d662009-12-15 19:16:48 +0000137 return NULL;
138 return I->second;
139 }
Devang Pateld90672c2009-11-20 21:37:22 +0000140
141 /// insertDIEEntry - Insert debug information entry into the map.
Devang Patel9c371c62010-05-07 20:54:48 +0000142 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
Devang Patel0f23f262010-07-07 20:49:57 +0000143 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000144 }
145
Devang Patelc50078e2009-11-21 02:48:08 +0000146 /// addDie - Adds or interns the DIE to the compile unit.
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000147 ///
Devang Patelc50078e2009-11-21 02:48:08 +0000148 void addDie(DIE *Buffer) {
149 this->CUDie->addChild(Buffer);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000150 }
Devang Patel1233f912009-11-21 00:31:03 +0000151
152 // getIndexTyDie - Get an anonymous type for index type.
153 DIE *getIndexTyDie() {
154 return IndexTyDie;
155 }
156
Jim Grosbachb23f2422009-11-22 19:20:36 +0000157 // setIndexTyDie - Set D as anonymous type for index which can be reused
158 // later.
Devang Patel1233f912009-11-21 00:31:03 +0000159 void setIndexTyDie(DIE *D) {
160 IndexTyDie = D;
161 }
162
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000163};
164
165//===----------------------------------------------------------------------===//
166/// DbgVariable - This class is used to track local variable information.
167///
Devang Patel4cb32c32009-11-16 21:53:40 +0000168class DbgVariable {
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000169 DIVariable Var; // Variable Descriptor.
Devang Patel12188d52010-05-25 23:40:22 +0000170 DIE *TheDIE; // Variable DIE.
171 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000172public:
Jeffrey Yasskinecca2e62010-03-12 17:45:06 +0000173 // AbsVar may be NULL.
Devang Patel12188d52010-05-25 23:40:22 +0000174 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000175
176 // Accessors.
Devang Patel90a0fe32009-11-10 23:06:00 +0000177 DIVariable getVariable() const { return Var; }
Devang Patel90a0fe32009-11-10 23:06:00 +0000178 void setDIE(DIE *D) { TheDIE = D; }
179 DIE *getDIE() const { return TheDIE; }
Devang Patel12188d52010-05-25 23:40:22 +0000180 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
181 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000182};
183
184//===----------------------------------------------------------------------===//
Devang Patelce7bf012010-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 Wendlingb12b3d72009-05-15 09:23:25 +0000191/// DbgScope - This class is used to track scope information.
192///
Devang Patel4cb32c32009-11-16 21:53:40 +0000193class DbgScope {
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000194 DbgScope *Parent; // Parent to this scope.
Jim Grosbach652b7432009-11-21 23:12:12 +0000195 DIDescriptor Desc; // Debug info descriptor for scope.
Devang Patelae89d3b2010-01-26 21:39:14 +0000196 // Location at which this scope is inlined.
Devang Patel9c371c62010-05-07 20:54:48 +0000197 AssertingVH<const MDNode> InlinedAtLocation;
Devang Patel90a0fe32009-11-10 23:06:00 +0000198 bool AbstractScope; // Abstract Scope
Devang Patel90ecd192009-10-01 18:25:23 +0000199 const MachineInstr *LastInsn; // Last instruction of this scope.
200 const MachineInstr *FirstInsn; // First instruction of this scope.
Devang Patelce7bf012010-04-27 19:46:33 +0000201 unsigned DFSIn, DFSOut;
Jeffrey Yasskinecca2e62010-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 Patelce7bf012010-04-27 19:46:33 +0000206 SmallVector<DbgRange, 4> Ranges;
Owen Anderson696d4862009-06-24 22:53:20 +0000207 // Private state for dump()
208 mutable unsigned IndentLevel;
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000209public:
Devang Patel9c371c62010-05-07 20:54:48 +0000210 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
Devang Patel90a0fe32009-11-10 23:06:00 +0000211 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
Devang Patelce7bf012010-04-27 19:46:33 +0000212 LastInsn(0), FirstInsn(0),
213 DFSIn(0), DFSOut(0), IndentLevel(0) {}
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000214 virtual ~DbgScope();
215
216 // Accessors.
217 DbgScope *getParent() const { return Parent; }
Devang Patel90a0fe32009-11-10 23:06:00 +0000218 void setParent(DbgScope *P) { Parent = P; }
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000219 DIDescriptor getDesc() const { return Desc; }
Devang Patel9c371c62010-05-07 20:54:48 +0000220 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
221 const MDNode *getScopeNode() const { return Desc; }
Jeffrey Yasskinecca2e62010-03-12 17:45:06 +0000222 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
223 const SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
Devang Patelce7bf012010-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 Patel90a0fe32009-11-10 23:06:00 +0000258 void setAbstractScope() { AbstractScope = true; }
259 bool isAbstractScope() const { return AbstractScope; }
Devang Patelce7bf012010-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 Patel90a0fe32009-11-10 23:06:00 +0000273
Devang Patelc50078e2009-11-21 02:48:08 +0000274 /// addScope - Add a scope to the scope.
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000275 ///
Devang Patelc50078e2009-11-21 02:48:08 +0000276 void addScope(DbgScope *S) { Scopes.push_back(S); }
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000277
Devang Patelc50078e2009-11-21 02:48:08 +0000278 /// addVariable - Add a variable to the scope.
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000279 ///
Devang Patelc50078e2009-11-21 02:48:08 +0000280 void addVariable(DbgVariable *V) { Variables.push_back(V); }
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000281
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000282#ifndef NDEBUG
283 void dump() const;
284#endif
285};
Devang Patelce7bf012010-04-27 19:46:33 +0000286
Chris Lattner8b9430c2010-04-05 04:09:20 +0000287} // end llvm namespace
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000288
289#ifndef NDEBUG
290void DbgScope::dump() const {
David Greenedbc06132009-12-24 00:31:35 +0000291 raw_ostream &err = dbgs();
Chris Lattnerebb8c082009-08-23 00:51:00 +0000292 err.indent(IndentLevel);
Devang Patel9c371c62010-05-07 20:54:48 +0000293 const MDNode *N = Desc;
Devang Patel90a0fe32009-11-10 23:06:00 +0000294 N->dump();
Devang Patel90a0fe32009-11-10 23:06:00 +0000295 if (AbstractScope)
296 err << "Abstract Scope\n";
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000297
298 IndentLevel += 2;
Devang Patel90a0fe32009-11-10 23:06:00 +0000299 if (!Scopes.empty())
300 err << "Children ...\n";
Bill Wendlingb12b3d72009-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 Wendlingb12b3d72009-05-15 09:23:25 +0000309DbgScope::~DbgScope() {
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000310 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
311 delete Variables[j];
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000312}
313
Chris Lattnerec9a1f42010-04-05 05:11:15 +0000314DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
Devang Patel7e5a86e2010-05-10 22:49:55 +0000315 : Asm(A), MMI(Asm->MMI), FirstCU(0),
Chris Lattner2cb53302010-04-05 03:52:55 +0000316 AbbreviationsSet(InitAbbreviationsSetSize),
Devang Patel146c6f72010-04-16 23:33:45 +0000317 CurrentFnDbgScope(0), PrevLabel(NULL) {
Chris Lattner0f093f82010-03-13 02:17:42 +0000318 NextStringPoolNumber = 0;
Chris Lattner66143d22010-04-04 22:59:04 +0000319
Chris Lattner094932e2010-04-04 23:10:38 +0000320 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
321 DwarfStrSectionSym = TextSectionSym = 0;
Devang Patel12188d52010-05-25 23:40:22 +0000322 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
Devang Pateldd385062010-06-29 20:17:53 +0000323 DwarfDebugLineSectionSym = CurrentLineSectionSym = 0;
Devang Patel12188d52010-05-25 23:40:22 +0000324 FunctionBeginSym = FunctionEndSym = 0;
Devang Pateld36a93d2010-07-08 20:10:35 +0000325 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
Dan Gohmane2a95082010-06-18 15:56:31 +0000326 {
327 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
328 beginModule(M);
Edwin Törökc669cb62010-04-07 10:44:46 +0000329 }
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000330}
331DwarfDebug::~DwarfDebug() {
Benjamin Kramer138c7ff2010-03-31 19:34:01 +0000332 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
333 DIEBlocks[j]->~DIEBlock();
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000334}
335
Chris Lattner0f093f82010-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 Lattnerb93558d2010-04-04 19:25:43 +0000341 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
Chris Lattner0f093f82010-03-13 02:17:42 +0000342}
343
344
Devang Patelc50078e2009-11-21 02:48:08 +0000345/// assignAbbrevNumber - Define a unique number for the abbreviation.
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000346///
Devang Patelc50078e2009-11-21 02:48:08 +0000347void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
Bill Wendlingb12b3d72009-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 Patelc50078e2009-11-21 02:48:08 +0000368/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
Bill Wendling0d3db8b2009-05-20 23:24:48 +0000369/// information entry.
Devang Patelc50078e2009-11-21 02:48:08 +0000370DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
Benjamin Kramer138c7ff2010-03-31 19:34:01 +0000371 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000372 return Value;
373}
374
Devang Patelc50078e2009-11-21 02:48:08 +0000375/// addUInt - Add an unsigned integer attribute data and value.
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000376///
Devang Patelc50078e2009-11-21 02:48:08 +0000377void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000378 unsigned Form, uint64_t Integer) {
379 if (!Form) Form = DIEInteger::BestForm(false, Integer);
Devang Pateld36a93d2010-07-08 20:10:35 +0000380 DIEValue *Value = Integer == 1 ?
381 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
Devang Patelc50078e2009-11-21 02:48:08 +0000382 Die->addValue(Attribute, Form, Value);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000383}
384
Devang Patelc50078e2009-11-21 02:48:08 +0000385/// addSInt - Add an signed integer attribute data and value.
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000386///
Devang Patelc50078e2009-11-21 02:48:08 +0000387void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000388 unsigned Form, int64_t Integer) {
389 if (!Form) Form = DIEInteger::BestForm(true, Integer);
Benjamin Kramer138c7ff2010-03-31 19:34:01 +0000390 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
Devang Patelc50078e2009-11-21 02:48:08 +0000391 Die->addValue(Attribute, Form, Value);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000392}
393
Devang Pateldf0f2152009-12-02 15:25:16 +0000394/// addString - Add a string attribute data and value. DIEString only
395/// keeps string reference.
Devang Patelc50078e2009-11-21 02:48:08 +0000396void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattnercc564642010-01-23 03:11:46 +0000397 StringRef String) {
Benjamin Kramer138c7ff2010-03-31 19:34:01 +0000398 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
Devang Patelc50078e2009-11-21 02:48:08 +0000399 Die->addValue(Attribute, Form, Value);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000400}
401
Devang Patelc50078e2009-11-21 02:48:08 +0000402/// addLabel - Add a Dwarf label attribute data and value.
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000403///
Devang Patelc50078e2009-11-21 02:48:08 +0000404void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattnerbe4c2fc2010-03-08 22:23:36 +0000405 const MCSymbol *Label) {
Benjamin Kramer138c7ff2010-03-31 19:34:01 +0000406 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
Devang Patelc50078e2009-11-21 02:48:08 +0000407 Die->addValue(Attribute, Form, Value);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000408}
409
Devang Patelc50078e2009-11-21 02:48:08 +0000410/// addDelta - Add a label delta attribute data and value.
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000411///
Devang Patelc50078e2009-11-21 02:48:08 +0000412void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
Chris Lattnerbe4c2fc2010-03-08 22:23:36 +0000413 const MCSymbol *Hi, const MCSymbol *Lo) {
Benjamin Kramer138c7ff2010-03-31 19:34:01 +0000414 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
Devang Patelc50078e2009-11-21 02:48:08 +0000415 Die->addValue(Attribute, Form, Value);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000416}
417
Chris Lattner855b6bb2010-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 Patelc50078e2009-11-21 02:48:08 +0000426/// addBlock - Add block data.
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000427///
Devang Patelc50078e2009-11-21 02:48:08 +0000428void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000429 DIEBlock *Block) {
Chris Lattner352c8e22010-04-05 00:18:22 +0000430 Block->ComputeSize(Asm);
Benjamin Kramer138c7ff2010-03-31 19:34:01 +0000431 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
Devang Patelc50078e2009-11-21 02:48:08 +0000432 Die->addValue(Attribute, Block->BestForm(), Block);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000433}
434
Devang Patelc50078e2009-11-21 02:48:08 +0000435/// addSourceLine - Add location information to specified debug information
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000436/// entry.
Devang Patelc50078e2009-11-21 02:48:08 +0000437void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
Devang Patel532a9a82010-05-07 23:33:41 +0000438 // Verify variable.
439 if (!V->Verify())
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000440 return;
441
442 unsigned Line = V->getLineNumber();
Devang Patel7f9e0f32010-03-08 22:02:50 +0000443 unsigned FileID = GetOrCreateSourceID(V->getContext().getDirectory(),
444 V->getContext().getFilename());
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000445 assert(FileID && "Invalid file id");
Devang Patelc50078e2009-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 Wendlingb12b3d72009-05-15 09:23:25 +0000448}
449
Devang Patelc50078e2009-11-21 02:48:08 +0000450/// addSourceLine - Add location information to specified debug information
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000451/// entry.
Devang Patel4942c4b2010-05-07 23:19:07 +0000452void DwarfDebug::addSourceLine(DIE *Die, const DIGlobalVariable *G) {
Devang Patel532a9a82010-05-07 23:33:41 +0000453 // Verify global variable.
454 if (!G->Verify())
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000455 return;
456
457 unsigned Line = G->getLineNumber();
Devang Patel7f9e0f32010-03-08 22:02:50 +0000458 unsigned FileID = GetOrCreateSourceID(G->getContext().getDirectory(),
459 G->getContext().getFilename());
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000460 assert(FileID && "Invalid file id");
Devang Patelc50078e2009-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 Wendlingb12b3d72009-05-15 09:23:25 +0000463}
Devang Patel318d70d2009-08-31 22:47:13 +0000464
Devang Patelc50078e2009-11-21 02:48:08 +0000465/// addSourceLine - Add location information to specified debug information
Devang Patel318d70d2009-08-31 22:47:13 +0000466/// entry.
Devang Patelc50078e2009-11-21 02:48:08 +0000467void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
Devang Patel532a9a82010-05-07 23:33:41 +0000468 // Verify subprogram.
469 if (!SP->Verify())
Devang Patel318d70d2009-08-31 22:47:13 +0000470 return;
Caroline Tice9da96d82009-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 Patel318d70d2009-08-31 22:47:13 +0000475 unsigned Line = SP->getLineNumber();
Devang Patel7f9e0f32010-03-08 22:02:50 +0000476 if (!SP->getContext().Verify())
477 return;
Devang Patele485a5d2010-03-24 21:30:35 +0000478 unsigned FileID = GetOrCreateSourceID(SP->getDirectory(),
479 SP->getFilename());
Devang Patel318d70d2009-08-31 22:47:13 +0000480 assert(FileID && "Invalid file id");
Devang Patelc50078e2009-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 Patel318d70d2009-08-31 22:47:13 +0000483}
484
Devang Patelc50078e2009-11-21 02:48:08 +0000485/// addSourceLine - Add location information to specified debug information
Devang Patel318d70d2009-08-31 22:47:13 +0000486/// entry.
Devang Patelc50078e2009-11-21 02:48:08 +0000487void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
Devang Patel532a9a82010-05-07 23:33:41 +0000488 // Verify type.
489 if (!Ty->Verify())
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000490 return;
491
492 unsigned Line = Ty->getLineNumber();
Devang Patel7f9e0f32010-03-08 22:02:50 +0000493 if (!Ty->getContext().Verify())
494 return;
495 unsigned FileID = GetOrCreateSourceID(Ty->getContext().getDirectory(),
496 Ty->getContext().getFilename());
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000497 assert(FileID && "Invalid file id");
Devang Patelc50078e2009-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 Wendlingb12b3d72009-05-15 09:23:25 +0000500}
501
Devang Patel8287d662009-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 Patel532a9a82010-05-07 23:33:41 +0000505 // Verify namespace.
506 if (!NS->Verify())
Devang Patel8287d662009-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 Tice248d5572009-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 Patelc50078e2009-11-21 02:48:08 +0000542 value of the variable. The function addBlockByrefType does this. */
Caroline Tice248d5572009-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 Patelc50078e2009-11-21 02:48:08 +0000547DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
Caroline Tice248d5572009-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 Patel19302aa2010-05-07 18:11:54 +0000553 DIDerivedType DTy = DIDerivedType(Ty);
Caroline Tice248d5572009-08-31 21:19:37 +0000554 subType = DTy.getTypeDerivedFrom();
555 }
556
Devang Patel19302aa2010-05-07 18:11:54 +0000557 DICompositeType blockStruct = DICompositeType(subType);
Caroline Tice248d5572009-08-31 21:19:37 +0000558 DIArray Elements = blockStruct.getTypeArray();
559
Caroline Tice248d5572009-08-31 21:19:37 +0000560 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
561 DIDescriptor Element = Elements.getElement(i);
Devang Patel19302aa2010-05-07 18:11:54 +0000562 DIDerivedType DT = DIDerivedType(Element);
Devang Patel7f75bbe2009-11-25 17:36:49 +0000563 if (Name == DT.getName())
Caroline Tice248d5572009-08-31 21:19:37 +0000564 return (DT.getTypeDerivedFrom());
565 }
566
567 return Ty;
568}
569
Devang Patelc50078e2009-11-21 02:48:08 +0000570/// addComplexAddress - Start with the address based on the location provided,
Mike Stumpb22cd0f2009-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 Patelc50078e2009-11-21 02:48:08 +0000575void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
Mike Stumpb22cd0f2009-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 Lattnerbc0027b2010-04-05 00:13:49 +0000583 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Mike Stumpb22cd0f2009-09-30 00:08:22 +0000584 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer138c7ff2010-03-31 19:34:01 +0000585 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Mike Stumpb22cd0f2009-09-30 00:08:22 +0000586
587 if (Location.isReg()) {
588 if (Reg < 32) {
Devang Patelc50078e2009-11-21 02:48:08 +0000589 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Mike Stumpb22cd0f2009-09-30 00:08:22 +0000590 } else {
591 Reg = Reg - dwarf::DW_OP_reg0;
Devang Patelc50078e2009-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 Stumpb22cd0f2009-09-30 00:08:22 +0000594 }
595 } else {
596 if (Reg < 32)
Devang Patelc50078e2009-11-21 02:48:08 +0000597 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Mike Stumpb22cd0f2009-09-30 00:08:22 +0000598 else {
Devang Patelc50078e2009-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 Stumpb22cd0f2009-09-30 00:08:22 +0000601 }
602
Devang Patelc50078e2009-11-21 02:48:08 +0000603 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Mike Stumpb22cd0f2009-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 Patelc50078e2009-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 Stumpb22cd0f2009-09-30 00:08:22 +0000612 } else if (Element == DIFactory::OpDeref) {
Devang Patelc50078e2009-11-21 02:48:08 +0000613 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Mike Stumpb22cd0f2009-09-30 00:08:22 +0000614 } else llvm_unreachable("unknown DIFactory Opcode");
615 }
616
617 // Now attach the location information to the DIE.
Devang Patelc50078e2009-11-21 02:48:08 +0000618 addBlock(Die, Attribute, 0, Block);
Mike Stumpb22cd0f2009-09-30 00:08:22 +0000619}
620
Caroline Tice248d5572009-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 Patelc50078e2009-11-21 02:48:08 +0000630 The function getBlockByrefType dives into the __Block_byref_x_VarName
Caroline Tice248d5572009-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 Dunbar41716322009-09-19 20:40:05 +0000635 expression that explains to the debugger how to navigate through the
Caroline Tice248d5572009-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 Gohmandf1a7ff2010-02-10 16:03:48 +0000658 2). Follow that pointer to get the real __Block_byref_x_VarName
Caroline Tice248d5572009-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 Patelc50078e2009-11-21 02:48:08 +0000675/// addBlockByrefAddress - Start with the address based on the location
Caroline Tice248d5572009-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 Patelc50078e2009-11-21 02:48:08 +0000681void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000682 unsigned Attribute,
683 const MachineLocation &Location) {
Caroline Tice248d5572009-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 Patel7f75bbe2009-11-25 17:36:49 +0000690 StringRef varName = VD.getName();
Caroline Tice248d5572009-08-31 21:19:37 +0000691
692 if (Tag == dwarf::DW_TAG_pointer_type) {
Devang Patel19302aa2010-05-07 18:11:54 +0000693 DIDerivedType DTy = DIDerivedType(Ty);
Caroline Tice248d5572009-08-31 21:19:37 +0000694 TmpTy = DTy.getTypeDerivedFrom();
695 isPointer = true;
696 }
697
Devang Patel19302aa2010-05-07 18:11:54 +0000698 DICompositeType blockStruct = DICompositeType(TmpTy);
Caroline Tice248d5572009-08-31 21:19:37 +0000699
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000700 // Find the __forwarding field and the variable field in the __Block_byref
701 // struct.
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000702 DIArray Fields = blockStruct.getTypeArray();
703 DIDescriptor varField = DIDescriptor();
704 DIDescriptor forwardingField = DIDescriptor();
Caroline Tice248d5572009-08-31 21:19:37 +0000705
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000706 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
707 DIDescriptor Element = Fields.getElement(i);
Devang Patel19302aa2010-05-07 18:11:54 +0000708 DIDerivedType DT = DIDerivedType(Element);
Devang Patel7f75bbe2009-11-25 17:36:49 +0000709 StringRef fieldName = DT.getName();
710 if (fieldName == "__forwarding")
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000711 forwardingField = Element;
Devang Patel7f75bbe2009-11-25 17:36:49 +0000712 else if (fieldName == varName)
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000713 varField = Element;
714 }
Daniel Dunbar41716322009-09-19 20:40:05 +0000715
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000716 // Get the offsets for the forwarding field and the variable field.
Chris Lattner5df82552010-03-31 06:06:37 +0000717 unsigned forwardingFieldOffset =
Devang Patel19302aa2010-05-07 18:11:54 +0000718 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
Chris Lattner5df82552010-03-31 06:06:37 +0000719 unsigned varFieldOffset =
Devang Patel19302aa2010-05-07 18:11:54 +0000720 DIDerivedType(varField).getOffsetInBits() >> 3;
Caroline Tice248d5572009-08-31 21:19:37 +0000721
Mike Stump2fd84e22009-09-24 23:21:26 +0000722 // Decode the original location, and use that as the start of the byref
723 // variable's location.
Chris Lattnerbc0027b2010-04-05 00:13:49 +0000724 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000725 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer138c7ff2010-03-31 19:34:01 +0000726 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Caroline Tice248d5572009-08-31 21:19:37 +0000727
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000728 if (Location.isReg()) {
729 if (Reg < 32)
Devang Patelc50078e2009-11-21 02:48:08 +0000730 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000731 else {
732 Reg = Reg - dwarf::DW_OP_reg0;
Devang Patelc50078e2009-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 Dunbar19f1d442009-09-19 20:40:14 +0000735 }
736 } else {
737 if (Reg < 32)
Devang Patelc50078e2009-11-21 02:48:08 +0000738 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000739 else {
Devang Patelc50078e2009-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 Dunbar19f1d442009-09-19 20:40:14 +0000742 }
Caroline Tice248d5572009-08-31 21:19:37 +0000743
Devang Patelc50078e2009-11-21 02:48:08 +0000744 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000745 }
Caroline Tice248d5572009-08-31 21:19:37 +0000746
Mike Stump2fd84e22009-09-24 23:21:26 +0000747 // If we started with a pointer to the __Block_byref... struct, then
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000748 // the first thing we need to do is dereference the pointer (DW_OP_deref).
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000749 if (isPointer)
Devang Patelc50078e2009-11-21 02:48:08 +0000750 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Caroline Tice248d5572009-08-31 21:19:37 +0000751
Daniel Dunbar19f1d442009-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 Dunbar19f1d442009-09-19 20:40:14 +0000755 if (forwardingFieldOffset > 0) {
Devang Patelc50078e2009-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 Dunbar19f1d442009-09-19 20:40:14 +0000758 }
Caroline Tice248d5572009-08-31 21:19:37 +0000759
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000760 // Now dereference the __forwarding field to get to the real __Block_byref
761 // struct: DW_OP_deref.
Devang Patelc50078e2009-11-21 02:48:08 +0000762 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
Caroline Tice248d5572009-08-31 21:19:37 +0000763
Daniel Dunbar19f1d442009-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 Dunbar19f1d442009-09-19 20:40:14 +0000767 if (varFieldOffset > 0) {
Devang Patelc50078e2009-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 Dunbar19f1d442009-09-19 20:40:14 +0000770 }
Caroline Tice248d5572009-08-31 21:19:37 +0000771
Daniel Dunbar19f1d442009-09-19 20:40:14 +0000772 // Now attach the location information to the DIE.
Devang Patelc50078e2009-11-21 02:48:08 +0000773 addBlock(Die, Attribute, 0, Block);
Caroline Tice248d5572009-08-31 21:19:37 +0000774}
775
Devang Patelc50078e2009-11-21 02:48:08 +0000776/// addAddress - Add an address attribute to a die based on the location
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000777/// provided.
Devang Patelc50078e2009-11-21 02:48:08 +0000778void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000779 const MachineLocation &Location) {
Chris Lattnerbc0027b2010-04-05 00:13:49 +0000780 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000781 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
Benjamin Kramer138c7ff2010-03-31 19:34:01 +0000782 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000783
784 if (Location.isReg()) {
785 if (Reg < 32) {
Devang Patelc50078e2009-11-21 02:48:08 +0000786 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000787 } else {
Devang Patelc50078e2009-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 Wendlingb12b3d72009-05-15 09:23:25 +0000790 }
791 } else {
792 if (Reg < 32) {
Devang Patelc50078e2009-11-21 02:48:08 +0000793 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000794 } else {
Devang Patelc50078e2009-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 Wendlingb12b3d72009-05-15 09:23:25 +0000797 }
798
Devang Patelc50078e2009-11-21 02:48:08 +0000799 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000800 }
801
Devang Patelc50078e2009-11-21 02:48:08 +0000802 addBlock(Die, Attribute, 0, Block);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000803}
804
Devang Patel7e625392010-04-28 01:03:09 +0000805/// addRegisterAddress - Add register location entry in variable DIE.
Devang Patelf0e70332010-05-20 16:36:41 +0000806bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
Devang Patel7e625392010-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 Patelf0e70332010-05-20 16:36:41 +0000814 if (VS)
Devang Patel7e625392010-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 Patelf0e70332010-05-20 16:36:41 +0000820bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
Devang Patel7e625392010-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 Patelf0e70332010-05-20 16:36:41 +0000827 if (VS)
Devang Patel7e625392010-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 Patelf0e70332010-05-20 16:36:41 +0000833bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
Devang Patel7e625392010-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 Patelf0e70332010-05-20 16:36:41 +0000855 if (VS)
856 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
Devang Patel7e625392010-04-28 01:03:09 +0000857 return true;
858}
859
860
Devang Patel1a8f9a82009-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 Patel9e592492010-03-08 20:52:55 +0000863 if (Context.isType()) {
Devang Patel19302aa2010-05-07 18:11:54 +0000864 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
Devang Patel1a8f9a82009-12-10 19:14:49 +0000865 ContextDIE->addChild(Die);
Devang Patel8287d662009-12-15 19:16:48 +0000866 } else if (Context.isNameSpace()) {
Devang Patel19302aa2010-05-07 18:11:54 +0000867 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
Devang Patel8287d662009-12-15 19:16:48 +0000868 ContextDIE->addChild(Die);
Stuart Hastingsaa685d62010-06-11 20:08:44 +0000869 } else if (Context.isSubprogram()) {
870 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
871 /*MakeDecl=*/false);
872 ContextDIE->addChild(Die);
Devang Patel7e5a86e2010-05-10 22:49:55 +0000873 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
Devang Patel1a8f9a82009-12-10 19:14:49 +0000874 ContextDIE->addChild(Die);
875 else
Devang Patel7e5a86e2010-05-10 22:49:55 +0000876 getCompileUnit(Context)->addDie(Die);
Devang Patel1a8f9a82009-12-10 19:14:49 +0000877}
878
Devang Patel7f139c12009-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 Patel7e5a86e2010-05-10 22:49:55 +0000882 CompileUnit *TypeCU = getCompileUnit(Ty);
883 DIE *TyDIE = TypeCU->getDIE(Ty);
Devang Patel7f139c12009-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 Patel7e5a86e2010-05-10 22:49:55 +0000889 TypeCU->insertDIE(Ty, TyDIE);
Devang Patel7f139c12009-12-10 18:05:33 +0000890 if (Ty.isBasicType())
Devang Patel19302aa2010-05-07 18:11:54 +0000891 constructTypeDIE(*TyDIE, DIBasicType(Ty));
Devang Patel7f139c12009-12-10 18:05:33 +0000892 else if (Ty.isCompositeType())
Devang Patel19302aa2010-05-07 18:11:54 +0000893 constructTypeDIE(*TyDIE, DICompositeType(Ty));
Devang Patel7f139c12009-12-10 18:05:33 +0000894 else {
895 assert(Ty.isDerivedType() && "Unknown kind of DIType");
Devang Patel19302aa2010-05-07 18:11:54 +0000896 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
Devang Patel7f139c12009-12-10 18:05:33 +0000897 }
898
Devang Patel1a8f9a82009-12-10 19:14:49 +0000899 addToContextOwner(TyDIE, Ty.getContext());
Devang Patel7f139c12009-12-10 18:05:33 +0000900 return TyDIE;
901}
902
Devang Patelc50078e2009-11-21 02:48:08 +0000903/// addType - Add a new type attribute to the specified entity.
Devang Patelfe0be132009-12-09 18:24:21 +0000904void DwarfDebug::addType(DIE *Entity, DIType Ty) {
Devang Patel9738af92010-05-07 21:45:47 +0000905 if (!Ty.Verify())
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000906 return;
907
908 // Check for pre-existence.
Devang Patel7e5a86e2010-05-10 22:49:55 +0000909 CompileUnit *TypeCU = getCompileUnit(Ty);
910 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000911 // If it exists then use the existing value.
Devang Patelc50078e2009-11-21 02:48:08 +0000912 if (Entry) {
913 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000914 return;
915 }
916
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000917 // Construct type.
Devang Patel7f139c12009-12-10 18:05:33 +0000918 DIE *Buffer = getOrCreateTypeDIE(Ty);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000919
Jeffrey Yasskinecca2e62010-03-12 17:45:06 +0000920 // Set up proxy.
921 Entry = createDIEEntry(Buffer);
Devang Patel7e5a86e2010-05-10 22:49:55 +0000922 TypeCU->insertDIEEntry(Ty, Entry);
Jeffrey Yasskinecca2e62010-03-12 17:45:06 +0000923
Devang Patelc50078e2009-11-21 02:48:08 +0000924 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000925}
926
Devang Patelc50078e2009-11-21 02:48:08 +0000927/// constructTypeDIE - Construct basic type die from DIBasicType.
Devang Patelfe0be132009-12-09 18:24:21 +0000928void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000929 // Get core information.
Devang Patel7f75bbe2009-11-25 17:36:49 +0000930 StringRef Name = BTy.getName();
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000931 Buffer.setTag(dwarf::DW_TAG_base_type);
Devang Patelc50078e2009-11-21 02:48:08 +0000932 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000933 BTy.getEncoding());
934
935 // Add name if not anonymous or intermediate type.
Devang Patel7f75bbe2009-11-25 17:36:49 +0000936 if (!Name.empty())
Devang Patelc50078e2009-11-21 02:48:08 +0000937 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000938 uint64_t Size = BTy.getSizeInBits() >> 3;
Devang Patelc50078e2009-11-21 02:48:08 +0000939 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000940}
941
Devang Patelc50078e2009-11-21 02:48:08 +0000942/// constructTypeDIE - Construct derived type die from DIDerivedType.
Devang Patelfe0be132009-12-09 18:24:21 +0000943void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000944 // Get core information.
Devang Patel7f75bbe2009-11-25 17:36:49 +0000945 StringRef Name = DTy.getName();
Bill Wendlingb12b3d72009-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 Patelfe0be132009-12-09 18:24:21 +0000956 addType(&Buffer, FromTy);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000957
958 // Add name if not anonymous or intermediate type.
Devang Patel76b80672009-11-30 23:56:56 +0000959 if (!Name.empty())
Devang Patelc50078e2009-11-21 02:48:08 +0000960 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000961
962 // Add size if non-zero (derived types might be zero-sized.)
963 if (Size)
Devang Patelc50078e2009-11-21 02:48:08 +0000964 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000965
966 // Add source line info if available and TyDesc is not a forward declaration.
Devang Patelb125c6e2009-11-23 18:43:37 +0000967 if (!DTy.isForwardDecl())
Devang Patelc50078e2009-11-21 02:48:08 +0000968 addSourceLine(&Buffer, &DTy);
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000969}
970
Devang Patelc50078e2009-11-21 02:48:08 +0000971/// constructTypeDIE - Construct type DIE from DICompositeType.
Devang Patelfe0be132009-12-09 18:24:21 +0000972void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
Bill Wendlingb12b3d72009-05-15 09:23:25 +0000973 // Get core information.
Devang Patel7f75bbe2009-11-25 17:36:49 +0000974 StringRef Name = CTy.getName();
Bill Wendlingb12b3d72009-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 Patelfe0be132009-12-09 18:24:21 +0000983 constructArrayTypeDIE(Buffer, &CTy);
Bill Wendlingb12b3d72009-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 Patel19302aa2010-05-07 18:11:54 +0000991 DIDescriptor Enum(Elements.getElement(i));
Devang Patel9e592492010-03-08 20:52:55 +0000992 if (Enum.isEnumerator()) {
Devang Patel19302aa2010-05-07 18:11:54 +0000993 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
Devang Patelc50078e2009-11-21 02:48:08 +0000994 Buffer.addChild(ElemDie);
Devang Patelfb812752009-10-09 17:51:49 +0000995 }
Bill Wendlingb12b3d72009-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 Patel19302aa2010-05-07 18:11:54 +00001003 addType(&Buffer, DIType(RTy));
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001004
1005 // Add prototype flag.
Devang Patelc50078e2009-11-21 02:48:08 +00001006 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Bill Wendlingb12b3d72009-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 Patel19302aa2010-05-07 18:11:54 +00001012 addType(Arg, DIType(Ty));
Devang Patelc50078e2009-11-21 02:48:08 +00001013 Buffer.addChild(Arg);
Bill Wendlingb12b3d72009-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 Patel9e592492010-03-08 20:52:55 +00001024 unsigned N = Elements.getNumElements();
1025 if (N == 0)
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001026 break;
1027
1028 // Add elements to structure type.
Devang Patel9e592492010-03-08 20:52:55 +00001029 for (unsigned i = 0; i < N; ++i) {
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001030 DIDescriptor Element = Elements.getElement(i);
1031 DIE *ElemDie = NULL;
Devang Patel9e592492010-03-08 20:52:55 +00001032 if (Element.isSubprogram())
Devang Patel19302aa2010-05-07 18:11:54 +00001033 ElemDie = createSubprogramDIE(DISubprogram(Element));
Devang Patel9e592492010-03-08 20:52:55 +00001034 else if (Element.isVariable()) {
Devang Patel19302aa2010-05-07 18:11:54 +00001035 DIVariable DV(Element);
Devang Patel423dfa02010-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 Patel9e592492010-03-08 20:52:55 +00001043 } else if (Element.isDerivedType())
Devang Patel19302aa2010-05-07 18:11:54 +00001044 ElemDie = createMemberDIE(DIDerivedType(Element));
Devang Patel9e592492010-03-08 20:52:55 +00001045 else
1046 continue;
Devang Patelc50078e2009-11-21 02:48:08 +00001047 Buffer.addChild(ElemDie);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001048 }
1049
Devang Patel20b32102009-08-27 23:51:51 +00001050 if (CTy.isAppleBlockExtension())
Devang Patelc50078e2009-11-21 02:48:08 +00001051 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001052
1053 unsigned RLang = CTy.getRunTimeLang();
1054 if (RLang)
Devang Patelc50078e2009-11-21 02:48:08 +00001055 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001056 dwarf::DW_FORM_data1, RLang);
Devang Patel5ae52402010-01-26 21:16:06 +00001057
1058 DICompositeType ContainingType = CTy.getContainingType();
Devang Patel19302aa2010-05-07 18:11:54 +00001059 if (DIDescriptor(ContainingType).isCompositeType())
Devang Patel5ae52402010-01-26 21:16:06 +00001060 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
Devang Patel19302aa2010-05-07 18:11:54 +00001061 getOrCreateTypeDIE(DIType(ContainingType)));
Stuart Hastingsaa685d62010-06-11 20:08:44 +00001062 else {
1063 DIDescriptor Context = CTy.getContext();
1064 addToContextOwner(&Buffer, Context);
1065 }
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001066 break;
1067 }
1068 default:
1069 break;
1070 }
1071
1072 // Add name if not anonymous or intermediate type.
Devang Patel7f75bbe2009-11-25 17:36:49 +00001073 if (!Name.empty())
Devang Patelc50078e2009-11-21 02:48:08 +00001074 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001075
Devang Patel84afdd52010-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 Wendlingb12b3d72009-05-15 09:23:25 +00001079 // Add size if non-zero (derived types might be zero-sized.)
1080 if (Size)
Devang Patelc50078e2009-11-21 02:48:08 +00001081 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001082 else {
1083 // Add zero size if it is not a forward declaration.
1084 if (CTy.isForwardDecl())
Devang Patelc50078e2009-11-21 02:48:08 +00001085 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001086 else
Devang Patelc50078e2009-11-21 02:48:08 +00001087 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001088 }
1089
1090 // Add source line info if available.
1091 if (!CTy.isForwardDecl())
Devang Patelc50078e2009-11-21 02:48:08 +00001092 addSourceLine(&Buffer, &CTy);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001093 }
1094}
1095
Devang Patelc50078e2009-11-21 02:48:08 +00001096/// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1097void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
Bill Wendlingb12b3d72009-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 Patelc50078e2009-11-21 02:48:08 +00001102 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
Devang Patele7ff5092009-08-14 20:59:16 +00001103 if (L)
Devang Patelc50078e2009-11-21 02:48:08 +00001104 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
Devang Pateld3df6972009-12-04 23:10:24 +00001105 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001106
Devang Patelc50078e2009-11-21 02:48:08 +00001107 Buffer.addChild(DW_Subrange);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001108}
1109
Devang Patelc50078e2009-11-21 02:48:08 +00001110/// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
Devang Patelfe0be132009-12-09 18:24:21 +00001111void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
Bill Wendlingb12b3d72009-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 Patelc50078e2009-11-21 02:48:08 +00001115 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001116
1117 // Emit derived type.
Devang Patelfe0be132009-12-09 18:24:21 +00001118 addType(&Buffer, CTy->getTypeDerivedFrom());
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001119 DIArray Elements = CTy->getTypeArray();
1120
Devang Patel1233f912009-11-21 00:31:03 +00001121 // Get an anonymous type for index type.
Devang Patel7e5a86e2010-05-10 22:49:55 +00001122 CompileUnit *TheCU = getCompileUnit(*CTy);
1123 DIE *IdxTy = TheCU->getIndexTyDie();
Devang Patel1233f912009-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 Patelc50078e2009-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 Patel1233f912009-11-21 00:31:03 +00001129 dwarf::DW_ATE_signed);
Devang Patel7e5a86e2010-05-10 22:49:55 +00001130 TheCU->addDie(IdxTy);
1131 TheCU->setIndexTyDie(IdxTy);
Devang Patel1233f912009-11-21 00:31:03 +00001132 }
Bill Wendlingb12b3d72009-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 Patel19302aa2010-05-07 18:11:54 +00001138 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001139 }
1140}
1141
Devang Patelc50078e2009-11-21 02:48:08 +00001142/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
Devang Patel9e592492010-03-08 20:52:55 +00001143DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001144 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
Devang Patel9e592492010-03-08 20:52:55 +00001145 StringRef Name = ETy.getName();
Devang Patelc50078e2009-11-21 02:48:08 +00001146 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Devang Patel9e592492010-03-08 20:52:55 +00001147 int64_t Value = ETy.getEnumValue();
Devang Patelc50078e2009-11-21 02:48:08 +00001148 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001149 return Enumerator;
1150}
1151
Devang Patel141e1c42010-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 Patelc50078e2009-11-21 02:48:08 +00001162/// createGlobalVariableDIE - Create new DIE using GV.
Devang Patelfe0be132009-12-09 18:24:21 +00001163DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
Jim Grosbachb23f2422009-11-22 19:20:36 +00001164 // If the global variable was optmized out then no need to create debug info
1165 // entry.
Devang Patel83e42c72009-11-06 17:58:12 +00001166 if (!GV.getGlobal()) return NULL;
Devang Patel7f75bbe2009-11-25 17:36:49 +00001167 if (GV.getDisplayName().empty()) return NULL;
Devang Patelfabc47c2009-11-06 01:30:04 +00001168
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001169 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
Jim Grosbach652b7432009-11-21 23:12:12 +00001170 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
Devang Patelaaf012e2009-09-29 18:40:58 +00001171 GV.getDisplayName());
1172
Devang Patel7f75bbe2009-11-25 17:36:49 +00001173 StringRef LinkageName = GV.getLinkageName();
Devang Patel141e1c42010-01-05 01:46:14 +00001174 if (!LinkageName.empty())
Devang Patelc50078e2009-11-21 02:48:08 +00001175 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
Devang Patel141e1c42010-01-05 01:46:14 +00001176 getRealLinkageName(LinkageName));
1177
Devang Patelfe0be132009-12-09 18:24:21 +00001178 addType(GVDie, GV.getType());
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001179 if (!GV.isLocalToUnit())
Devang Patelc50078e2009-11-21 02:48:08 +00001180 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1181 addSourceLine(GVDie, &GV);
Devang Patel6bd5cc82009-10-05 23:22:08 +00001182
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001183 return GVDie;
1184}
1185
Devang Patelc50078e2009-11-21 02:48:08 +00001186/// createMemberDIE - Create new member DIE.
Devang Patelfe0be132009-12-09 18:24:21 +00001187DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001188 DIE *MemberDie = new DIE(DT.getTag());
Devang Patel7f75bbe2009-11-25 17:36:49 +00001189 StringRef Name = DT.getName();
1190 if (!Name.empty())
Devang Patelc50078e2009-11-21 02:48:08 +00001191 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
Devang Patel7f75bbe2009-11-25 17:36:49 +00001192
Devang Patelfe0be132009-12-09 18:24:21 +00001193 addType(MemberDie, DT.getTypeDerivedFrom());
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001194
Devang Patelc50078e2009-11-21 02:48:08 +00001195 addSourceLine(MemberDie, &DT);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001196
Benjamin Kramer138c7ff2010-03-31 19:34:01 +00001197 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
Devang Patelc50078e2009-11-21 02:48:08 +00001198 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
Devang Patel7d9fe582009-11-04 22:06:12 +00001199
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001200 uint64_t Size = DT.getSizeInBits();
Devang Patel71842a92009-11-04 23:48:00 +00001201 uint64_t FieldSize = DT.getOriginalTypeSize();
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001202
1203 if (Size != FieldSize) {
1204 // Handle bitfield.
Devang Patelc50078e2009-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 Wendlingb12b3d72009-05-15 09:23:25 +00001207
1208 uint64_t Offset = DT.getOffsetInBits();
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001209 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1210 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
Benjamin Kramer631e3e32010-01-07 17:50:57 +00001211 uint64_t FieldOffset = (HiMark - FieldSize);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001212 Offset -= FieldOffset;
1213
1214 // Maybe we need to work from the other end.
Chris Lattnerbc0027b2010-04-05 00:13:49 +00001215 if (Asm->getTargetData().isLittleEndian())
1216 Offset = FieldSize - (Offset + Size);
Devang Patelc50078e2009-11-21 02:48:08 +00001217 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001218
Devang Patel7d9fe582009-11-04 22:06:12 +00001219 // Here WD_AT_data_member_location points to the anonymous
1220 // field that includes this bit field.
Devang Patelc50078e2009-11-21 02:48:08 +00001221 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
Devang Patel7d9fe582009-11-04 22:06:12 +00001222
1223 } else
1224 // This is not a bitfield.
Devang Patelc50078e2009-11-21 02:48:08 +00001225 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
Devang Patel7d9fe582009-11-04 22:06:12 +00001226
Devang Patel84aba942010-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 Kramer138c7ff2010-03-31 19:34:01 +00001234 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
Devang Patel84aba942010-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 Wendlingb12b3d72009-05-15 09:23:25 +00001247
1248 if (DT.isProtected())
Devang Patel188c85d2009-12-03 19:11:07 +00001249 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001250 dwarf::DW_ACCESS_protected);
1251 else if (DT.isPrivate())
Devang Patel188c85d2009-12-03 19:11:07 +00001252 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001253 dwarf::DW_ACCESS_private);
Devang Patel188c85d2009-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 Wendlingb12b3d72009-05-15 09:23:25 +00001260 return MemberDie;
1261}
1262
Devang Patel814a12c2009-12-14 16:18:45 +00001263/// createSubprogramDIE - Create new DIE using SP.
1264DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
Devang Patel7e5a86e2010-05-10 22:49:55 +00001265 CompileUnit *SPCU = getCompileUnit(SP);
1266 DIE *SPDie = SPCU->getDIE(SP);
Devang Patel814a12c2009-12-14 16:18:45 +00001267 if (SPDie)
1268 return SPDie;
1269
1270 SPDie = new DIE(dwarf::DW_TAG_subprogram);
Devang Patel36cd9f82010-03-02 17:58:15 +00001271 // Constructors and operators for anonymous aggregates do not have names.
Devang Patel0ab194f2010-03-02 01:26:20 +00001272 if (!SP.getName().empty())
1273 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001274
Devang Patel7f75bbe2009-11-25 17:36:49 +00001275 StringRef LinkageName = SP.getLinkageName();
Devang Patel141e1c42010-01-05 01:46:14 +00001276 if (!LinkageName.empty())
Devang Patelc50078e2009-11-21 02:48:08 +00001277 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
Devang Patel141e1c42010-01-05 01:46:14 +00001278 getRealLinkageName(LinkageName));
1279
Devang Patelc50078e2009-11-21 02:48:08 +00001280 addSourceLine(SPDie, &SP);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001281
Bill Wendlingb12b3d72009-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 Patelc50078e2009-11-21 02:48:08 +00001286 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001287
1288 // Add Return Type.
Devang Patelc1df8792009-12-03 01:25:38 +00001289 DICompositeType SPTy = SP.getType();
1290 DIArray Args = SPTy.getTypeArray();
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001291 unsigned SPTag = SPTy.getTag();
Devang Patel188c85d2009-12-03 19:11:07 +00001292
Devang Patel9e592492010-03-08 20:52:55 +00001293 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
Devang Patelfe0be132009-12-09 18:24:21 +00001294 addType(SPDie, SPTy);
Devang Patelc1df8792009-12-03 01:25:38 +00001295 else
Devang Patel19302aa2010-05-07 18:11:54 +00001296 addType(SPDie, DIType(Args.getElement(0)));
Devang Patelc1df8792009-12-03 01:25:38 +00001297
Devang Patel188c85d2009-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 Kramer138c7ff2010-03-31 19:34:01 +00001301 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel188c85d2009-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 Patel7d707f92010-01-19 06:19:05 +00001305 ContainingTypeMap.insert(std::make_pair(SPDie,
Devang Patel19302aa2010-05-07 18:11:54 +00001306 SP.getContainingType()));
Devang Patel188c85d2009-12-03 19:11:07 +00001307 }
1308
Devang Patel814a12c2009-12-14 16:18:45 +00001309 if (MakeDecl || !SP.isDefinition()) {
Devang Patelc50078e2009-11-21 02:48:08 +00001310 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001311
1312 // Add arguments. Do not add arguments for subprogram definition. They will
Devang Patelc1df8792009-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 Wendlingb12b3d72009-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 Patel19302aa2010-05-07 18:11:54 +00001321 DIType ATy = DIType(DIType(Args.getElement(i)));
Devang Patelc5dc7252010-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 Patelc50078e2009-11-21 02:48:08 +00001325 SPDie->addChild(Arg);
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001326 }
1327 }
1328
Devang Patelbf7d00a2010-02-03 19:57:19 +00001329 if (SP.isArtificial())
1330 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1331
Devang Patel9e3b7ae2010-04-30 19:38:23 +00001332 if (!SP.isLocalToUnit())
1333 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
Devang Patel91474172010-04-19 19:14:02 +00001334
Devang Patel9e3b7ae2010-04-30 19:38:23 +00001335 if (SP.isOptimized())
1336 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1337
Devang Patel9e3b7ae2010-04-30 19:38:23 +00001338 // DW_TAG_inlined_subroutine may refer to this DIE.
Devang Patel7e5a86e2010-05-10 22:49:55 +00001339 SPCU->insertDIE(SP, SPDie);
Devang Patel9e3b7ae2010-04-30 19:38:23 +00001340
Stuart Hastingsaa685d62010-06-11 20:08:44 +00001341 // Add to context owner.
1342 addToContextOwner(SPDie, SP.getContext());
1343
Bill Wendlingb12b3d72009-05-15 09:23:25 +00001344 return SPDie;
1345}
1346
Devang Patel9c371c62010-05-07 20:54:48 +00001347DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
Chris Lattner8143ce82010-03-31 05:36:29 +00001348 assert(N && "Invalid Scope encoding!");
Devang Patel90a0fe32009-11-10 23:06:00 +00001349
1350 DbgScope *AScope = AbstractScopes.lookup(N);
1351 if (AScope)
1352 return AScope;
Jim Grosbach652b7432009-11-21 23:12:12 +00001353
Devang Patel90a0fe32009-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 Patel19302aa2010-05-07 18:11:54 +00001360 Parent = getOrCreateAbstractScope(ParentDesc);
Devang Patel90a0fe32009-11-10 23:06:00 +00001361 }
1362
1363 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1364
1365 if (Parent)
Devang Patelc50078e2009-11-21 02:48:08 +00001366 Parent->addScope(AScope);
Devang Patel90a0fe32009-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 Patel6a260102009-10-01 20:31:14 +00001373
Devang Patel75c10622010-04-06 23:53:48 +00001374/// isSubprogramContext - Return true if Context is either a subprogram
1375/// or another context nested inside a subprogram.
Devang Patel9c371c62010-05-07 20:54:48 +00001376static bool isSubprogramContext(const MDNode *Context) {
Devang Patel75c10622010-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 Patel19302aa2010-05-07 18:11:54 +00001383 return isSubprogramContext(DIType(Context).getContext());
Devang Patel75c10622010-04-06 23:53:48 +00001384 return false;
1385}
1386
Jim Grosbach652b7432009-11-21 23:12:12 +00001387/// updateSubprogramScopeDIE - Find DIE for the given subprogram and
Devang Patelc50078e2009-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 Patel9c371c62010-05-07 20:54:48 +00001391DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
Devang Patel7e5a86e2010-05-10 22:49:55 +00001392 CompileUnit *SPCU = getCompileUnit(SPNode);
1393 DIE *SPDie = SPCU->getDIE(SPNode);
Devang Patel82aaace2010-07-07 22:20:57 +00001394
Chris Lattnerbc0027b2010-04-05 00:13:49 +00001395 assert(SPDie && "Unable to find subprogram DIE!");
1396 DISubprogram SP(SPNode);
Chris Lattnerdd21da82010-03-13 07:26:18 +00001397
Chris Lattnerbc0027b2010-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 Patel75c10622010-04-06 23:53:48 +00001404 !SP.getContext().isFile() &&
Devang Patel19302aa2010-05-07 18:11:54 +00001405 !isSubprogramContext(SP.getContext())) {
Chris Lattnerbc0027b2010-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 Patel19302aa2010-05-07 18:11:54 +00001415 DIType ATy = DIType(DIType(Args.getElement(i)));
Chris Lattnerbc0027b2010-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 Patel7e5a86e2010-05-10 22:49:55 +00001425 SPCU->addDie(SPDie);
Chris Lattnerbc0027b2010-04-05 00:13:49 +00001426 }
1427
Devang Patel82aaace2010-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 Lattnerbc0027b2010-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 Patelc5dc7252010-02-06 01:02:37 +00001443
Chris Lattnerbc0027b2010-04-05 00:13:49 +00001444 return SPDie;
Devang Patel90a0fe32009-11-10 23:06:00 +00001445}
1446
Jim Grosbach652b7432009-11-21 23:12:12 +00001447/// constructLexicalScope - Construct new DW_TAG_lexical_block
Devang Patelc50078e2009-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 Patelce7bf012010-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 Patel12188d52010-05-25 23:40:22 +00001468 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1469 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
Devang Patelce7bf012010-04-27 19:46:33 +00001470 }
1471 DebugRangeSymbols.push_back(NULL);
1472 DebugRangeSymbols.push_back(NULL);
1473 return ScopeDIE;
1474 }
1475
Devang Patel12188d52010-05-25 23:40:22 +00001476 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1477 const MCSymbol *End = getLabelAfterInsn(RI->second);
Devang Patelce7bf012010-04-27 19:46:33 +00001478
Devang Patel12188d52010-05-25 23:40:22 +00001479 if (End == 0) return 0;
Devang Patel90a0fe32009-11-10 23:06:00 +00001480
Chris Lattner855e8f52010-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 Lattner5e423432010-03-09 01:51:43 +00001483
Devang Patelce7bf012010-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 Patel90a0fe32009-11-10 23:06:00 +00001486
1487 return ScopeDIE;
1488}
1489
Devang Patelc50078e2009-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 Patelce7bf012010-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 Patel12188d52010-05-25 23:40:22 +00001504 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1505 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
Devang Patelce7bf012010-04-27 19:46:33 +00001506
Devang Patel1b2773b2010-07-08 22:39:20 +00001507 if (StartLabel == 0 || EndLabel == 0) {
Devang Patelce7bf012010-04-27 19:46:33 +00001508 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1509 return 0;
1510 }
Chris Lattner855e8f52010-03-09 01:58:53 +00001511 assert(StartLabel->isDefined() &&
Chris Lattner5e423432010-03-09 01:51:43 +00001512 "Invalid starting label for an inlined scope!");
Chris Lattner855e8f52010-03-09 01:58:53 +00001513 assert(EndLabel->isDefined() &&
Chris Lattner5e423432010-03-09 01:51:43 +00001514 "Invalid end label for an inlined scope!");
Devang Patelce7bf012010-04-27 19:46:33 +00001515
Devang Patel9e592492010-03-08 20:52:55 +00001516 if (!Scope->getScopeNode())
Devang Patelbe149872010-03-08 19:20:38 +00001517 return NULL;
Devang Patel9e592492010-03-08 20:52:55 +00001518 DIScope DS(Scope->getScopeNode());
Devang Patel90a0fe32009-11-10 23:06:00 +00001519 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1520
Devang Patel19302aa2010-05-07 18:11:54 +00001521 DISubprogram InlinedSP = getDISubprogram(DS);
Devang Patel7e5a86e2010-05-10 22:49:55 +00001522 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1523 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
Chris Lattner8143ce82010-03-31 05:36:29 +00001524 assert(OriginDIE && "Unable to find Origin DIE!");
Devang Patelc50078e2009-11-21 02:48:08 +00001525 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
Devang Patel90a0fe32009-11-10 23:06:00 +00001526 dwarf::DW_FORM_ref4, OriginDIE);
1527
Chris Lattneread58652010-03-09 00:31:02 +00001528 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
Chris Lattner855e8f52010-03-09 01:58:53 +00001529 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
Devang Patel90a0fe32009-11-10 23:06:00 +00001530
1531 InlinedSubprogramDIEs.insert(OriginDIE);
1532
1533 // Track the start label for this inlined function.
Devang Patel9c371c62010-05-07 20:54:48 +00001534 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
Devang Patel19302aa2010-05-07 18:11:54 +00001535 I = InlineInfo.find(InlinedSP);
Devang Patel90a0fe32009-11-10 23:06:00 +00001536
1537 if (I == InlineInfo.end()) {
Devang Patel19302aa2010-05-07 18:11:54 +00001538 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
Jim Grosbachb23f2422009-11-22 19:20:36 +00001539 ScopeDIE));
Devang Patel19302aa2010-05-07 18:11:54 +00001540 InlinedSPNodes.push_back(InlinedSP);
Devang Patel90a0fe32009-11-10 23:06:00 +00001541 } else
Chris Lattneread58652010-03-09 00:31:02 +00001542 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
Devang Patel90a0fe32009-11-10 23:06:00 +00001543
Devang Patel90a0fe32009-11-10 23:06:00 +00001544 DILocation DL(Scope->getInlinedAt());
Devang Patel7e5a86e2010-05-10 22:49:55 +00001545 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
Devang Patelc50078e2009-11-21 02:48:08 +00001546 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
Devang Patel90a0fe32009-11-10 23:06:00 +00001547
1548 return ScopeDIE;
1549}
1550
Devang Patelc50078e2009-11-21 02:48:08 +00001551
1552/// constructVariableDIE - Construct a DIE for the given DbgVariable.
Devang Patelfe0be132009-12-09 18:24:21 +00001553DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
Devang Patel90a0fe32009-11-10 23:06:00 +00001554 // Get the descriptor.
1555 const DIVariable &VD = DV->getVariable();
Devang Patel7f75bbe2009-11-25 17:36:49 +00001556 StringRef Name = VD.getName();
1557 if (Name.empty())
Devang Patelab9a0682009-11-13 02:25:26 +00001558 return NULL;
Devang Patel90a0fe32009-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 Patel90a0fe32009-11-10 23:06:00 +00001578 DIE *AbsDIE = NULL;
Devang Patelf0e70332010-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 Grosbach652b7432009-11-21 23:12:12 +00001583
Devang Patelf0e70332010-05-20 16:36:41 +00001584 if (AbsDIE)
Devang Patelc50078e2009-11-21 02:48:08 +00001585 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
Devang Patel90a0fe32009-11-10 23:06:00 +00001586 dwarf::DW_FORM_ref4, AbsDIE);
Devang Patel90a0fe32009-11-10 23:06:00 +00001587 else {
Devang Patelc50078e2009-11-21 02:48:08 +00001588 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1589 addSourceLine(VariableDie, &VD);
Devang Patel90a0fe32009-11-10 23:06:00 +00001590
1591 // Add variable type.
Jim Grosbach652b7432009-11-21 23:12:12 +00001592 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
Devang Patel90a0fe32009-11-10 23:06:00 +00001593 // addresses instead.
1594 if (VD.isBlockByrefVariable())
Devang Patelfe0be132009-12-09 18:24:21 +00001595 addType(VariableDie, getBlockByrefType(VD.getType(), Name));
Devang Patel90a0fe32009-11-10 23:06:00 +00001596 else
Devang Patelfe0be132009-12-09 18:24:21 +00001597 addType(VariableDie, VD.getType());
Devang Patel90a0fe32009-11-10 23:06:00 +00001598 }
1599
Devang Patelc5dc7252010-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 Patel12188d52010-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 Patel84afdd52010-07-07 20:12:52 +00001629 updated =
1630 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
Devang Patel12188d52010-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 Patel84afdd52010-07-07 20:12:52 +00001634 updated =
1635 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
Devang Patel12188d52010-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 Patel90a0fe32009-11-10 23:06:00 +00001672 DV->setDIE(VariableDie);
1673 return VariableDie;
1674
1675}
Devang Patelc50078e2009-11-21 02:48:08 +00001676
Devang Patelec13b4f2009-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 Patelec13b4f2009-11-24 01:14:22 +00001684 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
Devang Patel19302aa2010-05-07 18:11:54 +00001685 DIType ATy(Args.getElement(i));
Devang Patel9738af92010-05-07 21:45:47 +00001686 if (!ATy.Verify())
Devang Patelec13b4f2009-11-24 01:14:22 +00001687 continue;
1688 DICompositeType CATy = getDICompositeType(ATy);
Devang Patel19302aa2010-05-07 18:11:54 +00001689 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
Devang Patel21171c22010-04-13 20:35:04 +00001690 && !CATy.isForwardDecl()) {
Devang Patel7e5a86e2010-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 Patelec13b4f2009-11-24 01:14:22 +00001694 }
1695 }
1696}
1697
Devang Patelc50078e2009-11-21 02:48:08 +00001698/// constructScopeDIE - Construct a DIE for this scope.
1699DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
Devang Patel9e592492010-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 Patel50d17d22010-06-28 20:53:04 +00001708 ProcessedSPNodes.insert(DS);
Devang Patel82aaace2010-07-07 22:20:57 +00001709 if (Scope->isAbstractScope()) {
Devang Patel7e5a86e2010-05-10 22:49:55 +00001710 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
Devang Patel82aaace2010-07-07 22:20:57 +00001711 // Note down abstract DIE.
1712 if (ScopeDIE)
1713 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1714 }
Devang Patel9e592492010-03-08 20:52:55 +00001715 else
Devang Patel19302aa2010-05-07 18:11:54 +00001716 ScopeDIE = updateSubprogramScopeDIE(DS);
Devang Patel9e592492010-03-08 20:52:55 +00001717 }
Devang Patel9a9a4ac2010-03-29 22:59:58 +00001718 else
Devang Patel9e592492010-03-08 20:52:55 +00001719 ScopeDIE = constructLexicalScopeDIE(Scope);
Devang Patel9a9a4ac2010-03-29 22:59:58 +00001720 if (!ScopeDIE) return NULL;
Devang Patel9e592492010-03-08 20:52:55 +00001721
Devang Patel90a0fe32009-11-10 23:06:00 +00001722 // Add variables to scope.
Jeffrey Yasskinecca2e62010-03-12 17:45:06 +00001723 const SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
Devang Patel90a0fe32009-11-10 23:06:00 +00001724 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
Devang Patelfe0be132009-12-09 18:24:21 +00001725 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
Jim Grosbach652b7432009-11-21 23:12:12 +00001726 if (VariableDIE)
Devang Patelc50078e2009-11-21 02:48:08 +00001727 ScopeDIE->addChild(VariableDIE);
Devang Patel90a0fe32009-11-10 23:06:00 +00001728 }
1729
1730 // Add nested scopes.
Jeffrey Yasskinecca2e62010-03-12 17:45:06 +00001731 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
Devang Patel90a0fe32009-11-10 23:06:00 +00001732 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1733 // Define the Scope debug information entry.
Devang Patelc50078e2009-11-21 02:48:08 +00001734 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
Jim Grosbach652b7432009-11-21 23:12:12 +00001735 if (NestedDIE)
Devang Patelc50078e2009-11-21 02:48:08 +00001736 ScopeDIE->addChild(NestedDIE);
Devang Patel90a0fe32009-11-10 23:06:00 +00001737 }
Devang Patelec13b4f2009-11-24 01:14:22 +00001738
1739 if (DS.isSubprogram())
Devang Patel19302aa2010-05-07 18:11:54 +00001740 addPubTypes(DISubprogram(DS));
Devang Patelec13b4f2009-11-24 01:14:22 +00001741
1742 return ScopeDIE;
Devang Patel90a0fe32009-11-10 23:06:00 +00001743}
1744
Bill Wendlingf5839192009-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 Lattner5df82552010-03-31 06:06:37 +00001749unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
Bill Wendlingf5839192009-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 Patel8287d662009-12-15 19:16:48 +00001782/// getOrCreateNameSpace - Create a DIE for DINameSpace.
1783DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
Devang Patel7e5a86e2010-05-10 22:49:55 +00001784 CompileUnit *TheCU = getCompileUnit(NS);
1785 DIE *NDie = TheCU->getDIE(NS);
Devang Patel8287d662009-12-15 19:16:48 +00001786 if (NDie)
1787 return NDie;
1788 NDie = new DIE(dwarf::DW_TAG_namespace);
Devang Patel7e5a86e2010-05-10 22:49:55 +00001789 TheCU->insertDIE(NS, NDie);
Devang Patel8287d662009-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 Patel7e5a86e2010-05-10 22:49:55 +00001797/// constructCompileUnit - Create new CompileUnit for the given
1798/// metadata node with tag DW_TAG_compile_unit.
Devang Patel9c371c62010-05-07 20:54:48 +00001799void DwarfDebug::constructCompileUnit(const MDNode *N) {
Devang Patel15e723d2009-08-28 23:24:31 +00001800 DICompileUnit DIUnit(N);
Devang Patel7f75bbe2009-11-25 17:36:49 +00001801 StringRef FN = DIUnit.getFilename();
1802 StringRef Dir = DIUnit.getDirectory();
Devang Patelaaf012e2009-09-29 18:40:58 +00001803 unsigned ID = GetOrCreateSourceID(Dir, FN);
Bill Wendlingf5839192009-05-20 23:19:06 +00001804
1805 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
Devang Patelc50078e2009-11-21 02:48:08 +00001806 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
Devang Patelaaf012e2009-09-29 18:40:58 +00001807 DIUnit.getProducer());
Devang Patelc50078e2009-11-21 02:48:08 +00001808 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
Bill Wendlingf5839192009-05-20 23:19:06 +00001809 DIUnit.getLanguage());
Devang Patelc50078e2009-11-21 02:48:08 +00001810 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
Devang Patel325691a2010-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 Patelefc6c9e2010-06-28 22:22:47 +00001813 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
Devang Patel7ac39832010-03-22 23:11:36 +00001814 // DW_AT_stmt_list is a offset of line number information for this
Devang Pateldd385062010-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 Wendlingf5839192009-05-20 23:19:06 +00001818
Devang Patel7f75bbe2009-11-25 17:36:49 +00001819 if (!Dir.empty())
Devang Patelc50078e2009-11-21 02:48:08 +00001820 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
Bill Wendlingf5839192009-05-20 23:19:06 +00001821 if (DIUnit.isOptimized())
Devang Patelc50078e2009-11-21 02:48:08 +00001822 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
Bill Wendlingf5839192009-05-20 23:19:06 +00001823
Devang Patel7f75bbe2009-11-25 17:36:49 +00001824 StringRef Flags = DIUnit.getFlags();
1825 if (!Flags.empty())
Devang Patelc50078e2009-11-21 02:48:08 +00001826 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
Bill Wendlingf5839192009-05-20 23:19:06 +00001827
1828 unsigned RVer = DIUnit.getRunTimeVersion();
1829 if (RVer)
Devang Patelc50078e2009-11-21 02:48:08 +00001830 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
Bill Wendlingf5839192009-05-20 23:19:06 +00001831 dwarf::DW_FORM_data1, RVer);
1832
Devang Patel7e5a86e2010-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 Wendlingf5839192009-05-20 23:19:06 +00001837}
1838
Devang Patel7e5a86e2010-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 Patel9c371c62010-05-07 20:54:48 +00001870void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
Devang Patel15e723d2009-08-28 23:24:31 +00001871 DIGlobalVariable DI_GV(N);
Daniel Dunbar41716322009-09-19 20:40:05 +00001872
Devang Patel0c03f062009-09-04 23:59:07 +00001873 // If debug information is malformed then ignore it.
1874 if (DI_GV.Verify() == false)
1875 return;
Bill Wendlingf5839192009-05-20 23:19:06 +00001876
1877 // Check for pre-existence.
Devang Patel7e5a86e2010-05-10 22:49:55 +00001878 CompileUnit *TheCU = getCompileUnit(N);
1879 if (TheCU->getDIE(DI_GV))
Devang Patel166f8432009-06-26 01:49:18 +00001880 return;
Bill Wendlingf5839192009-05-20 23:19:06 +00001881
Devang Patelfe0be132009-12-09 18:24:21 +00001882 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
Devang Patel6d479632009-12-10 23:25:41 +00001883 if (!VariableDie)
1884 return;
Bill Wendlingf5839192009-05-20 23:19:06 +00001885
Bill Wendlingf5839192009-05-20 23:19:06 +00001886 // Add to map.
Devang Patel7e5a86e2010-05-10 22:49:55 +00001887 TheCU->insertDIE(N, VariableDie);
Bill Wendlingf5839192009-05-20 23:19:06 +00001888
1889 // Add to context owner.
Devang Pateldcc0dce2010-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 Lattner5df82552010-03-31 06:06:37 +00001893 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
Devang Patel75c10622010-04-06 23:53:48 +00001894 !GVContext.isFile() &&
Devang Patel19302aa2010-05-07 18:11:54 +00001895 !isSubprogramContext(GVContext)) {
Devang Patel8287d662009-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 Kramer138c7ff2010-03-31 19:34:01 +00001900 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel8287d662009-12-15 19:16:48 +00001901 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
Chris Lattner703d12e2010-03-08 22:31:46 +00001902 addLabel(Block, 0, dwarf::DW_FORM_udata,
Chris Lattner90825792010-03-12 21:09:07 +00001903 Asm->Mang->getSymbol(DI_GV.getGlobal()));
Devang Patel8287d662009-12-15 19:16:48 +00001904 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
Devang Patela0a98582010-02-09 01:58:33 +00001905 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
Devang Patel7e5a86e2010-05-10 22:49:55 +00001906 TheCU->addDie(VariableSpecDIE);
Devang Patel8287d662009-12-15 19:16:48 +00001907 } else {
Benjamin Kramer138c7ff2010-03-31 19:34:01 +00001908 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
Devang Patel8287d662009-12-15 19:16:48 +00001909 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
Chris Lattner703d12e2010-03-08 22:31:46 +00001910 addLabel(Block, 0, dwarf::DW_FORM_udata,
Chris Lattner90825792010-03-12 21:09:07 +00001911 Asm->Mang->getSymbol(DI_GV.getGlobal()));
Devang Patel8287d662009-12-15 19:16:48 +00001912 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1913 }
Devang Pateldcc0dce2010-01-15 01:12:22 +00001914 addToContextOwner(VariableDie, GVContext);
Devang Patel1a8f9a82009-12-10 19:14:49 +00001915
Bill Wendlingf5839192009-05-20 23:19:06 +00001916 // Expose as global. FIXME - need to check external flag.
Devang Patel7e5a86e2010-05-10 22:49:55 +00001917 TheCU->addGlobal(DI_GV.getName(), VariableDie);
Devang Patelec13b4f2009-11-24 01:14:22 +00001918
1919 DIType GTy = DI_GV.getType();
Devang Patel21171c22010-04-13 20:35:04 +00001920 if (GTy.isCompositeType() && !GTy.getName().empty()
1921 && !GTy.isForwardDecl()) {
Devang Patel7e5a86e2010-05-10 22:49:55 +00001922 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
Chris Lattner8143ce82010-03-31 05:36:29 +00001923 assert(Entry && "Missing global type!");
Devang Patel7e5a86e2010-05-10 22:49:55 +00001924 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
Devang Patelec13b4f2009-11-24 01:14:22 +00001925 }
Devang Patel166f8432009-06-26 01:49:18 +00001926 return;
Bill Wendlingf5839192009-05-20 23:19:06 +00001927}
1928
Devang Patel7e5a86e2010-05-10 22:49:55 +00001929/// construct SubprogramDIE - Construct subprogram DIE.
Devang Patel9c371c62010-05-07 20:54:48 +00001930void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
Devang Patel15e723d2009-08-28 23:24:31 +00001931 DISubprogram SP(N);
Bill Wendlingf5839192009-05-20 23:19:06 +00001932
Stuart Hastings0f5779e2010-04-06 21:38:29 +00001933 // Check for pre-existence.
Devang Patel7e5a86e2010-05-10 22:49:55 +00001934 CompileUnit *TheCU = getCompileUnit(N);
1935 if (TheCU->getDIE(N))
Stuart Hastings0f5779e2010-04-06 21:38:29 +00001936 return;
1937
Bill Wendlingf5839192009-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 Patel166f8432009-06-26 01:49:18 +00001941 return;
Bill Wendlingf5839192009-05-20 23:19:06 +00001942
Stuart Hastings0f5779e2010-04-06 21:38:29 +00001943 DIE *SubprogramDie = createSubprogramDIE(SP);
1944
1945 // Add to map.
Devang Patel7e5a86e2010-05-10 22:49:55 +00001946 TheCU->insertDIE(N, SubprogramDie);
Bill Wendlingf5839192009-05-20 23:19:06 +00001947
1948 // Add to context owner.
Devang Patel8287d662009-12-15 19:16:48 +00001949 addToContextOwner(SubprogramDie, SP.getContext());
Devang Patelde2d3682009-12-08 23:21:45 +00001950
Bill Wendlingf5839192009-05-20 23:19:06 +00001951 // Expose as global.
Devang Patel7e5a86e2010-05-10 22:49:55 +00001952 TheCU->addGlobal(SP.getName(), SubprogramDie);
Devang Patelec13b4f2009-11-24 01:14:22 +00001953
Devang Patel166f8432009-06-26 01:49:18 +00001954 return;
Bill Wendlingf5839192009-05-20 23:19:06 +00001955}
1956
Devang Patelc50078e2009-11-21 02:48:08 +00001957/// beginModule - Emit all Dwarf sections that should come prior to the
Daniel Dunbar19f1d442009-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 Lattner75e113c2010-04-04 07:48:20 +00001960void DwarfDebug::beginModule(Module *M) {
Devang Patelce7bf012010-04-27 19:46:33 +00001961 if (DisableDebugInfoPrinting)
1962 return;
1963
Devang Patelfda766d2009-07-30 18:56:46 +00001964 DebugInfoFinder DbgFinder;
1965 DbgFinder.processModule(*M);
Devang Patel166f8432009-06-26 01:49:18 +00001966
Chris Lattnera52b6172010-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 Lattner706afc02010-04-04 23:17:54 +00001984 // Emit initial sections.
Chris Lattnera52b6172010-04-05 02:19:28 +00001985 EmitSectionLabels();
Chris Lattner706afc02010-04-04 23:17:54 +00001986
Bill Wendlingf5839192009-05-20 23:19:06 +00001987 // Create all the compile unit DIEs.
Devang Patelfda766d2009-07-30 18:56:46 +00001988 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1989 E = DbgFinder.compile_unit_end(); I != E; ++I)
Devang Patelc50078e2009-11-21 02:48:08 +00001990 constructCompileUnit(*I);
Bill Wendlingf5839192009-05-20 23:19:06 +00001991
Devang Patel90a0fe32009-11-10 23:06:00 +00001992 // Create DIEs for each subprogram.
Devang Patelfda766d2009-07-30 18:56:46 +00001993 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1994 E = DbgFinder.subprogram_end(); I != E; ++I)
Devang Patelc50078e2009-11-21 02:48:08 +00001995 constructSubprogramDIE(*I);
Devang Patel166f8432009-06-26 01:49:18 +00001996
Devang Patel1a8f9a82009-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 Wendlingf5839192009-05-20 23:19:06 +00002002 // Prime section data.
Chris Lattnerc4c40a92009-07-28 03:13:23 +00002003 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
Bill Wendlingf5839192009-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 Lattnerbc0027b2010-04-05 00:13:49 +00002007 if (Asm->MAI->hasDotLocAndDotFile()) {
Bill Wendlingf5839192009-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 Lattnerad653482010-01-22 22:09:00 +00002011 // FIXME: don't use sys::path for this! This should not depend on the
2012 // host.
Bill Wendlingf5839192009-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 Lattner59be4ea2010-01-25 18:58:59 +00002018 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
Bill Wendlingf5839192009-05-20 23:19:06 +00002019 }
2020 }
Bill Wendlingf5839192009-05-20 23:19:06 +00002021}
2022
Devang Patelc50078e2009-11-21 02:48:08 +00002023/// endModule - Emit all Dwarf sections that should come after the content.
Bill Wendlingf5839192009-05-20 23:19:06 +00002024///
Devang Patelc50078e2009-11-21 02:48:08 +00002025void DwarfDebug::endModule() {
Devang Patel7e5a86e2010-05-10 22:49:55 +00002026 if (!FirstCU) return;
Devang Patel82335072010-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 Patel99fbafe2010-07-19 17:53:55 +00002035 if (!SP.isDefinition()) continue;
Devang Patel82335072010-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 Wendlingf5839192009-05-20 23:19:06 +00002062
Devang Patel90a0fe32009-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 Patelc50078e2009-11-21 02:48:08 +00002067 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
Devang Patel90a0fe32009-11-10 23:06:00 +00002068 }
2069
Devang Patel9c371c62010-05-07 20:54:48 +00002070 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
Devang Patel188c85d2009-12-03 19:11:07 +00002071 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2072 DIE *SPDie = CI->first;
Devang Patel9c371c62010-05-07 20:54:48 +00002073 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
Devang Patel188c85d2009-12-03 19:11:07 +00002074 if (!N) continue;
Devang Patel7e5a86e2010-05-10 22:49:55 +00002075 DIE *NDie = getCompileUnit(N)->getDIE(N);
Devang Patel188c85d2009-12-03 19:11:07 +00002076 if (!NDie) continue;
2077 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
Devang Patel188c85d2009-12-03 19:11:07 +00002078 }
2079
Bill Wendlingf5839192009-05-20 23:19:06 +00002080 // Standard sections final addresses.
Chris Lattner73266f92009-08-19 05:49:37 +00002081 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
Chris Lattnerb93558d2010-04-04 19:25:43 +00002082 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
Chris Lattner73266f92009-08-19 05:49:37 +00002083 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
Chris Lattnerb93558d2010-04-04 19:25:43 +00002084 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
Bill Wendlingf5839192009-05-20 23:19:06 +00002085
2086 // End text sections.
2087 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
Chris Lattner73266f92009-08-19 05:49:37 +00002088 Asm->OutStreamer.SwitchSection(SectionMap[i]);
Chris Lattnerb93558d2010-04-04 19:25:43 +00002089 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
Bill Wendlingf5839192009-05-20 23:19:06 +00002090 }
2091
2092 // Emit common frame information.
Devang Patelc50078e2009-11-21 02:48:08 +00002093 emitCommonDebugFrame();
Bill Wendlingf5839192009-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 Patelc50078e2009-11-21 02:48:08 +00002098 emitFunctionDebugFrame(*I);
Bill Wendlingf5839192009-05-20 23:19:06 +00002099
2100 // Compute DIE offsets and sizes.
Devang Patelc50078e2009-11-21 02:48:08 +00002101 computeSizeAndOffsets();
Bill Wendlingf5839192009-05-20 23:19:06 +00002102
Devang Pateldd385062010-06-29 20:17:53 +00002103 // Emit source line correspondence into a debug line section.
2104 emitDebugLines();
2105
Bill Wendlingf5839192009-05-20 23:19:06 +00002106 // Emit all the DIEs into a debug info section
Devang Patelc50078e2009-11-21 02:48:08 +00002107 emitDebugInfo();
Bill Wendlingf5839192009-05-20 23:19:06 +00002108
2109 // Corresponding abbreviations into a abbrev section.
Devang Patelc50078e2009-11-21 02:48:08 +00002110 emitAbbreviations();
Bill Wendlingf5839192009-05-20 23:19:06 +00002111
Bill Wendlingf5839192009-05-20 23:19:06 +00002112 // Emit info into a debug pubnames section.
Devang Patelc50078e2009-11-21 02:48:08 +00002113 emitDebugPubNames();
Bill Wendlingf5839192009-05-20 23:19:06 +00002114
Devang Patelec13b4f2009-11-24 01:14:22 +00002115 // Emit info into a debug pubtypes section.
2116 emitDebugPubTypes();
2117
Bill Wendlingf5839192009-05-20 23:19:06 +00002118 // Emit info into a debug loc section.
Devang Patelc50078e2009-11-21 02:48:08 +00002119 emitDebugLoc();
Bill Wendlingf5839192009-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 Patelc50078e2009-11-21 02:48:08 +00002125 emitDebugRanges();
Bill Wendlingf5839192009-05-20 23:19:06 +00002126
2127 // Emit info into a debug macinfo section.
Devang Patelc50078e2009-11-21 02:48:08 +00002128 emitDebugMacInfo();
Bill Wendlingf5839192009-05-20 23:19:06 +00002129
2130 // Emit inline info.
Devang Patelc50078e2009-11-21 02:48:08 +00002131 emitDebugInlineInfo();
Bill Wendlingf5839192009-05-20 23:19:06 +00002132
Chris Lattner0f093f82010-03-13 02:17:42 +00002133 // Emit info into a debug str section.
2134 emitDebugStr();
2135
Devang Patel7e5a86e2010-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 Wendlingf5839192009-05-20 23:19:06 +00002140}
2141
Devang Patel90a0fe32009-11-10 23:06:00 +00002142/// findAbstractVariable - Find abstract variable, if any, associated with Var.
Devang Patelf0e70332010-05-20 16:36:41 +00002143DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
Chris Lattnerb9692a72010-04-02 19:42:39 +00002144 DebugLoc ScopeLoc) {
Devang Patel90a0fe32009-11-10 23:06:00 +00002145
Devang Patel19302aa2010-05-07 18:11:54 +00002146 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
Devang Patel90a0fe32009-11-10 23:06:00 +00002147 if (AbsDbgVariable)
2148 return AbsDbgVariable;
2149
Devang Patel19302aa2010-05-07 18:11:54 +00002150 LLVMContext &Ctx = Var->getContext();
Chris Lattnerb9692a72010-04-02 19:42:39 +00002151 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
Devang Patel90a0fe32009-11-10 23:06:00 +00002152 if (!Scope)
2153 return NULL;
2154
Devang Patelf0e70332010-05-20 16:36:41 +00002155 AbsDbgVariable = new DbgVariable(Var);
Devang Patelc50078e2009-11-21 02:48:08 +00002156 Scope->addVariable(AbsDbgVariable);
Devang Patel19302aa2010-05-07 18:11:54 +00002157 AbstractVariables[Var] = AbsDbgVariable;
Devang Patel90a0fe32009-11-10 23:06:00 +00002158 return AbsDbgVariable;
2159}
2160
Devang Patel6da145f2010-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 Lattnerbc0027b2010-04-05 00:13:49 +00002166 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
Devang Patel84139992009-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 Patel9c371c62010-05-07 20:54:48 +00002170 const MDNode *Var = VI->first;
Devang Patel90a0fe32009-11-10 23:06:00 +00002171 if (!Var) continue;
Devang Patelfad01682010-05-14 21:01:35 +00002172 Processed.insert(Var);
Chris Lattnerb9692a72010-04-02 19:42:39 +00002173 DIVariable DV(Var);
2174 const std::pair<unsigned, DebugLoc> &VP = VI->second;
Devang Patel90a0fe32009-11-10 23:06:00 +00002175
Chris Lattnerb9692a72010-04-02 19:42:39 +00002176 DbgScope *Scope = 0;
Devang Patel9c371c62010-05-07 20:54:48 +00002177 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
Chris Lattnerb9692a72010-04-02 19:42:39 +00002178 Scope = ConcreteScopes.lookup(IA);
2179 if (Scope == 0)
2180 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2181
Devang Patelbad42262009-11-10 23:20:04 +00002182 // If variable scope is not found then skip this variable.
Chris Lattnerb9692a72010-04-02 19:42:39 +00002183 if (Scope == 0)
Devang Patelbad42262009-11-10 23:20:04 +00002184 continue;
Devang Patel90a0fe32009-11-10 23:06:00 +00002185
Devang Patelf0e70332010-05-20 16:36:41 +00002186 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2187 DbgVariable *RegVar = new DbgVariable(DV);
2188 recordVariableFrameIndex(RegVar, VP.first);
Devang Patelc50078e2009-11-21 02:48:08 +00002189 Scope->addVariable(RegVar);
Devang Patelf0e70332010-05-20 16:36:41 +00002190 if (AbsDbgVariable) {
2191 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2192 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2193 }
Devang Patel84139992009-10-06 01:26:37 +00002194 }
Devang Patel6da145f2010-05-20 19:57:06 +00002195}
Devang Patel14da02f2010-03-15 18:33:46 +00002196
Devang Patel12188d52010-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 Patel6da145f2010-05-20 19:57:06 +00002215/// collectVariableInfo - Populate DbgScope entries with variables' info.
Devang Patel55202ea2010-06-25 22:07:34 +00002216void
2217DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2218 SmallPtrSet<const MDNode *, 16> &Processed) {
Devang Patel6da145f2010-05-20 19:57:06 +00002219
2220 /// collection info from MMI table.
2221 collectVariableInfoFromMMITable(MF, Processed);
2222
2223 SmallVector<const MachineInstr *, 8> DbgValues;
Devang Patel14da02f2010-03-15 18:33:46 +00002224 // Collect variable information from DBG_VALUE machine instructions;
Chris Lattnerbc0027b2010-04-05 00:13:49 +00002225 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
Devang Patel6da145f2010-05-20 19:57:06 +00002226 I != E; ++I)
Devang Patel14da02f2010-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 Patel12188d52010-05-25 23:40:22 +00002230 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
Devang Patel14da02f2010-03-15 18:33:46 +00002231 continue;
Devang Patel6da145f2010-05-20 19:57:06 +00002232 DbgValues.push_back(MInsn);
2233 }
Devang Patel14da02f2010-03-15 18:33:46 +00002234
Devang Patel12188d52010-05-25 23:40:22 +00002235 // This is a collection of DBV_VALUE instructions describing same variable.
2236 SmallVector<const MachineInstr *, 4> MultipleValues;
Devang Patel6da145f2010-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 Patel12188d52010-05-25 23:40:22 +00002240 MultipleValues.clear();
2241 if (isDbgValueInDefinedReg(MInsn))
2242 MultipleValues.push_back(MInsn);
Devang Patel6da145f2010-05-20 19:57:06 +00002243 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2244 if (Processed.count(DV) != 0)
2245 continue;
2246
Devang Patela17d0b82010-06-02 19:05:13 +00002247 const MachineInstr *PrevMI = MInsn;
Devang Patel12188d52010-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 Patela17d0b82010-06-02 19:05:13 +00002252 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2253 !PrevMI->isIdenticalTo(*MI))
Devang Patel12188d52010-05-25 23:40:22 +00002254 MultipleValues.push_back(*MI);
Devang Patela17d0b82010-06-02 19:05:13 +00002255 PrevMI = *MI;
Devang Patel12188d52010-05-25 23:40:22 +00002256 }
2257
Devang Patel6da145f2010-05-20 19:57:06 +00002258 DbgScope *Scope = findDbgScope(MInsn);
Devang Patel82699742010-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 Patelc4f998d2010-05-21 00:10:20 +00002264 Scope = CurrentFnDbgScope;
Devang Patel6da145f2010-05-20 19:57:06 +00002265 // If variable scope is not found then skip this variable.
Devang Patelc4f998d2010-05-21 00:10:20 +00002266 if (!Scope)
Devang Patel6da145f2010-05-20 19:57:06 +00002267 continue;
2268
2269 Processed.insert(DV);
Devang Patel6da145f2010-05-20 19:57:06 +00002270 DbgVariable *RegVar = new DbgVariable(DV);
Devang Patel6da145f2010-05-20 19:57:06 +00002271 Scope->addVariable(RegVar);
Devang Patel82699742010-05-27 20:25:04 +00002272 if (!CurFnArg)
Devang Patel12188d52010-05-25 23:40:22 +00002273 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
Devang Patelc4f998d2010-05-21 00:10:20 +00002274 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2275 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2276 VarToAbstractVarMap[RegVar] = AbsVar;
Devang Patel14da02f2010-03-15 18:33:46 +00002277 }
Devang Patel12188d52010-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 Patel12188d52010-05-25 23:40:22 +00002284 if (DotDebugLocEntries.empty())
Devang Pateld09fbfa2010-05-26 23:55:23 +00002285 RegVar->setDotDebugLocOffset(0);
2286 else
2287 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
Devang Patel23720f42010-05-26 17:29:32 +00002288 const MachineInstr *Begin = NULL;
2289 const MachineInstr *End = NULL;
2290 for (SmallVector<const MachineInstr *, 4>::iterator
Devang Patel84afdd52010-07-07 20:12:52 +00002291 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2292 MVI != MVE; ++MVI) {
Devang Patel23720f42010-05-26 17:29:32 +00002293 if (!Begin) {
2294 Begin = *MVI;
2295 continue;
2296 }
2297 End = *MVI;
Devang Patel12188d52010-05-25 23:40:22 +00002298 MachineLocation MLoc;
Devang Patel23720f42010-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 Patel12188d52010-05-25 23:40:22 +00002302 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
Devang Patel23720f42010-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 Patel12188d52010-05-25 23:40:22 +00002306 // until the end of the funtion.
Devang Patel23720f42010-05-26 17:29:32 +00002307 MLoc.set(End->getOperand(0).getReg(), 0);
Devang Patel12188d52010-05-25 23:40:22 +00002308 DotDebugLocEntries.
2309 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, MLoc));
2310 }
2311 }
2312 DotDebugLocEntries.push_back(DotDebugLocEntry());
Devang Patel14da02f2010-03-15 18:33:46 +00002313 }
Devang Patelfad01682010-05-14 21:01:35 +00002314
2315 // Collect info for variables that were optimized out.
Devang Patelb7edda02010-06-22 01:01:58 +00002316 const Function *F = MF->getFunction();
2317 const Module *M = F->getParent();
2318 if (NamedMDNode *NMD =
Devang Patel8fa7adc2010-06-22 01:19:38 +00002319 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2320 getRealLinkageName(F->getName())))) {
Devang Patelfad01682010-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 Patel6da145f2010-05-20 19:57:06 +00002323 if (!DV || !Processed.insert(DV))
Devang Patelfad01682010-05-14 21:01:35 +00002324 continue;
2325 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2326 if (Scope)
Devang Patelf0e70332010-05-20 16:36:41 +00002327 Scope->addVariable(new DbgVariable(DV));
Devang Patelfad01682010-05-14 21:01:35 +00002328 }
2329 }
Devang Patel12188d52010-05-25 23:40:22 +00002330}
Devang Patelfad01682010-05-14 21:01:35 +00002331
Devang Patel12188d52010-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 Patel84139992009-10-06 01:26:37 +00002349}
2350
Devang Patelabc2b352010-03-29 17:20:31 +00002351/// beginScope - Process beginning of a scope.
2352void DwarfDebug::beginScope(const MachineInstr *MI) {
Devang Pateld28f15b2010-05-26 19:37:24 +00002353 if (InsnNeedsLabel.count(MI) == 0) {
2354 LabelsBeforeInsn[MI] = PrevLabel;
Devang Patelabc2b352010-03-29 17:20:31 +00002355 return;
Devang Patel12188d52010-05-25 23:40:22 +00002356 }
Devang Patel9a9a4ac2010-03-29 22:59:58 +00002357
Devang Pateld28f15b2010-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 Patelce7bf012010-04-27 19:46:33 +00002363 PrevInstLoc = DL;
Devang Pateld28f15b2010-05-26 19:37:24 +00002364 LabelsBeforeInsn[MI] = PrevLabel;
2365 return;
Devang Patelce7bf012010-04-27 19:46:33 +00002366 }
Devang Patelabc2b352010-03-29 17:20:31 +00002367
Devang Patel8d91da92010-05-26 21:23:46 +00002368 // If location is unknown then use temp label for this DBG_VALUE
Devang Pateld28f15b2010-05-26 19:37:24 +00002369 // instruction.
2370 if (MI->isDebugValue()) {
Devang Patel8d91da92010-05-26 21:23:46 +00002371 PrevLabel = MMI->getContext().CreateTempSymbol();
2372 Asm->OutStreamer.EmitLabel(PrevLabel);
Devang Pateld28f15b2010-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 Patel393a46d2009-10-06 01:50:42 +00002384}
2385
Devang Patelc50078e2009-11-21 02:48:08 +00002386/// endScope - Process end of a scope.
2387void DwarfDebug::endScope(const MachineInstr *MI) {
Devang Patel6f878382010-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 Patelce7bf012010-04-27 19:46:33 +00002392 LabelsAfterInsn[MI] = Label;
Devang Patel6f878382010-04-08 16:50:29 +00002393 }
Devang Patel90a0fe32009-11-10 23:06:00 +00002394}
2395
Devang Patelce7bf012010-04-27 19:46:33 +00002396/// getOrCreateDbgScope - Create DbgScope for the scope.
Devang Patel84afdd52010-07-07 20:12:52 +00002397DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2398 const MDNode *InlinedAt) {
Devang Patel90a0fe32009-11-10 23:06:00 +00002399 if (!InlinedAt) {
2400 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2401 if (WScope)
Devang Patelce7bf012010-04-27 19:46:33 +00002402 return WScope;
Devang Patel90a0fe32009-11-10 23:06:00 +00002403 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2404 DbgScopeMap.insert(std::make_pair(Scope, WScope));
Devang Patelce7bf012010-04-27 19:46:33 +00002405 if (DIDescriptor(Scope).isLexicalBlock()) {
2406 DbgScope *Parent =
Devang Patel19302aa2010-05-07 18:11:54 +00002407 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
Devang Patelce7bf012010-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 Hastings9182e272010-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 Hastingsaa685d62010-06-11 20:08:44 +00002419 if (SPName == Asm->MF->getFunction()->getName() ||
2420 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
Devang Patelce7bf012010-04-27 19:46:33 +00002421 CurrentFnDbgScope = WScope;
2422 }
2423
2424 return WScope;
Devang Patel90a0fe32009-11-10 23:06:00 +00002425 }
2426
Devang Patel55202ea2010-06-25 22:07:34 +00002427 getOrCreateAbstractScope(Scope);
Devang Patel90a0fe32009-11-10 23:06:00 +00002428 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2429 if (WScope)
Devang Patelce7bf012010-04-27 19:46:33 +00002430 return WScope;
Devang Patel90a0fe32009-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 Patelce7bf012010-04-27 19:46:33 +00002435 DbgScope *Parent =
Devang Patel19302aa2010-05-07 18:11:54 +00002436 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
Devang Patelce7bf012010-04-27 19:46:33 +00002437 WScope->setParent(Parent);
2438 Parent->addScope(WScope);
2439
2440 ConcreteScopes[InlinedAt] = WScope;
Devang Patelce7bf012010-04-27 19:46:33 +00002441
2442 return WScope;
Devang Patel393a46d2009-10-06 01:50:42 +00002443}
2444
Devang Patelce7bf012010-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 Patel9c371c62010-05-07 20:54:48 +00002449 const MDNode *&Scope, const MDNode *&InlinedAt) {
Devang Patelce7bf012010-04-27 19:46:33 +00002450 DebugLoc DL = MInsn->getDebugLoc();
2451 if (DL.isUnknown()) return false;
2452
Devang Patel9c371c62010-05-07 20:54:48 +00002453 const MDNode *S = DL.getScope(Ctx);
Devang Patelce7bf012010-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 Patel9c371c62010-05-07 20:54:48 +00002505 const MDNode *Scope = NULL;
2506 const MDNode *InlinedAt = NULL;
Devang Patelce7bf012010-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 Patelc50078e2009-11-21 02:48:08 +00002530/// extractScopeInformation - Scan machine instructions in this function
Chris Lattner202f10b2010-03-31 05:39:57 +00002531/// and collect DbgScopes. Return true, if at least one scope was found.
Chris Lattner69a76972010-01-26 23:18:02 +00002532bool DwarfDebug::extractScopeInformation() {
Devang Patel6a260102009-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 Gohman30573dd2010-04-23 01:18:53 +00002538 // Scan each instruction and create scopes. First build working set of scopes.
Devang Patelce7bf012010-04-27 19:46:33 +00002539 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2540 SmallVector<DbgRange, 4> MIRanges;
2541 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
Devang Patel9c371c62010-05-07 20:54:48 +00002542 const MDNode *PrevScope = NULL;
2543 const MDNode *PrevInlinedAt = NULL;
Devang Patelce7bf012010-04-27 19:46:33 +00002544 const MachineInstr *RangeBeginMI = NULL;
2545 const MachineInstr *PrevMI = NULL;
Chris Lattnerbc0027b2010-04-05 00:13:49 +00002546 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
Devang Patel6a260102009-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 Patel9c371c62010-05-07 20:54:48 +00002551 const MDNode *Scope = NULL;
2552 const MDNode *InlinedAt = NULL;
Devang Patelce7bf012010-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 Lattnerb9692a72010-04-02 19:42:39 +00002559
Devang Patelce7bf012010-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 Patel84afdd52010-07-07 20:12:52 +00002571 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2572 PrevInlinedAt);
Devang Patelce7bf012010-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 Lattnerb9692a72010-04-02 19:42:39 +00002578
Devang Patelce7bf012010-04-27 19:46:33 +00002579 // Reset previous markers.
2580 PrevMI = MInsn;
2581 PrevScope = Scope;
2582 PrevInlinedAt = InlinedAt;
Devang Patel90a0fe32009-11-10 23:06:00 +00002583 }
2584 }
2585
Devang Patelce7bf012010-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 Patel6a260102009-10-01 20:31:14 +00002591 }
Devang Patelce7bf012010-04-27 19:46:33 +00002592
Devang Patel98e77302010-01-04 20:44:00 +00002593 if (!CurrentFnDbgScope)
2594 return false;
2595
Devang Patelce7bf012010-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 Patel6a260102009-10-01 20:31:14 +00002616
Devang Patelf63b2262010-04-08 18:43:56 +00002617 identifyScopeMarkers();
Devang Patel0d8f3b72010-04-08 15:37:09 +00002618
2619 return !DbgScopeMap.empty();
2620}
2621
Devang Patelce7bf012010-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 Patelf63b2262010-04-08 18:43:56 +00002627void DwarfDebug::identifyScopeMarkers() {
Devang Patelfd311df2010-01-20 02:05:23 +00002628 SmallVector<DbgScope *, 4> WorkList;
2629 WorkList.push_back(CurrentFnDbgScope);
2630 while (!WorkList.empty()) {
Chris Lattner202f10b2010-03-31 05:39:57 +00002631 DbgScope *S = WorkList.pop_back_val();
Devang Patelce7bf012010-04-27 19:46:33 +00002632
Jeffrey Yasskinecca2e62010-03-12 17:45:06 +00002633 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
Devang Patelfd311df2010-01-20 02:05:23 +00002634 if (!Children.empty())
Jeffrey Yasskinecca2e62010-03-12 17:45:06 +00002635 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
Devang Patelfd311df2010-01-20 02:05:23 +00002636 SE = Children.end(); SI != SE; ++SI)
2637 WorkList.push_back(*SI);
2638
Devang Patel90a0fe32009-11-10 23:06:00 +00002639 if (S->isAbstractScope())
2640 continue;
Devang Patelce7bf012010-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 Patelf25c5832010-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 Patelce7bf012010-04-27 19:46:33 +00002649 InsnsEndScopeSet.insert(RI->second);
2650 }
Devang Patel6a260102009-10-01 20:31:14 +00002651 }
Devang Patel6a260102009-10-01 20:31:14 +00002652}
2653
Dan Gohmand0e9b672010-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 Patelc50078e2009-11-21 02:48:08 +00002669/// beginFunction - Gather pre-function debug information. Assumes being
Bill Wendlingf5839192009-05-20 23:19:06 +00002670/// emitted immediately after the function entry point.
Chris Lattner69a76972010-01-26 23:18:02 +00002671void DwarfDebug::beginFunction(const MachineFunction *MF) {
Chris Lattner2cb53302010-04-05 03:52:55 +00002672 if (!MMI->hasDebugInfo()) return;
Bill Wendlingce3c6252010-04-07 09:28:04 +00002673 if (!extractScopeInformation()) return;
Devang Patel0feae422009-10-06 18:37:31 +00002674
Devang Patelce7bf012010-04-27 19:46:33 +00002675 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2676 Asm->getFunctionNumber());
Bill Wendlingf5839192009-05-20 23:19:06 +00002677 // Assumes in correct section after the entry point.
Devang Patelce7bf012010-04-27 19:46:33 +00002678 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
Bill Wendlingf5839192009-05-20 23:19:06 +00002679
2680 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2681 // function.
Dan Gohmand0e9b672010-04-20 00:37:27 +00002682 DebugLoc FDL = FindFirstDebugLoc(MF);
Chris Lattnerb9692a72010-04-02 19:42:39 +00002683 if (FDL.isUnknown()) return;
2684
Devang Patel9c371c62010-05-07 20:54:48 +00002685 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
Stuart Hastings45b08d32010-07-19 23:56:30 +00002686 const MDNode *TheScope = 0;
Chris Lattnerb9692a72010-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 Hastings45b08d32010-07-19 23:56:30 +00002693 TheScope = SP;
Chris Lattnerb9692a72010-04-02 19:42:39 +00002694 } else {
2695 Line = FDL.getLine();
2696 Col = FDL.getCol();
Stuart Hastings45b08d32010-07-19 23:56:30 +00002697 TheScope = Scope;
Bill Wendlingf5839192009-05-20 23:19:06 +00002698 }
Chris Lattnerb9692a72010-04-02 19:42:39 +00002699
Stuart Hastings45b08d32010-07-19 23:56:30 +00002700 recordSourceLine(Line, Col, TheScope);
Devang Pateld28f15b2010-05-26 19:37:24 +00002701
Devang Patela1b75ab2010-06-02 16:42:51 +00002702 /// ProcessedArgs - Collection of arguments already processed.
2703 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2704
Devang Pateld28f15b2010-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 Pateld28f15b2010-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 Patelff71bf82010-05-27 16:47:30 +00002716 // If DBG_VALUE is for a local variable then it needs a label.
Devang Patelc7be3132010-07-01 21:38:08 +00002717 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2718 && isDbgValueInUndefinedReg(MI) == false)
Devang Pateld28f15b2010-05-26 19:37:24 +00002719 InsnNeedsLabel.insert(MI);
Devang Patelff71bf82010-05-27 16:47:30 +00002720 // DBG_VALUE for inlined functions argument needs a label.
Devang Patelc7be3132010-07-01 21:38:08 +00002721 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2722 describes(MF->getFunction()))
Devang Patelff71bf82010-05-27 16:47:30 +00002723 InsnNeedsLabel.insert(MI);
2724 // DBG_VALUE indicating argument location change needs a label.
Devang Patel3d5b9832010-06-24 21:51:19 +00002725 else if (isDbgValueInUndefinedReg(MI) == false && !ProcessedArgs.insert(DV))
Devang Pateld28f15b2010-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 Wendlingf5839192009-05-20 23:19:06 +00002743}
2744
Devang Patelc50078e2009-11-21 02:48:08 +00002745/// endFunction - Gather and emit post-function debug information.
Bill Wendlingf5839192009-05-20 23:19:06 +00002746///
Chris Lattner69a76972010-01-26 23:18:02 +00002747void DwarfDebug::endFunction(const MachineFunction *MF) {
Bill Wendlingce3c6252010-04-07 09:28:04 +00002748 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
Devang Patel4a7ef8d2009-11-12 19:02:56 +00002749
Devang Patel98e77302010-01-04 20:44:00 +00002750 if (CurrentFnDbgScope) {
Devang Patelfc01d2a2010-05-22 00:04:14 +00002751
Devang Patel12188d52010-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 Patel55202ea2010-06-25 22:07:34 +00002758 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2759 collectVariableInfo(MF, ProcessedVars);
Devang Patelfc01d2a2010-05-22 00:04:14 +00002760
Devang Patel98e77302010-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 Patel55202ea2010-06-25 22:07:34 +00002774 AE = AbstractScopesList.end(); AI != AE; ++AI) {
Devang Patel55202ea2010-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 Patel014bba22010-06-30 00:11:08 +00002789 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
Devang Patel55202ea2010-06-25 22:07:34 +00002790 if (Scope)
2791 Scope->addVariable(new DbgVariable(DV));
2792 }
2793 }
2794 }
Devang Patela6aad8b2010-06-30 01:40:11 +00002795 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2796 constructScopeDIE(*AI);
Devang Patel55202ea2010-06-25 22:07:34 +00002797 }
Devang Patel84afdd52010-07-07 20:12:52 +00002798
Devang Patelab4b3ce2010-05-04 06:15:30 +00002799 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
Devang Patel98e77302010-01-04 20:44:00 +00002800
Devang Patelab4b3ce2010-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 Lattnerbc0027b2010-04-05 00:13:49 +00002806 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
Devang Patel98e77302010-01-04 20:44:00 +00002807 MMI->getFrameMoves()));
Bill Wendlingf5839192009-05-20 23:19:06 +00002808 }
2809
Bill Wendlingf5839192009-05-20 23:19:06 +00002810 // Clear debug info
Devang Patel387e9c12010-01-19 01:26:02 +00002811 CurrentFnDbgScope = NULL;
Devang Pateld28f15b2010-05-26 19:37:24 +00002812 InsnNeedsLabel.clear();
Devang Patelf0e70332010-05-20 16:36:41 +00002813 DbgVariableToFrameIndexMap.clear();
2814 VarToAbstractVarMap.clear();
2815 DbgVariableToDbgInstMap.clear();
2816 DbgVariableLabelsMap.clear();
Jeffrey Yasskinecca2e62010-03-12 17:45:06 +00002817 DeleteContainerSeconds(DbgScopeMap);
Devang Patelfd0ebd52010-04-09 16:04:20 +00002818 InsnsEndScopeSet.clear();
Devang Patel387e9c12010-01-19 01:26:02 +00002819 ConcreteScopes.clear();
Jeffrey Yasskinecca2e62010-03-12 17:45:06 +00002820 DeleteContainerSeconds(AbstractScopes);
Devang Patel387e9c12010-01-19 01:26:02 +00002821 AbstractScopesList.clear();
Jeffrey Yasskinecca2e62010-03-12 17:45:06 +00002822 AbstractVariables.clear();
Devang Patelce7bf012010-04-27 19:46:33 +00002823 LabelsBeforeInsn.clear();
2824 LabelsAfterInsn.clear();
Bill Wendlingf5839192009-05-20 23:19:06 +00002825 Lines.clear();
Devang Patel146c6f72010-04-16 23:33:45 +00002826 PrevLabel = NULL;
Bill Wendlingf5839192009-05-20 23:19:06 +00002827}
2828
Devang Patelf0e70332010-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 Patel6da145f2010-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 Lattner597b0fc2010-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 Patel84afdd52010-07-07 20:12:52 +00002879MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2880 const MDNode *S) {
Devang Patel7f75bbe2009-11-25 17:36:49 +00002881 StringRef Dir;
2882 StringRef Fn;
Devang Patel946d0ae2009-10-05 18:03:19 +00002883
Dan Gohman5d0dda52010-05-05 23:41:32 +00002884 unsigned Src = 1;
2885 if (S) {
2886 DIDescriptor Scope(S);
Devang Patel946d0ae2009-10-05 18:03:19 +00002887
Dan Gohman5d0dda52010-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 Lattner54e56f22010-03-14 08:36:50 +00002906 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
Chris Lattner8d9d06a2010-03-14 08:15:55 +00002907 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
Bill Wendlingf5839192009-05-20 23:19:06 +00002908
Chris Lattner597b0fc2010-03-09 04:54:43 +00002909 Asm->OutStreamer.EmitLabel(Label);
2910 return Label;
Bill Wendlingf5839192009-05-20 23:19:06 +00002911}
2912
Bill Wendlinge1a5bbb2009-05-20 23:22:40 +00002913//===----------------------------------------------------------------------===//
2914// Emit Methods
2915//===----------------------------------------------------------------------===//
2916
Devang Patelc50078e2009-11-21 02:48:08 +00002917/// computeSizeAndOffset - Compute the size and offset of a DIE.
Bill Wendling55fccda2009-05-20 23:21:38 +00002918///
Jim Grosbachb23f2422009-11-22 19:20:36 +00002919unsigned
2920DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
Bill Wendling55fccda2009-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 Yasskin2944ced2010-03-22 18:47:14 +00002925 if (!Last && !Children.empty())
Benjamin Kramer138c7ff2010-03-31 19:34:01 +00002926 Die->addSiblingOffset(DIEValueAllocator);
Bill Wendling55fccda2009-05-20 23:21:38 +00002927
2928 // Record the abbreviation.
Devang Patelc50078e2009-11-21 02:48:08 +00002929 assignAbbrevNumber(Die->getAbbrev());
Bill Wendling55fccda2009-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 Lattner621c44d2009-08-22 20:48:53 +00002939 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
Bill Wendling55fccda2009-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 Lattner352c8e22010-04-05 00:18:22 +00002947 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
Bill Wendling55fccda2009-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 Patelc50078e2009-11-21 02:48:08 +00002955 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
Bill Wendling55fccda2009-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 Patelc50078e2009-11-21 02:48:08 +00002965/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
Bill Wendling55fccda2009-05-20 23:21:38 +00002966///
Devang Patelc50078e2009-11-21 02:48:08 +00002967void DwarfDebug::computeSizeAndOffsets() {
Devang Patel7e5a86e2010-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 Wendling55fccda2009-05-20 23:21:38 +00002980}
2981
Chris Lattner733c69d2010-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 Lattner66143d22010-04-04 22:59:04 +00002984static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
Chris Lattner733c69d2010-04-04 23:02:02 +00002985 const char *SymbolStem = 0) {
Chris Lattner66143d22010-04-04 22:59:04 +00002986 Asm->OutStreamer.SwitchSection(Section);
Chris Lattner733c69d2010-04-04 23:02:02 +00002987 if (!SymbolStem) return 0;
2988
Chris Lattner66143d22010-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 Lattnerd91fd8c2010-04-04 22:33:59 +00002996void DwarfDebug::EmitSectionLabels() {
Chris Lattner73266f92009-08-19 05:49:37 +00002997 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
Daniel Dunbar41716322009-09-19 20:40:05 +00002998
Bill Wendling55fccda2009-05-20 23:21:38 +00002999 // Dwarf sections base addresses.
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003000 if (Asm->MAI->doesDwarfRequireFrameSection()) {
Chris Lattner66143d22010-04-04 22:59:04 +00003001 DwarfFrameSectionSym =
3002 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3003 }
Bill Wendling55fccda2009-05-20 23:21:38 +00003004
Chris Lattner66143d22010-04-04 22:59:04 +00003005 DwarfInfoSectionSym =
3006 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3007 DwarfAbbrevSectionSym =
3008 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
Chris Lattner733c69d2010-04-04 23:02:02 +00003009 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
Chris Lattner66143d22010-04-04 22:59:04 +00003010
3011 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
Chris Lattner733c69d2010-04-04 23:02:02 +00003012 EmitSectionSym(Asm, MacroInfo);
Bill Wendling55fccda2009-05-20 23:21:38 +00003013
Devang Pateldd385062010-06-29 20:17:53 +00003014 DwarfDebugLineSectionSym =
3015 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
Chris Lattner733c69d2010-04-04 23:02:02 +00003016 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3017 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3018 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
Chris Lattner66143d22010-04-04 22:59:04 +00003019 DwarfStrSectionSym =
3020 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
Devang Patel146c6f72010-04-16 23:33:45 +00003021 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3022 "debug_range");
Bill Wendling55fccda2009-05-20 23:21:38 +00003023
Devang Patel12188d52010-05-25 23:40:22 +00003024 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3025 "section_debug_loc");
3026
Chris Lattner66143d22010-04-04 22:59:04 +00003027 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
Chris Lattner094932e2010-04-04 23:10:38 +00003028 EmitSectionSym(Asm, TLOF.getDataSection());
Bill Wendling55fccda2009-05-20 23:21:38 +00003029}
3030
Devang Patelc50078e2009-11-21 02:48:08 +00003031/// emitDIE - Recusively Emits a debug information entry.
Bill Wendling55fccda2009-05-20 23:21:38 +00003032///
Devang Patelc50078e2009-11-21 02:48:08 +00003033void DwarfDebug::emitDIE(DIE *Die) {
Bill Wendling55fccda2009-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 Wendling55fccda2009-05-20 23:21:38 +00003038 // Emit the code (index) for the abbreviation.
Chris Lattner97c69b72010-04-04 18:52:31 +00003039 if (Asm->isVerbose())
Chris Lattnerbcc79432010-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 Lattner26be1c12010-04-04 19:09:29 +00003044 Asm->EmitULEB128(AbbrevNumber);
Bill Wendling55fccda2009-05-20 23:21:38 +00003045
Jeffrey Yasskin2944ced2010-03-22 18:47:14 +00003046 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
Bill Wendling55fccda2009-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 Lattner97c69b72010-04-04 18:52:31 +00003055 if (Asm->isVerbose())
Chris Lattner91e06b42010-01-24 18:54:17 +00003056 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3057
Bill Wendling55fccda2009-05-20 23:21:38 +00003058 switch (Attr) {
3059 case dwarf::DW_AT_sibling:
Devang Patelc50078e2009-11-21 02:48:08 +00003060 Asm->EmitInt32(Die->getSiblingOffset());
Bill Wendling55fccda2009-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 Patel90a0fe32009-11-10 23:06:00 +00003065 unsigned Addr = Origin->getOffset();
Bill Wendling55fccda2009-05-20 23:21:38 +00003066 Asm->EmitInt32(Addr);
3067 break;
3068 }
Devang Patel146c6f72010-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 Pateldd385062010-06-29 20:17:53 +00003078 case dwarf::DW_AT_stmt_list: {
3079 Asm->EmitLabelDifference(CurrentLineSectionSym,
3080 DwarfDebugLineSectionSym, 4);
3081 break;
3082 }
Devang Patel12188d52010-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 Wendling55fccda2009-05-20 23:21:38 +00003091 default:
3092 // Emit an attribute using the defined form.
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003093 Values[i]->EmitValue(Asm, Form);
Bill Wendling55fccda2009-05-20 23:21:38 +00003094 break;
3095 }
Bill Wendling55fccda2009-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 Patelc50078e2009-11-21 02:48:08 +00003103 emitDIE(Children[j]);
Bill Wendling55fccda2009-05-20 23:21:38 +00003104
Chris Lattner97c69b72010-04-04 18:52:31 +00003105 if (Asm->isVerbose())
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003106 Asm->OutStreamer.AddComment("End Of Children Mark");
3107 Asm->EmitInt8(0);
Bill Wendling55fccda2009-05-20 23:21:38 +00003108 }
3109}
3110
Devang Patelfe0be132009-12-09 18:24:21 +00003111/// emitDebugInfo - Emit the debug info section.
Bill Wendling55fccda2009-05-20 23:21:38 +00003112///
Devang Patelfe0be132009-12-09 18:24:21 +00003113void DwarfDebug::emitDebugInfo() {
3114 // Start debug info section.
3115 Asm->OutStreamer.SwitchSection(
3116 Asm->getObjFileLowering().getDwarfInfoSection());
Devang Patel7e5a86e2010-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 Wendling55fccda2009-05-20 23:21:38 +00003152}
3153
Devang Patelc50078e2009-11-21 02:48:08 +00003154/// emitAbbreviations - Emit the abbreviation section.
Bill Wendling55fccda2009-05-20 23:21:38 +00003155///
Devang Patelc50078e2009-11-21 02:48:08 +00003156void DwarfDebug::emitAbbreviations() const {
Bill Wendling55fccda2009-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 Lattner73266f92009-08-19 05:49:37 +00003160 Asm->OutStreamer.SwitchSection(
3161 Asm->getObjFileLowering().getDwarfAbbrevSection());
Bill Wendling55fccda2009-05-20 23:21:38 +00003162
Chris Lattnerb93558d2010-04-04 19:25:43 +00003163 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
Bill Wendling55fccda2009-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 Lattner26be1c12010-04-04 19:09:29 +00003171 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
Bill Wendling55fccda2009-05-20 23:21:38 +00003172
3173 // Emit the abbreviations data.
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003174 Abbrev->Emit(Asm);
Bill Wendling55fccda2009-05-20 23:21:38 +00003175 }
3176
3177 // Mark end of abbreviations.
Chris Lattner26be1c12010-04-04 19:09:29 +00003178 Asm->EmitULEB128(0, "EOM(3)");
Bill Wendling55fccda2009-05-20 23:21:38 +00003179
Chris Lattnerb93558d2010-04-04 19:25:43 +00003180 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
Bill Wendling55fccda2009-05-20 23:21:38 +00003181 }
3182}
3183
Devang Patelc50078e2009-11-21 02:48:08 +00003184/// emitEndOfLineMatrix - Emit the last address of the section and the end of
Bill Wendling55fccda2009-05-20 23:21:38 +00003185/// the line matrix.
3186///
Devang Patelc50078e2009-11-21 02:48:08 +00003187void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Bill Wendling55fccda2009-05-20 23:21:38 +00003188 // Define last address of section.
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003189 Asm->OutStreamer.AddComment("Extended Op");
3190 Asm->EmitInt8(0);
3191
3192 Asm->OutStreamer.AddComment("Op size");
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003193 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner9ef8efd2010-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 Lattnereb159d62010-03-10 01:17:49 +00003198
Chris Lattnerb93558d2010-04-04 19:25:43 +00003199 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003200 Asm->getTargetData().getPointerSize(),
3201 0/*AddrSpace*/);
Bill Wendling55fccda2009-05-20 23:21:38 +00003202
3203 // Mark end of matrix.
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003204 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3205 Asm->EmitInt8(0);
Chris Lattnerad653482010-01-22 22:09:00 +00003206 Asm->EmitInt8(1);
Chris Lattnerbcc79432010-01-22 23:18:42 +00003207 Asm->EmitInt8(1);
Bill Wendling55fccda2009-05-20 23:21:38 +00003208}
3209
Devang Patelc50078e2009-11-21 02:48:08 +00003210/// emitDebugLines - Emit source line information.
Bill Wendling55fccda2009-05-20 23:21:38 +00003211///
Devang Patelc50078e2009-11-21 02:48:08 +00003212void DwarfDebug::emitDebugLines() {
Bill Wendling55fccda2009-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 Lattnerbc0027b2010-04-05 00:13:49 +00003215 if (Asm->MAI->hasDotLocAndDotFile())
Bill Wendling55fccda2009-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 Lattner73266f92009-08-19 05:49:37 +00003224 Asm->OutStreamer.SwitchSection(
3225 Asm->getObjFileLowering().getDwarfLineSection());
Bill Wendling55fccda2009-05-20 23:21:38 +00003226
3227 // Construct the section header.
Devang Pateldd385062010-06-29 20:17:53 +00003228 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3229 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003230 Asm->OutStreamer.AddComment("Length of Source Line Info");
Chris Lattnerfd2a3f62010-04-04 19:58:12 +00003231 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3232 Asm->GetTempSymbol("line_begin"), 4);
Chris Lattnerb93558d2010-04-04 19:25:43 +00003233 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
Bill Wendling55fccda2009-05-20 23:21:38 +00003234
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003235 Asm->OutStreamer.AddComment("DWARF version number");
3236 Asm->EmitInt16(dwarf::DWARF_VERSION);
Bill Wendling55fccda2009-05-20 23:21:38 +00003237
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003238 Asm->OutStreamer.AddComment("Prolog Length");
Chris Lattnerfd2a3f62010-04-04 19:58:12 +00003239 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3240 Asm->GetTempSymbol("line_prolog_begin"), 4);
Chris Lattnerb93558d2010-04-04 19:25:43 +00003241 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
Bill Wendling55fccda2009-05-20 23:21:38 +00003242
Chris Lattner9ef8efd2010-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 Wendling55fccda2009-05-20 23:21:38 +00003253
3254 // Line number standard opcode encodings argument count
Chris Lattner9ef8efd2010-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 Wendling55fccda2009-05-20 23:21:38 +00003273
3274 // Emit directories.
3275 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
Chris Lattnercc564642010-01-23 03:11:46 +00003276 const std::string &Dir = getSourceDirectoryName(DI);
Chris Lattner97c69b72010-04-04 18:52:31 +00003277 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
Chris Lattnercc564642010-01-23 03:11:46 +00003278 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
Bill Wendling55fccda2009-05-20 23:21:38 +00003279 }
3280
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003281 Asm->OutStreamer.AddComment("End of directories");
3282 Asm->EmitInt8(0);
Bill Wendling55fccda2009-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 Lattnercc564642010-01-23 03:11:46 +00003288 const std::string &FN = getSourceFileName(Id.second);
Chris Lattner97c69b72010-04-04 18:52:31 +00003289 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
Chris Lattnercc564642010-01-23 03:11:46 +00003290 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3291
Chris Lattner26be1c12010-04-04 19:09:29 +00003292 Asm->EmitULEB128(Id.first, "Directory #");
3293 Asm->EmitULEB128(0, "Mod date");
3294 Asm->EmitULEB128(0, "File size");
Bill Wendling55fccda2009-05-20 23:21:38 +00003295 }
3296
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003297 Asm->OutStreamer.AddComment("End of files");
3298 Asm->EmitInt8(0);
Bill Wendling55fccda2009-05-20 23:21:38 +00003299
Chris Lattnerb93558d2010-04-04 19:25:43 +00003300 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
Bill Wendling55fccda2009-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 Wendling55fccda2009-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 Lattner8d9d06a2010-03-14 08:15:55 +00003316 MCSymbol *Label = LineInfo.getLabel();
Chris Lattner31ae74d2010-03-14 02:20:58 +00003317 if (!Label->isDefined()) continue; // Not emitted, in dead code.
Bill Wendling55fccda2009-05-20 23:21:38 +00003318
Chris Lattner8bd2f8f2010-03-09 23:38:23 +00003319 if (Asm->isVerbose()) {
Chris Lattneree3b40f2010-03-10 01:04:13 +00003320 std::pair<unsigned, unsigned> SrcID =
Bill Wendling55fccda2009-05-20 23:21:38 +00003321 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
Chris Lattneree3b40f2010-03-10 01:04:13 +00003322 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
Chris Lattner48fb0b12010-03-10 02:29:31 +00003323 "/" +
3324 Twine(getSourceFileName(SrcID.second)) +
Chris Lattneree3b40f2010-03-10 01:04:13 +00003325 ":" + Twine(LineInfo.getLine()));
Bill Wendling55fccda2009-05-20 23:21:38 +00003326 }
3327
3328 // Define the line address.
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003329 Asm->OutStreamer.AddComment("Extended Op");
3330 Asm->EmitInt8(0);
3331 Asm->OutStreamer.AddComment("Op size");
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003332 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
Chris Lattner9ef8efd2010-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 Lattnerbc0027b2010-04-05 00:13:49 +00003338 Asm->OutStreamer.EmitSymbolValue(Label,
3339 Asm->getTargetData().getPointerSize(),
Chris Lattner31ae74d2010-03-14 02:20:58 +00003340 0/*AddrSpace*/);
Chris Lattnereb159d62010-03-10 01:17:49 +00003341
Bill Wendling55fccda2009-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 Lattner9ef8efd2010-03-09 23:52:58 +00003345 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3346 Asm->EmitInt8(dwarf::DW_LNS_set_file);
Chris Lattner26be1c12010-04-04 19:09:29 +00003347 Asm->EmitULEB128(Source, "New Source");
Bill Wendling55fccda2009-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 Lattner9ef8efd2010-03-09 23:52:58 +00003362 Asm->OutStreamer.AddComment("Line Delta");
3363 Asm->EmitInt8(Delta - MinLineDelta);
Bill Wendling55fccda2009-05-20 23:21:38 +00003364 } else {
3365 // ... otherwise use long hand.
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003366 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
Bill Wendling55fccda2009-05-20 23:21:38 +00003367 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
Chris Lattner26be1c12010-04-04 19:09:29 +00003368 Asm->EmitSLEB128(Offset, "Line Offset");
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003369 Asm->OutStreamer.AddComment("DW_LNS_copy");
3370 Asm->EmitInt8(dwarf::DW_LNS_copy);
Bill Wendling55fccda2009-05-20 23:21:38 +00003371 }
3372 } else {
3373 // Copy the previous row (different address or source)
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003374 Asm->OutStreamer.AddComment("DW_LNS_copy");
3375 Asm->EmitInt8(dwarf::DW_LNS_copy);
Bill Wendling55fccda2009-05-20 23:21:38 +00003376 }
3377 }
3378
Devang Patelc50078e2009-11-21 02:48:08 +00003379 emitEndOfLineMatrix(j + 1);
Bill Wendling55fccda2009-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 Patelc50078e2009-11-21 02:48:08 +00003386 emitEndOfLineMatrix(1);
Bill Wendling55fccda2009-05-20 23:21:38 +00003387
Chris Lattnerb93558d2010-04-04 19:25:43 +00003388 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
Bill Wendling55fccda2009-05-20 23:21:38 +00003389}
3390
Devang Patelc50078e2009-11-21 02:48:08 +00003391/// emitCommonDebugFrame - Emit common frame info into a debug frame section.
Bill Wendling55fccda2009-05-20 23:21:38 +00003392///
Devang Patelc50078e2009-11-21 02:48:08 +00003393void DwarfDebug::emitCommonDebugFrame() {
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003394 if (!Asm->MAI->doesDwarfRequireFrameSection())
Bill Wendling55fccda2009-05-20 23:21:38 +00003395 return;
3396
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003397 int stackGrowth = Asm->getTargetData().getPointerSize();
3398 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3399 TargetFrameInfo::StackGrowsDown)
3400 stackGrowth *= -1;
Bill Wendling55fccda2009-05-20 23:21:38 +00003401
3402 // Start the dwarf frame section.
Chris Lattner73266f92009-08-19 05:49:37 +00003403 Asm->OutStreamer.SwitchSection(
3404 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling55fccda2009-05-20 23:21:38 +00003405
Chris Lattnerb93558d2010-04-04 19:25:43 +00003406 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003407 Asm->OutStreamer.AddComment("Length of Common Information Entry");
Chris Lattnerfd2a3f62010-04-04 19:58:12 +00003408 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3409 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
Bill Wendling55fccda2009-05-20 23:21:38 +00003410
Chris Lattnerb93558d2010-04-04 19:25:43 +00003411 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003412 Asm->OutStreamer.AddComment("CIE Identifier Tag");
Bill Wendling55fccda2009-05-20 23:21:38 +00003413 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003414 Asm->OutStreamer.AddComment("CIE Version");
Bill Wendling55fccda2009-05-20 23:21:38 +00003415 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003416 Asm->OutStreamer.AddComment("CIE Augmentation");
Chris Lattnercc564642010-01-23 03:11:46 +00003417 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
Chris Lattner26be1c12010-04-04 19:09:29 +00003418 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3419 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003420 Asm->OutStreamer.AddComment("CIE RA Column");
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003421 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
Bill Wendling55fccda2009-05-20 23:21:38 +00003422 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
Bill Wendling55fccda2009-05-20 23:21:38 +00003423
3424 std::vector<MachineMove> Moves;
3425 RI->getInitialFrameState(Moves);
3426
Chris Lattner193fec02010-04-04 23:41:46 +00003427 Asm->EmitFrameMoves(Moves, 0, false);
Bill Wendling55fccda2009-05-20 23:21:38 +00003428
Chris Lattner7101e232010-04-28 01:05:45 +00003429 Asm->EmitAlignment(2);
Chris Lattnerb93558d2010-04-04 19:25:43 +00003430 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
Bill Wendling55fccda2009-05-20 23:21:38 +00003431}
3432
Devang Patelc50078e2009-11-21 02:48:08 +00003433/// emitFunctionDebugFrame - Emit per function frame info into a debug frame
Bill Wendling55fccda2009-05-20 23:21:38 +00003434/// section.
Chris Lattnerdd21da82010-03-13 07:26:18 +00003435void DwarfDebug::
3436emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003437 if (!Asm->MAI->doesDwarfRequireFrameSection())
Bill Wendling55fccda2009-05-20 23:21:38 +00003438 return;
3439
3440 // Start the dwarf frame section.
Chris Lattner73266f92009-08-19 05:49:37 +00003441 Asm->OutStreamer.SwitchSection(
3442 Asm->getObjFileLowering().getDwarfFrameSection());
Bill Wendling55fccda2009-05-20 23:21:38 +00003443
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003444 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
Chris Lattnerdd21da82010-03-13 07:26:18 +00003445 MCSymbol *DebugFrameBegin =
Chris Lattnerb93558d2010-04-04 19:25:43 +00003446 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
Chris Lattnerdd21da82010-03-13 07:26:18 +00003447 MCSymbol *DebugFrameEnd =
Chris Lattnerb93558d2010-04-04 19:25:43 +00003448 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
Chris Lattnerfd2a3f62010-04-04 19:58:12 +00003449 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
Bill Wendling55fccda2009-05-20 23:21:38 +00003450
Chris Lattnerdd21da82010-03-13 07:26:18 +00003451 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
Bill Wendling55fccda2009-05-20 23:21:38 +00003452
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003453 Asm->OutStreamer.AddComment("FDE CIE offset");
Chris Lattnerc06b4742010-04-04 23:25:33 +00003454 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3455 DwarfFrameSectionSym);
Bill Wendling55fccda2009-05-20 23:21:38 +00003456
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003457 Asm->OutStreamer.AddComment("FDE initial location");
Chris Lattnerb93558d2010-04-04 19:25:43 +00003458 MCSymbol *FuncBeginSym =
3459 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
Chris Lattner314e3362010-03-13 07:40:56 +00003460 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003461 Asm->getTargetData().getPointerSize(),
3462 0/*AddrSpace*/);
Chris Lattnereb159d62010-03-10 01:17:49 +00003463
3464
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003465 Asm->OutStreamer.AddComment("FDE address range");
Chris Lattnerfd2a3f62010-04-04 19:58:12 +00003466 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003467 FuncBeginSym, Asm->getTargetData().getPointerSize());
Bill Wendling55fccda2009-05-20 23:21:38 +00003468
Chris Lattner193fec02010-04-04 23:41:46 +00003469 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
Bill Wendling55fccda2009-05-20 23:21:38 +00003470
Chris Lattner7101e232010-04-28 01:05:45 +00003471 Asm->EmitAlignment(2);
Chris Lattnerdd21da82010-03-13 07:26:18 +00003472 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
Bill Wendling55fccda2009-05-20 23:21:38 +00003473}
3474
Devang Patelfe0be132009-12-09 18:24:21 +00003475/// emitDebugPubNames - Emit visible names into a debug pubnames section.
3476///
3477void DwarfDebug::emitDebugPubNames() {
Devang Patel7e5a86e2010-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 Lattnercc564642010-01-23 03:11:46 +00003484
Devang Patel7e5a86e2010-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 Wendling55fccda2009-05-20 23:21:38 +00003523 }
Bill Wendling55fccda2009-05-20 23:21:38 +00003524}
3525
Devang Patelec13b4f2009-11-24 01:14:22 +00003526void DwarfDebug::emitDebugPubTypes() {
Devang Patel7e5a86e2010-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 Lattnercc564642010-01-23 03:11:46 +00003537
Devang Patel7e5a86e2010-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 Patelec13b4f2009-11-24 01:14:22 +00003570 }
Devang Patelec13b4f2009-11-24 01:14:22 +00003571}
3572
Devang Patelc50078e2009-11-21 02:48:08 +00003573/// emitDebugStr - Emit visible names into a debug str section.
Bill Wendling55fccda2009-05-20 23:21:38 +00003574///
Devang Patelc50078e2009-11-21 02:48:08 +00003575void DwarfDebug::emitDebugStr() {
Bill Wendling55fccda2009-05-20 23:21:38 +00003576 // Check to see if it is worth the effort.
Chris Lattner8bd2f8f2010-03-09 23:38:23 +00003577 if (StringPool.empty()) return;
3578
3579 // Start the dwarf str section.
3580 Asm->OutStreamer.SwitchSection(
Chris Lattner73266f92009-08-19 05:49:37 +00003581 Asm->getObjFileLowering().getDwarfStrSection());
Bill Wendling55fccda2009-05-20 23:21:38 +00003582
Chris Lattner0f093f82010-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 Lattner8bd2f8f2010-03-09 23:38:23 +00003595 // Emit a label for reference from debug information entries.
Chris Lattner0f093f82010-03-13 02:17:42 +00003596 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
Chris Lattner8bd2f8f2010-03-09 23:38:23 +00003597
3598 // Emit the string itself.
Chris Lattner0f093f82010-03-13 02:17:42 +00003599 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
Bill Wendling55fccda2009-05-20 23:21:38 +00003600 }
3601}
3602
Devang Patelc50078e2009-11-21 02:48:08 +00003603/// emitDebugLoc - Emit visible names into a debug loc section.
Bill Wendling55fccda2009-05-20 23:21:38 +00003604///
Devang Patelc50078e2009-11-21 02:48:08 +00003605void DwarfDebug::emitDebugLoc() {
Devang Pateld09fbfa2010-05-26 23:55:23 +00003606 if (DotDebugLocEntries.empty())
3607 return;
3608
Bill Wendling55fccda2009-05-20 23:21:38 +00003609 // Start the dwarf loc section.
Chris Lattner73266f92009-08-19 05:49:37 +00003610 Asm->OutStreamer.SwitchSection(
Devang Patel12188d52010-05-25 23:40:22 +00003611 Asm->getObjFileLowering().getDwarfLocSection());
3612 unsigned char Size = Asm->getTargetData().getPointerSize();
Devang Pateld09fbfa2010-05-26 23:55:23 +00003613 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3614 unsigned index = 1;
Devang Patel84afdd52010-07-07 20:12:52 +00003615 for (SmallVector<DotDebugLocEntry, 4>::iterator
3616 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3617 I != E; ++I, ++index) {
Devang Patel12188d52010-05-25 23:40:22 +00003618 DotDebugLocEntry Entry = *I;
Devang Patel12188d52010-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 Pateld09fbfa2010-05-26 23:55:23 +00003622 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
Devang Patel12188d52010-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 Wendling55fccda2009-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 Lattner73266f92009-08-19 05:49:37 +00003646 Asm->OutStreamer.SwitchSection(
3647 Asm->getObjFileLowering().getDwarfARangesSection());
Bill Wendling55fccda2009-05-20 23:21:38 +00003648}
3649
Devang Patelc50078e2009-11-21 02:48:08 +00003650/// emitDebugRanges - Emit visible names into a debug ranges section.
Bill Wendling55fccda2009-05-20 23:21:38 +00003651///
Devang Patelc50078e2009-11-21 02:48:08 +00003652void DwarfDebug::emitDebugRanges() {
Bill Wendling55fccda2009-05-20 23:21:38 +00003653 // Start the dwarf ranges section.
Chris Lattner73266f92009-08-19 05:49:37 +00003654 Asm->OutStreamer.SwitchSection(
Devang Patel146c6f72010-04-16 23:33:45 +00003655 Asm->getObjFileLowering().getDwarfRangesSection());
Devang Patelce7bf012010-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 Patel146c6f72010-04-16 23:33:45 +00003662 else
Devang Patelce7bf012010-04-27 19:46:33 +00003663 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
Devang Patel146c6f72010-04-16 23:33:45 +00003664 }
Bill Wendling55fccda2009-05-20 23:21:38 +00003665}
3666
Devang Patelc50078e2009-11-21 02:48:08 +00003667/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
Bill Wendling55fccda2009-05-20 23:21:38 +00003668///
Devang Patelc50078e2009-11-21 02:48:08 +00003669void DwarfDebug::emitDebugMacInfo() {
Daniel Dunbar41716322009-09-19 20:40:05 +00003670 if (const MCSection *LineInfo =
Chris Lattner72d228d2009-08-02 07:24:22 +00003671 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
Bill Wendling55fccda2009-05-20 23:21:38 +00003672 // Start the dwarf macinfo section.
Chris Lattner73266f92009-08-19 05:49:37 +00003673 Asm->OutStreamer.SwitchSection(LineInfo);
Bill Wendling55fccda2009-05-20 23:21:38 +00003674 }
3675}
3676
Devang Patelc50078e2009-11-21 02:48:08 +00003677/// emitDebugInlineInfo - Emit inline info using following format.
Bill Wendling55fccda2009-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 Patelc50078e2009-11-21 02:48:08 +00003695void DwarfDebug::emitDebugInlineInfo() {
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003696 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
Bill Wendling55fccda2009-05-20 23:21:38 +00003697 return;
3698
Devang Patel7e5a86e2010-05-10 22:49:55 +00003699 if (!FirstCU)
Bill Wendling55fccda2009-05-20 23:21:38 +00003700 return;
3701
Chris Lattner73266f92009-08-19 05:49:37 +00003702 Asm->OutStreamer.SwitchSection(
3703 Asm->getObjFileLowering().getDwarfDebugInlineSection());
Chris Lattnerad653482010-01-22 22:09:00 +00003704
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003705 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
Chris Lattnerfd2a3f62010-04-04 19:58:12 +00003706 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3707 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
Bill Wendling55fccda2009-05-20 23:21:38 +00003708
Chris Lattnerb93558d2010-04-04 19:25:43 +00003709 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
Bill Wendling55fccda2009-05-20 23:21:38 +00003710
Chris Lattner9ef8efd2010-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 Lattnerbc0027b2010-04-05 00:13:49 +00003714 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
Bill Wendling55fccda2009-05-20 23:21:38 +00003715
Devang Patel9c371c62010-05-07 20:54:48 +00003716 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
Devang Patel90a0fe32009-11-10 23:06:00 +00003717 E = InlinedSPNodes.end(); I != E; ++I) {
Jim Grosbach652b7432009-11-21 23:12:12 +00003718
Devang Patel9c371c62010-05-07 20:54:48 +00003719 const MDNode *Node = *I;
3720 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
Jim Grosbachb23f2422009-11-22 19:20:36 +00003721 = InlineInfo.find(Node);
Devang Patel90a0fe32009-11-10 23:06:00 +00003722 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
Devang Patel15e723d2009-08-28 23:24:31 +00003723 DISubprogram SP(Node);
Devang Patel7f75bbe2009-11-25 17:36:49 +00003724 StringRef LName = SP.getLinkageName();
3725 StringRef Name = SP.getName();
Bill Wendling55fccda2009-05-20 23:21:38 +00003726
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003727 Asm->OutStreamer.AddComment("MIPS linkage name");
Chris Lattnercc564642010-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 Lattnerc06b4742010-04-04 23:25:33 +00003732 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3733 DwarfStrSectionSym);
Devang Patel90a0fe32009-11-10 23:06:00 +00003734
Chris Lattner9ef8efd2010-03-09 23:52:58 +00003735 Asm->OutStreamer.AddComment("Function name");
Chris Lattnerc06b4742010-04-04 23:25:33 +00003736 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
Chris Lattner26be1c12010-04-04 19:09:29 +00003737 Asm->EmitULEB128(Labels.size(), "Inline count");
Bill Wendling55fccda2009-05-20 23:21:38 +00003738
Devang Patel90a0fe32009-11-10 23:06:00 +00003739 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
Bill Wendling55fccda2009-05-20 23:21:38 +00003740 LE = Labels.end(); LI != LE; ++LI) {
Chris Lattner97c69b72010-04-04 18:52:31 +00003741 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
Chris Lattneread58652010-03-09 00:31:02 +00003742 Asm->EmitInt32(LI->second->getOffset());
Bill Wendling55fccda2009-05-20 23:21:38 +00003743
Chris Lattner97c69b72010-04-04 18:52:31 +00003744 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
Chris Lattnerbc0027b2010-04-05 00:13:49 +00003745 Asm->OutStreamer.EmitSymbolValue(LI->first,
3746 Asm->getTargetData().getPointerSize(),0);
Bill Wendling55fccda2009-05-20 23:21:38 +00003747 }
3748 }
3749
Chris Lattnerb93558d2010-04-04 19:25:43 +00003750 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
Bill Wendling55fccda2009-05-20 23:21:38 +00003751}