remove a noop function.
[oota-llvm.git] / lib / CodeGen / AsmPrinter / DwarfDebug.cpp
1 //===-- 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 //===----------------------------------------------------------------------===//
13 #define DEBUG_TYPE "dwarfdebug"
14 #include "DwarfDebug.h"
15 #include "llvm/Module.h"
16 #include "llvm/CodeGen/MachineFunction.h"
17 #include "llvm/CodeGen/MachineModuleInfo.h"
18 #include "llvm/MC/MCSection.h"
19 #include "llvm/MC/MCStreamer.h"
20 #include "llvm/MC/MCAsmInfo.h"
21 #include "llvm/Target/Mangler.h"
22 #include "llvm/Target/TargetData.h"
23 #include "llvm/Target/TargetFrameInfo.h"
24 #include "llvm/Target/TargetLoweringObjectFile.h"
25 #include "llvm/Target/TargetRegisterInfo.h"
26 #include "llvm/ADT/StringExtras.h"
27 #include "llvm/Support/Debug.h"
28 #include "llvm/Support/ErrorHandling.h"
29 #include "llvm/Support/ValueHandle.h"
30 #include "llvm/Support/FormattedStream.h"
31 #include "llvm/Support/Timer.h"
32 #include "llvm/System/Path.h"
33 using namespace llvm;
34
35 //===----------------------------------------------------------------------===//
36
37 /// Configuration values for initial hash set sizes (log2).
38 ///
39 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
40
41 namespace llvm {
42
43 //===----------------------------------------------------------------------===//
44 /// CompileUnit - This dwarf writer support class manages information associate
45 /// with a source file.
46 class CompileUnit {
47   /// ID - File identifier for source.
48   ///
49   unsigned ID;
50
51   /// Die - Compile unit debug information entry.
52   ///
53   DIE *CUDie;
54
55   /// IndexTyDie - An anonymous type for index type.
56   DIE *IndexTyDie;
57
58   /// GVToDieMap - Tracks the mapping of unit level debug informaton
59   /// variables to debug information entries.
60   /// FIXME : Rename GVToDieMap -> NodeToDieMap
61   DenseMap<MDNode *, DIE *> GVToDieMap;
62
63   /// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
64   /// descriptors to debug information entries using a DIEEntry proxy.
65   /// FIXME : Rename
66   DenseMap<MDNode *, DIEEntry *> GVToDIEEntryMap;
67
68   /// Globals - A map of globally visible named entities for this unit.
69   ///
70   StringMap<DIE*> Globals;
71
72   /// GlobalTypes - A map of globally visible types for this unit.
73   ///
74   StringMap<DIE*> GlobalTypes;
75
76 public:
77   CompileUnit(unsigned I, DIE *D)
78     : ID(I), CUDie(D), IndexTyDie(0) {}
79   ~CompileUnit() { delete CUDie; delete IndexTyDie; }
80
81   // Accessors.
82   unsigned getID()                  const { return ID; }
83   DIE* getCUDie()                   const { return CUDie; }
84   const StringMap<DIE*> &getGlobals()     const { return Globals; }
85   const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
86
87   /// hasContent - Return true if this compile unit has something to write out.
88   ///
89   bool hasContent() const { return !CUDie->getChildren().empty(); }
90
91   /// addGlobal - Add a new global entity to the compile unit.
92   ///
93   void addGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; }
94
95   /// addGlobalType - Add a new global type to the compile unit.
96   ///
97   void addGlobalType(const std::string &Name, DIE *Die) { 
98     GlobalTypes[Name] = Die; 
99   }
100
101   /// getDIE - Returns the debug information entry map slot for the
102   /// specified debug variable.
103   DIE *getDIE(MDNode *N) { return GVToDieMap.lookup(N); }
104
105   /// insertDIE - Insert DIE into the map.
106   void insertDIE(MDNode *N, DIE *D) {
107     GVToDieMap.insert(std::make_pair(N, D));
108   }
109
110   /// getDIEEntry - Returns the debug information entry for the speciefied
111   /// debug variable.
112   DIEEntry *getDIEEntry(MDNode *N) { 
113     DenseMap<MDNode *, DIEEntry *>::iterator I = GVToDIEEntryMap.find(N);
114     if (I == GVToDIEEntryMap.end())
115       return NULL;
116     return I->second;
117   }
118
119   /// insertDIEEntry - Insert debug information entry into the map.
120   void insertDIEEntry(MDNode *N, DIEEntry *E) {
121     GVToDIEEntryMap.insert(std::make_pair(N, E));
122   }
123
124   /// addDie - Adds or interns the DIE to the compile unit.
125   ///
126   void addDie(DIE *Buffer) {
127     this->CUDie->addChild(Buffer);
128   }
129
130   // getIndexTyDie - Get an anonymous type for index type.
131   DIE *getIndexTyDie() {
132     return IndexTyDie;
133   }
134
135   // setIndexTyDie - Set D as anonymous type for index which can be reused
136   // later.
137   void setIndexTyDie(DIE *D) {
138     IndexTyDie = D;
139   }
140
141 };
142
143 //===----------------------------------------------------------------------===//
144 /// DbgVariable - This class is used to track local variable information.
145 ///
146 class DbgVariable {
147   DIVariable Var;                    // Variable Descriptor.
148   unsigned FrameIndex;               // Variable frame index.
149   DbgVariable *AbstractVar;          // Abstract variable for this variable.
150   DIE *TheDIE;
151 public:
152   DbgVariable(DIVariable V, unsigned I)
153     : Var(V), FrameIndex(I), AbstractVar(0), TheDIE(0)  {}
154
155   // Accessors.
156   DIVariable getVariable()           const { return Var; }
157   unsigned getFrameIndex()           const { return FrameIndex; }
158   void setAbstractVariable(DbgVariable *V) { AbstractVar = V; }
159   DbgVariable *getAbstractVariable() const { return AbstractVar; }
160   void setDIE(DIE *D)                      { TheDIE = D; }
161   DIE *getDIE()                      const { return TheDIE; }
162 };
163
164 //===----------------------------------------------------------------------===//
165 /// DbgScope - This class is used to track scope information.
166 ///
167 class DbgScope {
168   DbgScope *Parent;                   // Parent to this scope.
169   DIDescriptor Desc;                  // Debug info descriptor for scope.
170   // Location at which this scope is inlined.
171   AssertingVH<MDNode> InlinedAtLocation;  
172   bool AbstractScope;                 // Abstract Scope
173   unsigned StartLabelID;              // Label ID of the beginning of scope.
174   unsigned EndLabelID;                // Label ID of the end of scope.
175   const MachineInstr *LastInsn;       // Last instruction of this scope.
176   const MachineInstr *FirstInsn;      // First instruction of this scope.
177   SmallVector<DbgScope *, 4> Scopes;  // Scopes defined in scope.
178   SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
179
180   // Private state for dump()
181   mutable unsigned IndentLevel;
182 public:
183   DbgScope(DbgScope *P, DIDescriptor D, MDNode *I = 0)
184     : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
185       StartLabelID(0), EndLabelID(0),
186       LastInsn(0), FirstInsn(0), IndentLevel(0) {}
187   virtual ~DbgScope();
188
189   // Accessors.
190   DbgScope *getParent()          const { return Parent; }
191   void setParent(DbgScope *P)          { Parent = P; }
192   DIDescriptor getDesc()         const { return Desc; }
193   MDNode *getInlinedAt()         const {
194     return InlinedAtLocation;
195   }
196   MDNode *getScopeNode()         const { return Desc.getNode(); }
197   unsigned getStartLabelID()     const { return StartLabelID; }
198   unsigned getEndLabelID()       const { return EndLabelID; }
199   SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
200   SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
201   void setStartLabelID(unsigned S) { StartLabelID = S; }
202   void setEndLabelID(unsigned E)   { EndLabelID = E; }
203   void setLastInsn(const MachineInstr *MI) { LastInsn = MI; }
204   const MachineInstr *getLastInsn()      { return LastInsn; }
205   void setFirstInsn(const MachineInstr *MI) { FirstInsn = MI; }
206   void setAbstractScope() { AbstractScope = true; }
207   bool isAbstractScope() const { return AbstractScope; }
208   const MachineInstr *getFirstInsn()      { return FirstInsn; }
209
210   /// addScope - Add a scope to the scope.
211   ///
212   void addScope(DbgScope *S) { Scopes.push_back(S); }
213
214   /// addVariable - Add a variable to the scope.
215   ///
216   void addVariable(DbgVariable *V) { Variables.push_back(V); }
217
218   void fixInstructionMarkers(DenseMap<const MachineInstr *, 
219                              unsigned> &MIIndexMap) {
220     assert (getFirstInsn() && "First instruction is missing!");
221     
222     // Use the end of last child scope as end of this scope.
223     SmallVector<DbgScope *, 4> &Scopes = getScopes();
224     const MachineInstr *LastInsn = getFirstInsn();
225     unsigned LIndex = 0;
226     if (Scopes.empty()) {
227       assert (getLastInsn() && "Inner most scope does not have last insn!");
228       return;
229     }
230     for (SmallVector<DbgScope *, 4>::iterator SI = Scopes.begin(),
231            SE = Scopes.end(); SI != SE; ++SI) {
232       DbgScope *DS = *SI;
233       DS->fixInstructionMarkers(MIIndexMap);
234       const MachineInstr *DSLastInsn = DS->getLastInsn();
235       unsigned DSI = MIIndexMap[DSLastInsn];
236       if (DSI > LIndex) {
237         LastInsn = DSLastInsn;
238         LIndex = DSI;
239       }
240     }
241     setLastInsn(LastInsn);
242   }
243
244 #ifndef NDEBUG
245   void dump() const;
246 #endif
247 };
248
249 #ifndef NDEBUG
250 void DbgScope::dump() const {
251   raw_ostream &err = dbgs();
252   err.indent(IndentLevel);
253   MDNode *N = Desc.getNode();
254   N->dump();
255   err << " [" << StartLabelID << ", " << EndLabelID << "]\n";
256   if (AbstractScope)
257     err << "Abstract Scope\n";
258
259   IndentLevel += 2;
260   if (!Scopes.empty())
261     err << "Children ...\n";
262   for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
263     if (Scopes[i] != this)
264       Scopes[i]->dump();
265
266   IndentLevel -= 2;
267 }
268 #endif
269
270 DbgScope::~DbgScope() {
271   for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
272     delete Scopes[i];
273   for (unsigned j = 0, M = Variables.size(); j < M; ++j)
274     delete Variables[j];
275 }
276
277 } // end llvm namespace
278
279 DwarfDebug::DwarfDebug(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T)
280   : DwarfPrinter(OS, A, T, "dbg"), ModuleCU(0),
281     AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
282     DIEValues(), StringPool(),
283     SectionSourceLines(), didInitial(false), shouldEmit(false),
284     CurrentFnDbgScope(0), DebugTimer(0) {
285   if (TimePassesIsEnabled)
286     DebugTimer = new Timer("Dwarf Debug Writer");
287 }
288 DwarfDebug::~DwarfDebug() {
289   for (unsigned j = 0, M = DIEValues.size(); j < M; ++j)
290     delete DIEValues[j];
291
292   delete DebugTimer;
293 }
294
295 /// assignAbbrevNumber - Define a unique number for the abbreviation.
296 ///
297 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
298   // Profile the node so that we can make it unique.
299   FoldingSetNodeID ID;
300   Abbrev.Profile(ID);
301
302   // Check the set for priors.
303   DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
304
305   // If it's newly added.
306   if (InSet == &Abbrev) {
307     // Add to abbreviation list.
308     Abbreviations.push_back(&Abbrev);
309
310     // Assign the vector position + 1 as its number.
311     Abbrev.setNumber(Abbreviations.size());
312   } else {
313     // Assign existing abbreviation number.
314     Abbrev.setNumber(InSet->getNumber());
315   }
316 }
317
318 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
319 /// information entry.
320 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
321   DIEEntry *Value = new DIEEntry(Entry);
322   DIEValues.push_back(Value);
323   return Value;
324 }
325
326 /// addUInt - Add an unsigned integer attribute data and value.
327 ///
328 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
329                          unsigned Form, uint64_t Integer) {
330   if (!Form) Form = DIEInteger::BestForm(false, Integer);
331   DIEValue *Value = new DIEInteger(Integer);
332   DIEValues.push_back(Value);
333   Die->addValue(Attribute, Form, Value);
334 }
335
336 /// addSInt - Add an signed integer attribute data and value.
337 ///
338 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
339                          unsigned Form, int64_t Integer) {
340   if (!Form) Form = DIEInteger::BestForm(true, Integer);
341   DIEValue *Value = new DIEInteger(Integer);
342   DIEValues.push_back(Value);
343   Die->addValue(Attribute, Form, Value);
344 }
345
346 /// addString - Add a string attribute data and value. DIEString only
347 /// keeps string reference. 
348 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
349                            StringRef String) {
350   DIEValue *Value = new DIEString(String);
351   DIEValues.push_back(Value);
352   Die->addValue(Attribute, Form, Value);
353 }
354
355 /// addLabel - Add a Dwarf label attribute data and value.
356 ///
357 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
358                           const DWLabel &Label) {
359   DIEValue *Value = new DIEDwarfLabel(Label);
360   DIEValues.push_back(Value);
361   Die->addValue(Attribute, Form, Value);
362 }
363
364 /// addObjectLabel - Add an non-Dwarf label attribute data and value.
365 ///
366 void DwarfDebug::addObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
367                                 const MCSymbol *Sym) {
368   DIEValue *Value = new DIEObjectLabel(Sym);
369   DIEValues.push_back(Value);
370   Die->addValue(Attribute, Form, Value);
371 }
372
373 /// addSectionOffset - Add a section offset label attribute data and value.
374 ///
375 void DwarfDebug::addSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
376                                   const DWLabel &Label, const DWLabel &Section,
377                                   bool isEH, bool useSet) {
378   DIEValue *Value = new DIESectionOffset(Label, Section, isEH, useSet);
379   DIEValues.push_back(Value);
380   Die->addValue(Attribute, Form, Value);
381 }
382
383 /// addDelta - Add a label delta attribute data and value.
384 ///
385 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
386                           const DWLabel &Hi, const DWLabel &Lo) {
387   DIEValue *Value = new DIEDelta(Hi, Lo);
388   DIEValues.push_back(Value);
389   Die->addValue(Attribute, Form, Value);
390 }
391
392 /// addBlock - Add block data.
393 ///
394 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
395                           DIEBlock *Block) {
396   Block->ComputeSize(TD);
397   DIEValues.push_back(Block);
398   Die->addValue(Attribute, Block->BestForm(), Block);
399 }
400
401 /// addSourceLine - Add location information to specified debug information
402 /// entry.
403 void DwarfDebug::addSourceLine(DIE *Die, const DIVariable *V) {
404   // If there is no compile unit specified, don't add a line #.
405   if (V->getCompileUnit().isNull())
406     return;
407
408   unsigned Line = V->getLineNumber();
409   unsigned FileID = findCompileUnit(V->getCompileUnit())->getID();
410   assert(FileID && "Invalid file id");
411   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
412   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
413 }
414
415 /// addSourceLine - Add location information to specified debug information
416 /// entry.
417 void DwarfDebug::addSourceLine(DIE *Die, const DIGlobal *G) {
418   // If there is no compile unit specified, don't add a line #.
419   if (G->getCompileUnit().isNull())
420     return;
421
422   unsigned Line = G->getLineNumber();
423   unsigned FileID = findCompileUnit(G->getCompileUnit())->getID();
424   assert(FileID && "Invalid file id");
425   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
426   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
427 }
428
429 /// addSourceLine - Add location information to specified debug information
430 /// entry.
431 void DwarfDebug::addSourceLine(DIE *Die, const DISubprogram *SP) {
432   // If there is no compile unit specified, don't add a line #.
433   if (SP->getCompileUnit().isNull())
434     return;
435   // If the line number is 0, don't add it.
436   if (SP->getLineNumber() == 0)
437     return;
438
439
440   unsigned Line = SP->getLineNumber();
441   unsigned FileID = findCompileUnit(SP->getCompileUnit())->getID();
442   assert(FileID && "Invalid file id");
443   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
444   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
445 }
446
447 /// addSourceLine - Add location information to specified debug information
448 /// entry.
449 void DwarfDebug::addSourceLine(DIE *Die, const DIType *Ty) {
450   // If there is no compile unit specified, don't add a line #.
451   DICompileUnit CU = Ty->getCompileUnit();
452   if (CU.isNull())
453     return;
454
455   unsigned Line = Ty->getLineNumber();
456   unsigned FileID = findCompileUnit(CU)->getID();
457   assert(FileID && "Invalid file id");
458   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
459   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
460 }
461
462 /// addSourceLine - Add location information to specified debug information
463 /// entry.
464 void DwarfDebug::addSourceLine(DIE *Die, const DINameSpace *NS) {
465   // If there is no compile unit specified, don't add a line #.
466   if (NS->getCompileUnit().isNull())
467     return;
468
469   unsigned Line = NS->getLineNumber();
470   StringRef FN = NS->getFilename();
471   StringRef Dir = NS->getDirectory();
472
473   unsigned FileID = GetOrCreateSourceID(Dir, FN);
474   assert(FileID && "Invalid file id");
475   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
476   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
477 }
478
479 /* Byref variables, in Blocks, are declared by the programmer as
480    "SomeType VarName;", but the compiler creates a
481    __Block_byref_x_VarName struct, and gives the variable VarName
482    either the struct, or a pointer to the struct, as its type.  This
483    is necessary for various behind-the-scenes things the compiler
484    needs to do with by-reference variables in blocks.
485
486    However, as far as the original *programmer* is concerned, the
487    variable should still have type 'SomeType', as originally declared.
488
489    The following function dives into the __Block_byref_x_VarName
490    struct to find the original type of the variable.  This will be
491    passed back to the code generating the type for the Debug
492    Information Entry for the variable 'VarName'.  'VarName' will then
493    have the original type 'SomeType' in its debug information.
494
495    The original type 'SomeType' will be the type of the field named
496    'VarName' inside the __Block_byref_x_VarName struct.
497
498    NOTE: In order for this to not completely fail on the debugger
499    side, the Debug Information Entry for the variable VarName needs to
500    have a DW_AT_location that tells the debugger how to unwind through
501    the pointers and __Block_byref_x_VarName struct to find the actual
502    value of the variable.  The function addBlockByrefType does this.  */
503
504 /// Find the type the programmer originally declared the variable to be
505 /// and return that type.
506 ///
507 DIType DwarfDebug::getBlockByrefType(DIType Ty, std::string Name) {
508
509   DIType subType = Ty;
510   unsigned tag = Ty.getTag();
511
512   if (tag == dwarf::DW_TAG_pointer_type) {
513     DIDerivedType DTy = DIDerivedType(Ty.getNode());
514     subType = DTy.getTypeDerivedFrom();
515   }
516
517   DICompositeType blockStruct = DICompositeType(subType.getNode());
518
519   DIArray Elements = blockStruct.getTypeArray();
520
521   if (Elements.isNull())
522     return Ty;
523
524   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
525     DIDescriptor Element = Elements.getElement(i);
526     DIDerivedType DT = DIDerivedType(Element.getNode());
527     if (Name == DT.getName())
528       return (DT.getTypeDerivedFrom());
529   }
530
531   return Ty;
532 }
533
534 /// addComplexAddress - Start with the address based on the location provided,
535 /// and generate the DWARF information necessary to find the actual variable
536 /// given the extra address information encoded in the DIVariable, starting from
537 /// the starting location.  Add the DWARF information to the die.
538 ///
539 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
540                                    unsigned Attribute,
541                                    const MachineLocation &Location) {
542   const DIVariable &VD = DV->getVariable();
543   DIType Ty = VD.getType();
544
545   // Decode the original location, and use that as the start of the byref
546   // variable's location.
547   unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
548   DIEBlock *Block = new DIEBlock();
549
550   if (Location.isReg()) {
551     if (Reg < 32) {
552       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
553     } else {
554       Reg = Reg - dwarf::DW_OP_reg0;
555       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
556       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
557     }
558   } else {
559     if (Reg < 32)
560       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
561     else {
562       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
563       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
564     }
565
566     addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
567   }
568
569   for (unsigned i = 0, N = VD.getNumAddrElements(); i < N; ++i) {
570     uint64_t Element = VD.getAddrElement(i);
571
572     if (Element == DIFactory::OpPlus) {
573       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
574       addUInt(Block, 0, dwarf::DW_FORM_udata, VD.getAddrElement(++i));
575     } else if (Element == DIFactory::OpDeref) {
576       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
577     } else llvm_unreachable("unknown DIFactory Opcode");
578   }
579
580   // Now attach the location information to the DIE.
581   addBlock(Die, Attribute, 0, Block);
582 }
583
584 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
585    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
586    gives the variable VarName either the struct, or a pointer to the struct, as
587    its type.  This is necessary for various behind-the-scenes things the
588    compiler needs to do with by-reference variables in Blocks.
589
590    However, as far as the original *programmer* is concerned, the variable
591    should still have type 'SomeType', as originally declared.
592
593    The function getBlockByrefType dives into the __Block_byref_x_VarName
594    struct to find the original type of the variable, which is then assigned to
595    the variable's Debug Information Entry as its real type.  So far, so good.
596    However now the debugger will expect the variable VarName to have the type
597    SomeType.  So we need the location attribute for the variable to be an
598    expression that explains to the debugger how to navigate through the
599    pointers and struct to find the actual variable of type SomeType.
600
601    The following function does just that.  We start by getting
602    the "normal" location for the variable. This will be the location
603    of either the struct __Block_byref_x_VarName or the pointer to the
604    struct __Block_byref_x_VarName.
605
606    The struct will look something like:
607
608    struct __Block_byref_x_VarName {
609      ... <various fields>
610      struct __Block_byref_x_VarName *forwarding;
611      ... <various other fields>
612      SomeType VarName;
613      ... <maybe more fields>
614    };
615
616    If we are given the struct directly (as our starting point) we
617    need to tell the debugger to:
618
619    1).  Add the offset of the forwarding field.
620
621    2).  Follow that pointer to get the the real __Block_byref_x_VarName
622    struct to use (the real one may have been copied onto the heap).
623
624    3).  Add the offset for the field VarName, to find the actual variable.
625
626    If we started with a pointer to the struct, then we need to
627    dereference that pointer first, before the other steps.
628    Translating this into DWARF ops, we will need to append the following
629    to the current location description for the variable:
630
631    DW_OP_deref                    -- optional, if we start with a pointer
632    DW_OP_plus_uconst <forward_fld_offset>
633    DW_OP_deref
634    DW_OP_plus_uconst <varName_fld_offset>
635
636    That is what this function does.  */
637
638 /// addBlockByrefAddress - Start with the address based on the location
639 /// provided, and generate the DWARF information necessary to find the
640 /// actual Block variable (navigating the Block struct) based on the
641 /// starting location.  Add the DWARF information to the die.  For
642 /// more information, read large comment just above here.
643 ///
644 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
645                                       unsigned Attribute,
646                                       const MachineLocation &Location) {
647   const DIVariable &VD = DV->getVariable();
648   DIType Ty = VD.getType();
649   DIType TmpTy = Ty;
650   unsigned Tag = Ty.getTag();
651   bool isPointer = false;
652
653   StringRef varName = VD.getName();
654
655   if (Tag == dwarf::DW_TAG_pointer_type) {
656     DIDerivedType DTy = DIDerivedType(Ty.getNode());
657     TmpTy = DTy.getTypeDerivedFrom();
658     isPointer = true;
659   }
660
661   DICompositeType blockStruct = DICompositeType(TmpTy.getNode());
662
663   // Find the __forwarding field and the variable field in the __Block_byref
664   // struct.
665   DIArray Fields = blockStruct.getTypeArray();
666   DIDescriptor varField = DIDescriptor();
667   DIDescriptor forwardingField = DIDescriptor();
668
669
670   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
671     DIDescriptor Element = Fields.getElement(i);
672     DIDerivedType DT = DIDerivedType(Element.getNode());
673     StringRef fieldName = DT.getName();
674     if (fieldName == "__forwarding")
675       forwardingField = Element;
676     else if (fieldName == varName)
677       varField = Element;
678   }
679
680   assert(!varField.isNull() && "Can't find byref variable in Block struct");
681   assert(!forwardingField.isNull()
682          && "Can't find forwarding field in Block struct");
683
684   // Get the offsets for the forwarding field and the variable field.
685   unsigned int forwardingFieldOffset =
686     DIDerivedType(forwardingField.getNode()).getOffsetInBits() >> 3;
687   unsigned int varFieldOffset =
688     DIDerivedType(varField.getNode()).getOffsetInBits() >> 3;
689
690   // Decode the original location, and use that as the start of the byref
691   // variable's location.
692   unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
693   DIEBlock *Block = new DIEBlock();
694
695   if (Location.isReg()) {
696     if (Reg < 32)
697       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
698     else {
699       Reg = Reg - dwarf::DW_OP_reg0;
700       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
701       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
702     }
703   } else {
704     if (Reg < 32)
705       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
706     else {
707       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
708       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
709     }
710
711     addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
712   }
713
714   // If we started with a pointer to the __Block_byref... struct, then
715   // the first thing we need to do is dereference the pointer (DW_OP_deref).
716   if (isPointer)
717     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
718
719   // Next add the offset for the '__forwarding' field:
720   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
721   // adding the offset if it's 0.
722   if (forwardingFieldOffset > 0) {
723     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
724     addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
725   }
726
727   // Now dereference the __forwarding field to get to the real __Block_byref
728   // struct:  DW_OP_deref.
729   addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
730
731   // Now that we've got the real __Block_byref... struct, add the offset
732   // for the variable's field to get to the location of the actual variable:
733   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
734   if (varFieldOffset > 0) {
735     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
736     addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
737   }
738
739   // Now attach the location information to the DIE.
740   addBlock(Die, Attribute, 0, Block);
741 }
742
743 /// addAddress - Add an address attribute to a die based on the location
744 /// provided.
745 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
746                             const MachineLocation &Location) {
747   unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
748   DIEBlock *Block = new DIEBlock();
749
750   if (Location.isReg()) {
751     if (Reg < 32) {
752       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
753     } else {
754       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
755       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
756     }
757   } else {
758     if (Reg < 32) {
759       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
760     } else {
761       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
762       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
763     }
764
765     addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
766   }
767
768   addBlock(Die, Attribute, 0, Block);
769 }
770
771 /// addToContextOwner - Add Die into the list of its context owner's children.
772 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
773   if (Context.isNull())
774     ModuleCU->addDie(Die);
775   else if (Context.isType()) {
776     DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context.getNode()));
777     ContextDIE->addChild(Die);
778   } else if (Context.isNameSpace()) {
779     DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context.getNode()));
780     ContextDIE->addChild(Die);
781   } else if (DIE *ContextDIE = ModuleCU->getDIE(Context.getNode()))
782     ContextDIE->addChild(Die);
783   else 
784     ModuleCU->addDie(Die);
785 }
786
787 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
788 /// given DIType.
789 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
790   DIE *TyDIE = ModuleCU->getDIE(Ty.getNode());
791   if (TyDIE)
792     return TyDIE;
793
794   // Create new type.
795   TyDIE = new DIE(dwarf::DW_TAG_base_type);
796   ModuleCU->insertDIE(Ty.getNode(), TyDIE);
797   if (Ty.isBasicType())
798     constructTypeDIE(*TyDIE, DIBasicType(Ty.getNode()));
799   else if (Ty.isCompositeType())
800     constructTypeDIE(*TyDIE, DICompositeType(Ty.getNode()));
801   else {
802     assert(Ty.isDerivedType() && "Unknown kind of DIType");
803     constructTypeDIE(*TyDIE, DIDerivedType(Ty.getNode()));
804   }
805
806   addToContextOwner(TyDIE, Ty.getContext());
807   return TyDIE;
808 }
809
810 /// addType - Add a new type attribute to the specified entity.
811 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
812   if (Ty.isNull())
813     return;
814
815   // Check for pre-existence.
816   DIEEntry *Entry = ModuleCU->getDIEEntry(Ty.getNode());
817   // If it exists then use the existing value.
818   if (Entry) {
819     Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
820     return;
821   }
822
823   // Set up proxy.
824   Entry = createDIEEntry();
825   ModuleCU->insertDIEEntry(Ty.getNode(), Entry);
826
827   // Construct type.
828   DIE *Buffer = getOrCreateTypeDIE(Ty);
829
830   Entry->setEntry(Buffer);
831   Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
832 }
833
834 /// constructTypeDIE - Construct basic type die from DIBasicType.
835 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
836   // Get core information.
837   StringRef Name = BTy.getName();
838   Buffer.setTag(dwarf::DW_TAG_base_type);
839   addUInt(&Buffer, dwarf::DW_AT_encoding,  dwarf::DW_FORM_data1,
840           BTy.getEncoding());
841
842   // Add name if not anonymous or intermediate type.
843   if (!Name.empty())
844     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
845   uint64_t Size = BTy.getSizeInBits() >> 3;
846   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
847 }
848
849 /// constructTypeDIE - Construct derived type die from DIDerivedType.
850 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
851   // Get core information.
852   StringRef Name = DTy.getName();
853   uint64_t Size = DTy.getSizeInBits() >> 3;
854   unsigned Tag = DTy.getTag();
855
856   // FIXME - Workaround for templates.
857   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
858
859   Buffer.setTag(Tag);
860
861   // Map to main type, void will not have a type.
862   DIType FromTy = DTy.getTypeDerivedFrom();
863   addType(&Buffer, FromTy);
864
865   // Add name if not anonymous or intermediate type.
866   if (!Name.empty())
867     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
868
869   // Add size if non-zero (derived types might be zero-sized.)
870   if (Size)
871     addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
872
873   // Add source line info if available and TyDesc is not a forward declaration.
874   if (!DTy.isForwardDecl())
875     addSourceLine(&Buffer, &DTy);
876 }
877
878 /// constructTypeDIE - Construct type DIE from DICompositeType.
879 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
880   // Get core information.
881   StringRef Name = CTy.getName();
882
883   uint64_t Size = CTy.getSizeInBits() >> 3;
884   unsigned Tag = CTy.getTag();
885   Buffer.setTag(Tag);
886
887   switch (Tag) {
888   case dwarf::DW_TAG_vector_type:
889   case dwarf::DW_TAG_array_type:
890     constructArrayTypeDIE(Buffer, &CTy);
891     break;
892   case dwarf::DW_TAG_enumeration_type: {
893     DIArray Elements = CTy.getTypeArray();
894
895     // Add enumerators to enumeration type.
896     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
897       DIE *ElemDie = NULL;
898       DIEnumerator Enum(Elements.getElement(i).getNode());
899       if (!Enum.isNull()) {
900         ElemDie = constructEnumTypeDIE(&Enum);
901         Buffer.addChild(ElemDie);
902       }
903     }
904   }
905     break;
906   case dwarf::DW_TAG_subroutine_type: {
907     // Add return type.
908     DIArray Elements = CTy.getTypeArray();
909     DIDescriptor RTy = Elements.getElement(0);
910     addType(&Buffer, DIType(RTy.getNode()));
911
912     // Add prototype flag.
913     addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
914
915     // Add arguments.
916     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
917       DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
918       DIDescriptor Ty = Elements.getElement(i);
919       addType(Arg, DIType(Ty.getNode()));
920       Buffer.addChild(Arg);
921     }
922   }
923     break;
924   case dwarf::DW_TAG_structure_type:
925   case dwarf::DW_TAG_union_type:
926   case dwarf::DW_TAG_class_type: {
927     // Add elements to structure type.
928     DIArray Elements = CTy.getTypeArray();
929
930     // A forward struct declared type may not have elements available.
931     if (Elements.isNull())
932       break;
933
934     // Add elements to structure type.
935     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
936       DIDescriptor Element = Elements.getElement(i);
937       if (Element.isNull())
938         continue;
939       DIE *ElemDie = NULL;
940       if (Element.getTag() == dwarf::DW_TAG_subprogram)
941         ElemDie = createSubprogramDIE(DISubprogram(Element.getNode()));
942       else
943         ElemDie = createMemberDIE(DIDerivedType(Element.getNode()));
944       Buffer.addChild(ElemDie);
945     }
946
947     if (CTy.isAppleBlockExtension())
948       addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
949
950     unsigned RLang = CTy.getRunTimeLang();
951     if (RLang)
952       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
953               dwarf::DW_FORM_data1, RLang);
954
955     DICompositeType ContainingType = CTy.getContainingType();
956     if (!ContainingType.isNull())
957       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 
958                   getOrCreateTypeDIE(DIType(ContainingType.getNode())));
959     break;
960   }
961   default:
962     break;
963   }
964
965   // Add name if not anonymous or intermediate type.
966   if (!Name.empty())
967     addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
968
969   if (Tag == dwarf::DW_TAG_enumeration_type ||
970       Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
971     // Add size if non-zero (derived types might be zero-sized.)
972     if (Size)
973       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
974     else {
975       // Add zero size if it is not a forward declaration.
976       if (CTy.isForwardDecl())
977         addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
978       else
979         addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
980     }
981
982     // Add source line info if available.
983     if (!CTy.isForwardDecl())
984       addSourceLine(&Buffer, &CTy);
985   }
986 }
987
988 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
989 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
990   int64_t L = SR.getLo();
991   int64_t H = SR.getHi();
992   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
993
994   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
995   if (L)
996     addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
997   addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
998
999   Buffer.addChild(DW_Subrange);
1000 }
1001
1002 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1003 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1004                                        DICompositeType *CTy) {
1005   Buffer.setTag(dwarf::DW_TAG_array_type);
1006   if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1007     addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1008
1009   // Emit derived type.
1010   addType(&Buffer, CTy->getTypeDerivedFrom());
1011   DIArray Elements = CTy->getTypeArray();
1012
1013   // Get an anonymous type for index type.
1014   DIE *IdxTy = ModuleCU->getIndexTyDie();
1015   if (!IdxTy) {
1016     // Construct an anonymous type for index type.
1017     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1018     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1019     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1020             dwarf::DW_ATE_signed);
1021     ModuleCU->addDie(IdxTy);
1022     ModuleCU->setIndexTyDie(IdxTy);
1023   }
1024
1025   // Add subranges to array type.
1026   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1027     DIDescriptor Element = Elements.getElement(i);
1028     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1029       constructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IdxTy);
1030   }
1031 }
1032
1033 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1034 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator *ETy) {
1035   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1036   StringRef Name = ETy->getName();
1037   addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1038   int64_t Value = ETy->getEnumValue();
1039   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1040   return Enumerator;
1041 }
1042
1043 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm 
1044 /// printer to not emit usual symbol prefix before the symbol name is used then
1045 /// return linkage name after skipping this special LLVM prefix.
1046 static StringRef getRealLinkageName(StringRef LinkageName) {
1047   char One = '\1';
1048   if (LinkageName.startswith(StringRef(&One, 1)))
1049     return LinkageName.substr(1);
1050   return LinkageName;
1051 }
1052
1053 /// createGlobalVariableDIE - Create new DIE using GV.
1054 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1055   // If the global variable was optmized out then no need to create debug info
1056   // entry.
1057   if (!GV.getGlobal()) return NULL;
1058   if (GV.getDisplayName().empty()) return NULL;
1059
1060   DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1061   addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1062             GV.getDisplayName());
1063
1064   StringRef LinkageName = GV.getLinkageName();
1065   if (!LinkageName.empty())
1066     addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1067               getRealLinkageName(LinkageName));
1068
1069   addType(GVDie, GV.getType());
1070   if (!GV.isLocalToUnit())
1071     addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1072   addSourceLine(GVDie, &GV);
1073
1074   return GVDie;
1075 }
1076
1077 /// createMemberDIE - Create new member DIE.
1078 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1079   DIE *MemberDie = new DIE(DT.getTag());
1080   StringRef Name = DT.getName();
1081   if (!Name.empty())
1082     addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1083   
1084   addType(MemberDie, DT.getTypeDerivedFrom());
1085
1086   addSourceLine(MemberDie, &DT);
1087
1088   DIEBlock *MemLocationDie = new DIEBlock();
1089   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1090
1091   uint64_t Size = DT.getSizeInBits();
1092   uint64_t FieldSize = DT.getOriginalTypeSize();
1093
1094   if (Size != FieldSize) {
1095     // Handle bitfield.
1096     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1097     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1098
1099     uint64_t Offset = DT.getOffsetInBits();
1100     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1101     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1102     uint64_t FieldOffset = (HiMark - FieldSize);
1103     Offset -= FieldOffset;
1104
1105     // Maybe we need to work from the other end.
1106     if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
1107     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1108
1109     // Here WD_AT_data_member_location points to the anonymous
1110     // field that includes this bit field.
1111     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1112
1113   } else
1114     // This is not a bitfield.
1115     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1116
1117   addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1118
1119   if (DT.isProtected())
1120     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1121             dwarf::DW_ACCESS_protected);
1122   else if (DT.isPrivate())
1123     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1124             dwarf::DW_ACCESS_private);
1125   else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1126     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1127             dwarf::DW_ACCESS_public);
1128   if (DT.isVirtual())
1129     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1130             dwarf::DW_VIRTUALITY_virtual);
1131   return MemberDie;
1132 }
1133
1134 /// createSubprogramDIE - Create new DIE using SP.
1135 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1136   DIE *SPDie = ModuleCU->getDIE(SP.getNode());
1137   if (SPDie)
1138     return SPDie;
1139
1140   SPDie = new DIE(dwarf::DW_TAG_subprogram);
1141   addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1142
1143   StringRef LinkageName = SP.getLinkageName();
1144   if (!LinkageName.empty())
1145     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1146               getRealLinkageName(LinkageName));
1147
1148   addSourceLine(SPDie, &SP);
1149
1150   // Add prototyped tag, if C or ObjC.
1151   unsigned Lang = SP.getCompileUnit().getLanguage();
1152   if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1153       Lang == dwarf::DW_LANG_ObjC)
1154     addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1155
1156   // Add Return Type.
1157   DICompositeType SPTy = SP.getType();
1158   DIArray Args = SPTy.getTypeArray();
1159   unsigned SPTag = SPTy.getTag();
1160
1161   if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
1162     addType(SPDie, SPTy);
1163   else
1164     addType(SPDie, DIType(Args.getElement(0).getNode()));
1165
1166   unsigned VK = SP.getVirtuality();
1167   if (VK) {
1168     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1169     DIEBlock *Block = new DIEBlock();
1170     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1171     addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1172     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1173     ContainingTypeMap.insert(std::make_pair(SPDie, 
1174                                             SP.getContainingType().getNode()));
1175   }
1176
1177   if (MakeDecl || !SP.isDefinition()) {
1178     addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1179
1180     // Add arguments. Do not add arguments for subprogram definition. They will
1181     // be handled while processing variables.
1182     DICompositeType SPTy = SP.getType();
1183     DIArray Args = SPTy.getTypeArray();
1184     unsigned SPTag = SPTy.getTag();
1185
1186     if (SPTag == dwarf::DW_TAG_subroutine_type)
1187       for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1188         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1189         addType(Arg, DIType(Args.getElement(i).getNode()));
1190         addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1191         SPDie->addChild(Arg);
1192       }
1193   }
1194
1195   // DW_TAG_inlined_subroutine may refer to this DIE.
1196   ModuleCU->insertDIE(SP.getNode(), SPDie);
1197   return SPDie;
1198 }
1199
1200 /// findCompileUnit - Get the compile unit for the given descriptor.
1201 ///
1202 CompileUnit *DwarfDebug::findCompileUnit(DICompileUnit Unit) {
1203   DenseMap<Value *, CompileUnit *>::const_iterator I =
1204     CompileUnitMap.find(Unit.getNode());
1205   if (I == CompileUnitMap.end())
1206     return constructCompileUnit(Unit.getNode());
1207   return I->second;
1208 }
1209
1210 /// getUpdatedDbgScope - Find or create DbgScope assicated with the instruction.
1211 /// Initialize scope and update scope hierarchy.
1212 DbgScope *DwarfDebug::getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
1213   MDNode *InlinedAt) {
1214   assert (N && "Invalid Scope encoding!");
1215   assert (MI && "Missing machine instruction!");
1216   bool GetConcreteScope = (MI && InlinedAt);
1217
1218   DbgScope *NScope = NULL;
1219
1220   if (InlinedAt)
1221     NScope = DbgScopeMap.lookup(InlinedAt);
1222   else
1223     NScope = DbgScopeMap.lookup(N);
1224   assert (NScope && "Unable to find working scope!");
1225
1226   if (NScope->getFirstInsn())
1227     return NScope;
1228
1229   DbgScope *Parent = NULL;
1230   if (GetConcreteScope) {
1231     DILocation IL(InlinedAt);
1232     Parent = getUpdatedDbgScope(IL.getScope().getNode(), MI,
1233                          IL.getOrigLocation().getNode());
1234     assert (Parent && "Unable to find Parent scope!");
1235     NScope->setParent(Parent);
1236     Parent->addScope(NScope);
1237   } else if (DIDescriptor(N).isLexicalBlock()) {
1238     DILexicalBlock DB(N);
1239     if (!DB.getContext().isNull()) {
1240       Parent = getUpdatedDbgScope(DB.getContext().getNode(), MI, InlinedAt);
1241       NScope->setParent(Parent);
1242       Parent->addScope(NScope);
1243     }
1244   }
1245
1246   NScope->setFirstInsn(MI);
1247
1248   if (!Parent && !InlinedAt) {
1249     StringRef SPName = DISubprogram(N).getLinkageName();
1250     if (SPName == MF->getFunction()->getName())
1251       CurrentFnDbgScope = NScope;
1252   }
1253
1254   if (GetConcreteScope) {
1255     ConcreteScopes[InlinedAt] = NScope;
1256     getOrCreateAbstractScope(N);
1257   }
1258
1259   return NScope;
1260 }
1261
1262 DbgScope *DwarfDebug::getOrCreateAbstractScope(MDNode *N) {
1263   assert (N && "Invalid Scope encoding!");
1264
1265   DbgScope *AScope = AbstractScopes.lookup(N);
1266   if (AScope)
1267     return AScope;
1268
1269   DbgScope *Parent = NULL;
1270
1271   DIDescriptor Scope(N);
1272   if (Scope.isLexicalBlock()) {
1273     DILexicalBlock DB(N);
1274     DIDescriptor ParentDesc = DB.getContext();
1275     if (!ParentDesc.isNull())
1276       Parent = getOrCreateAbstractScope(ParentDesc.getNode());
1277   }
1278
1279   AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1280
1281   if (Parent)
1282     Parent->addScope(AScope);
1283   AScope->setAbstractScope();
1284   AbstractScopes[N] = AScope;
1285   if (DIDescriptor(N).isSubprogram())
1286     AbstractScopesList.push_back(AScope);
1287   return AScope;
1288 }
1289
1290 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1291 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1292 /// If there are global variables in this scope then create and insert
1293 /// DIEs for these variables.
1294 DIE *DwarfDebug::updateSubprogramScopeDIE(MDNode *SPNode) {
1295
1296  DIE *SPDie = ModuleCU->getDIE(SPNode);
1297  assert (SPDie && "Unable to find subprogram DIE!");
1298  DISubprogram SP(SPNode);
1299  if (SP.isDefinition() && !SP.getContext().isCompileUnit()) {
1300    addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1301   // Add arguments. 
1302    DICompositeType SPTy = SP.getType();
1303    DIArray Args = SPTy.getTypeArray();
1304    unsigned SPTag = SPTy.getTag();
1305    if (SPTag == dwarf::DW_TAG_subroutine_type)
1306      for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1307        DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1308        addType(Arg, DIType(Args.getElement(i).getNode()));
1309        addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
1310        SPDie->addChild(Arg);
1311      }
1312    DIE *SPDeclDie = SPDie;
1313    SPDie = new DIE(dwarf::DW_TAG_subprogram);
1314    addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4, 
1315                SPDeclDie);
1316    ModuleCU->addDie(SPDie);
1317  }
1318    
1319  addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1320           DWLabel("func_begin", SubprogramCount));
1321  addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1322           DWLabel("func_end", SubprogramCount));
1323  MachineLocation Location(RI->getFrameRegister(*MF));
1324  addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1325
1326  if (!DISubprogram(SPNode).isLocalToUnit())
1327    addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1328
1329  return SPDie;
1330 }
1331
1332 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1333 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1334 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1335   unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1336   unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1337
1338   // Ignore empty scopes.
1339   if (StartID == EndID && StartID != 0)
1340     return NULL;
1341
1342   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1343   if (Scope->isAbstractScope())
1344     return ScopeDIE;
1345
1346   addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1347            StartID ?
1348              DWLabel("label", StartID)
1349            : DWLabel("func_begin", SubprogramCount));
1350   addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1351            EndID ?
1352              DWLabel("label", EndID)
1353            : DWLabel("func_end", SubprogramCount));
1354
1355
1356
1357   return ScopeDIE;
1358 }
1359
1360 /// constructInlinedScopeDIE - This scope represents inlined body of
1361 /// a function. Construct DIE to represent this concrete inlined copy
1362 /// of the function.
1363 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1364   unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
1365   unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
1366   assert (StartID && "Invalid starting label for an inlined scope!");
1367   assert (EndID && "Invalid end label for an inlined scope!");
1368   // Ignore empty scopes.
1369   if (StartID == EndID && StartID != 0)
1370     return NULL;
1371
1372   DIScope DS(Scope->getScopeNode());
1373   if (DS.isNull())
1374     return NULL;
1375   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1376
1377   DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1378   DIE *OriginDIE = ModuleCU->getDIE(InlinedSP.getNode());
1379   assert (OriginDIE && "Unable to find Origin DIE!");
1380   addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1381               dwarf::DW_FORM_ref4, OriginDIE);
1382
1383   addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1384            DWLabel("label", StartID));
1385   addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1386            DWLabel("label", EndID));
1387
1388   InlinedSubprogramDIEs.insert(OriginDIE);
1389
1390   // Track the start label for this inlined function.
1391   DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1392     I = InlineInfo.find(InlinedSP.getNode());
1393
1394   if (I == InlineInfo.end()) {
1395     InlineInfo[InlinedSP.getNode()].push_back(std::make_pair(StartID,
1396                                                              ScopeDIE));
1397     InlinedSPNodes.push_back(InlinedSP.getNode());
1398   } else
1399     I->second.push_back(std::make_pair(StartID, ScopeDIE));
1400
1401   StringPool.insert(InlinedSP.getName());
1402   StringPool.insert(getRealLinkageName(InlinedSP.getLinkageName()));
1403
1404   DILocation DL(Scope->getInlinedAt());
1405   addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
1406   addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1407
1408   return ScopeDIE;
1409 }
1410
1411
1412 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1413 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1414   // Get the descriptor.
1415   const DIVariable &VD = DV->getVariable();
1416   StringRef Name = VD.getName();
1417   if (Name.empty())
1418     return NULL;
1419
1420   // Translate tag to proper Dwarf tag.  The result variable is dropped for
1421   // now.
1422   unsigned Tag;
1423   switch (VD.getTag()) {
1424   case dwarf::DW_TAG_return_variable:
1425     return NULL;
1426   case dwarf::DW_TAG_arg_variable:
1427     Tag = dwarf::DW_TAG_formal_parameter;
1428     break;
1429   case dwarf::DW_TAG_auto_variable:    // fall thru
1430   default:
1431     Tag = dwarf::DW_TAG_variable;
1432     break;
1433   }
1434
1435   // Define variable debug information entry.
1436   DIE *VariableDie = new DIE(Tag);
1437
1438
1439   DIE *AbsDIE = NULL;
1440   if (DbgVariable *AV = DV->getAbstractVariable())
1441     AbsDIE = AV->getDIE();
1442
1443   if (AbsDIE) {
1444     DIScope DS(Scope->getScopeNode());
1445     DISubprogram InlinedSP = getDISubprogram(DS.getNode());
1446     DIE *OriginSPDIE = ModuleCU->getDIE(InlinedSP.getNode());
1447     (void) OriginSPDIE;
1448     assert (OriginSPDIE && "Unable to find Origin DIE for the SP!");
1449     DIE *AbsDIE = DV->getAbstractVariable()->getDIE();
1450     assert (AbsDIE && "Unable to find Origin DIE for the Variable!");
1451     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1452                 dwarf::DW_FORM_ref4, AbsDIE);
1453   }
1454   else {
1455     addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1456     addSourceLine(VariableDie, &VD);
1457
1458     // Add variable type.
1459     // FIXME: isBlockByrefVariable should be reformulated in terms of complex
1460     // addresses instead.
1461     if (VD.isBlockByrefVariable())
1462       addType(VariableDie, getBlockByrefType(VD.getType(), Name));
1463     else
1464       addType(VariableDie, VD.getType());
1465   }
1466
1467   // Add variable address.
1468   if (!Scope->isAbstractScope()) {
1469     MachineLocation Location;
1470     unsigned FrameReg;
1471     int Offset = RI->getFrameIndexReference(*MF, DV->getFrameIndex(), FrameReg);
1472     Location.set(FrameReg, Offset);
1473
1474     if (VD.hasComplexAddress())
1475       addComplexAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1476     else if (VD.isBlockByrefVariable())
1477       addBlockByrefAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1478     else
1479       addAddress(VariableDie, dwarf::DW_AT_location, Location);
1480   }
1481   DV->setDIE(VariableDie);
1482   return VariableDie;
1483
1484 }
1485
1486 void DwarfDebug::addPubTypes(DISubprogram SP) {
1487   DICompositeType SPTy = SP.getType();
1488   unsigned SPTag = SPTy.getTag();
1489   if (SPTag != dwarf::DW_TAG_subroutine_type) 
1490     return;
1491
1492   DIArray Args = SPTy.getTypeArray();
1493   if (Args.isNull()) 
1494     return;
1495
1496   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1497     DIType ATy(Args.getElement(i).getNode());
1498     if (ATy.isNull())
1499       continue;
1500     DICompositeType CATy = getDICompositeType(ATy);
1501     if (!CATy.isNull() && !CATy.getName().empty()) {
1502       if (DIEEntry *Entry = ModuleCU->getDIEEntry(CATy.getNode()))
1503         ModuleCU->addGlobalType(CATy.getName(), Entry->getEntry());
1504     }
1505   }
1506 }
1507
1508 /// constructScopeDIE - Construct a DIE for this scope.
1509 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1510  if (!Scope)
1511   return NULL;
1512  DIScope DS(Scope->getScopeNode());
1513  if (DS.isNull())
1514    return NULL;
1515
1516  DIE *ScopeDIE = NULL;
1517  if (Scope->getInlinedAt())
1518    ScopeDIE = constructInlinedScopeDIE(Scope);
1519  else if (DS.isSubprogram()) {
1520    if (Scope->isAbstractScope())
1521      ScopeDIE = ModuleCU->getDIE(DS.getNode());
1522    else
1523      ScopeDIE = updateSubprogramScopeDIE(DS.getNode());
1524  }
1525  else {
1526    ScopeDIE = constructLexicalScopeDIE(Scope);
1527    if (!ScopeDIE) return NULL;
1528  }
1529
1530   // Add variables to scope.
1531   SmallVector<DbgVariable *, 8> &Variables = Scope->getVariables();
1532   for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1533     DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1534     if (VariableDIE)
1535       ScopeDIE->addChild(VariableDIE);
1536   }
1537
1538   // Add nested scopes.
1539   SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1540   for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1541     // Define the Scope debug information entry.
1542     DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1543     if (NestedDIE)
1544       ScopeDIE->addChild(NestedDIE);
1545   }
1546
1547   if (DS.isSubprogram()) 
1548     addPubTypes(DISubprogram(DS.getNode()));
1549  
1550  return ScopeDIE;
1551 }
1552
1553 /// GetOrCreateSourceID - Look up the source id with the given directory and
1554 /// source file names. If none currently exists, create a new id and insert it
1555 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1556 /// maps as well.
1557 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName) {
1558   unsigned DId;
1559   StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1560   if (DI != DirectoryIdMap.end()) {
1561     DId = DI->getValue();
1562   } else {
1563     DId = DirectoryNames.size() + 1;
1564     DirectoryIdMap[DirName] = DId;
1565     DirectoryNames.push_back(DirName);
1566   }
1567
1568   unsigned FId;
1569   StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1570   if (FI != SourceFileIdMap.end()) {
1571     FId = FI->getValue();
1572   } else {
1573     FId = SourceFileNames.size() + 1;
1574     SourceFileIdMap[FileName] = FId;
1575     SourceFileNames.push_back(FileName);
1576   }
1577
1578   DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1579     SourceIdMap.find(std::make_pair(DId, FId));
1580   if (SI != SourceIdMap.end())
1581     return SI->second;
1582
1583   unsigned SrcId = SourceIds.size() + 1;  // DW_AT_decl_file cannot be 0.
1584   SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1585   SourceIds.push_back(std::make_pair(DId, FId));
1586
1587   return SrcId;
1588 }
1589
1590 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1591 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1592   DIE *NDie = ModuleCU->getDIE(NS.getNode());
1593   if (NDie)
1594     return NDie;
1595   NDie = new DIE(dwarf::DW_TAG_namespace);
1596   ModuleCU->insertDIE(NS.getNode(), NDie);
1597   if (!NS.getName().empty())
1598     addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1599   addSourceLine(NDie, &NS);
1600   addToContextOwner(NDie, NS.getContext());
1601   return NDie;
1602 }
1603
1604 CompileUnit *DwarfDebug::constructCompileUnit(MDNode *N) {
1605   DICompileUnit DIUnit(N);
1606   StringRef FN = DIUnit.getFilename();
1607   StringRef Dir = DIUnit.getDirectory();
1608   unsigned ID = GetOrCreateSourceID(Dir, FN);
1609
1610   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1611   addSectionOffset(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
1612                    DWLabel("section_line", 0), DWLabel("section_line", 0),
1613                    false);
1614   addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1615             DIUnit.getProducer());
1616   addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1617           DIUnit.getLanguage());
1618   addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1619
1620   if (!Dir.empty())
1621     addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1622   if (DIUnit.isOptimized())
1623     addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1624
1625   StringRef Flags = DIUnit.getFlags();
1626   if (!Flags.empty())
1627     addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1628
1629   unsigned RVer = DIUnit.getRunTimeVersion();
1630   if (RVer)
1631     addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1632             dwarf::DW_FORM_data1, RVer);
1633
1634   CompileUnit *Unit = new CompileUnit(ID, Die);
1635   if (!ModuleCU && DIUnit.isMain()) {
1636     // Use first compile unit marked as isMain as the compile unit
1637     // for this module.
1638     ModuleCU = Unit;
1639   }
1640
1641   CompileUnitMap[DIUnit.getNode()] = Unit;
1642   CompileUnits.push_back(Unit);
1643   return Unit;
1644 }
1645
1646 void DwarfDebug::constructGlobalVariableDIE(MDNode *N) {
1647   DIGlobalVariable DI_GV(N);
1648
1649   // If debug information is malformed then ignore it.
1650   if (DI_GV.Verify() == false)
1651     return;
1652
1653   // Check for pre-existence.
1654   if (ModuleCU->getDIE(DI_GV.getNode()))
1655     return;
1656
1657   DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1658   if (!VariableDie)
1659     return;
1660
1661   // Add to map.
1662   ModuleCU->insertDIE(N, VariableDie);
1663
1664   // Add to context owner.
1665   DIDescriptor GVContext = DI_GV.getContext();
1666   // Do not create specification DIE if context is either compile unit
1667   // or a subprogram.
1668   if (DI_GV.isDefinition() && !GVContext.isCompileUnit()
1669       && !GVContext.isSubprogram()) {
1670     // Create specification DIE.
1671     DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1672     addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1673                 dwarf::DW_FORM_ref4, VariableDie);
1674     DIEBlock *Block = new DIEBlock();
1675     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1676     addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1677                    Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1678     addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1679     ModuleCU->addDie(VariableSpecDIE);
1680   } else {
1681     DIEBlock *Block = new DIEBlock();
1682     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1683     addObjectLabel(Block, 0, dwarf::DW_FORM_udata,
1684                    Asm->GetGlobalValueSymbol(DI_GV.getGlobal()));
1685     addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1686   }
1687   addToContextOwner(VariableDie, GVContext);
1688   
1689   // Expose as global. FIXME - need to check external flag.
1690   ModuleCU->addGlobal(DI_GV.getName(), VariableDie);
1691
1692   DIType GTy = DI_GV.getType();
1693   if (GTy.isCompositeType() && !GTy.getName().empty()) {
1694     DIEEntry *Entry = ModuleCU->getDIEEntry(GTy.getNode());
1695     assert (Entry && "Missing global type!");
1696     ModuleCU->addGlobalType(GTy.getName(), Entry->getEntry());
1697   }
1698   return;
1699 }
1700
1701 void DwarfDebug::constructSubprogramDIE(MDNode *N) {
1702   DISubprogram SP(N);
1703
1704   // Check for pre-existence.
1705   if (ModuleCU->getDIE(N))
1706     return;
1707
1708   if (!SP.isDefinition())
1709     // This is a method declaration which will be handled while constructing
1710     // class type.
1711     return;
1712
1713   DIE *SubprogramDie = createSubprogramDIE(SP);
1714
1715   // Add to map.
1716   ModuleCU->insertDIE(N, SubprogramDie);
1717
1718   // Add to context owner.
1719   addToContextOwner(SubprogramDie, SP.getContext());
1720
1721   // Expose as global.
1722   ModuleCU->addGlobal(SP.getName(), SubprogramDie);
1723
1724   return;
1725 }
1726
1727 /// beginModule - Emit all Dwarf sections that should come prior to the
1728 /// content. Create global DIEs and emit initial debug info sections.
1729 /// This is inovked by the target AsmPrinter.
1730 void DwarfDebug::beginModule(Module *M, MachineModuleInfo *mmi) {
1731   this->M = M;
1732
1733   if (TimePassesIsEnabled)
1734     DebugTimer->startTimer();
1735
1736   if (!MAI->doesSupportDebugInformation())
1737     return;
1738
1739   DebugInfoFinder DbgFinder;
1740   DbgFinder.processModule(*M);
1741
1742   // Create all the compile unit DIEs.
1743   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1744          E = DbgFinder.compile_unit_end(); I != E; ++I)
1745     constructCompileUnit(*I);
1746
1747   if (CompileUnits.empty()) {
1748     if (TimePassesIsEnabled)
1749       DebugTimer->stopTimer();
1750
1751     return;
1752   }
1753
1754   // If main compile unit for this module is not seen than randomly
1755   // select first compile unit.
1756   if (!ModuleCU)
1757     ModuleCU = CompileUnits[0];
1758
1759   // Create DIEs for each subprogram.
1760   for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1761          E = DbgFinder.subprogram_end(); I != E; ++I)
1762     constructSubprogramDIE(*I);
1763
1764   // Create DIEs for each global variable.
1765   for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1766          E = DbgFinder.global_variable_end(); I != E; ++I)
1767     constructGlobalVariableDIE(*I);
1768
1769   MMI = mmi;
1770   shouldEmit = true;
1771   MMI->setDebugInfoAvailability(true);
1772
1773   // Prime section data.
1774   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1775
1776   // Print out .file directives to specify files for .loc directives. These are
1777   // printed out early so that they precede any .loc directives.
1778   if (MAI->hasDotLocAndDotFile()) {
1779     for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
1780       // Remember source id starts at 1.
1781       std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
1782       // FIXME: don't use sys::path for this!  This should not depend on the
1783       // host.
1784       sys::Path FullPath(getSourceDirectoryName(Id.first));
1785       bool AppendOk =
1786         FullPath.appendComponent(getSourceFileName(Id.second));
1787       assert(AppendOk && "Could not append filename to directory!");
1788       AppendOk = false;
1789       Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
1790     }
1791   }
1792
1793   // Emit initial sections
1794   emitInitial();
1795
1796   if (TimePassesIsEnabled)
1797     DebugTimer->stopTimer();
1798 }
1799
1800 /// endModule - Emit all Dwarf sections that should come after the content.
1801 ///
1802 void DwarfDebug::endModule() {
1803   if (!ModuleCU)
1804     return;
1805
1806   if (TimePassesIsEnabled)
1807     DebugTimer->startTimer();
1808
1809   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1810   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1811          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1812     DIE *ISP = *AI;
1813     addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1814   }
1815
1816   // Insert top level DIEs.
1817   for (SmallVector<DIE *, 4>::iterator TI = TopLevelDIEsVector.begin(),
1818          TE = TopLevelDIEsVector.end(); TI != TE; ++TI)
1819     ModuleCU->getCUDie()->addChild(*TI);
1820
1821   for (DenseMap<DIE *, MDNode *>::iterator CI = ContainingTypeMap.begin(),
1822          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1823     DIE *SPDie = CI->first;
1824     MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1825     if (!N) continue;
1826     DIE *NDie = ModuleCU->getDIE(N);
1827     if (!NDie) continue;
1828     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1829     // FIXME - This is not the correct approach.
1830     // addDIEEntry(NDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1831   }
1832
1833   // Standard sections final addresses.
1834   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1835   EmitLabel("text_end", 0);
1836   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1837   EmitLabel("data_end", 0);
1838
1839   // End text sections.
1840   for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1841     Asm->OutStreamer.SwitchSection(SectionMap[i]);
1842     EmitLabel("section_end", i);
1843   }
1844
1845   // Emit common frame information.
1846   emitCommonDebugFrame();
1847
1848   // Emit function debug frame information
1849   for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
1850          E = DebugFrames.end(); I != E; ++I)
1851     emitFunctionDebugFrame(*I);
1852
1853   // Compute DIE offsets and sizes.
1854   computeSizeAndOffsets();
1855
1856   // Emit all the DIEs into a debug info section
1857   emitDebugInfo();
1858
1859   // Corresponding abbreviations into a abbrev section.
1860   emitAbbreviations();
1861
1862   // Emit source line correspondence into a debug line section.
1863   emitDebugLines();
1864
1865   // Emit info into a debug pubnames section.
1866   emitDebugPubNames();
1867
1868   // Emit info into a debug pubtypes section.
1869   emitDebugPubTypes();
1870
1871   // Emit info into a debug str section.
1872   emitDebugStr();
1873
1874   // Emit info into a debug loc section.
1875   emitDebugLoc();
1876
1877   // Emit info into a debug aranges section.
1878   EmitDebugARanges();
1879
1880   // Emit info into a debug ranges section.
1881   emitDebugRanges();
1882
1883   // Emit info into a debug macinfo section.
1884   emitDebugMacInfo();
1885
1886   // Emit inline info.
1887   emitDebugInlineInfo();
1888
1889   if (TimePassesIsEnabled)
1890     DebugTimer->stopTimer();
1891 }
1892
1893 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1894 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1895                                               unsigned FrameIdx,
1896                                               DILocation &ScopeLoc) {
1897
1898   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
1899   if (AbsDbgVariable)
1900     return AbsDbgVariable;
1901
1902   DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
1903   if (!Scope)
1904     return NULL;
1905
1906   AbsDbgVariable = new DbgVariable(Var, FrameIdx);
1907   Scope->addVariable(AbsDbgVariable);
1908   AbstractVariables[Var.getNode()] = AbsDbgVariable;
1909   return AbsDbgVariable;
1910 }
1911
1912 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1913 void DwarfDebug::collectVariableInfo() {
1914   if (!MMI) return;
1915
1916   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1917   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1918          VE = VMap.end(); VI != VE; ++VI) {
1919     MDNode *Var = VI->first;
1920     if (!Var) continue;
1921     DIVariable DV (Var);
1922     std::pair< unsigned, MDNode *> VP = VI->second;
1923     DILocation ScopeLoc(VP.second);
1924
1925     DbgScope *Scope =
1926       ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
1927     if (!Scope)
1928       Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
1929     // If variable scope is not found then skip this variable.
1930     if (!Scope)
1931       continue;
1932
1933     DbgVariable *RegVar = new DbgVariable(DV, VP.first);
1934     Scope->addVariable(RegVar);
1935     if (DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first,
1936                                                            ScopeLoc))
1937       RegVar->setAbstractVariable(AbsDbgVariable);
1938   }
1939 }
1940
1941 /// beginScope - Process beginning of a scope starting at Label.
1942 void DwarfDebug::beginScope(const MachineInstr *MI, unsigned Label) {
1943   InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
1944   if (I == DbgScopeBeginMap.end())
1945     return;
1946   ScopeVector &SD = I->second;
1947   for (ScopeVector::iterator SDI = SD.begin(), SDE = SD.end();
1948        SDI != SDE; ++SDI)
1949     (*SDI)->setStartLabelID(Label);
1950 }
1951
1952 /// endScope - Process end of a scope.
1953 void DwarfDebug::endScope(const MachineInstr *MI) {
1954   InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
1955   if (I == DbgScopeEndMap.end())
1956     return;
1957
1958   unsigned Label = MMI->NextLabelID();
1959   Asm->printLabel(Label);
1960   O << '\n';
1961
1962   SmallVector<DbgScope *, 2> &SD = I->second;
1963   for (SmallVector<DbgScope *, 2>::iterator SDI = SD.begin(), SDE = SD.end();
1964        SDI != SDE; ++SDI)
1965     (*SDI)->setEndLabelID(Label);
1966   return;
1967 }
1968
1969 /// createDbgScope - Create DbgScope for the scope.
1970 void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
1971
1972   if (!InlinedAt) {
1973     DbgScope *WScope = DbgScopeMap.lookup(Scope);
1974     if (WScope)
1975       return;
1976     WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1977     DbgScopeMap.insert(std::make_pair(Scope, WScope));
1978     if (DIDescriptor(Scope).isLexicalBlock())
1979       createDbgScope(DILexicalBlock(Scope).getContext().getNode(), NULL);
1980     return;
1981   }
1982
1983   DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1984   if (WScope)
1985     return;
1986
1987   WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1988   DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1989   DILocation DL(InlinedAt);
1990   createDbgScope(DL.getScope().getNode(), DL.getOrigLocation().getNode());
1991 }
1992
1993 /// extractScopeInformation - Scan machine instructions in this function
1994 /// and collect DbgScopes. Return true, if atleast one scope was found.
1995 bool DwarfDebug::extractScopeInformation() {
1996   // If scope information was extracted using .dbg intrinsics then there is not
1997   // any need to extract these information by scanning each instruction.
1998   if (!DbgScopeMap.empty())
1999     return false;
2000
2001   DenseMap<const MachineInstr *, unsigned> MIIndexMap;
2002   unsigned MIIndex = 0;
2003   // Scan each instruction and create scopes. First build working set of scopes.
2004   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2005        I != E; ++I) {
2006     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2007          II != IE; ++II) {
2008       const MachineInstr *MInsn = II;
2009       MIIndexMap[MInsn] = MIIndex++;
2010       DebugLoc DL = MInsn->getDebugLoc();
2011       if (DL.isUnknown()) continue;
2012       DILocation DLT = MF->getDILocation(DL);
2013       DIScope DLTScope = DLT.getScope();
2014       if (DLTScope.isNull()) continue;
2015       // There is no need to create another DIE for compile unit. For all
2016       // other scopes, create one DbgScope now. This will be translated
2017       // into a scope DIE at the end.
2018       if (DLTScope.isCompileUnit()) continue;
2019       createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
2020     }
2021   }
2022
2023
2024   // Build scope hierarchy using working set of scopes.
2025   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2026        I != E; ++I) {
2027     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2028          II != IE; ++II) {
2029       const MachineInstr *MInsn = II;
2030       DebugLoc DL = MInsn->getDebugLoc();
2031       if (DL.isUnknown())  continue;
2032       DILocation DLT = MF->getDILocation(DL);
2033       DIScope DLTScope = DLT.getScope();
2034       if (DLTScope.isNull())  continue;
2035       // There is no need to create another DIE for compile unit. For all
2036       // other scopes, create one DbgScope now. This will be translated
2037       // into a scope DIE at the end.
2038       if (DLTScope.isCompileUnit()) continue;
2039       DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn, 
2040                                            DLT.getOrigLocation().getNode());
2041       Scope->setLastInsn(MInsn);
2042     }
2043   }
2044
2045   if (!CurrentFnDbgScope)
2046     return false;
2047
2048   CurrentFnDbgScope->fixInstructionMarkers(MIIndexMap);
2049
2050   // Each scope has first instruction and last instruction to mark beginning
2051   // and end of a scope respectively. Create an inverse map that list scopes
2052   // starts (and ends) with an instruction. One instruction may start (or end)
2053   // multiple scopes. Ignore scopes that are not reachable.
2054   SmallVector<DbgScope *, 4> WorkList;
2055   WorkList.push_back(CurrentFnDbgScope);
2056   while (!WorkList.empty()) {
2057     DbgScope *S = WorkList.back(); WorkList.pop_back();
2058
2059     SmallVector<DbgScope *, 4> &Children = S->getScopes();
2060     if (!Children.empty()) 
2061       for (SmallVector<DbgScope *, 4>::iterator SI = Children.begin(),
2062              SE = Children.end(); SI != SE; ++SI)
2063         WorkList.push_back(*SI);
2064
2065     if (S->isAbstractScope())
2066       continue;
2067     const MachineInstr *MI = S->getFirstInsn();
2068     assert (MI && "DbgScope does not have first instruction!");
2069
2070     InsnToDbgScopeMapTy::iterator IDI = DbgScopeBeginMap.find(MI);
2071     if (IDI != DbgScopeBeginMap.end())
2072       IDI->second.push_back(S);
2073     else
2074       DbgScopeBeginMap[MI].push_back(S);
2075
2076     MI = S->getLastInsn();
2077     assert (MI && "DbgScope does not have last instruction!");
2078     IDI = DbgScopeEndMap.find(MI);
2079     if (IDI != DbgScopeEndMap.end())
2080       IDI->second.push_back(S);
2081     else
2082       DbgScopeEndMap[MI].push_back(S);
2083   }
2084
2085   return !DbgScopeMap.empty();
2086 }
2087
2088 /// beginFunction - Gather pre-function debug information.  Assumes being
2089 /// emitted immediately after the function entry point.
2090 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2091   this->MF = MF;
2092
2093   if (!ShouldEmitDwarfDebug()) return;
2094
2095   if (TimePassesIsEnabled)
2096     DebugTimer->startTimer();
2097
2098   if (!extractScopeInformation())
2099     return;
2100
2101   collectVariableInfo();
2102
2103   // Assumes in correct section after the entry point.
2104   EmitLabel("func_begin", ++SubprogramCount);
2105
2106   // Emit label for the implicitly defined dbg.stoppoint at the start of the
2107   // function.
2108   DebugLoc FDL = MF->getDefaultDebugLoc();
2109   if (!FDL.isUnknown()) {
2110     DILocation DLT = MF->getDILocation(FDL);
2111     unsigned LabelID = 0;
2112     DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
2113     if (!SP.isNull())
2114       LabelID = recordSourceLine(SP.getLineNumber(), 0, 
2115                                  DLT.getScope().getNode());
2116     else
2117       LabelID = recordSourceLine(DLT.getLineNumber(), 
2118                                  DLT.getColumnNumber(), 
2119                                  DLT.getScope().getNode());
2120     Asm->printLabel(LabelID);
2121     O << '\n';
2122   }
2123   if (TimePassesIsEnabled)
2124     DebugTimer->stopTimer();
2125 }
2126
2127 /// endFunction - Gather and emit post-function debug information.
2128 ///
2129 void DwarfDebug::endFunction(const MachineFunction *MF) {
2130   if (!ShouldEmitDwarfDebug()) return;
2131
2132   if (TimePassesIsEnabled)
2133     DebugTimer->startTimer();
2134
2135   if (DbgScopeMap.empty())
2136     return;
2137
2138   if (CurrentFnDbgScope) {
2139     // Define end label for subprogram.
2140     EmitLabel("func_end", SubprogramCount);
2141     
2142     // Get function line info.
2143     if (!Lines.empty()) {
2144       // Get section line info.
2145       unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2146       if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2147       std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2148       // Append the function info to section info.
2149       SectionLineInfos.insert(SectionLineInfos.end(),
2150                               Lines.begin(), Lines.end());
2151     }
2152     
2153     // Construct abstract scopes.
2154     for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2155            AE = AbstractScopesList.end(); AI != AE; ++AI)
2156       constructScopeDIE(*AI);
2157     
2158     constructScopeDIE(CurrentFnDbgScope);
2159     
2160     DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
2161                                                  MMI->getFrameMoves()));
2162   }
2163
2164   // Clear debug info
2165   CurrentFnDbgScope = NULL;
2166   DbgScopeMap.clear();
2167   DbgScopeBeginMap.clear();
2168   DbgScopeEndMap.clear();
2169   ConcreteScopes.clear();
2170   AbstractScopesList.clear();
2171   Lines.clear();
2172   
2173   if (TimePassesIsEnabled)
2174     DebugTimer->stopTimer();
2175 }
2176
2177 /// recordSourceLine - Records location information and associates it with a
2178 /// label. Returns a unique label ID used to generate a label and provide
2179 /// correspondence to the source line list.
2180 unsigned DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2181                                       MDNode *S) {
2182   if (!MMI)
2183     return 0;
2184
2185   if (TimePassesIsEnabled)
2186     DebugTimer->startTimer();
2187
2188   StringRef Dir;
2189   StringRef Fn;
2190
2191   DIDescriptor Scope(S);
2192   if (Scope.isCompileUnit()) {
2193     DICompileUnit CU(S);
2194     Dir = CU.getDirectory();
2195     Fn = CU.getFilename();
2196   } else if (Scope.isSubprogram()) {
2197     DISubprogram SP(S);
2198     Dir = SP.getDirectory();
2199     Fn = SP.getFilename();
2200   } else if (Scope.isLexicalBlock()) {
2201     DILexicalBlock DB(S);
2202     Dir = DB.getDirectory();
2203     Fn = DB.getFilename();
2204   } else
2205     assert (0 && "Unexpected scope info");
2206
2207   unsigned Src = GetOrCreateSourceID(Dir, Fn);
2208   unsigned ID = MMI->NextLabelID();
2209   Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
2210
2211   if (TimePassesIsEnabled)
2212     DebugTimer->stopTimer();
2213
2214   return ID;
2215 }
2216
2217 /// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
2218 /// timed. Look up the source id with the given directory and source file
2219 /// names. If none currently exists, create a new id and insert it in the
2220 /// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
2221 /// well.
2222 unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
2223                                          const std::string &FileName) {
2224   if (TimePassesIsEnabled)
2225     DebugTimer->startTimer();
2226
2227   unsigned SrcId = GetOrCreateSourceID(DirName.c_str(), FileName.c_str());
2228
2229   if (TimePassesIsEnabled)
2230     DebugTimer->stopTimer();
2231
2232   return SrcId;
2233 }
2234
2235 //===----------------------------------------------------------------------===//
2236 // Emit Methods
2237 //===----------------------------------------------------------------------===//
2238
2239 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2240 ///
2241 unsigned
2242 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2243   // Get the children.
2244   const std::vector<DIE *> &Children = Die->getChildren();
2245
2246   // If not last sibling and has children then add sibling offset attribute.
2247   if (!Last && !Children.empty()) Die->addSiblingOffset();
2248
2249   // Record the abbreviation.
2250   assignAbbrevNumber(Die->getAbbrev());
2251
2252   // Get the abbreviation for this DIE.
2253   unsigned AbbrevNumber = Die->getAbbrevNumber();
2254   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2255
2256   // Set DIE offset
2257   Die->setOffset(Offset);
2258
2259   // Start the size with the size of abbreviation code.
2260   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2261
2262   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2263   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2264
2265   // Size the DIE attribute values.
2266   for (unsigned i = 0, N = Values.size(); i < N; ++i)
2267     // Size attribute value.
2268     Offset += Values[i]->SizeOf(TD, AbbrevData[i].getForm());
2269
2270   // Size the DIE children if any.
2271   if (!Children.empty()) {
2272     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2273            "Children flag not set");
2274
2275     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2276       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2277
2278     // End of children marker.
2279     Offset += sizeof(int8_t);
2280   }
2281
2282   Die->setSize(Offset - Die->getOffset());
2283   return Offset;
2284 }
2285
2286 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2287 ///
2288 void DwarfDebug::computeSizeAndOffsets() {
2289   // Compute size of compile unit header.
2290   static unsigned Offset =
2291     sizeof(int32_t) + // Length of Compilation Unit Info
2292     sizeof(int16_t) + // DWARF version number
2293     sizeof(int32_t) + // Offset Into Abbrev. Section
2294     sizeof(int8_t);   // Pointer Size (in bytes)
2295
2296   computeSizeAndOffset(ModuleCU->getCUDie(), Offset, true);
2297   CompileUnitOffsets[ModuleCU] = 0;
2298 }
2299
2300 /// emitInitial - Emit initial Dwarf declarations.  This is necessary for cc
2301 /// tools to recognize the object file contains Dwarf information.
2302 void DwarfDebug::emitInitial() {
2303   // Check to see if we already emitted intial headers.
2304   if (didInitial) return;
2305   didInitial = true;
2306
2307   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2308
2309   // Dwarf sections base addresses.
2310   if (MAI->doesDwarfRequireFrameSection()) {
2311     Asm->OutStreamer.SwitchSection(TLOF.getDwarfFrameSection());
2312     EmitLabel("section_debug_frame", 0);
2313   }
2314
2315   Asm->OutStreamer.SwitchSection(TLOF.getDwarfInfoSection());
2316   EmitLabel("section_info", 0);
2317   Asm->OutStreamer.SwitchSection(TLOF.getDwarfAbbrevSection());
2318   EmitLabel("section_abbrev", 0);
2319   Asm->OutStreamer.SwitchSection(TLOF.getDwarfARangesSection());
2320   EmitLabel("section_aranges", 0);
2321
2322   if (const MCSection *LineInfoDirective = TLOF.getDwarfMacroInfoSection()) {
2323     Asm->OutStreamer.SwitchSection(LineInfoDirective);
2324     EmitLabel("section_macinfo", 0);
2325   }
2326
2327   Asm->OutStreamer.SwitchSection(TLOF.getDwarfLineSection());
2328   EmitLabel("section_line", 0);
2329   Asm->OutStreamer.SwitchSection(TLOF.getDwarfLocSection());
2330   EmitLabel("section_loc", 0);
2331   Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubNamesSection());
2332   EmitLabel("section_pubnames", 0);
2333   Asm->OutStreamer.SwitchSection(TLOF.getDwarfPubTypesSection());
2334   EmitLabel("section_pubtypes", 0);
2335   Asm->OutStreamer.SwitchSection(TLOF.getDwarfStrSection());
2336   EmitLabel("section_str", 0);
2337   Asm->OutStreamer.SwitchSection(TLOF.getDwarfRangesSection());
2338   EmitLabel("section_ranges", 0);
2339
2340   Asm->OutStreamer.SwitchSection(TLOF.getTextSection());
2341   EmitLabel("text_begin", 0);
2342   Asm->OutStreamer.SwitchSection(TLOF.getDataSection());
2343   EmitLabel("data_begin", 0);
2344 }
2345
2346 /// emitDIE - Recusively Emits a debug information entry.
2347 ///
2348 void DwarfDebug::emitDIE(DIE *Die) {
2349   // Get the abbreviation for this DIE.
2350   unsigned AbbrevNumber = Die->getAbbrevNumber();
2351   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2352
2353   Asm->O << '\n';
2354
2355   // Emit the code (index) for the abbreviation.
2356   if (Asm->VerboseAsm)
2357     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2358                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2359                                 Twine::utohexstr(Die->getSize()) + " " +
2360                                 dwarf::TagString(Abbrev->getTag()));
2361   EmitULEB128(AbbrevNumber);
2362
2363   SmallVector<DIEValue*, 32> &Values = Die->getValues();
2364   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2365
2366   // Emit the DIE attribute values.
2367   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2368     unsigned Attr = AbbrevData[i].getAttribute();
2369     unsigned Form = AbbrevData[i].getForm();
2370     assert(Form && "Too many attributes for DIE (check abbreviation)");
2371
2372     if (Asm->VerboseAsm)
2373       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2374     
2375     switch (Attr) {
2376     case dwarf::DW_AT_sibling:
2377       Asm->EmitInt32(Die->getSiblingOffset());
2378       break;
2379     case dwarf::DW_AT_abstract_origin: {
2380       DIEEntry *E = cast<DIEEntry>(Values[i]);
2381       DIE *Origin = E->getEntry();
2382       unsigned Addr = Origin->getOffset();
2383       Asm->EmitInt32(Addr);
2384       break;
2385     }
2386     default:
2387       // Emit an attribute using the defined form.
2388       Values[i]->EmitValue(this, Form);
2389       O << "\n"; // REMOVE This once all EmitValue impls emit their own newline.
2390       break;
2391     }
2392   }
2393
2394   // Emit the DIE children if any.
2395   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2396     const std::vector<DIE *> &Children = Die->getChildren();
2397
2398     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2399       emitDIE(Children[j]);
2400
2401     Asm->EmitInt8(0); EOL("End Of Children Mark");
2402   }
2403 }
2404
2405 /// emitDebugInfo - Emit the debug info section.
2406 ///
2407 void DwarfDebug::emitDebugInfo() {
2408   // Start debug info section.
2409   Asm->OutStreamer.SwitchSection(
2410                             Asm->getObjFileLowering().getDwarfInfoSection());
2411   DIE *Die = ModuleCU->getCUDie();
2412
2413   // Emit the compile units header.
2414   EmitLabel("info_begin", ModuleCU->getID());
2415
2416   // Emit size of content not including length itself
2417   unsigned ContentSize = Die->getSize() +
2418     sizeof(int16_t) + // DWARF version number
2419     sizeof(int32_t) + // Offset Into Abbrev. Section
2420     sizeof(int8_t) +  // Pointer Size (in bytes)
2421     sizeof(int32_t);  // FIXME - extra pad for gdb bug.
2422
2423   Asm->EmitInt32(ContentSize);  EOL("Length of Compilation Unit Info");
2424   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2425   EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
2426   EOL("Offset Into Abbrev. Section");
2427   Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2428
2429   emitDIE(Die);
2430   // FIXME - extra padding for gdb bug.
2431   Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2432   Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2433   Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2434   Asm->EmitInt8(0); EOL("Extra Pad For GDB");
2435   EmitLabel("info_end", ModuleCU->getID());
2436   Asm->O << '\n';
2437 }
2438
2439 /// emitAbbreviations - Emit the abbreviation section.
2440 ///
2441 void DwarfDebug::emitAbbreviations() const {
2442   // Check to see if it is worth the effort.
2443   if (!Abbreviations.empty()) {
2444     // Start the debug abbrev section.
2445     Asm->OutStreamer.SwitchSection(
2446                             Asm->getObjFileLowering().getDwarfAbbrevSection());
2447
2448     EmitLabel("abbrev_begin", 0);
2449
2450     // For each abbrevation.
2451     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2452       // Get abbreviation data
2453       const DIEAbbrev *Abbrev = Abbreviations[i];
2454
2455       // Emit the abbrevations code (base 1 index.)
2456       EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2457
2458       // Emit the abbreviations data.
2459       Abbrev->Emit(this);
2460       Asm->O << '\n';
2461     }
2462
2463     // Mark end of abbreviations.
2464     EmitULEB128(0, "EOM(3)");
2465
2466     EmitLabel("abbrev_end", 0);
2467     Asm->O << '\n';
2468   }
2469 }
2470
2471 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2472 /// the line matrix.
2473 ///
2474 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2475   // Define last address of section.
2476   Asm->EmitInt8(0); EOL("Extended Op");
2477   Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2478   Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2479   EmitReference("section_end", SectionEnd); EOL("Section end label");
2480
2481   // Mark end of matrix.
2482   Asm->EmitInt8(0); EOL("DW_LNE_end_sequence");
2483   Asm->EmitInt8(1);
2484   Asm->EmitInt8(1);
2485 }
2486
2487 /// emitDebugLines - Emit source line information.
2488 ///
2489 void DwarfDebug::emitDebugLines() {
2490   // If the target is using .loc/.file, the assembler will be emitting the
2491   // .debug_line table automatically.
2492   if (MAI->hasDotLocAndDotFile())
2493     return;
2494
2495   // Minimum line delta, thus ranging from -10..(255-10).
2496   const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
2497   // Maximum line delta, thus ranging from -10..(255-10).
2498   const int MaxLineDelta = 255 + MinLineDelta;
2499
2500   // Start the dwarf line section.
2501   Asm->OutStreamer.SwitchSection(
2502                             Asm->getObjFileLowering().getDwarfLineSection());
2503
2504   // Construct the section header.
2505   EmitDifference("line_end", 0, "line_begin", 0, true);
2506   EOL("Length of Source Line Info");
2507   EmitLabel("line_begin", 0);
2508
2509   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF version number");
2510
2511   EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
2512   EOL("Prolog Length");
2513   EmitLabel("line_prolog_begin", 0);
2514
2515   Asm->EmitInt8(1); EOL("Minimum Instruction Length");
2516   Asm->EmitInt8(1); EOL("Default is_stmt_start flag");
2517   Asm->EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)");
2518   Asm->EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)");
2519   Asm->EmitInt8(-MinLineDelta); EOL("Special Opcode Base");
2520
2521   // Line number standard opcode encodings argument count
2522   Asm->EmitInt8(0); EOL("DW_LNS_copy arg count");
2523   Asm->EmitInt8(1); EOL("DW_LNS_advance_pc arg count");
2524   Asm->EmitInt8(1); EOL("DW_LNS_advance_line arg count");
2525   Asm->EmitInt8(1); EOL("DW_LNS_set_file arg count");
2526   Asm->EmitInt8(1); EOL("DW_LNS_set_column arg count");
2527   Asm->EmitInt8(0); EOL("DW_LNS_negate_stmt arg count");
2528   Asm->EmitInt8(0); EOL("DW_LNS_set_basic_block arg count");
2529   Asm->EmitInt8(0); EOL("DW_LNS_const_add_pc arg count");
2530   Asm->EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count");
2531
2532   // Emit directories.
2533   for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
2534     const std::string &Dir = getSourceDirectoryName(DI);
2535     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Directory");
2536     Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
2537   }
2538
2539   Asm->EmitInt8(0); EOL("End of directories");
2540
2541   // Emit files.
2542   for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
2543     // Remember source id starts at 1.
2544     std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
2545     const std::string &FN = getSourceFileName(Id.second);
2546     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("Source");
2547     Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
2548     
2549     EmitULEB128(Id.first, "Directory #");
2550     EmitULEB128(0, "Mod date");
2551     EmitULEB128(0, "File size");
2552   }
2553
2554   Asm->EmitInt8(0); EOL("End of files");
2555
2556   EmitLabel("line_prolog_end", 0);
2557
2558   // A sequence for each text section.
2559   unsigned SecSrcLinesSize = SectionSourceLines.size();
2560
2561   for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
2562     // Isolate current sections line info.
2563     const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
2564
2565     /*if (Asm->isVerbose()) {
2566       const MCSection *S = SectionMap[j + 1];
2567       O << '\t' << MAI->getCommentString() << " Section"
2568         << S->getName() << '\n';
2569     }*/
2570     Asm->O << '\n';
2571
2572     // Dwarf assumes we start with first line of first source file.
2573     unsigned Source = 1;
2574     unsigned Line = 1;
2575
2576     // Construct rows of the address, source, line, column matrix.
2577     for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
2578       const SrcLineInfo &LineInfo = LineInfos[i];
2579       unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
2580       if (!LabelID) continue;
2581
2582       if (LineInfo.getLine() == 0) continue;
2583
2584       if (!Asm->isVerbose())
2585         Asm->O << '\n';
2586       else {
2587         std::pair<unsigned, unsigned> SourceID =
2588           getSourceDirectoryAndFileIds(LineInfo.getSourceID());
2589         O << '\t' << MAI->getCommentString() << ' '
2590           << getSourceDirectoryName(SourceID.first) << '/'
2591           << getSourceFileName(SourceID.second)
2592           << ':' << utostr_32(LineInfo.getLine()) << '\n';
2593       }
2594
2595       // Define the line address.
2596       Asm->EmitInt8(0); EOL("Extended Op");
2597       Asm->EmitInt8(TD->getPointerSize() + 1); EOL("Op size");
2598       Asm->EmitInt8(dwarf::DW_LNE_set_address); EOL("DW_LNE_set_address");
2599       EmitReference("label",  LabelID); EOL("Location label");
2600
2601       // If change of source, then switch to the new source.
2602       if (Source != LineInfo.getSourceID()) {
2603         Source = LineInfo.getSourceID();
2604         Asm->EmitInt8(dwarf::DW_LNS_set_file); EOL("DW_LNS_set_file");
2605         EmitULEB128(Source, "New Source");
2606       }
2607
2608       // If change of line.
2609       if (Line != LineInfo.getLine()) {
2610         // Determine offset.
2611         int Offset = LineInfo.getLine() - Line;
2612         int Delta = Offset - MinLineDelta;
2613
2614         // Update line.
2615         Line = LineInfo.getLine();
2616
2617         // If delta is small enough and in range...
2618         if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
2619           // ... then use fast opcode.
2620           Asm->EmitInt8(Delta - MinLineDelta); EOL("Line Delta");
2621         } else {
2622           // ... otherwise use long hand.
2623           Asm->EmitInt8(dwarf::DW_LNS_advance_line);
2624           EOL("DW_LNS_advance_line");
2625           EmitSLEB128(Offset, "Line Offset");
2626           Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2627         }
2628       } else {
2629         // Copy the previous row (different address or source)
2630         Asm->EmitInt8(dwarf::DW_LNS_copy); EOL("DW_LNS_copy");
2631       }
2632     }
2633
2634     emitEndOfLineMatrix(j + 1);
2635   }
2636
2637   if (SecSrcLinesSize == 0)
2638     // Because we're emitting a debug_line section, we still need a line
2639     // table. The linker and friends expect it to exist. If there's nothing to
2640     // put into it, emit an empty table.
2641     emitEndOfLineMatrix(1);
2642
2643   EmitLabel("line_end", 0);
2644   Asm->O << '\n';
2645 }
2646
2647 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
2648 ///
2649 void DwarfDebug::emitCommonDebugFrame() {
2650   if (!MAI->doesDwarfRequireFrameSection())
2651     return;
2652
2653   int stackGrowth =
2654     Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
2655       TargetFrameInfo::StackGrowsUp ?
2656     TD->getPointerSize() : -TD->getPointerSize();
2657
2658   // Start the dwarf frame section.
2659   Asm->OutStreamer.SwitchSection(
2660                               Asm->getObjFileLowering().getDwarfFrameSection());
2661
2662   EmitLabel("debug_frame_common", 0);
2663   EmitDifference("debug_frame_common_end", 0,
2664                  "debug_frame_common_begin", 0, true);
2665   EOL("Length of Common Information Entry");
2666
2667   EmitLabel("debug_frame_common_begin", 0);
2668   Asm->EmitInt32((int)dwarf::DW_CIE_ID);
2669   EOL("CIE Identifier Tag");
2670   Asm->EmitInt8(dwarf::DW_CIE_VERSION);
2671   EOL("CIE Version");
2672   Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
2673   EOL("CIE Augmentation");
2674   EmitULEB128(1, "CIE Code Alignment Factor");
2675   EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
2676   Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
2677   EOL("CIE RA Column");
2678
2679   std::vector<MachineMove> Moves;
2680   RI->getInitialFrameState(Moves);
2681
2682   EmitFrameMoves(NULL, 0, Moves, false);
2683
2684   Asm->EmitAlignment(2, 0, 0, false);
2685   EmitLabel("debug_frame_common_end", 0);
2686   Asm->O << '\n';
2687 }
2688
2689 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
2690 /// section.
2691 void
2692 DwarfDebug::emitFunctionDebugFrame(const FunctionDebugFrameInfo&DebugFrameInfo){
2693   if (!MAI->doesDwarfRequireFrameSection())
2694     return;
2695
2696   // Start the dwarf frame section.
2697   Asm->OutStreamer.SwitchSection(
2698                               Asm->getObjFileLowering().getDwarfFrameSection());
2699
2700   EmitDifference("debug_frame_end", DebugFrameInfo.Number,
2701                  "debug_frame_begin", DebugFrameInfo.Number, true);
2702   EOL("Length of Frame Information Entry");
2703
2704   EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
2705
2706   EmitSectionOffset("debug_frame_common", "section_debug_frame",
2707                     0, 0, true, false);
2708   EOL("FDE CIE offset");
2709
2710   EmitReference("func_begin", DebugFrameInfo.Number);
2711   EOL("FDE initial location");
2712   EmitDifference("func_end", DebugFrameInfo.Number,
2713                  "func_begin", DebugFrameInfo.Number);
2714   EOL("FDE address range");
2715
2716   EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
2717                  false);
2718
2719   Asm->EmitAlignment(2, 0, 0, false);
2720   EmitLabel("debug_frame_end", DebugFrameInfo.Number);
2721   Asm->O << '\n';
2722 }
2723
2724 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2725 ///
2726 void DwarfDebug::emitDebugPubNames() {
2727   // Start the dwarf pubnames section.
2728   Asm->OutStreamer.SwitchSection(
2729                           Asm->getObjFileLowering().getDwarfPubNamesSection());
2730
2731   EmitDifference("pubnames_end", ModuleCU->getID(),
2732                  "pubnames_begin", ModuleCU->getID(), true);
2733   EOL("Length of Public Names Info");
2734
2735   EmitLabel("pubnames_begin", ModuleCU->getID());
2736
2737   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2738
2739   EmitSectionOffset("info_begin", "section_info",
2740                     ModuleCU->getID(), 0, true, false);
2741   EOL("Offset of Compilation Unit Info");
2742
2743   EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2744                  true);
2745   EOL("Compilation Unit Length");
2746
2747   const StringMap<DIE*> &Globals = ModuleCU->getGlobals();
2748   for (StringMap<DIE*>::const_iterator
2749          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2750     const char *Name = GI->getKeyData();
2751     DIE * Entity = GI->second;
2752
2753     Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2754     
2755     if (Asm->VerboseAsm)
2756       Asm->OutStreamer.AddComment("External Name");
2757     Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2758   }
2759
2760   Asm->EmitInt32(0); EOL("End Mark");
2761   EmitLabel("pubnames_end", ModuleCU->getID());
2762   Asm->O << '\n';
2763 }
2764
2765 void DwarfDebug::emitDebugPubTypes() {
2766   // Start the dwarf pubnames section.
2767   Asm->OutStreamer.SwitchSection(
2768                           Asm->getObjFileLowering().getDwarfPubTypesSection());
2769   EmitDifference("pubtypes_end", ModuleCU->getID(),
2770                  "pubtypes_begin", ModuleCU->getID(), true);
2771   EOL("Length of Public Types Info");
2772
2773   EmitLabel("pubtypes_begin", ModuleCU->getID());
2774
2775   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("DWARF Version");
2776
2777   EmitSectionOffset("info_begin", "section_info",
2778                     ModuleCU->getID(), 0, true, false);
2779   EOL("Offset of Compilation ModuleCU Info");
2780
2781   EmitDifference("info_end", ModuleCU->getID(), "info_begin", ModuleCU->getID(),
2782                  true);
2783   EOL("Compilation ModuleCU Length");
2784
2785   const StringMap<DIE*> &Globals = ModuleCU->getGlobalTypes();
2786   for (StringMap<DIE*>::const_iterator
2787          GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2788     const char *Name = GI->getKeyData();
2789     DIE * Entity = GI->second;
2790
2791     Asm->EmitInt32(Entity->getOffset()); EOL("DIE offset");
2792     
2793     if (Asm->VerboseAsm) Asm->OutStreamer.AddComment("External Name");
2794     Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)), 0);
2795   }
2796
2797   Asm->EmitInt32(0); EOL("End Mark");
2798   EmitLabel("pubtypes_end", ModuleCU->getID());
2799   Asm->O << '\n';
2800 }
2801
2802 /// emitDebugStr - Emit visible names into a debug str section.
2803 ///
2804 void DwarfDebug::emitDebugStr() {
2805   // Check to see if it is worth the effort.
2806   if (!StringPool.empty()) {
2807     // Start the dwarf str section.
2808     Asm->OutStreamer.SwitchSection(
2809                                 Asm->getObjFileLowering().getDwarfStrSection());
2810
2811     // For each of strings in the string pool.
2812     for (unsigned StringID = 1, N = StringPool.size();
2813          StringID <= N; ++StringID) {
2814       // Emit a label for reference from debug information entries.
2815       EmitLabel("string", StringID);
2816
2817       // Emit the string itself.
2818       const std::string &String = StringPool[StringID];
2819       Asm->OutStreamer.EmitBytes(StringRef(String.c_str(), String.size()+1), 0);
2820     }
2821
2822     Asm->O << '\n';
2823   }
2824 }
2825
2826 /// emitDebugLoc - Emit visible names into a debug loc section.
2827 ///
2828 void DwarfDebug::emitDebugLoc() {
2829   // Start the dwarf loc section.
2830   Asm->OutStreamer.SwitchSection(
2831                               Asm->getObjFileLowering().getDwarfLocSection());
2832 }
2833
2834 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2835 ///
2836 void DwarfDebug::EmitDebugARanges() {
2837   // Start the dwarf aranges section.
2838   Asm->OutStreamer.SwitchSection(
2839                           Asm->getObjFileLowering().getDwarfARangesSection());
2840
2841   // FIXME - Mock up
2842 #if 0
2843   CompileUnit *Unit = GetBaseCompileUnit();
2844
2845   // Don't include size of length
2846   Asm->EmitInt32(0x1c); EOL("Length of Address Ranges Info");
2847
2848   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2849
2850   EmitReference("info_begin", Unit->getID());
2851   EOL("Offset of Compilation Unit Info");
2852
2853   Asm->EmitInt8(TD->getPointerSize()); EOL("Size of Address");
2854
2855   Asm->EmitInt8(0); EOL("Size of Segment Descriptor");
2856
2857   Asm->EmitInt16(0);  EOL("Pad (1)");
2858   Asm->EmitInt16(0);  EOL("Pad (2)");
2859
2860   // Range 1
2861   EmitReference("text_begin", 0); EOL("Address");
2862   EmitDifference("text_end", 0, "text_begin", 0, true); EOL("Length");
2863
2864   Asm->EmitInt32(0); EOL("EOM (1)");
2865   Asm->EmitInt32(0); EOL("EOM (2)");
2866 #endif
2867 }
2868
2869 /// emitDebugRanges - Emit visible names into a debug ranges section.
2870 ///
2871 void DwarfDebug::emitDebugRanges() {
2872   // Start the dwarf ranges section.
2873   Asm->OutStreamer.SwitchSection(
2874                             Asm->getObjFileLowering().getDwarfRangesSection());
2875 }
2876
2877 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2878 ///
2879 void DwarfDebug::emitDebugMacInfo() {
2880   if (const MCSection *LineInfo =
2881       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2882     // Start the dwarf macinfo section.
2883     Asm->OutStreamer.SwitchSection(LineInfo);
2884   }
2885 }
2886
2887 /// emitDebugInlineInfo - Emit inline info using following format.
2888 /// Section Header:
2889 /// 1. length of section
2890 /// 2. Dwarf version number
2891 /// 3. address size.
2892 ///
2893 /// Entries (one "entry" for each function that was inlined):
2894 ///
2895 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2896 ///   otherwise offset into __debug_str for regular function name.
2897 /// 2. offset into __debug_str section for regular function name.
2898 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2899 /// instances for the function.
2900 ///
2901 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2902 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2903 /// __debug_info section, and the low_pc is the starting address for the
2904 /// inlining instance.
2905 void DwarfDebug::emitDebugInlineInfo() {
2906   if (!MAI->doesDwarfUsesInlineInfoSection())
2907     return;
2908
2909   if (!ModuleCU)
2910     return;
2911
2912   Asm->OutStreamer.SwitchSection(
2913                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2914
2915   EmitDifference("debug_inlined_end", 1,
2916                  "debug_inlined_begin", 1, true);
2917   EOL("Length of Debug Inlined Information Entry");
2918
2919   EmitLabel("debug_inlined_begin", 1);
2920
2921   Asm->EmitInt16(dwarf::DWARF_VERSION); EOL("Dwarf Version");
2922   Asm->EmitInt8(TD->getPointerSize()); EOL("Address Size (in bytes)");
2923
2924   for (SmallVector<MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2925          E = InlinedSPNodes.end(); I != E; ++I) {
2926
2927     MDNode *Node = *I;
2928     DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2929       = InlineInfo.find(Node);
2930     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2931     DISubprogram SP(Node);
2932     StringRef LName = SP.getLinkageName();
2933     StringRef Name = SP.getName();
2934
2935     if (LName.empty()) {
2936       Asm->OutStreamer.EmitBytes(Name, 0);
2937       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2938     } else 
2939       EmitSectionOffset("string", "section_str",
2940                       StringPool.idFor(getRealLinkageName(LName)), false, true);
2941
2942     EOL("MIPS linkage name");
2943     EmitSectionOffset("string", "section_str",
2944                       StringPool.idFor(Name), false, true);
2945     EOL("Function name");
2946     EmitULEB128(Labels.size(), "Inline count");
2947
2948     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2949            LE = Labels.end(); LI != LE; ++LI) {
2950       DIE *SP = LI->second;
2951       Asm->EmitInt32(SP->getOffset()); EOL("DIE offset");
2952
2953       if (TD->getPointerSize() == sizeof(int32_t))
2954         O << MAI->getData32bitsDirective();
2955       else
2956         O << MAI->getData64bitsDirective();
2957
2958       PrintLabelName("label", LI->first); EOL("low_pc");
2959     }
2960   }
2961
2962   EmitLabel("debug_inlined_end", 1);
2963   Asm->O << '\n';
2964 }