DwarfDebug.cpp revision 5e25ee8a1fcf8288d00d731b0f7ab7976f33b123 
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
14#define DEBUG_TYPE "dwarfdebug"
15#include "DwarfDebug.h"
16#include "DIE.h"
17#include "DwarfAccelTable.h"
18#include "DwarfCompileUnit.h"
19#include "llvm/Constants.h"
20#include "llvm/Module.h"
21#include "llvm/Instructions.h"
22#include "llvm/CodeGen/MachineFunction.h"
23#include "llvm/CodeGen/MachineModuleInfo.h"
24#include "llvm/MC/MCAsmInfo.h"
25#include "llvm/MC/MCSection.h"
26#include "llvm/MC/MCStreamer.h"
27#include "llvm/MC/MCSymbol.h"
28#include "llvm/Target/TargetData.h"
29#include "llvm/Target/TargetFrameLowering.h"
30#include "llvm/Target/TargetLoweringObjectFile.h"
31#include "llvm/Target/TargetMachine.h"
32#include "llvm/Target/TargetRegisterInfo.h"
33#include "llvm/Target/TargetOptions.h"
34#include "llvm/Analysis/DebugInfo.h"
35#include "llvm/Analysis/DIBuilder.h"
36#include "llvm/ADT/Statistic.h"
37#include "llvm/ADT/STLExtras.h"
38#include "llvm/ADT/StringExtras.h"
39#include "llvm/Support/CommandLine.h"
40#include "llvm/Support/Debug.h"
41#include "llvm/Support/ErrorHandling.h"
42#include "llvm/Support/ValueHandle.h"
43#include "llvm/Support/FormattedStream.h"
44#include "llvm/Support/Timer.h"
45#include "llvm/Support/Path.h"
46using namespace llvm;
47
48static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
49                                              cl::Hidden,
50     cl::desc("Disable debug info printing"));
51
52static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
53     cl::desc("Make an absence of debug location information explicit."),
54     cl::init(false));
55
56static cl::opt<bool> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
57     cl::desc("Output prototype dwarf accelerator tables."),
58     cl::init(false));
59
60namespace {
61  const char *DWARFGroupName = "DWARF Emission";
62  const char *DbgTimerName = "DWARF Debug Writer";
63} // end anonymous namespace
64
65//===----------------------------------------------------------------------===//
66
67/// Configuration values for initial hash set sizes (log2).
68///
69static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
70
71namespace llvm {
72
73DIType DbgVariable::getType() const {
74  DIType Ty = Var.getType();
75  // FIXME: isBlockByrefVariable should be reformulated in terms of complex
76  // addresses instead.
77  if (Var.isBlockByrefVariable()) {
78    /* Byref variables, in Blocks, are declared by the programmer as
79       "SomeType VarName;", but the compiler creates a
80       __Block_byref_x_VarName struct, and gives the variable VarName
81       either the struct, or a pointer to the struct, as its type.  This
82       is necessary for various behind-the-scenes things the compiler
83       needs to do with by-reference variables in blocks.
84
85       However, as far as the original *programmer* is concerned, the
86       variable should still have type 'SomeType', as originally declared.
87
88       The following function dives into the __Block_byref_x_VarName
89       struct to find the original type of the variable.  This will be
90       passed back to the code generating the type for the Debug
91       Information Entry for the variable 'VarName'.  'VarName' will then
92       have the original type 'SomeType' in its debug information.
93
94       The original type 'SomeType' will be the type of the field named
95       'VarName' inside the __Block_byref_x_VarName struct.
96
97       NOTE: In order for this to not completely fail on the debugger
98       side, the Debug Information Entry for the variable VarName needs to
99       have a DW_AT_location that tells the debugger how to unwind through
100       the pointers and __Block_byref_x_VarName struct to find the actual
101       value of the variable.  The function addBlockByrefType does this.  */
102    DIType subType = Ty;
103    unsigned tag = Ty.getTag();
104
105    if (tag == dwarf::DW_TAG_pointer_type) {
106      DIDerivedType DTy = DIDerivedType(Ty);
107      subType = DTy.getTypeDerivedFrom();
108    }
109
110    DICompositeType blockStruct = DICompositeType(subType);
111    DIArray Elements = blockStruct.getTypeArray();
112
113    for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
114      DIDescriptor Element = Elements.getElement(i);
115      DIDerivedType DT = DIDerivedType(Element);
116      if (getName() == DT.getName())
117        return (DT.getTypeDerivedFrom());
118    }
119    return Ty;
120  }
121  return Ty;
122}
123
124} // end llvm namespace
125
126DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
127  : Asm(A), MMI(Asm->MMI), FirstCU(0),
128    AbbreviationsSet(InitAbbreviationsSetSize),
129    PrevLabel(NULL) {
130  NextStringPoolNumber = 0;
131
132  DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
133  DwarfStrSectionSym = TextSectionSym = 0;
134  DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
135  FunctionBeginSym = FunctionEndSym = 0;
136  {
137    NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
138    beginModule(M);
139  }
140}
141DwarfDebug::~DwarfDebug() {
142}
143
144/// EmitSectionSym - Switch to the specified MCSection and emit an assembler
145/// temporary label to it if SymbolStem is specified.
146static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
147                                const char *SymbolStem = 0) {
148  Asm->OutStreamer.SwitchSection(Section);
149  if (!SymbolStem) return 0;
150
151  MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
152  Asm->OutStreamer.EmitLabel(TmpSym);
153  return TmpSym;
154}
155
156MCSymbol *DwarfDebug::getStringPool() {
157  return Asm->GetTempSymbol("section_str");
158}
159
160MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
161  std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
162  if (Entry.first) return Entry.first;
163
164  Entry.second = NextStringPoolNumber++;
165  return Entry.first = Asm->GetTempSymbol("string", Entry.second);
166}
167
168/// assignAbbrevNumber - Define a unique number for the abbreviation.
169///
170void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
171  // Profile the node so that we can make it unique.
172  FoldingSetNodeID ID;
173  Abbrev.Profile(ID);
174
175  // Check the set for priors.
176  DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
177
178  // If it's newly added.
179  if (InSet == &Abbrev) {
180    // Add to abbreviation list.
181    Abbreviations.push_back(&Abbrev);
182
183    // Assign the vector position + 1 as its number.
184    Abbrev.setNumber(Abbreviations.size());
185  } else {
186    // Assign existing abbreviation number.
187    Abbrev.setNumber(InSet->getNumber());
188  }
189}
190
191/// getRealLinkageName - If special LLVM prefix that is used to inform the asm
192/// printer to not emit usual symbol prefix before the symbol name is used then
193/// return linkage name after skipping this special LLVM prefix.
194static StringRef getRealLinkageName(StringRef LinkageName) {
195  char One = '\1';
196  if (LinkageName.startswith(StringRef(&One, 1)))
197    return LinkageName.substr(1);
198  return LinkageName;
199}
200
201static bool isObjCClass(StringRef Name) {
202  return Name.startswith("+") || Name.startswith("-");
203}
204
205static bool hasObjCCategory(StringRef Name) {
206  if (!isObjCClass(Name)) return false;
207
208  size_t pos = Name.find(')');
209  if (pos != std::string::npos) {
210    if (Name[pos+1] != ' ') return false;
211    return true;
212  }
213  return false;
214}
215
216static void getObjCClassCategory(StringRef In, StringRef &Class,
217                                 StringRef &Category) {
218  if (!hasObjCCategory(In)) {
219    Class = In.slice(In.find('[') + 1, In.find(' '));
220    Category = "";
221    return;
222  }
223
224  Class = In.slice(In.find('[') + 1, In.find('('));
225  Category = In.slice(In.find('[') + 1, In.find(' '));
226  return;
227}
228
229static StringRef getObjCMethodName(StringRef In) {
230  return In.slice(In.find(' ') + 1, In.find(']'));
231}
232
233// Add the various names to the Dwarf accelerator table names.
234static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
235                               DIE* Die) {
236  if (!SP.isDefinition()) return;
237
238  TheCU->addAccelName(SP.getName(), Die);
239
240  // If the linkage name is different than the name, go ahead and output
241  // that as well into the name table.
242  if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
243    TheCU->addAccelName(SP.getLinkageName(), Die);
244
245  // If this is an Objective-C selector name add it to the ObjC accelerator
246  // too.
247  if (isObjCClass(SP.getName())) {
248    StringRef Class, Category;
249    getObjCClassCategory(SP.getName(), Class, Category);
250    TheCU->addAccelObjC(Class, Die);
251    if (Category != "")
252      TheCU->addAccelObjC(Category, Die);
253    // Also add the base method name to the name table.
254    TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
255  }
256}
257
258/// updateSubprogramScopeDIE - Find DIE for the given subprogram and
259/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
260/// If there are global variables in this scope then create and insert
261/// DIEs for these variables.
262DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
263                                          const MDNode *SPNode) {
264  DIE *SPDie = SPCU->getDIE(SPNode);
265
266  assert(SPDie && "Unable to find subprogram DIE!");
267  DISubprogram SP(SPNode);
268
269  DISubprogram SPDecl = SP.getFunctionDeclaration();
270  if (!SPDecl.isSubprogram()) {
271    // There is not any need to generate specification DIE for a function
272    // defined at compile unit level. If a function is defined inside another
273    // function then gdb prefers the definition at top level and but does not
274    // expect specification DIE in parent function. So avoid creating
275    // specification DIE for a function defined inside a function.
276    if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
277        !SP.getContext().isFile() &&
278        !isSubprogramContext(SP.getContext())) {
279      SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
280
281      // Add arguments.
282      DICompositeType SPTy = SP.getType();
283      DIArray Args = SPTy.getTypeArray();
284      unsigned SPTag = SPTy.getTag();
285      if (SPTag == dwarf::DW_TAG_subroutine_type)
286        for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
287          DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
288          DIType ATy = DIType(DIType(Args.getElement(i)));
289          SPCU->addType(Arg, ATy);
290          if (ATy.isArtificial())
291            SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
292          SPDie->addChild(Arg);
293        }
294      DIE *SPDeclDie = SPDie;
295      SPDie = new DIE(dwarf::DW_TAG_subprogram);
296      SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
297                        SPDeclDie);
298      SPCU->addDie(SPDie);
299    }
300  }
301  // Pick up abstract subprogram DIE.
302  if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
303    SPDie = new DIE(dwarf::DW_TAG_subprogram);
304    SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
305                      dwarf::DW_FORM_ref4, AbsSPDIE);
306    SPCU->addDie(SPDie);
307  }
308
309  SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
310                 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
311  SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
312                 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
313  const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
314  MachineLocation Location(RI->getFrameRegister(*Asm->MF));
315  SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
316
317  // Add name to the name table, we do this here because we're guaranteed
318  // to have concrete versions of our DW_TAG_subprogram nodes.
319  addSubprogramNames(SPCU, SP, SPDie);
320
321  return SPDie;
322}
323
324/// constructLexicalScope - Construct new DW_TAG_lexical_block
325/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
326DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
327                                          LexicalScope *Scope) {
328  DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
329  if (Scope->isAbstractScope())
330    return ScopeDIE;
331
332  const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
333  if (Ranges.empty())
334    return 0;
335
336  SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
337  if (Ranges.size() > 1) {
338    // .debug_range section has not been laid out yet. Emit offset in
339    // .debug_range as a uint, size 4, for now. emitDIE will handle
340    // DW_AT_ranges appropriately.
341    TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
342                   DebugRangeSymbols.size()
343                   * Asm->getTargetData().getPointerSize());
344    for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
345         RE = Ranges.end(); RI != RE; ++RI) {
346      DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
347      DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
348    }
349    DebugRangeSymbols.push_back(NULL);
350    DebugRangeSymbols.push_back(NULL);
351    return ScopeDIE;
352  }
353
354  const MCSymbol *Start = getLabelBeforeInsn(RI->first);
355  const MCSymbol *End = getLabelAfterInsn(RI->second);
356
357  if (End == 0) return 0;
358
359  assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
360  assert(End->isDefined() && "Invalid end label for an inlined scope!");
361
362  TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
363  TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
364
365  return ScopeDIE;
366}
367
368/// constructInlinedScopeDIE - This scope represents inlined body of
369/// a function. Construct DIE to represent this concrete inlined copy
370/// of the function.
371DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
372                                          LexicalScope *Scope) {
373  const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
374  assert(Ranges.empty() == false &&
375         "LexicalScope does not have instruction markers!");
376
377  if (!Scope->getScopeNode())
378    return NULL;
379  DIScope DS(Scope->getScopeNode());
380  DISubprogram InlinedSP = getDISubprogram(DS);
381  DIE *OriginDIE = TheCU->getDIE(InlinedSP);
382  if (!OriginDIE) {
383    DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
384    return NULL;
385  }
386
387  SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
388  const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
389  const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
390
391  if (StartLabel == 0 || EndLabel == 0) {
392    llvm_unreachable("Unexpected Start and End labels for a inlined scope!");
393  }
394  assert(StartLabel->isDefined() &&
395         "Invalid starting label for an inlined scope!");
396  assert(EndLabel->isDefined() &&
397         "Invalid end label for an inlined scope!");
398
399  DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
400  TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
401                     dwarf::DW_FORM_ref4, OriginDIE);
402
403  if (Ranges.size() > 1) {
404    // .debug_range section has not been laid out yet. Emit offset in
405    // .debug_range as a uint, size 4, for now. emitDIE will handle
406    // DW_AT_ranges appropriately.
407    TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
408                   DebugRangeSymbols.size()
409                   * Asm->getTargetData().getPointerSize());
410    for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
411         RE = Ranges.end(); RI != RE; ++RI) {
412      DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
413      DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
414    }
415    DebugRangeSymbols.push_back(NULL);
416    DebugRangeSymbols.push_back(NULL);
417  } else {
418    TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
419                    StartLabel);
420    TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
421                    EndLabel);
422  }
423
424  InlinedSubprogramDIEs.insert(OriginDIE);
425
426  // Track the start label for this inlined function.
427  //.debug_inlined section specification does not clearly state how
428  // to emit inlined scope that is split into multiple instruction ranges.
429  // For now, use first instruction range and emit low_pc/high_pc pair and
430  // corresponding .debug_inlined section entry for this pair.
431  DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
432    I = InlineInfo.find(InlinedSP);
433
434  if (I == InlineInfo.end()) {
435    InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
436    InlinedSPNodes.push_back(InlinedSP);
437  } else
438    I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
439
440  DILocation DL(Scope->getInlinedAt());
441  TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
442  TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
443
444  // Add name to the name table, we do this here because we're guaranteed
445  // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
446  addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
447
448  return ScopeDIE;
449}
450
451/// constructScopeDIE - Construct a DIE for this scope.
452DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
453  if (!Scope || !Scope->getScopeNode())
454    return NULL;
455
456  SmallVector<DIE *, 8> Children;
457
458  // Collect arguments for current function.
459  if (LScopes.isCurrentFunctionScope(Scope))
460    for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
461      if (DbgVariable *ArgDV = CurrentFnArguments[i])
462        if (DIE *Arg =
463            TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
464          Children.push_back(Arg);
465
466  // Collect lexical scope children first.
467  const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
468  for (unsigned i = 0, N = Variables.size(); i < N; ++i)
469    if (DIE *Variable =
470        TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
471      Children.push_back(Variable);
472  const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
473  for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
474    if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
475      Children.push_back(Nested);
476  DIScope DS(Scope->getScopeNode());
477  DIE *ScopeDIE = NULL;
478  if (Scope->getInlinedAt())
479    ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
480  else if (DS.isSubprogram()) {
481    ProcessedSPNodes.insert(DS);
482    if (Scope->isAbstractScope()) {
483      ScopeDIE = TheCU->getDIE(DS);
484      // Note down abstract DIE.
485      if (ScopeDIE)
486        AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
487    }
488    else
489      ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
490  }
491  else {
492    // There is no need to emit empty lexical block DIE.
493    if (Children.empty())
494      return NULL;
495    ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
496  }
497
498  if (!ScopeDIE) return NULL;
499
500  // Add children
501  for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
502         E = Children.end(); I != E; ++I)
503    ScopeDIE->addChild(*I);
504
505  if (DS.isSubprogram())
506    TheCU->addPubTypes(DISubprogram(DS));
507
508  return ScopeDIE;
509}
510
511/// GetOrCreateSourceID - Look up the source id with the given directory and
512/// source file names. If none currently exists, create a new id and insert it
513/// in the SourceIds map. This can update DirectoryNames and SourceFileNames
514/// maps as well.
515unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
516                                         StringRef DirName) {
517  // If FE did not provide a file name, then assume stdin.
518  if (FileName.empty())
519    return GetOrCreateSourceID("<stdin>", StringRef());
520
521  // TODO: this might not belong here. See if we can factor this better.
522  if (DirName == CompilationDir)
523    DirName = "";
524
525  unsigned SrcId = SourceIdMap.size()+1;
526  std::pair<std::string, std::string> SourceName =
527      std::make_pair(FileName, DirName);
528  std::pair<std::pair<std::string, std::string>, unsigned> Entry =
529      make_pair(SourceName, SrcId);
530
531  std::map<std::pair<std::string, std::string>, unsigned>::iterator I;
532  bool NewlyInserted;
533  tie(I, NewlyInserted) = SourceIdMap.insert(Entry);
534  if (!NewlyInserted)
535    return I->second;
536
537  // Print out a .file directive to specify files for .loc directives.
538  Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.first.second,
539                                          Entry.first.first);
540
541  return SrcId;
542}
543
544/// constructCompileUnit - Create new CompileUnit for the given
545/// metadata node with tag DW_TAG_compile_unit.
546CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
547  DICompileUnit DIUnit(N);
548  StringRef FN = DIUnit.getFilename();
549  CompilationDir = DIUnit.getDirectory();
550  unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
551
552  DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
553  CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
554  NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
555  NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
556                 DIUnit.getLanguage());
557  NewCU->addString(Die, dwarf::DW_AT_name, FN);
558  // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
559  // simplifies debug range entries.
560  NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
561  // DW_AT_stmt_list is a offset of line number information for this
562  // compile unit in debug_line section.
563  if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
564    NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
565                    Asm->GetTempSymbol("section_line"));
566  else
567    NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
568
569  if (!CompilationDir.empty())
570    NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
571  if (DIUnit.isOptimized())
572    NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
573
574  StringRef Flags = DIUnit.getFlags();
575  if (!Flags.empty())
576    NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
577
578  if (unsigned RVer = DIUnit.getRunTimeVersion())
579    NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
580            dwarf::DW_FORM_data1, RVer);
581
582  if (!FirstCU)
583    FirstCU = NewCU;
584  CUMap.insert(std::make_pair(N, NewCU));
585  return NewCU;
586}
587
588/// construct SubprogramDIE - Construct subprogram DIE.
589void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
590                                        const MDNode *N) {
591  CompileUnit *&CURef = SPMap[N];
592  if (CURef)
593    return;
594  CURef = TheCU;
595
596  DISubprogram SP(N);
597  if (!SP.isDefinition())
598    // This is a method declaration which will be handled while constructing
599    // class type.
600    return;
601
602  DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
603
604  // Add to map.
605  TheCU->insertDIE(N, SubprogramDie);
606
607  // Add to context owner.
608  TheCU->addToContextOwner(SubprogramDie, SP.getContext());
609
610  return;
611}
612
613/// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
614/// as llvm.dbg.enum and llvm.dbg.ty
615void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
616  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
617    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
618      const MDNode *N = NMD->getOperand(i);
619      if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
620        constructSubprogramDIE(CU, N);
621    }
622
623  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
624    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
625      const MDNode *N = NMD->getOperand(i);
626      if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
627        CU->createGlobalVariableDIE(N);
628    }
629
630  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
631    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
632      DIType Ty(NMD->getOperand(i));
633      if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
634        CU->getOrCreateTypeDIE(Ty);
635    }
636
637  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
638    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
639      DIType Ty(NMD->getOperand(i));
640      if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
641        CU->getOrCreateTypeDIE(Ty);
642    }
643}
644
645/// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
646/// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
647bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
648  DebugInfoFinder DbgFinder;
649  DbgFinder.processModule(*M);
650
651  bool HasDebugInfo = false;
652  // Scan all the compile-units to see if there are any marked as the main
653  // unit. If not, we do not generate debug info.
654  for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
655         E = DbgFinder.compile_unit_end(); I != E; ++I) {
656    if (DICompileUnit(*I).isMain()) {
657      HasDebugInfo = true;
658      break;
659    }
660  }
661  if (!HasDebugInfo) return false;
662
663  // Create all the compile unit DIEs.
664  for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
665         E = DbgFinder.compile_unit_end(); I != E; ++I)
666    constructCompileUnit(*I);
667
668  // Create DIEs for each global variable.
669  for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
670         E = DbgFinder.global_variable_end(); I != E; ++I) {
671    const MDNode *N = *I;
672    if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
673      CU->createGlobalVariableDIE(N);
674  }
675
676  // Create DIEs for each subprogram.
677  for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
678         E = DbgFinder.subprogram_end(); I != E; ++I) {
679    const MDNode *N = *I;
680    if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
681      constructSubprogramDIE(CU, N);
682  }
683
684  return HasDebugInfo;
685}
686
687/// beginModule - Emit all Dwarf sections that should come prior to the
688/// content. Create global DIEs and emit initial debug info sections.
689/// This is invoked by the target AsmPrinter.
690void DwarfDebug::beginModule(Module *M) {
691  if (DisableDebugInfoPrinting)
692    return;
693
694  // If module has named metadata anchors then use them, otherwise scan the
695  // module using debug info finder to collect debug info.
696  NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
697  if (CU_Nodes) {
698    for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
699      DICompileUnit CUNode(CU_Nodes->getOperand(i));
700      CompileUnit *CU = constructCompileUnit(CUNode);
701      DIArray GVs = CUNode.getGlobalVariables();
702      for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
703        CU->createGlobalVariableDIE(GVs.getElement(i));
704      DIArray SPs = CUNode.getSubprograms();
705      for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
706        constructSubprogramDIE(CU, SPs.getElement(i));
707      DIArray EnumTypes = CUNode.getEnumTypes();
708      for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
709        CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
710      DIArray RetainedTypes = CUNode.getRetainedTypes();
711      for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
712        CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
713    }
714  } else if (!collectLegacyDebugInfo(M))
715    return;
716
717  collectInfoFromNamedMDNodes(M);
718
719  // Tell MMI that we have debug info.
720  MMI->setDebugInfoAvailability(true);
721
722  // Emit initial sections.
723  EmitSectionLabels();
724
725  // Prime section data.
726  SectionMap.insert(Asm->getObjFileLowering().getTextSection());
727}
728
729/// endModule - Emit all Dwarf sections that should come after the content.
730///
731void DwarfDebug::endModule() {
732  if (!FirstCU) return;
733  const Module *M = MMI->getModule();
734  DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
735
736  // Collect info for variables that were optimized out.
737  if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
738    for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
739      DICompileUnit TheCU(CU_Nodes->getOperand(i));
740      DIArray Subprograms = TheCU.getSubprograms();
741      for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
742        DISubprogram SP(Subprograms.getElement(i));
743        if (ProcessedSPNodes.count(SP) != 0) continue;
744        if (!SP.Verify()) continue;
745        if (!SP.isDefinition()) continue;
746        DIArray Variables = SP.getVariables();
747        if (Variables.getNumElements() == 0) continue;
748
749        LexicalScope *Scope =
750          new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
751        DeadFnScopeMap[SP] = Scope;
752
753        // Construct subprogram DIE and add variables DIEs.
754        CompileUnit *SPCU = CUMap.lookup(TheCU);
755        assert(SPCU && "Unable to find Compile Unit!");
756        constructSubprogramDIE(SPCU, SP);
757        DIE *ScopeDIE = SPCU->getDIE(SP);
758        for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
759          DIVariable DV(Variables.getElement(vi));
760          if (!DV.Verify()) continue;
761          DbgVariable *NewVar = new DbgVariable(DV, NULL);
762          if (DIE *VariableDIE =
763              SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
764            ScopeDIE->addChild(VariableDIE);
765        }
766      }
767    }
768  }
769
770  // Attach DW_AT_inline attribute with inlined subprogram DIEs.
771  for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
772         AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
773    DIE *ISP = *AI;
774    FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
775  }
776  for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
777         AE = AbstractSPDies.end(); AI != AE; ++AI) {
778    DIE *ISP = AI->second;
779    if (InlinedSubprogramDIEs.count(ISP))
780      continue;
781    FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
782  }
783
784  // Emit DW_AT_containing_type attribute to connect types with their
785  // vtable holding type.
786  for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
787         CUE = CUMap.end(); CUI != CUE; ++CUI) {
788    CompileUnit *TheCU = CUI->second;
789    TheCU->constructContainingTypeDIEs();
790  }
791
792  // Standard sections final addresses.
793  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
794  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
795  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
796  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
797
798  // End text sections.
799  for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
800    Asm->OutStreamer.SwitchSection(SectionMap[i]);
801    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
802  }
803
804  // Compute DIE offsets and sizes.
805  computeSizeAndOffsets();
806
807  // Emit all the DIEs into a debug info section
808  emitDebugInfo();
809
810  // Corresponding abbreviations into a abbrev section.
811  emitAbbreviations();
812
813  // Emit info into a dwarf accelerator table sections.
814  if (DwarfAccelTables) {
815    emitAccelNames();
816    emitAccelObjC();
817    emitAccelNamespaces();
818    emitAccelTypes();
819  }
820
821  // Emit info into a debug pubtypes section.
822  emitDebugPubTypes();
823
824  // Emit info into a debug loc section.
825  emitDebugLoc();
826
827  // Emit info into a debug aranges section.
828  EmitDebugARanges();
829
830  // Emit info into a debug ranges section.
831  emitDebugRanges();
832
833  // Emit info into a debug macinfo section.
834  emitDebugMacInfo();
835
836  // Emit inline info.
837  emitDebugInlineInfo();
838
839  // Emit info into a debug str section.
840  emitDebugStr();
841
842  // clean up.
843  DeleteContainerSeconds(DeadFnScopeMap);
844  SPMap.clear();
845  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
846         E = CUMap.end(); I != E; ++I)
847    delete I->second;
848  FirstCU = NULL;  // Reset for the next Module, if any.
849}
850
851/// findAbstractVariable - Find abstract variable, if any, associated with Var.
852DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
853                                              DebugLoc ScopeLoc) {
854  LLVMContext &Ctx = DV->getContext();
855  // More then one inlined variable corresponds to one abstract variable.
856  DIVariable Var = cleanseInlinedVariable(DV, Ctx);
857  DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
858  if (AbsDbgVariable)
859    return AbsDbgVariable;
860
861  LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
862  if (!Scope)
863    return NULL;
864
865  AbsDbgVariable = new DbgVariable(Var, NULL);
866  addScopeVariable(Scope, AbsDbgVariable);
867  AbstractVariables[Var] = AbsDbgVariable;
868  return AbsDbgVariable;
869}
870
871/// addCurrentFnArgument - If Var is a current function argument then add
872/// it to CurrentFnArguments list.
873bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
874                                      DbgVariable *Var, LexicalScope *Scope) {
875  if (!LScopes.isCurrentFunctionScope(Scope))
876    return false;
877  DIVariable DV = Var->getVariable();
878  if (DV.getTag() != dwarf::DW_TAG_arg_variable)
879    return false;
880  unsigned ArgNo = DV.getArgNumber();
881  if (ArgNo == 0)
882    return false;
883
884  size_t Size = CurrentFnArguments.size();
885  if (Size == 0)
886    CurrentFnArguments.resize(MF->getFunction()->arg_size());
887  // llvm::Function argument size is not good indicator of how many
888  // arguments does the function have at source level.
889  if (ArgNo > Size)
890    CurrentFnArguments.resize(ArgNo * 2);
891  CurrentFnArguments[ArgNo - 1] = Var;
892  return true;
893}
894
895/// collectVariableInfoFromMMITable - Collect variable information from
896/// side table maintained by MMI.
897void
898DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
899                                   SmallPtrSet<const MDNode *, 16> &Processed) {
900  MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
901  for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
902         VE = VMap.end(); VI != VE; ++VI) {
903    const MDNode *Var = VI->first;
904    if (!Var) continue;
905    Processed.insert(Var);
906    DIVariable DV(Var);
907    const std::pair<unsigned, DebugLoc> &VP = VI->second;
908
909    LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
910
911    // If variable scope is not found then skip this variable.
912    if (Scope == 0)
913      continue;
914
915    DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
916    DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
917    RegVar->setFrameIndex(VP.first);
918    if (!addCurrentFnArgument(MF, RegVar, Scope))
919      addScopeVariable(Scope, RegVar);
920    if (AbsDbgVariable)
921      AbsDbgVariable->setFrameIndex(VP.first);
922  }
923}
924
925/// isDbgValueInDefinedReg - Return true if debug value, encoded by
926/// DBG_VALUE instruction, is in a defined reg.
927static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
928  assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
929  return MI->getNumOperands() == 3 &&
930         MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
931         MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
932}
933
934/// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
935/// at MI.
936static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
937                                         const MCSymbol *FLabel,
938                                         const MCSymbol *SLabel,
939                                         const MachineInstr *MI) {
940  const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
941
942  if (MI->getNumOperands() != 3) {
943    MachineLocation MLoc = Asm->getDebugValueLocation(MI);
944    return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
945  }
946  if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
947    MachineLocation MLoc;
948    MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
949    return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
950  }
951  if (MI->getOperand(0).isImm())
952    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
953  if (MI->getOperand(0).isFPImm())
954    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
955  if (MI->getOperand(0).isCImm())
956    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
957
958  llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
959}
960
961/// collectVariableInfo - Find variables for each lexical scope.
962void
963DwarfDebug::collectVariableInfo(const MachineFunction *MF,
964                                SmallPtrSet<const MDNode *, 16> &Processed) {
965
966  /// collection info from MMI table.
967  collectVariableInfoFromMMITable(MF, Processed);
968
969  for (SmallVectorImpl<const MDNode*>::const_iterator
970         UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
971         ++UVI) {
972    const MDNode *Var = *UVI;
973    if (Processed.count(Var))
974      continue;
975
976    // History contains relevant DBG_VALUE instructions for Var and instructions
977    // clobbering it.
978    SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
979    if (History.empty())
980      continue;
981    const MachineInstr *MInsn = History.front();
982
983    DIVariable DV(Var);
984    LexicalScope *Scope = NULL;
985    if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
986        DISubprogram(DV.getContext()).describes(MF->getFunction()))
987      Scope = LScopes.getCurrentFunctionScope();
988    else {
989      if (DV.getVersion() <= LLVMDebugVersion9)
990        Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
991      else {
992        if (MDNode *IA = DV.getInlinedAt())
993          Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
994        else
995          Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
996      }
997    }
998    // If variable scope is not found then skip this variable.
999    if (!Scope)
1000      continue;
1001
1002    Processed.insert(DV);
1003    assert(MInsn->isDebugValue() && "History must begin with debug value");
1004    DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1005    DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1006    if (!addCurrentFnArgument(MF, RegVar, Scope))
1007      addScopeVariable(Scope, RegVar);
1008    if (AbsVar)
1009      AbsVar->setMInsn(MInsn);
1010
1011    // Simple ranges that are fully coalesced.
1012    if (History.size() <= 1 || (History.size() == 2 &&
1013                                MInsn->isIdenticalTo(History.back()))) {
1014      RegVar->setMInsn(MInsn);
1015      continue;
1016    }
1017
1018    // handle multiple DBG_VALUE instructions describing one variable.
1019    RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1020
1021    for (SmallVectorImpl<const MachineInstr*>::const_iterator
1022           HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1023      const MachineInstr *Begin = *HI;
1024      assert(Begin->isDebugValue() && "Invalid History entry");
1025
1026      // Check if DBG_VALUE is truncating a range.
1027      if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1028          && !Begin->getOperand(0).getReg())
1029        continue;
1030
1031      // Compute the range for a register location.
1032      const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1033      const MCSymbol *SLabel = 0;
1034
1035      if (HI + 1 == HE)
1036        // If Begin is the last instruction in History then its value is valid
1037        // until the end of the function.
1038        SLabel = FunctionEndSym;
1039      else {
1040        const MachineInstr *End = HI[1];
1041        DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1042              << "\t" << *Begin << "\t" << *End << "\n");
1043        if (End->isDebugValue())
1044          SLabel = getLabelBeforeInsn(End);
1045        else {
1046          // End is a normal instruction clobbering the range.
1047          SLabel = getLabelAfterInsn(End);
1048          assert(SLabel && "Forgot label after clobber instruction");
1049          ++HI;
1050        }
1051      }
1052
1053      // The value is valid until the next DBG_VALUE or clobber.
1054      DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1055                                                    Begin));
1056    }
1057    DotDebugLocEntries.push_back(DotDebugLocEntry());
1058  }
1059
1060  // Collect info for variables that were optimized out.
1061  LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1062  DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1063  for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1064    DIVariable DV(Variables.getElement(i));
1065    if (!DV || !DV.Verify() || !Processed.insert(DV))
1066      continue;
1067    if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1068      addScopeVariable(Scope, new DbgVariable(DV, NULL));
1069  }
1070}
1071
1072/// getLabelBeforeInsn - Return Label preceding the instruction.
1073const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1074  MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1075  assert(Label && "Didn't insert label before instruction");
1076  return Label;
1077}
1078
1079/// getLabelAfterInsn - Return Label immediately following the instruction.
1080const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1081  return LabelsAfterInsn.lookup(MI);
1082}
1083
1084/// beginInstruction - Process beginning of an instruction.
1085void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1086  // Check if source location changes, but ignore DBG_VALUE locations.
1087  if (!MI->isDebugValue()) {
1088    DebugLoc DL = MI->getDebugLoc();
1089    if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1090      unsigned Flags = DWARF2_FLAG_IS_STMT;
1091      PrevInstLoc = DL;
1092      if (DL == PrologEndLoc) {
1093        Flags |= DWARF2_FLAG_PROLOGUE_END;
1094        PrologEndLoc = DebugLoc();
1095      }
1096      if (!DL.isUnknown()) {
1097        const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1098        recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1099      } else
1100        recordSourceLine(0, 0, 0, 0);
1101    }
1102  }
1103
1104  // Insert labels where requested.
1105  DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1106    LabelsBeforeInsn.find(MI);
1107
1108  // No label needed.
1109  if (I == LabelsBeforeInsn.end())
1110    return;
1111
1112  // Label already assigned.
1113  if (I->second)
1114    return;
1115
1116  if (!PrevLabel) {
1117    PrevLabel = MMI->getContext().CreateTempSymbol();
1118    Asm->OutStreamer.EmitLabel(PrevLabel);
1119  }
1120  I->second = PrevLabel;
1121}
1122
1123/// endInstruction - Process end of an instruction.
1124void DwarfDebug::endInstruction(const MachineInstr *MI) {
1125  // Don't create a new label after DBG_VALUE instructions.
1126  // They don't generate code.
1127  if (!MI->isDebugValue())
1128    PrevLabel = 0;
1129
1130  DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1131    LabelsAfterInsn.find(MI);
1132
1133  // No label needed.
1134  if (I == LabelsAfterInsn.end())
1135    return;
1136
1137  // Label already assigned.
1138  if (I->second)
1139    return;
1140
1141  // We need a label after this instruction.
1142  if (!PrevLabel) {
1143    PrevLabel = MMI->getContext().CreateTempSymbol();
1144    Asm->OutStreamer.EmitLabel(PrevLabel);
1145  }
1146  I->second = PrevLabel;
1147}
1148
1149/// identifyScopeMarkers() -
1150/// Each LexicalScope has first instruction and last instruction to mark
1151/// beginning and end of a scope respectively. Create an inverse map that list
1152/// scopes starts (and ends) with an instruction. One instruction may start (or
1153/// end) multiple scopes. Ignore scopes that are not reachable.
1154void DwarfDebug::identifyScopeMarkers() {
1155  SmallVector<LexicalScope *, 4> WorkList;
1156  WorkList.push_back(LScopes.getCurrentFunctionScope());
1157  while (!WorkList.empty()) {
1158    LexicalScope *S = WorkList.pop_back_val();
1159
1160    const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1161    if (!Children.empty())
1162      for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1163             SE = Children.end(); SI != SE; ++SI)
1164        WorkList.push_back(*SI);
1165
1166    if (S->isAbstractScope())
1167      continue;
1168
1169    const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1170    if (Ranges.empty())
1171      continue;
1172    for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1173           RE = Ranges.end(); RI != RE; ++RI) {
1174      assert(RI->first && "InsnRange does not have first instruction!");
1175      assert(RI->second && "InsnRange does not have second instruction!");
1176      requestLabelBeforeInsn(RI->first);
1177      requestLabelAfterInsn(RI->second);
1178    }
1179  }
1180}
1181
1182/// getScopeNode - Get MDNode for DebugLoc's scope.
1183static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1184  if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1185    return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1186  return DL.getScope(Ctx);
1187}
1188
1189/// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1190/// line number  info for the function.
1191static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1192  const MDNode *Scope = getScopeNode(DL, Ctx);
1193  DISubprogram SP = getDISubprogram(Scope);
1194  if (SP.Verify())
1195    return DebugLoc::get(SP.getLineNumber(), 0, SP);
1196  return DebugLoc();
1197}
1198
1199/// beginFunction - Gather pre-function debug information.  Assumes being
1200/// emitted immediately after the function entry point.
1201void DwarfDebug::beginFunction(const MachineFunction *MF) {
1202  if (!MMI->hasDebugInfo()) return;
1203  LScopes.initialize(*MF);
1204  if (LScopes.empty()) return;
1205  identifyScopeMarkers();
1206
1207  FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1208                                        Asm->getFunctionNumber());
1209  // Assumes in correct section after the entry point.
1210  Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1211
1212  assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1213
1214  const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1215  /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1216  std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1217
1218  for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1219       I != E; ++I) {
1220    bool AtBlockEntry = true;
1221    for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1222         II != IE; ++II) {
1223      const MachineInstr *MI = II;
1224
1225      if (MI->isDebugValue()) {
1226        assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1227
1228        // Keep track of user variables.
1229        const MDNode *Var =
1230          MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1231
1232        // Variable is in a register, we need to check for clobbers.
1233        if (isDbgValueInDefinedReg(MI))
1234          LiveUserVar[MI->getOperand(0).getReg()] = Var;
1235
1236        // Check the history of this variable.
1237        SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1238        if (History.empty()) {
1239          UserVariables.push_back(Var);
1240          // The first mention of a function argument gets the FunctionBeginSym
1241          // label, so arguments are visible when breaking at function entry.
1242          DIVariable DV(Var);
1243          if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1244              DISubprogram(getDISubprogram(DV.getContext()))
1245                .describes(MF->getFunction()))
1246            LabelsBeforeInsn[MI] = FunctionBeginSym;
1247        } else {
1248          // We have seen this variable before. Try to coalesce DBG_VALUEs.
1249          const MachineInstr *Prev = History.back();
1250          if (Prev->isDebugValue()) {
1251            // Coalesce identical entries at the end of History.
1252            if (History.size() >= 2 &&
1253                Prev->isIdenticalTo(History[History.size() - 2])) {
1254              DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1255                    << "\t" << *Prev
1256                    << "\t" << *History[History.size() - 2] << "\n");
1257              History.pop_back();
1258            }
1259
1260            // Terminate old register assignments that don't reach MI;
1261            MachineFunction::const_iterator PrevMBB = Prev->getParent();
1262            if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1263                isDbgValueInDefinedReg(Prev)) {
1264              // Previous register assignment needs to terminate at the end of
1265              // its basic block.
1266              MachineBasicBlock::const_iterator LastMI =
1267                PrevMBB->getLastNonDebugInstr();
1268              if (LastMI == PrevMBB->end()) {
1269                // Drop DBG_VALUE for empty range.
1270                DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1271                      << "\t" << *Prev << "\n");
1272                History.pop_back();
1273              }
1274              else {
1275                // Terminate after LastMI.
1276                History.push_back(LastMI);
1277              }
1278            }
1279          }
1280        }
1281        History.push_back(MI);
1282      } else {
1283        // Not a DBG_VALUE instruction.
1284        if (!MI->isLabel())
1285          AtBlockEntry = false;
1286
1287        // First known non DBG_VALUE location marks beginning of function
1288        // body.
1289        if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1290          PrologEndLoc = MI->getDebugLoc();
1291
1292        // Check if the instruction clobbers any registers with debug vars.
1293        for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1294               MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1295          if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1296            continue;
1297          for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1298               unsigned Reg = *AI; ++AI) {
1299            const MDNode *Var = LiveUserVar[Reg];
1300            if (!Var)
1301              continue;
1302            // Reg is now clobbered.
1303            LiveUserVar[Reg] = 0;
1304
1305            // Was MD last defined by a DBG_VALUE referring to Reg?
1306            DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1307            if (HistI == DbgValues.end())
1308              continue;
1309            SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1310            if (History.empty())
1311              continue;
1312            const MachineInstr *Prev = History.back();
1313            // Sanity-check: Register assignments are terminated at the end of
1314            // their block.
1315            if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1316              continue;
1317            // Is the variable still in Reg?
1318            if (!isDbgValueInDefinedReg(Prev) ||
1319                Prev->getOperand(0).getReg() != Reg)
1320              continue;
1321            // Var is clobbered. Make sure the next instruction gets a label.
1322            History.push_back(MI);
1323          }
1324        }
1325      }
1326    }
1327  }
1328
1329  for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1330       I != E; ++I) {
1331    SmallVectorImpl<const MachineInstr*> &History = I->second;
1332    if (History.empty())
1333      continue;
1334
1335    // Make sure the final register assignments are terminated.
1336    const MachineInstr *Prev = History.back();
1337    if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1338      const MachineBasicBlock *PrevMBB = Prev->getParent();
1339      MachineBasicBlock::const_iterator LastMI =
1340        PrevMBB->getLastNonDebugInstr();
1341      if (LastMI == PrevMBB->end())
1342        // Drop DBG_VALUE for empty range.
1343        History.pop_back();
1344      else {
1345        // Terminate after LastMI.
1346        History.push_back(LastMI);
1347      }
1348    }
1349    // Request labels for the full history.
1350    for (unsigned i = 0, e = History.size(); i != e; ++i) {
1351      const MachineInstr *MI = History[i];
1352      if (MI->isDebugValue())
1353        requestLabelBeforeInsn(MI);
1354      else
1355        requestLabelAfterInsn(MI);
1356    }
1357  }
1358
1359  PrevInstLoc = DebugLoc();
1360  PrevLabel = FunctionBeginSym;
1361
1362  // Record beginning of function.
1363  if (!PrologEndLoc.isUnknown()) {
1364    DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1365                                       MF->getFunction()->getContext());
1366    recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1367                     FnStartDL.getScope(MF->getFunction()->getContext()),
1368                     DWARF2_FLAG_IS_STMT);
1369  }
1370}
1371
1372void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1373//  SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1374  ScopeVariables[LS].push_back(Var);
1375//  Vars.push_back(Var);
1376}
1377
1378/// endFunction - Gather and emit post-function debug information.
1379///
1380void DwarfDebug::endFunction(const MachineFunction *MF) {
1381  if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1382
1383  // Define end label for subprogram.
1384  FunctionEndSym = Asm->GetTempSymbol("func_end",
1385                                      Asm->getFunctionNumber());
1386  // Assumes in correct section after the entry point.
1387  Asm->OutStreamer.EmitLabel(FunctionEndSym);
1388
1389  SmallPtrSet<const MDNode *, 16> ProcessedVars;
1390  collectVariableInfo(MF, ProcessedVars);
1391
1392  LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1393  CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1394  assert(TheCU && "Unable to find compile unit!");
1395
1396  // Construct abstract scopes.
1397  ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1398  for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1399    LexicalScope *AScope = AList[i];
1400    DISubprogram SP(AScope->getScopeNode());
1401    if (SP.Verify()) {
1402      // Collect info for variables that were optimized out.
1403      DIArray Variables = SP.getVariables();
1404      for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1405        DIVariable DV(Variables.getElement(i));
1406        if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1407          continue;
1408        if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1409          addScopeVariable(Scope, new DbgVariable(DV, NULL));
1410      }
1411    }
1412    if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1413      constructScopeDIE(TheCU, AScope);
1414  }
1415
1416  DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1417
1418  if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1419    TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1420                   dwarf::DW_FORM_flag, 1);
1421
1422  DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1423                                               MMI->getFrameMoves()));
1424
1425  // Clear debug info
1426  for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1427         I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1428    DeleteContainerPointers(I->second);
1429  ScopeVariables.clear();
1430  DeleteContainerPointers(CurrentFnArguments);
1431  UserVariables.clear();
1432  DbgValues.clear();
1433  AbstractVariables.clear();
1434  LabelsBeforeInsn.clear();
1435  LabelsAfterInsn.clear();
1436  PrevLabel = NULL;
1437}
1438
1439/// recordSourceLine - Register a source line with debug info. Returns the
1440/// unique label that was emitted and which provides correspondence to
1441/// the source line list.
1442void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1443                                  unsigned Flags) {
1444  StringRef Fn;
1445  StringRef Dir;
1446  unsigned Src = 1;
1447  if (S) {
1448    DIDescriptor Scope(S);
1449
1450    if (Scope.isCompileUnit()) {
1451      DICompileUnit CU(S);
1452      Fn = CU.getFilename();
1453      Dir = CU.getDirectory();
1454    } else if (Scope.isFile()) {
1455      DIFile F(S);
1456      Fn = F.getFilename();
1457      Dir = F.getDirectory();
1458    } else if (Scope.isSubprogram()) {
1459      DISubprogram SP(S);
1460      Fn = SP.getFilename();
1461      Dir = SP.getDirectory();
1462    } else if (Scope.isLexicalBlockFile()) {
1463      DILexicalBlockFile DBF(S);
1464      Fn = DBF.getFilename();
1465      Dir = DBF.getDirectory();
1466    } else if (Scope.isLexicalBlock()) {
1467      DILexicalBlock DB(S);
1468      Fn = DB.getFilename();
1469      Dir = DB.getDirectory();
1470    } else
1471      llvm_unreachable("Unexpected scope info");
1472
1473    Src = GetOrCreateSourceID(Fn, Dir);
1474  }
1475  Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1476}
1477
1478//===----------------------------------------------------------------------===//
1479// Emit Methods
1480//===----------------------------------------------------------------------===//
1481
1482/// computeSizeAndOffset - Compute the size and offset of a DIE.
1483///
1484unsigned
1485DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1486  // Get the children.
1487  const std::vector<DIE *> &Children = Die->getChildren();
1488
1489  // Record the abbreviation.
1490  assignAbbrevNumber(Die->getAbbrev());
1491
1492  // Get the abbreviation for this DIE.
1493  unsigned AbbrevNumber = Die->getAbbrevNumber();
1494  const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1495
1496  // Set DIE offset
1497  Die->setOffset(Offset);
1498
1499  // Start the size with the size of abbreviation code.
1500  Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1501
1502  const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1503  const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1504
1505  // Size the DIE attribute values.
1506  for (unsigned i = 0, N = Values.size(); i < N; ++i)
1507    // Size attribute value.
1508    Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1509
1510  // Size the DIE children if any.
1511  if (!Children.empty()) {
1512    assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1513           "Children flag not set");
1514
1515    for (unsigned j = 0, M = Children.size(); j < M; ++j)
1516      Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1517
1518    // End of children marker.
1519    Offset += sizeof(int8_t);
1520  }
1521
1522  Die->setSize(Offset - Die->getOffset());
1523  return Offset;
1524}
1525
1526/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1527///
1528void DwarfDebug::computeSizeAndOffsets() {
1529  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1530         E = CUMap.end(); I != E; ++I) {
1531    // Compute size of compile unit header.
1532    unsigned Offset =
1533      sizeof(int32_t) + // Length of Compilation Unit Info
1534      sizeof(int16_t) + // DWARF version number
1535      sizeof(int32_t) + // Offset Into Abbrev. Section
1536      sizeof(int8_t);   // Pointer Size (in bytes)
1537    computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1538  }
1539}
1540
1541/// EmitSectionLabels - Emit initial Dwarf sections with a label at
1542/// the start of each one.
1543void DwarfDebug::EmitSectionLabels() {
1544  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1545
1546  // Dwarf sections base addresses.
1547  DwarfInfoSectionSym =
1548    EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1549  DwarfAbbrevSectionSym =
1550    EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1551  EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1552
1553  if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1554    EmitSectionSym(Asm, MacroInfo);
1555
1556  EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1557  EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1558  EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1559  DwarfStrSectionSym =
1560    EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1561  DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1562                                             "debug_range");
1563
1564  DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1565                                           "section_debug_loc");
1566
1567  TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1568  EmitSectionSym(Asm, TLOF.getDataSection());
1569}
1570
1571/// emitDIE - Recursively emits a debug information entry.
1572///
1573void DwarfDebug::emitDIE(DIE *Die) {
1574  // Get the abbreviation for this DIE.
1575  unsigned AbbrevNumber = Die->getAbbrevNumber();
1576  const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1577
1578  // Emit the code (index) for the abbreviation.
1579  if (Asm->isVerbose())
1580    Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1581                                Twine::utohexstr(Die->getOffset()) + ":0x" +
1582                                Twine::utohexstr(Die->getSize()) + " " +
1583                                dwarf::TagString(Abbrev->getTag()));
1584  Asm->EmitULEB128(AbbrevNumber);
1585
1586  const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1587  const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1588
1589  // Emit the DIE attribute values.
1590  for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1591    unsigned Attr = AbbrevData[i].getAttribute();
1592    unsigned Form = AbbrevData[i].getForm();
1593    assert(Form && "Too many attributes for DIE (check abbreviation)");
1594
1595    if (Asm->isVerbose())
1596      Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1597
1598    switch (Attr) {
1599    case dwarf::DW_AT_abstract_origin: {
1600      DIEEntry *E = cast<DIEEntry>(Values[i]);
1601      DIE *Origin = E->getEntry();
1602      unsigned Addr = Origin->getOffset();
1603      Asm->EmitInt32(Addr);
1604      break;
1605    }
1606    case dwarf::DW_AT_ranges: {
1607      // DW_AT_range Value encodes offset in debug_range section.
1608      DIEInteger *V = cast<DIEInteger>(Values[i]);
1609
1610      if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1611        Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1612                                 V->getValue(),
1613                                 4);
1614      } else {
1615        Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1616                                       V->getValue(),
1617                                       DwarfDebugRangeSectionSym,
1618                                       4);
1619      }
1620      break;
1621    }
1622    case dwarf::DW_AT_location: {
1623      if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1624        Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1625      else
1626        Values[i]->EmitValue(Asm, Form);
1627      break;
1628    }
1629    case dwarf::DW_AT_accessibility: {
1630      if (Asm->isVerbose()) {
1631        DIEInteger *V = cast<DIEInteger>(Values[i]);
1632        Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1633      }
1634      Values[i]->EmitValue(Asm, Form);
1635      break;
1636    }
1637    default:
1638      // Emit an attribute using the defined form.
1639      Values[i]->EmitValue(Asm, Form);
1640      break;
1641    }
1642  }
1643
1644  // Emit the DIE children if any.
1645  if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1646    const std::vector<DIE *> &Children = Die->getChildren();
1647
1648    for (unsigned j = 0, M = Children.size(); j < M; ++j)
1649      emitDIE(Children[j]);
1650
1651    if (Asm->isVerbose())
1652      Asm->OutStreamer.AddComment("End Of Children Mark");
1653    Asm->EmitInt8(0);
1654  }
1655}
1656
1657/// emitDebugInfo - Emit the debug info section.
1658///
1659void DwarfDebug::emitDebugInfo() {
1660  // Start debug info section.
1661  Asm->OutStreamer.SwitchSection(
1662                            Asm->getObjFileLowering().getDwarfInfoSection());
1663  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1664         E = CUMap.end(); I != E; ++I) {
1665    CompileUnit *TheCU = I->second;
1666    DIE *Die = TheCU->getCUDie();
1667
1668    // Emit the compile units header.
1669    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1670                                                  TheCU->getID()));
1671
1672    // Emit size of content not including length itself
1673    unsigned ContentSize = Die->getSize() +
1674      sizeof(int16_t) + // DWARF version number
1675      sizeof(int32_t) + // Offset Into Abbrev. Section
1676      sizeof(int8_t);   // Pointer Size (in bytes)
1677
1678    Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1679    Asm->EmitInt32(ContentSize);
1680    Asm->OutStreamer.AddComment("DWARF version number");
1681    Asm->EmitInt16(dwarf::DWARF_VERSION);
1682    Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1683    Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1684                           DwarfAbbrevSectionSym);
1685    Asm->OutStreamer.AddComment("Address Size (in bytes)");
1686    Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1687
1688    emitDIE(Die);
1689    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1690  }
1691}
1692
1693/// emitAbbreviations - Emit the abbreviation section.
1694///
1695void DwarfDebug::emitAbbreviations() const {
1696  // Check to see if it is worth the effort.
1697  if (!Abbreviations.empty()) {
1698    // Start the debug abbrev section.
1699    Asm->OutStreamer.SwitchSection(
1700                            Asm->getObjFileLowering().getDwarfAbbrevSection());
1701
1702    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1703
1704    // For each abbrevation.
1705    for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1706      // Get abbreviation data
1707      const DIEAbbrev *Abbrev = Abbreviations[i];
1708
1709      // Emit the abbrevations code (base 1 index.)
1710      Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1711
1712      // Emit the abbreviations data.
1713      Abbrev->Emit(Asm);
1714    }
1715
1716    // Mark end of abbreviations.
1717    Asm->EmitULEB128(0, "EOM(3)");
1718
1719    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1720  }
1721}
1722
1723/// emitEndOfLineMatrix - Emit the last address of the section and the end of
1724/// the line matrix.
1725///
1726void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1727  // Define last address of section.
1728  Asm->OutStreamer.AddComment("Extended Op");
1729  Asm->EmitInt8(0);
1730
1731  Asm->OutStreamer.AddComment("Op size");
1732  Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1733  Asm->OutStreamer.AddComment("DW_LNE_set_address");
1734  Asm->EmitInt8(dwarf::DW_LNE_set_address);
1735
1736  Asm->OutStreamer.AddComment("Section end label");
1737
1738  Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1739                                   Asm->getTargetData().getPointerSize(),
1740                                   0/*AddrSpace*/);
1741
1742  // Mark end of matrix.
1743  Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1744  Asm->EmitInt8(0);
1745  Asm->EmitInt8(1);
1746  Asm->EmitInt8(1);
1747}
1748
1749/// emitAccelNames - Emit visible names into a hashed accelerator table
1750/// section.
1751void DwarfDebug::emitAccelNames() {
1752  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1753                                           dwarf::DW_FORM_data4));
1754  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1755         E = CUMap.end(); I != E; ++I) {
1756    CompileUnit *TheCU = I->second;
1757    const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1758    for (StringMap<std::vector<DIE*> >::const_iterator
1759           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1760      const char *Name = GI->getKeyData();
1761      const std::vector<DIE *> &Entities = GI->second;
1762      for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1763             DE = Entities.end(); DI != DE; ++DI)
1764        AT.AddName(Name, (*DI));
1765    }
1766  }
1767
1768  AT.FinalizeTable(Asm, "Names");
1769  Asm->OutStreamer.SwitchSection(
1770    Asm->getObjFileLowering().getDwarfAccelNamesSection());
1771  MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1772  Asm->OutStreamer.EmitLabel(SectionBegin);
1773
1774  // Emit the full data.
1775  AT.Emit(Asm, SectionBegin, this);
1776}
1777
1778/// emitAccelObjC - Emit objective C classes and categories into a hashed
1779/// accelerator table section.
1780void DwarfDebug::emitAccelObjC() {
1781  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1782                                           dwarf::DW_FORM_data4));
1783  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1784         E = CUMap.end(); I != E; ++I) {
1785    CompileUnit *TheCU = I->second;
1786    const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1787    for (StringMap<std::vector<DIE*> >::const_iterator
1788           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1789      const char *Name = GI->getKeyData();
1790      const std::vector<DIE *> &Entities = GI->second;
1791      for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1792             DE = Entities.end(); DI != DE; ++DI)
1793        AT.AddName(Name, (*DI));
1794    }
1795  }
1796
1797  AT.FinalizeTable(Asm, "ObjC");
1798  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1799                                 .getDwarfAccelObjCSection());
1800  MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1801  Asm->OutStreamer.EmitLabel(SectionBegin);
1802
1803  // Emit the full data.
1804  AT.Emit(Asm, SectionBegin, this);
1805}
1806
1807/// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1808/// table.
1809void DwarfDebug::emitAccelNamespaces() {
1810  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1811                                           dwarf::DW_FORM_data4));
1812  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1813         E = CUMap.end(); I != E; ++I) {
1814    CompileUnit *TheCU = I->second;
1815    const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1816    for (StringMap<std::vector<DIE*> >::const_iterator
1817           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1818      const char *Name = GI->getKeyData();
1819      const std::vector<DIE *> &Entities = GI->second;
1820      for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1821             DE = Entities.end(); DI != DE; ++DI)
1822        AT.AddName(Name, (*DI));
1823    }
1824  }
1825
1826  AT.FinalizeTable(Asm, "namespac");
1827  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1828                                 .getDwarfAccelNamespaceSection());
1829  MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1830  Asm->OutStreamer.EmitLabel(SectionBegin);
1831
1832  // Emit the full data.
1833  AT.Emit(Asm, SectionBegin, this);
1834}
1835
1836/// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1837void DwarfDebug::emitAccelTypes() {
1838  std::vector<DwarfAccelTable::Atom> Atoms;
1839  Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1840                                        dwarf::DW_FORM_data4));
1841  Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1842                                        dwarf::DW_FORM_data2));
1843  Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1844                                        dwarf::DW_FORM_data1));
1845  DwarfAccelTable AT(Atoms);
1846  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1847         E = CUMap.end(); I != E; ++I) {
1848    CompileUnit *TheCU = I->second;
1849    const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1850      = TheCU->getAccelTypes();
1851    for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1852           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1853      const char *Name = GI->getKeyData();
1854      const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1855      for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1856             = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1857        AT.AddName(Name, (*DI).first, (*DI).second);
1858    }
1859  }
1860
1861  AT.FinalizeTable(Asm, "types");
1862  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1863                                 .getDwarfAccelTypesSection());
1864  MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1865  Asm->OutStreamer.EmitLabel(SectionBegin);
1866
1867  // Emit the full data.
1868  AT.Emit(Asm, SectionBegin, this);
1869}
1870
1871void DwarfDebug::emitDebugPubTypes() {
1872  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1873         E = CUMap.end(); I != E; ++I) {
1874    CompileUnit *TheCU = I->second;
1875    // Start the dwarf pubtypes section.
1876    Asm->OutStreamer.SwitchSection(
1877      Asm->getObjFileLowering().getDwarfPubTypesSection());
1878    Asm->OutStreamer.AddComment("Length of Public Types Info");
1879    Asm->EmitLabelDifference(
1880      Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1881      Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1882
1883    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1884                                                  TheCU->getID()));
1885
1886    if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1887    Asm->EmitInt16(dwarf::DWARF_VERSION);
1888
1889    Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1890    Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1891                           DwarfInfoSectionSym);
1892
1893    Asm->OutStreamer.AddComment("Compilation Unit Length");
1894    Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1895                             Asm->GetTempSymbol("info_begin", TheCU->getID()),
1896                             4);
1897
1898    const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1899    for (StringMap<DIE*>::const_iterator
1900           GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1901      const char *Name = GI->getKeyData();
1902      DIE *Entity = GI->second;
1903
1904      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1905      Asm->EmitInt32(Entity->getOffset());
1906
1907      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1908      // Emit the name with a terminating null byte.
1909      Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1910    }
1911
1912    Asm->OutStreamer.AddComment("End Mark");
1913    Asm->EmitInt32(0);
1914    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1915                                                  TheCU->getID()));
1916  }
1917}
1918
1919/// emitDebugStr - Emit visible names into a debug str section.
1920///
1921void DwarfDebug::emitDebugStr() {
1922  // Check to see if it is worth the effort.
1923  if (StringPool.empty()) return;
1924
1925  // Start the dwarf str section.
1926  Asm->OutStreamer.SwitchSection(
1927                                Asm->getObjFileLowering().getDwarfStrSection());
1928
1929  // Get all of the string pool entries and put them in an array by their ID so
1930  // we can sort them.
1931  SmallVector<std::pair<unsigned,
1932      StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1933
1934  for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1935       I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1936    Entries.push_back(std::make_pair(I->second.second, &*I));
1937
1938  array_pod_sort(Entries.begin(), Entries.end());
1939
1940  for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1941    // Emit a label for reference from debug information entries.
1942    Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1943
1944    // Emit the string itself with a terminating null byte.
1945    Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1946                                         Entries[i].second->getKeyLength()+1),
1947                               0/*addrspace*/);
1948  }
1949}
1950
1951/// emitDebugLoc - Emit visible names into a debug loc section.
1952///
1953void DwarfDebug::emitDebugLoc() {
1954  if (DotDebugLocEntries.empty())
1955    return;
1956
1957  for (SmallVector<DotDebugLocEntry, 4>::iterator
1958         I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1959       I != E; ++I) {
1960    DotDebugLocEntry &Entry = *I;
1961    if (I + 1 != DotDebugLocEntries.end())
1962      Entry.Merge(I+1);
1963  }
1964
1965  // Start the dwarf loc section.
1966  Asm->OutStreamer.SwitchSection(
1967    Asm->getObjFileLowering().getDwarfLocSection());
1968  unsigned char Size = Asm->getTargetData().getPointerSize();
1969  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1970  unsigned index = 1;
1971  for (SmallVector<DotDebugLocEntry, 4>::iterator
1972         I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1973       I != E; ++I, ++index) {
1974    DotDebugLocEntry &Entry = *I;
1975    if (Entry.isMerged()) continue;
1976    if (Entry.isEmpty()) {
1977      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1978      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1979      Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1980    } else {
1981      Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1982      Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1983      DIVariable DV(Entry.Variable);
1984      Asm->OutStreamer.AddComment("Loc expr size");
1985      MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1986      MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1987      Asm->EmitLabelDifference(end, begin, 2);
1988      Asm->OutStreamer.EmitLabel(begin);
1989      if (Entry.isInt()) {
1990        DIBasicType BTy(DV.getType());
1991        if (BTy.Verify() &&
1992            (BTy.getEncoding()  == dwarf::DW_ATE_signed
1993             || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1994          Asm->OutStreamer.AddComment("DW_OP_consts");
1995          Asm->EmitInt8(dwarf::DW_OP_consts);
1996          Asm->EmitSLEB128(Entry.getInt());
1997        } else {
1998          Asm->OutStreamer.AddComment("DW_OP_constu");
1999          Asm->EmitInt8(dwarf::DW_OP_constu);
2000          Asm->EmitULEB128(Entry.getInt());
2001        }
2002      } else if (Entry.isLocation()) {
2003        if (!DV.hasComplexAddress())
2004          // Regular entry.
2005          Asm->EmitDwarfRegOp(Entry.Loc);
2006        else {
2007          // Complex address entry.
2008          unsigned N = DV.getNumAddrElements();
2009          unsigned i = 0;
2010          if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2011            if (Entry.Loc.getOffset()) {
2012              i = 2;
2013              Asm->EmitDwarfRegOp(Entry.Loc);
2014              Asm->OutStreamer.AddComment("DW_OP_deref");
2015              Asm->EmitInt8(dwarf::DW_OP_deref);
2016              Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2017              Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2018              Asm->EmitSLEB128(DV.getAddrElement(1));
2019            } else {
2020              // If first address element is OpPlus then emit
2021              // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2022              MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2023              Asm->EmitDwarfRegOp(Loc);
2024              i = 2;
2025            }
2026          } else {
2027            Asm->EmitDwarfRegOp(Entry.Loc);
2028          }
2029
2030          // Emit remaining complex address elements.
2031          for (; i < N; ++i) {
2032            uint64_t Element = DV.getAddrElement(i);
2033            if (Element == DIBuilder::OpPlus) {
2034              Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2035              Asm->EmitULEB128(DV.getAddrElement(++i));
2036            } else if (Element == DIBuilder::OpDeref)
2037              Asm->EmitInt8(dwarf::DW_OP_deref);
2038            else llvm_unreachable("unknown Opcode found in complex address");
2039          }
2040        }
2041      }
2042      // else ... ignore constant fp. There is not any good way to
2043      // to represent them here in dwarf.
2044      Asm->OutStreamer.EmitLabel(end);
2045    }
2046  }
2047}
2048
2049/// EmitDebugARanges - Emit visible names into a debug aranges section.
2050///
2051void DwarfDebug::EmitDebugARanges() {
2052  // Start the dwarf aranges section.
2053  Asm->OutStreamer.SwitchSection(
2054                          Asm->getObjFileLowering().getDwarfARangesSection());
2055}
2056
2057/// emitDebugRanges - Emit visible names into a debug ranges section.
2058///
2059void DwarfDebug::emitDebugRanges() {
2060  // Start the dwarf ranges section.
2061  Asm->OutStreamer.SwitchSection(
2062    Asm->getObjFileLowering().getDwarfRangesSection());
2063  unsigned char Size = Asm->getTargetData().getPointerSize();
2064  for (SmallVector<const MCSymbol *, 8>::iterator
2065         I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2066       I != E; ++I) {
2067    if (*I)
2068      Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2069    else
2070      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2071  }
2072}
2073
2074/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2075///
2076void DwarfDebug::emitDebugMacInfo() {
2077  if (const MCSection *LineInfo =
2078      Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2079    // Start the dwarf macinfo section.
2080    Asm->OutStreamer.SwitchSection(LineInfo);
2081  }
2082}
2083
2084/// emitDebugInlineInfo - Emit inline info using following format.
2085/// Section Header:
2086/// 1. length of section
2087/// 2. Dwarf version number
2088/// 3. address size.
2089///
2090/// Entries (one "entry" for each function that was inlined):
2091///
2092/// 1. offset into __debug_str section for MIPS linkage name, if exists;
2093///   otherwise offset into __debug_str for regular function name.
2094/// 2. offset into __debug_str section for regular function name.
2095/// 3. an unsigned LEB128 number indicating the number of distinct inlining
2096/// instances for the function.
2097///
2098/// The rest of the entry consists of a {die_offset, low_pc} pair for each
2099/// inlined instance; the die_offset points to the inlined_subroutine die in the
2100/// __debug_info section, and the low_pc is the starting address for the
2101/// inlining instance.
2102void DwarfDebug::emitDebugInlineInfo() {
2103  if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2104    return;
2105
2106  if (!FirstCU)
2107    return;
2108
2109  Asm->OutStreamer.SwitchSection(
2110                        Asm->getObjFileLowering().getDwarfDebugInlineSection());
2111
2112  Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2113  Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2114                           Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2115
2116  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2117
2118  Asm->OutStreamer.AddComment("Dwarf Version");
2119  Asm->EmitInt16(dwarf::DWARF_VERSION);
2120  Asm->OutStreamer.AddComment("Address Size (in bytes)");
2121  Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2122
2123  for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2124         E = InlinedSPNodes.end(); I != E; ++I) {
2125
2126    const MDNode *Node = *I;
2127    DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2128      = InlineInfo.find(Node);
2129    SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2130    DISubprogram SP(Node);
2131    StringRef LName = SP.getLinkageName();
2132    StringRef Name = SP.getName();
2133
2134    Asm->OutStreamer.AddComment("MIPS linkage name");
2135    if (LName.empty()) {
2136      Asm->OutStreamer.EmitBytes(Name, 0);
2137      Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2138    } else
2139      Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2140                             DwarfStrSectionSym);
2141
2142    Asm->OutStreamer.AddComment("Function name");
2143    Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2144    Asm->EmitULEB128(Labels.size(), "Inline count");
2145
2146    for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2147           LE = Labels.end(); LI != LE; ++LI) {
2148      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2149      Asm->EmitInt32(LI->second->getOffset());
2150
2151      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2152      Asm->OutStreamer.EmitSymbolValue(LI->first,
2153                                       Asm->getTargetData().getPointerSize(),0);
2154    }
2155  }
2156
2157  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2158}
2159