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