DwarfDebug.cpp revision 80f3344904fb0678f06a2e69067421990d2e39df 
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.startswith("+") || Name.startswith("-");
529}
530
531static bool hasObjCCategory(StringRef Name) {
532  if (!isObjCClass(Name)) return false;
533
534  size_t pos = Name.find(')');
535  if (pos != std::string::npos) {
536    if (Name[pos+1] != ' ') return false;
537    return true;
538  }
539  return false;
540}
541
542static void getObjCClassCategory(StringRef In, StringRef &Class,
543                                 StringRef &Category) {
544  if (!hasObjCCategory(In)) {
545    Class = In.slice(In.find('[') + 1, In.find(' '));
546    Category = "";
547    return;
548  }
549
550  Class = In.slice(In.find('[') + 1, In.find('('));
551  Category = In.slice(In.find('[') + 1, In.find(' '));
552  return;
553}
554
555/// construct SubprogramDIE - Construct subprogram DIE.
556void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
557                                        const MDNode *N) {
558  CompileUnit *&CURef = SPMap[N];
559  if (CURef)
560    return;
561  CURef = TheCU;
562
563  DISubprogram SP(N);
564  if (!SP.isDefinition())
565    // This is a method declaration which will be handled while constructing
566    // class type.
567    return;
568
569  DISubprogram SPDecl = SP.getFunctionDeclaration();
570  DIE *DeclDie = NULL;
571  if (SPDecl.isSubprogram()) {
572    DeclDie = TheCU->getOrCreateSubprogramDIE(SPDecl);
573  }
574
575  DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
576
577  if (DeclDie) {
578    // Refer function declaration directly.
579    TheCU->addDIEEntry(SubprogramDie, dwarf::DW_AT_specification,
580                       dwarf::DW_FORM_ref4, DeclDie);
581  }
582
583  // Add to map.
584  TheCU->insertDIE(N, SubprogramDie);
585
586  // Add to context owner.
587  TheCU->addToContextOwner(SubprogramDie, SP.getContext());
588
589  // Expose as global.
590  TheCU->addGlobal(SP.getName(), SubprogramDie);
591
592  // Add to Accel Names
593  TheCU->addAccelName(SP.getName(), SubprogramDie);
594
595  // If this is an Objective-C selector name add it to the ObjC accelerator too.
596  if (isObjCClass(SP.getName())) {
597    StringRef Class, Category;
598    getObjCClassCategory(SP.getName(), Class, Category);
599    TheCU->addAccelObjC(Class, SubprogramDie);
600    if (Category != "")
601      TheCU->addAccelObjC(Category, SubprogramDie);
602  }
603
604  return;
605}
606
607/// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
608/// as llvm.dbg.enum and llvm.dbg.ty
609void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
610  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
611    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
612      const MDNode *N = NMD->getOperand(i);
613      if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
614        constructSubprogramDIE(CU, N);
615    }
616
617  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
618    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
619      const MDNode *N = NMD->getOperand(i);
620      if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
621        CU->createGlobalVariableDIE(N);
622    }
623
624  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
625    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
626      DIType Ty(NMD->getOperand(i));
627      if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
628        CU->getOrCreateTypeDIE(Ty);
629    }
630
631  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
632    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
633      DIType Ty(NMD->getOperand(i));
634      if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
635        CU->getOrCreateTypeDIE(Ty);
636    }
637}
638
639/// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
640/// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
641bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
642  DebugInfoFinder DbgFinder;
643  DbgFinder.processModule(*M);
644
645  bool HasDebugInfo = false;
646  // Scan all the compile-units to see if there are any marked as the main
647  // unit. If not, we do not generate debug info.
648  for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
649         E = DbgFinder.compile_unit_end(); I != E; ++I) {
650    if (DICompileUnit(*I).isMain()) {
651      HasDebugInfo = true;
652      break;
653    }
654  }
655  if (!HasDebugInfo) return false;
656
657  // Create all the compile unit DIEs.
658  for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
659         E = DbgFinder.compile_unit_end(); I != E; ++I)
660    constructCompileUnit(*I);
661
662  // Create DIEs for each global variable.
663  for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
664         E = DbgFinder.global_variable_end(); I != E; ++I) {
665    const MDNode *N = *I;
666    if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
667      CU->createGlobalVariableDIE(N);
668  }
669
670  // Create DIEs for each subprogram.
671  for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
672         E = DbgFinder.subprogram_end(); I != E; ++I) {
673    const MDNode *N = *I;
674    if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
675      constructSubprogramDIE(CU, N);
676  }
677
678  return HasDebugInfo;
679}
680
681/// beginModule - Emit all Dwarf sections that should come prior to the
682/// content. Create global DIEs and emit initial debug info sections.
683/// This is invoked by the target AsmPrinter.
684void DwarfDebug::beginModule(Module *M) {
685  if (DisableDebugInfoPrinting)
686    return;
687
688  // If module has named metadata anchors then use them, otherwise scan the
689  // module using debug info finder to collect debug info.
690  NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
691  if (CU_Nodes) {
692    for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
693      DICompileUnit CUNode(CU_Nodes->getOperand(i));
694      CompileUnit *CU = constructCompileUnit(CUNode);
695      DIArray GVs = CUNode.getGlobalVariables();
696      for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
697        CU->createGlobalVariableDIE(GVs.getElement(i));
698      DIArray SPs = CUNode.getSubprograms();
699      for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
700        constructSubprogramDIE(CU, SPs.getElement(i));
701      DIArray EnumTypes = CUNode.getEnumTypes();
702      for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
703        CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
704      DIArray RetainedTypes = CUNode.getRetainedTypes();
705      for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
706        CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
707    }
708  } else if (!collectLegacyDebugInfo(M))
709    return;
710
711  collectInfoFromNamedMDNodes(M);
712
713  // Tell MMI that we have debug info.
714  MMI->setDebugInfoAvailability(true);
715
716  // Emit initial sections.
717  EmitSectionLabels();
718
719  // Prime section data.
720  SectionMap.insert(Asm->getObjFileLowering().getTextSection());
721}
722
723/// endModule - Emit all Dwarf sections that should come after the content.
724///
725void DwarfDebug::endModule() {
726  if (!FirstCU) return;
727  const Module *M = MMI->getModule();
728  DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
729
730  // Collect info for variables that were optimized out.
731  if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
732    for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
733      DICompileUnit TheCU(CU_Nodes->getOperand(i));
734      DIArray Subprograms = TheCU.getSubprograms();
735      for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
736        DISubprogram SP(Subprograms.getElement(i));
737        if (ProcessedSPNodes.count(SP) != 0) continue;
738        if (!SP.Verify()) continue;
739        if (!SP.isDefinition()) continue;
740        DIArray Variables = SP.getVariables();
741        if (Variables.getNumElements() == 0) continue;
742
743        LexicalScope *Scope =
744          new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
745        DeadFnScopeMap[SP] = Scope;
746
747        // Construct subprogram DIE and add variables DIEs.
748        CompileUnit *SPCU = CUMap.lookup(TheCU);
749        assert(SPCU && "Unable to find Compile Unit!");
750        constructSubprogramDIE(SPCU, SP);
751        DIE *ScopeDIE = SPCU->getDIE(SP);
752        for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
753          DIVariable DV(Variables.getElement(vi));
754          if (!DV.Verify()) continue;
755          DbgVariable *NewVar = new DbgVariable(DV, NULL);
756          if (DIE *VariableDIE =
757              SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
758            ScopeDIE->addChild(VariableDIE);
759        }
760      }
761    }
762  }
763
764  // Attach DW_AT_inline attribute with inlined subprogram DIEs.
765  for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
766         AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
767    DIE *ISP = *AI;
768    FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
769  }
770
771  // Emit DW_AT_containing_type attribute to connect types with their
772  // vtable holding type.
773  for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
774         CUE = CUMap.end(); CUI != CUE; ++CUI) {
775    CompileUnit *TheCU = CUI->second;
776    TheCU->constructContainingTypeDIEs();
777  }
778
779  // Standard sections final addresses.
780  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
781  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
782  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
783  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
784
785  // End text sections.
786  for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
787    Asm->OutStreamer.SwitchSection(SectionMap[i]);
788    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
789  }
790
791  // Compute DIE offsets and sizes.
792  computeSizeAndOffsets();
793
794  // Emit all the DIEs into a debug info section
795  emitDebugInfo();
796
797  // Corresponding abbreviations into a abbrev section.
798  emitAbbreviations();
799
800  // Emit info into a dwarf accelerator table sections.
801  if (DwarfAccelTables) {
802    emitAccelNames();
803    emitAccelObjC();
804    emitAccelNamespaces();
805    emitAccelTypes();
806  }
807
808  // Emit info into a debug pubnames section.
809  emitDebugPubNames();
810
811  // Emit info into a debug pubtypes section.
812  emitDebugPubTypes();
813
814  // Emit info into a debug loc section.
815  emitDebugLoc();
816
817  // Emit info into a debug aranges section.
818  EmitDebugARanges();
819
820  // Emit info into a debug ranges section.
821  emitDebugRanges();
822
823  // Emit info into a debug macinfo section.
824  emitDebugMacInfo();
825
826  // Emit inline info.
827  emitDebugInlineInfo();
828
829  // Emit info into a debug str section.
830  emitDebugStr();
831
832  // clean up.
833  DeleteContainerSeconds(DeadFnScopeMap);
834  SPMap.clear();
835  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
836         E = CUMap.end(); I != E; ++I)
837    delete I->second;
838  FirstCU = NULL;  // Reset for the next Module, if any.
839}
840
841/// findAbstractVariable - Find abstract variable, if any, associated with Var.
842DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
843                                              DebugLoc ScopeLoc) {
844  LLVMContext &Ctx = DV->getContext();
845  // More then one inlined variable corresponds to one abstract variable.
846  DIVariable Var = cleanseInlinedVariable(DV, Ctx);
847  DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
848  if (AbsDbgVariable)
849    return AbsDbgVariable;
850
851  LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
852  if (!Scope)
853    return NULL;
854
855  AbsDbgVariable = new DbgVariable(Var, NULL);
856  addScopeVariable(Scope, AbsDbgVariable);
857  AbstractVariables[Var] = AbsDbgVariable;
858  return AbsDbgVariable;
859}
860
861/// addCurrentFnArgument - If Var is a current function argument then add
862/// it to CurrentFnArguments list.
863bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
864                                      DbgVariable *Var, LexicalScope *Scope) {
865  if (!LScopes.isCurrentFunctionScope(Scope))
866    return false;
867  DIVariable DV = Var->getVariable();
868  if (DV.getTag() != dwarf::DW_TAG_arg_variable)
869    return false;
870  unsigned ArgNo = DV.getArgNumber();
871  if (ArgNo == 0)
872    return false;
873
874  size_t Size = CurrentFnArguments.size();
875  if (Size == 0)
876    CurrentFnArguments.resize(MF->getFunction()->arg_size());
877  // llvm::Function argument size is not good indicator of how many
878  // arguments does the function have at source level.
879  if (ArgNo > Size)
880    CurrentFnArguments.resize(ArgNo * 2);
881  CurrentFnArguments[ArgNo - 1] = Var;
882  return true;
883}
884
885/// collectVariableInfoFromMMITable - Collect variable information from
886/// side table maintained by MMI.
887void
888DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
889                                   SmallPtrSet<const MDNode *, 16> &Processed) {
890  MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
891  for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
892         VE = VMap.end(); VI != VE; ++VI) {
893    const MDNode *Var = VI->first;
894    if (!Var) continue;
895    Processed.insert(Var);
896    DIVariable DV(Var);
897    const std::pair<unsigned, DebugLoc> &VP = VI->second;
898
899    LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
900
901    // If variable scope is not found then skip this variable.
902    if (Scope == 0)
903      continue;
904
905    DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
906    DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
907    RegVar->setFrameIndex(VP.first);
908    if (!addCurrentFnArgument(MF, RegVar, Scope))
909      addScopeVariable(Scope, RegVar);
910    if (AbsDbgVariable)
911      AbsDbgVariable->setFrameIndex(VP.first);
912  }
913}
914
915/// isDbgValueInDefinedReg - Return true if debug value, encoded by
916/// DBG_VALUE instruction, is in a defined reg.
917static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
918  assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
919  return MI->getNumOperands() == 3 &&
920         MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
921         MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
922}
923
924/// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
925/// at MI.
926static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
927                                         const MCSymbol *FLabel,
928                                         const MCSymbol *SLabel,
929                                         const MachineInstr *MI) {
930  const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
931
932  if (MI->getNumOperands() != 3) {
933    MachineLocation MLoc = Asm->getDebugValueLocation(MI);
934    return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
935  }
936  if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
937    MachineLocation MLoc;
938    MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
939    return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
940  }
941  if (MI->getOperand(0).isImm())
942    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
943  if (MI->getOperand(0).isFPImm())
944    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
945  if (MI->getOperand(0).isCImm())
946    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
947
948  assert(0 && "Unexpected 3 operand DBG_VALUE instruction!");
949  return DotDebugLocEntry();
950}
951
952/// collectVariableInfo - Find variables for each lexical scope.
953void
954DwarfDebug::collectVariableInfo(const MachineFunction *MF,
955                                SmallPtrSet<const MDNode *, 16> &Processed) {
956
957  /// collection info from MMI table.
958  collectVariableInfoFromMMITable(MF, Processed);
959
960  for (SmallVectorImpl<const MDNode*>::const_iterator
961         UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
962         ++UVI) {
963    const MDNode *Var = *UVI;
964    if (Processed.count(Var))
965      continue;
966
967    // History contains relevant DBG_VALUE instructions for Var and instructions
968    // clobbering it.
969    SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
970    if (History.empty())
971      continue;
972    const MachineInstr *MInsn = History.front();
973
974    DIVariable DV(Var);
975    LexicalScope *Scope = NULL;
976    if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
977        DISubprogram(DV.getContext()).describes(MF->getFunction()))
978      Scope = LScopes.getCurrentFunctionScope();
979    else {
980      if (DV.getVersion() <= LLVMDebugVersion9)
981        Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
982      else {
983        if (MDNode *IA = DV.getInlinedAt())
984          Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
985        else
986          Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
987      }
988    }
989    // If variable scope is not found then skip this variable.
990    if (!Scope)
991      continue;
992
993    Processed.insert(DV);
994    assert(MInsn->isDebugValue() && "History must begin with debug value");
995    DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
996    DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
997    if (!addCurrentFnArgument(MF, RegVar, Scope))
998      addScopeVariable(Scope, RegVar);
999    if (AbsVar)
1000      AbsVar->setMInsn(MInsn);
1001
1002    // Simple ranges that are fully coalesced.
1003    if (History.size() <= 1 || (History.size() == 2 &&
1004                                MInsn->isIdenticalTo(History.back()))) {
1005      RegVar->setMInsn(MInsn);
1006      continue;
1007    }
1008
1009    // handle multiple DBG_VALUE instructions describing one variable.
1010    RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1011
1012    for (SmallVectorImpl<const MachineInstr*>::const_iterator
1013           HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1014      const MachineInstr *Begin = *HI;
1015      assert(Begin->isDebugValue() && "Invalid History entry");
1016
1017      // Check if DBG_VALUE is truncating a range.
1018      if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1019          && !Begin->getOperand(0).getReg())
1020        continue;
1021
1022      // Compute the range for a register location.
1023      const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1024      const MCSymbol *SLabel = 0;
1025
1026      if (HI + 1 == HE)
1027        // If Begin is the last instruction in History then its value is valid
1028        // until the end of the function.
1029        SLabel = FunctionEndSym;
1030      else {
1031        const MachineInstr *End = HI[1];
1032        DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1033              << "\t" << *Begin << "\t" << *End << "\n");
1034        if (End->isDebugValue())
1035          SLabel = getLabelBeforeInsn(End);
1036        else {
1037          // End is a normal instruction clobbering the range.
1038          SLabel = getLabelAfterInsn(End);
1039          assert(SLabel && "Forgot label after clobber instruction");
1040          ++HI;
1041        }
1042      }
1043
1044      // The value is valid until the next DBG_VALUE or clobber.
1045      DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1046    }
1047    DotDebugLocEntries.push_back(DotDebugLocEntry());
1048  }
1049
1050  // Collect info for variables that were optimized out.
1051  LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1052  DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1053  for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1054    DIVariable DV(Variables.getElement(i));
1055    if (!DV || !DV.Verify() || !Processed.insert(DV))
1056      continue;
1057    if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1058      addScopeVariable(Scope, new DbgVariable(DV, NULL));
1059  }
1060}
1061
1062/// getLabelBeforeInsn - Return Label preceding the instruction.
1063const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1064  MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1065  assert(Label && "Didn't insert label before instruction");
1066  return Label;
1067}
1068
1069/// getLabelAfterInsn - Return Label immediately following the instruction.
1070const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1071  return LabelsAfterInsn.lookup(MI);
1072}
1073
1074/// beginInstruction - Process beginning of an instruction.
1075void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1076  // Check if source location changes, but ignore DBG_VALUE locations.
1077  if (!MI->isDebugValue()) {
1078    DebugLoc DL = MI->getDebugLoc();
1079    if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1080      unsigned Flags = DWARF2_FLAG_IS_STMT;
1081      PrevInstLoc = DL;
1082      if (DL == PrologEndLoc) {
1083        Flags |= DWARF2_FLAG_PROLOGUE_END;
1084        PrologEndLoc = DebugLoc();
1085      }
1086      if (!DL.isUnknown()) {
1087        const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1088        recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1089      } else
1090        recordSourceLine(0, 0, 0, 0);
1091    }
1092  }
1093
1094  // Insert labels where requested.
1095  DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1096    LabelsBeforeInsn.find(MI);
1097
1098  // No label needed.
1099  if (I == LabelsBeforeInsn.end())
1100    return;
1101
1102  // Label already assigned.
1103  if (I->second)
1104    return;
1105
1106  if (!PrevLabel) {
1107    PrevLabel = MMI->getContext().CreateTempSymbol();
1108    Asm->OutStreamer.EmitLabel(PrevLabel);
1109  }
1110  I->second = PrevLabel;
1111}
1112
1113/// endInstruction - Process end of an instruction.
1114void DwarfDebug::endInstruction(const MachineInstr *MI) {
1115  // Don't create a new label after DBG_VALUE instructions.
1116  // They don't generate code.
1117  if (!MI->isDebugValue())
1118    PrevLabel = 0;
1119
1120  DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1121    LabelsAfterInsn.find(MI);
1122
1123  // No label needed.
1124  if (I == LabelsAfterInsn.end())
1125    return;
1126
1127  // Label already assigned.
1128  if (I->second)
1129    return;
1130
1131  // We need a label after this instruction.
1132  if (!PrevLabel) {
1133    PrevLabel = MMI->getContext().CreateTempSymbol();
1134    Asm->OutStreamer.EmitLabel(PrevLabel);
1135  }
1136  I->second = PrevLabel;
1137}
1138
1139/// identifyScopeMarkers() -
1140/// Each LexicalScope has first instruction and last instruction to mark
1141/// beginning and end of a scope respectively. Create an inverse map that list
1142/// scopes starts (and ends) with an instruction. One instruction may start (or
1143/// end) multiple scopes. Ignore scopes that are not reachable.
1144void DwarfDebug::identifyScopeMarkers() {
1145  SmallVector<LexicalScope *, 4> WorkList;
1146  WorkList.push_back(LScopes.getCurrentFunctionScope());
1147  while (!WorkList.empty()) {
1148    LexicalScope *S = WorkList.pop_back_val();
1149
1150    const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1151    if (!Children.empty())
1152      for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1153             SE = Children.end(); SI != SE; ++SI)
1154        WorkList.push_back(*SI);
1155
1156    if (S->isAbstractScope())
1157      continue;
1158
1159    const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1160    if (Ranges.empty())
1161      continue;
1162    for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1163           RE = Ranges.end(); RI != RE; ++RI) {
1164      assert(RI->first && "InsnRange does not have first instruction!");
1165      assert(RI->second && "InsnRange does not have second instruction!");
1166      requestLabelBeforeInsn(RI->first);
1167      requestLabelAfterInsn(RI->second);
1168    }
1169  }
1170}
1171
1172/// getScopeNode - Get MDNode for DebugLoc's scope.
1173static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1174  if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1175    return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1176  return DL.getScope(Ctx);
1177}
1178
1179/// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1180/// line number  info for the function.
1181static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1182  const MDNode *Scope = getScopeNode(DL, Ctx);
1183  DISubprogram SP = getDISubprogram(Scope);
1184  if (SP.Verify())
1185    return DebugLoc::get(SP.getLineNumber(), 0, SP);
1186  return DebugLoc();
1187}
1188
1189/// beginFunction - Gather pre-function debug information.  Assumes being
1190/// emitted immediately after the function entry point.
1191void DwarfDebug::beginFunction(const MachineFunction *MF) {
1192  if (!MMI->hasDebugInfo()) return;
1193  LScopes.initialize(*MF);
1194  if (LScopes.empty()) return;
1195  identifyScopeMarkers();
1196
1197  FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1198                                        Asm->getFunctionNumber());
1199  // Assumes in correct section after the entry point.
1200  Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1201
1202  assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1203
1204  const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1205  /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1206  std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1207
1208  for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1209       I != E; ++I) {
1210    bool AtBlockEntry = true;
1211    for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1212         II != IE; ++II) {
1213      const MachineInstr *MI = II;
1214
1215      if (MI->isDebugValue()) {
1216        assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1217
1218        // Keep track of user variables.
1219        const MDNode *Var =
1220          MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1221
1222        // Variable is in a register, we need to check for clobbers.
1223        if (isDbgValueInDefinedReg(MI))
1224          LiveUserVar[MI->getOperand(0).getReg()] = Var;
1225
1226        // Check the history of this variable.
1227        SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1228        if (History.empty()) {
1229          UserVariables.push_back(Var);
1230          // The first mention of a function argument gets the FunctionBeginSym
1231          // label, so arguments are visible when breaking at function entry.
1232          DIVariable DV(Var);
1233          if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1234              DISubprogram(getDISubprogram(DV.getContext()))
1235                .describes(MF->getFunction()))
1236            LabelsBeforeInsn[MI] = FunctionBeginSym;
1237        } else {
1238          // We have seen this variable before. Try to coalesce DBG_VALUEs.
1239          const MachineInstr *Prev = History.back();
1240          if (Prev->isDebugValue()) {
1241            // Coalesce identical entries at the end of History.
1242            if (History.size() >= 2 &&
1243                Prev->isIdenticalTo(History[History.size() - 2])) {
1244              DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1245                    << "\t" << *Prev
1246                    << "\t" << *History[History.size() - 2] << "\n");
1247              History.pop_back();
1248            }
1249
1250            // Terminate old register assignments that don't reach MI;
1251            MachineFunction::const_iterator PrevMBB = Prev->getParent();
1252            if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1253                isDbgValueInDefinedReg(Prev)) {
1254              // Previous register assignment needs to terminate at the end of
1255              // its basic block.
1256              MachineBasicBlock::const_iterator LastMI =
1257                PrevMBB->getLastNonDebugInstr();
1258              if (LastMI == PrevMBB->end()) {
1259                // Drop DBG_VALUE for empty range.
1260                DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1261                      << "\t" << *Prev << "\n");
1262                History.pop_back();
1263              }
1264              else {
1265                // Terminate after LastMI.
1266                History.push_back(LastMI);
1267              }
1268            }
1269          }
1270        }
1271        History.push_back(MI);
1272      } else {
1273        // Not a DBG_VALUE instruction.
1274        if (!MI->isLabel())
1275          AtBlockEntry = false;
1276
1277        // First known non DBG_VALUE location marks beginning of function
1278        // body.
1279        if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1280          PrologEndLoc = MI->getDebugLoc();
1281
1282        // Check if the instruction clobbers any registers with debug vars.
1283        for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1284               MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1285          if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1286            continue;
1287          for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1288               unsigned Reg = *AI; ++AI) {
1289            const MDNode *Var = LiveUserVar[Reg];
1290            if (!Var)
1291              continue;
1292            // Reg is now clobbered.
1293            LiveUserVar[Reg] = 0;
1294
1295            // Was MD last defined by a DBG_VALUE referring to Reg?
1296            DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1297            if (HistI == DbgValues.end())
1298              continue;
1299            SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1300            if (History.empty())
1301              continue;
1302            const MachineInstr *Prev = History.back();
1303            // Sanity-check: Register assignments are terminated at the end of
1304            // their block.
1305            if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1306              continue;
1307            // Is the variable still in Reg?
1308            if (!isDbgValueInDefinedReg(Prev) ||
1309                Prev->getOperand(0).getReg() != Reg)
1310              continue;
1311            // Var is clobbered. Make sure the next instruction gets a label.
1312            History.push_back(MI);
1313          }
1314        }
1315      }
1316    }
1317  }
1318
1319  for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1320       I != E; ++I) {
1321    SmallVectorImpl<const MachineInstr*> &History = I->second;
1322    if (History.empty())
1323      continue;
1324
1325    // Make sure the final register assignments are terminated.
1326    const MachineInstr *Prev = History.back();
1327    if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1328      const MachineBasicBlock *PrevMBB = Prev->getParent();
1329      MachineBasicBlock::const_iterator LastMI =
1330        PrevMBB->getLastNonDebugInstr();
1331      if (LastMI == PrevMBB->end())
1332        // Drop DBG_VALUE for empty range.
1333        History.pop_back();
1334      else {
1335        // Terminate after LastMI.
1336        History.push_back(LastMI);
1337      }
1338    }
1339    // Request labels for the full history.
1340    for (unsigned i = 0, e = History.size(); i != e; ++i) {
1341      const MachineInstr *MI = History[i];
1342      if (MI->isDebugValue())
1343        requestLabelBeforeInsn(MI);
1344      else
1345        requestLabelAfterInsn(MI);
1346    }
1347  }
1348
1349  PrevInstLoc = DebugLoc();
1350  PrevLabel = FunctionBeginSym;
1351
1352  // Record beginning of function.
1353  if (!PrologEndLoc.isUnknown()) {
1354    DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1355                                       MF->getFunction()->getContext());
1356    recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1357                     FnStartDL.getScope(MF->getFunction()->getContext()),
1358                     DWARF2_FLAG_IS_STMT);
1359  }
1360}
1361
1362void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1363//  SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1364  ScopeVariables[LS].push_back(Var);
1365//  Vars.push_back(Var);
1366}
1367
1368/// endFunction - Gather and emit post-function debug information.
1369///
1370void DwarfDebug::endFunction(const MachineFunction *MF) {
1371  if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1372
1373  // Define end label for subprogram.
1374  FunctionEndSym = Asm->GetTempSymbol("func_end",
1375                                      Asm->getFunctionNumber());
1376  // Assumes in correct section after the entry point.
1377  Asm->OutStreamer.EmitLabel(FunctionEndSym);
1378
1379  SmallPtrSet<const MDNode *, 16> ProcessedVars;
1380  collectVariableInfo(MF, ProcessedVars);
1381
1382  LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1383  CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1384  assert(TheCU && "Unable to find compile unit!");
1385
1386  // Construct abstract scopes.
1387  ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1388  for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1389    LexicalScope *AScope = AList[i];
1390    DISubprogram SP(AScope->getScopeNode());
1391    if (SP.Verify()) {
1392      // Collect info for variables that were optimized out.
1393      DIArray Variables = SP.getVariables();
1394      for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1395        DIVariable DV(Variables.getElement(i));
1396        if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1397          continue;
1398        if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1399          addScopeVariable(Scope, new DbgVariable(DV, NULL));
1400      }
1401    }
1402    if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1403      constructScopeDIE(TheCU, AScope);
1404  }
1405
1406  DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1407
1408  if (!DisableFramePointerElim(*MF))
1409    TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1410                   dwarf::DW_FORM_flag, 1);
1411
1412  DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1413                                               MMI->getFrameMoves()));
1414
1415  // Clear debug info
1416  for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1417         I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1418    DeleteContainerPointers(I->second);
1419  ScopeVariables.clear();
1420  DeleteContainerPointers(CurrentFnArguments);
1421  UserVariables.clear();
1422  DbgValues.clear();
1423  AbstractVariables.clear();
1424  LabelsBeforeInsn.clear();
1425  LabelsAfterInsn.clear();
1426  PrevLabel = NULL;
1427}
1428
1429/// recordSourceLine - Register a source line with debug info. Returns the
1430/// unique label that was emitted and which provides correspondence to
1431/// the source line list.
1432void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1433                                  unsigned Flags) {
1434  StringRef Fn;
1435  StringRef Dir;
1436  unsigned Src = 1;
1437  if (S) {
1438    DIDescriptor Scope(S);
1439
1440    if (Scope.isCompileUnit()) {
1441      DICompileUnit CU(S);
1442      Fn = CU.getFilename();
1443      Dir = CU.getDirectory();
1444    } else if (Scope.isFile()) {
1445      DIFile F(S);
1446      Fn = F.getFilename();
1447      Dir = F.getDirectory();
1448    } else if (Scope.isSubprogram()) {
1449      DISubprogram SP(S);
1450      Fn = SP.getFilename();
1451      Dir = SP.getDirectory();
1452    } else if (Scope.isLexicalBlockFile()) {
1453      DILexicalBlockFile DBF(S);
1454      Fn = DBF.getFilename();
1455      Dir = DBF.getDirectory();
1456    } else if (Scope.isLexicalBlock()) {
1457      DILexicalBlock DB(S);
1458      Fn = DB.getFilename();
1459      Dir = DB.getDirectory();
1460    } else
1461      assert(0 && "Unexpected scope info");
1462
1463    Src = GetOrCreateSourceID(Fn, Dir);
1464  }
1465  Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1466}
1467
1468//===----------------------------------------------------------------------===//
1469// Emit Methods
1470//===----------------------------------------------------------------------===//
1471
1472/// computeSizeAndOffset - Compute the size and offset of a DIE.
1473///
1474unsigned
1475DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1476  // Get the children.
1477  const std::vector<DIE *> &Children = Die->getChildren();
1478
1479  // If not last sibling and has children then add sibling offset attribute.
1480  if (!Last && !Children.empty())
1481    Die->addSiblingOffset(DIEValueAllocator);
1482
1483  // Record the abbreviation.
1484  assignAbbrevNumber(Die->getAbbrev());
1485
1486  // Get the abbreviation for this DIE.
1487  unsigned AbbrevNumber = Die->getAbbrevNumber();
1488  const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1489
1490  // Set DIE offset
1491  Die->setOffset(Offset);
1492
1493  // Start the size with the size of abbreviation code.
1494  Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1495
1496  const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1497  const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1498
1499  // Size the DIE attribute values.
1500  for (unsigned i = 0, N = Values.size(); i < N; ++i)
1501    // Size attribute value.
1502    Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1503
1504  // Size the DIE children if any.
1505  if (!Children.empty()) {
1506    assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1507           "Children flag not set");
1508
1509    for (unsigned j = 0, M = Children.size(); j < M; ++j)
1510      Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1511
1512    // End of children marker.
1513    Offset += sizeof(int8_t);
1514  }
1515
1516  Die->setSize(Offset - Die->getOffset());
1517  return Offset;
1518}
1519
1520/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1521///
1522void DwarfDebug::computeSizeAndOffsets() {
1523  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1524         E = CUMap.end(); I != E; ++I) {
1525    // Compute size of compile unit header.
1526    unsigned Offset =
1527      sizeof(int32_t) + // Length of Compilation Unit Info
1528      sizeof(int16_t) + // DWARF version number
1529      sizeof(int32_t) + // Offset Into Abbrev. Section
1530      sizeof(int8_t);   // Pointer Size (in bytes)
1531    computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1532  }
1533}
1534
1535/// EmitSectionLabels - Emit initial Dwarf sections with a label at
1536/// the start of each one.
1537void DwarfDebug::EmitSectionLabels() {
1538  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1539
1540  // Dwarf sections base addresses.
1541  DwarfInfoSectionSym =
1542    EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1543  DwarfAbbrevSectionSym =
1544    EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1545  EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1546
1547  if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1548    EmitSectionSym(Asm, MacroInfo);
1549
1550  EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1551  EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1552  EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1553  EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1554  DwarfStrSectionSym =
1555    EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1556  DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1557                                             "debug_range");
1558
1559  DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1560                                           "section_debug_loc");
1561
1562  TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1563  EmitSectionSym(Asm, TLOF.getDataSection());
1564}
1565
1566/// emitDIE - Recursively emits a debug information entry.
1567///
1568void DwarfDebug::emitDIE(DIE *Die) {
1569  // Get the abbreviation for this DIE.
1570  unsigned AbbrevNumber = Die->getAbbrevNumber();
1571  const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1572
1573  // Emit the code (index) for the abbreviation.
1574  if (Asm->isVerbose())
1575    Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1576                                Twine::utohexstr(Die->getOffset()) + ":0x" +
1577                                Twine::utohexstr(Die->getSize()) + " " +
1578                                dwarf::TagString(Abbrev->getTag()));
1579  Asm->EmitULEB128(AbbrevNumber);
1580
1581  const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1582  const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1583
1584  // Emit the DIE attribute values.
1585  for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1586    unsigned Attr = AbbrevData[i].getAttribute();
1587    unsigned Form = AbbrevData[i].getForm();
1588    assert(Form && "Too many attributes for DIE (check abbreviation)");
1589
1590    if (Asm->isVerbose())
1591      Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1592
1593    switch (Attr) {
1594    case dwarf::DW_AT_sibling:
1595      Asm->EmitInt32(Die->getSiblingOffset());
1596      break;
1597    case dwarf::DW_AT_abstract_origin: {
1598      DIEEntry *E = cast<DIEEntry>(Values[i]);
1599      DIE *Origin = E->getEntry();
1600      unsigned Addr = Origin->getOffset();
1601      Asm->EmitInt32(Addr);
1602      break;
1603    }
1604    case dwarf::DW_AT_ranges: {
1605      // DW_AT_range Value encodes offset in debug_range section.
1606      DIEInteger *V = cast<DIEInteger>(Values[i]);
1607
1608      if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1609        Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1610                                 V->getValue(),
1611                                 4);
1612      } else {
1613        Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1614                                       V->getValue(),
1615                                       DwarfDebugRangeSectionSym,
1616                                       4);
1617      }
1618      break;
1619    }
1620    case dwarf::DW_AT_location: {
1621      if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1622        Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1623      else
1624        Values[i]->EmitValue(Asm, Form);
1625      break;
1626    }
1627    case dwarf::DW_AT_accessibility: {
1628      if (Asm->isVerbose()) {
1629        DIEInteger *V = cast<DIEInteger>(Values[i]);
1630        Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1631      }
1632      Values[i]->EmitValue(Asm, Form);
1633      break;
1634    }
1635    default:
1636      // Emit an attribute using the defined form.
1637      Values[i]->EmitValue(Asm, Form);
1638      break;
1639    }
1640  }
1641
1642  // Emit the DIE children if any.
1643  if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1644    const std::vector<DIE *> &Children = Die->getChildren();
1645
1646    for (unsigned j = 0, M = Children.size(); j < M; ++j)
1647      emitDIE(Children[j]);
1648
1649    if (Asm->isVerbose())
1650      Asm->OutStreamer.AddComment("End Of Children Mark");
1651    Asm->EmitInt8(0);
1652  }
1653}
1654
1655/// emitDebugInfo - Emit the debug info section.
1656///
1657void DwarfDebug::emitDebugInfo() {
1658  // Start debug info section.
1659  Asm->OutStreamer.SwitchSection(
1660                            Asm->getObjFileLowering().getDwarfInfoSection());
1661  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1662         E = CUMap.end(); I != E; ++I) {
1663    CompileUnit *TheCU = I->second;
1664    DIE *Die = TheCU->getCUDie();
1665
1666    // Emit the compile units header.
1667    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1668                                                  TheCU->getID()));
1669
1670    // Emit size of content not including length itself
1671    unsigned ContentSize = Die->getSize() +
1672      sizeof(int16_t) + // DWARF version number
1673      sizeof(int32_t) + // Offset Into Abbrev. Section
1674      sizeof(int8_t);   // Pointer Size (in bytes)
1675
1676    Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1677    Asm->EmitInt32(ContentSize);
1678    Asm->OutStreamer.AddComment("DWARF version number");
1679    Asm->EmitInt16(dwarf::DWARF_VERSION);
1680    Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1681    Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1682                           DwarfAbbrevSectionSym);
1683    Asm->OutStreamer.AddComment("Address Size (in bytes)");
1684    Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1685
1686    emitDIE(Die);
1687    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1688  }
1689}
1690
1691/// emitAbbreviations - Emit the abbreviation section.
1692///
1693void DwarfDebug::emitAbbreviations() const {
1694  // Check to see if it is worth the effort.
1695  if (!Abbreviations.empty()) {
1696    // Start the debug abbrev section.
1697    Asm->OutStreamer.SwitchSection(
1698                            Asm->getObjFileLowering().getDwarfAbbrevSection());
1699
1700    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1701
1702    // For each abbrevation.
1703    for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1704      // Get abbreviation data
1705      const DIEAbbrev *Abbrev = Abbreviations[i];
1706
1707      // Emit the abbrevations code (base 1 index.)
1708      Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1709
1710      // Emit the abbreviations data.
1711      Abbrev->Emit(Asm);
1712    }
1713
1714    // Mark end of abbreviations.
1715    Asm->EmitULEB128(0, "EOM(3)");
1716
1717    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1718  }
1719}
1720
1721/// emitEndOfLineMatrix - Emit the last address of the section and the end of
1722/// the line matrix.
1723///
1724void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1725  // Define last address of section.
1726  Asm->OutStreamer.AddComment("Extended Op");
1727  Asm->EmitInt8(0);
1728
1729  Asm->OutStreamer.AddComment("Op size");
1730  Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1731  Asm->OutStreamer.AddComment("DW_LNE_set_address");
1732  Asm->EmitInt8(dwarf::DW_LNE_set_address);
1733
1734  Asm->OutStreamer.AddComment("Section end label");
1735
1736  Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1737                                   Asm->getTargetData().getPointerSize(),
1738                                   0/*AddrSpace*/);
1739
1740  // Mark end of matrix.
1741  Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1742  Asm->EmitInt8(0);
1743  Asm->EmitInt8(1);
1744  Asm->EmitInt8(1);
1745}
1746
1747/// emitAccelNames - Emit visible names into a hashed accelerator table
1748/// section.
1749void DwarfDebug::emitAccelNames() {
1750  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1751                                           dwarf::DW_FORM_data4));
1752  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1753         E = CUMap.end(); I != E; ++I) {
1754    CompileUnit *TheCU = I->second;
1755    const StringMap<DIE*> &Names = TheCU->getAccelNames();
1756    for (StringMap<DIE*>::const_iterator
1757           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1758      const char *Name = GI->getKeyData();
1759      DIE *Entity = GI->second;
1760      AT.AddName(Name, Entity);
1761    }
1762  }
1763
1764  AT.FinalizeTable(Asm, "Names");
1765  Asm->OutStreamer.SwitchSection(
1766    Asm->getObjFileLowering().getDwarfAccelNamesSection());
1767  MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1768  Asm->OutStreamer.EmitLabel(SectionBegin);
1769
1770  // Emit the full data.
1771  AT.Emit(Asm, SectionBegin, this);
1772}
1773
1774/// emitAccelObjC - Emit objective C classes and categories into a hashed
1775/// accelerator table section.
1776void DwarfDebug::emitAccelObjC() {
1777  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1778                                           dwarf::DW_FORM_data4));
1779  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1780         E = CUMap.end(); I != E; ++I) {
1781    CompileUnit *TheCU = I->second;
1782    const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1783    for (StringMap<std::vector<DIE*> >::const_iterator
1784           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1785      const char *Name = GI->getKeyData();
1786      std::vector<DIE *> Entities = GI->second;
1787      for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1788             DE = Entities.end(); DI != DE; ++DI)
1789        AT.AddName(Name, (*DI));
1790    }
1791  }
1792
1793  AT.FinalizeTable(Asm, "ObjC");
1794  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1795                                 .getDwarfAccelObjCSection());
1796  MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1797  Asm->OutStreamer.EmitLabel(SectionBegin);
1798
1799  // Emit the full data.
1800  AT.Emit(Asm, SectionBegin, this);
1801}
1802
1803/// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1804/// table.
1805void DwarfDebug::emitAccelNamespaces() {
1806  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1807                                           dwarf::DW_FORM_data4));
1808  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1809         E = CUMap.end(); I != E; ++I) {
1810    CompileUnit *TheCU = I->second;
1811    const StringMap<DIE*> &Names = TheCU->getAccelNamespace();
1812    for (StringMap<DIE*>::const_iterator
1813           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1814      const char *Name = GI->getKeyData();
1815      DIE *Entity = GI->second;
1816      AT.AddName(Name, Entity);
1817    }
1818  }
1819
1820  AT.FinalizeTable(Asm, "namespac");
1821  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1822                                 .getDwarfAccelNamespaceSection());
1823  MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1824  Asm->OutStreamer.EmitLabel(SectionBegin);
1825
1826  // Emit the full data.
1827  AT.Emit(Asm, SectionBegin, this);
1828}
1829
1830/// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1831void DwarfDebug::emitAccelTypes() {
1832  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1833                                           dwarf::DW_FORM_data4));
1834  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1835         E = CUMap.end(); I != E; ++I) {
1836    CompileUnit *TheCU = I->second;
1837    const StringMap<DIE*> &Names = TheCU->getGlobalTypes();
1838    //TODO: TheCU->getAccelTypes();
1839    for (StringMap<DIE*>::const_iterator
1840           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1841      const char *Name = GI->getKeyData();
1842      DIE *Entity = GI->second;
1843      AT.AddName(Name, Entity);
1844    }
1845  }
1846
1847  AT.FinalizeTable(Asm, "types");
1848  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1849                                 .getDwarfAccelTypesSection());
1850  MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1851  Asm->OutStreamer.EmitLabel(SectionBegin);
1852
1853  // Emit the full data.
1854  AT.Emit(Asm, SectionBegin, this);
1855}
1856
1857/// emitDebugPubNames - Emit visible names into a debug pubnames section.
1858///
1859void DwarfDebug::emitDebugPubNames() {
1860  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1861         E = CUMap.end(); I != E; ++I) {
1862    CompileUnit *TheCU = I->second;
1863    // Start the dwarf pubnames section.
1864    Asm->OutStreamer.SwitchSection(
1865      Asm->getObjFileLowering().getDwarfPubNamesSection());
1866
1867    Asm->OutStreamer.AddComment("Length of Public Names Info");
1868    Asm->EmitLabelDifference(
1869      Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
1870      Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
1871
1872    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
1873                                                  TheCU->getID()));
1874
1875    Asm->OutStreamer.AddComment("DWARF Version");
1876    Asm->EmitInt16(dwarf::DWARF_VERSION);
1877
1878    Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1879    Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1880                           DwarfInfoSectionSym);
1881
1882    Asm->OutStreamer.AddComment("Compilation Unit Length");
1883    Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1884                             Asm->GetTempSymbol("info_begin", TheCU->getID()),
1885                             4);
1886
1887    const StringMap<DIE*> &Globals = TheCU->getGlobals();
1888    for (StringMap<DIE*>::const_iterator
1889           GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1890      const char *Name = GI->getKeyData();
1891      DIE *Entity = GI->second;
1892
1893      Asm->OutStreamer.AddComment("DIE offset");
1894      Asm->EmitInt32(Entity->getOffset());
1895
1896      if (Asm->isVerbose())
1897        Asm->OutStreamer.AddComment("External Name");
1898      Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
1899    }
1900
1901    Asm->OutStreamer.AddComment("End Mark");
1902    Asm->EmitInt32(0);
1903    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
1904                                                  TheCU->getID()));
1905  }
1906}
1907
1908void DwarfDebug::emitDebugPubTypes() {
1909  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1910         E = CUMap.end(); I != E; ++I) {
1911    CompileUnit *TheCU = I->second;
1912    // Start the dwarf pubtypes section.
1913    Asm->OutStreamer.SwitchSection(
1914      Asm->getObjFileLowering().getDwarfPubTypesSection());
1915    Asm->OutStreamer.AddComment("Length of Public Types Info");
1916    Asm->EmitLabelDifference(
1917      Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1918      Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1919
1920    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1921                                                  TheCU->getID()));
1922
1923    if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1924    Asm->EmitInt16(dwarf::DWARF_VERSION);
1925
1926    Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1927    Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1928                           DwarfInfoSectionSym);
1929
1930    Asm->OutStreamer.AddComment("Compilation Unit Length");
1931    Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1932                             Asm->GetTempSymbol("info_begin", TheCU->getID()),
1933                             4);
1934
1935    const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1936    for (StringMap<DIE*>::const_iterator
1937           GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1938      const char *Name = GI->getKeyData();
1939      DIE *Entity = GI->second;
1940
1941      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1942      Asm->EmitInt32(Entity->getOffset());
1943
1944      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1945      Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1946    }
1947
1948    Asm->OutStreamer.AddComment("End Mark");
1949    Asm->EmitInt32(0);
1950    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1951                                                  TheCU->getID()));
1952  }
1953}
1954
1955/// emitDebugStr - Emit visible names into a debug str section.
1956///
1957void DwarfDebug::emitDebugStr() {
1958  // Check to see if it is worth the effort.
1959  if (StringPool.empty()) return;
1960
1961  // Start the dwarf str section.
1962  Asm->OutStreamer.SwitchSection(
1963                                Asm->getObjFileLowering().getDwarfStrSection());
1964
1965  // Get all of the string pool entries and put them in an array by their ID so
1966  // we can sort them.
1967  SmallVector<std::pair<unsigned,
1968      StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1969
1970  for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1971       I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1972    Entries.push_back(std::make_pair(I->second.second, &*I));
1973
1974  array_pod_sort(Entries.begin(), Entries.end());
1975
1976  for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1977    // Emit a label for reference from debug information entries.
1978    Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1979
1980    // Emit the string itself.
1981    Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
1982    Asm->OutStreamer.EmitZeros(1, 0);
1983  }
1984}
1985
1986/// emitDebugLoc - Emit visible names into a debug loc section.
1987///
1988void DwarfDebug::emitDebugLoc() {
1989  if (DotDebugLocEntries.empty())
1990    return;
1991
1992  for (SmallVector<DotDebugLocEntry, 4>::iterator
1993         I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1994       I != E; ++I) {
1995    DotDebugLocEntry &Entry = *I;
1996    if (I + 1 != DotDebugLocEntries.end())
1997      Entry.Merge(I+1);
1998  }
1999
2000  // Start the dwarf loc section.
2001  Asm->OutStreamer.SwitchSection(
2002    Asm->getObjFileLowering().getDwarfLocSection());
2003  unsigned char Size = Asm->getTargetData().getPointerSize();
2004  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2005  unsigned index = 1;
2006  for (SmallVector<DotDebugLocEntry, 4>::iterator
2007         I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2008       I != E; ++I, ++index) {
2009    DotDebugLocEntry &Entry = *I;
2010    if (Entry.isMerged()) continue;
2011    if (Entry.isEmpty()) {
2012      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2013      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2014      Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2015    } else {
2016      Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2017      Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2018      DIVariable DV(Entry.Variable);
2019      Asm->OutStreamer.AddComment("Loc expr size");
2020      MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2021      MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2022      Asm->EmitLabelDifference(end, begin, 2);
2023      Asm->OutStreamer.EmitLabel(begin);
2024      if (Entry.isInt()) {
2025        DIBasicType BTy(DV.getType());
2026        if (BTy.Verify() &&
2027            (BTy.getEncoding()  == dwarf::DW_ATE_signed
2028             || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2029          Asm->OutStreamer.AddComment("DW_OP_consts");
2030          Asm->EmitInt8(dwarf::DW_OP_consts);
2031          Asm->EmitSLEB128(Entry.getInt());
2032        } else {
2033          Asm->OutStreamer.AddComment("DW_OP_constu");
2034          Asm->EmitInt8(dwarf::DW_OP_constu);
2035          Asm->EmitULEB128(Entry.getInt());
2036        }
2037      } else if (Entry.isLocation()) {
2038        if (!DV.hasComplexAddress())
2039          // Regular entry.
2040          Asm->EmitDwarfRegOp(Entry.Loc);
2041        else {
2042          // Complex address entry.
2043          unsigned N = DV.getNumAddrElements();
2044          unsigned i = 0;
2045          if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2046            if (Entry.Loc.getOffset()) {
2047              i = 2;
2048              Asm->EmitDwarfRegOp(Entry.Loc);
2049              Asm->OutStreamer.AddComment("DW_OP_deref");
2050              Asm->EmitInt8(dwarf::DW_OP_deref);
2051              Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2052              Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2053              Asm->EmitSLEB128(DV.getAddrElement(1));
2054            } else {
2055              // If first address element is OpPlus then emit
2056              // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2057              MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2058              Asm->EmitDwarfRegOp(Loc);
2059              i = 2;
2060            }
2061          } else {
2062            Asm->EmitDwarfRegOp(Entry.Loc);
2063          }
2064
2065          // Emit remaining complex address elements.
2066          for (; i < N; ++i) {
2067            uint64_t Element = DV.getAddrElement(i);
2068            if (Element == DIBuilder::OpPlus) {
2069              Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2070              Asm->EmitULEB128(DV.getAddrElement(++i));
2071            } else if (Element == DIBuilder::OpDeref)
2072              Asm->EmitInt8(dwarf::DW_OP_deref);
2073            else llvm_unreachable("unknown Opcode found in complex address");
2074          }
2075        }
2076      }
2077      // else ... ignore constant fp. There is not any good way to
2078      // to represent them here in dwarf.
2079      Asm->OutStreamer.EmitLabel(end);
2080    }
2081  }
2082}
2083
2084/// EmitDebugARanges - Emit visible names into a debug aranges section.
2085///
2086void DwarfDebug::EmitDebugARanges() {
2087  // Start the dwarf aranges section.
2088  Asm->OutStreamer.SwitchSection(
2089                          Asm->getObjFileLowering().getDwarfARangesSection());
2090}
2091
2092/// emitDebugRanges - Emit visible names into a debug ranges section.
2093///
2094void DwarfDebug::emitDebugRanges() {
2095  // Start the dwarf ranges section.
2096  Asm->OutStreamer.SwitchSection(
2097    Asm->getObjFileLowering().getDwarfRangesSection());
2098  unsigned char Size = Asm->getTargetData().getPointerSize();
2099  for (SmallVector<const MCSymbol *, 8>::iterator
2100         I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2101       I != E; ++I) {
2102    if (*I)
2103      Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2104    else
2105      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2106  }
2107}
2108
2109/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2110///
2111void DwarfDebug::emitDebugMacInfo() {
2112  if (const MCSection *LineInfo =
2113      Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2114    // Start the dwarf macinfo section.
2115    Asm->OutStreamer.SwitchSection(LineInfo);
2116  }
2117}
2118
2119/// emitDebugInlineInfo - Emit inline info using following format.
2120/// Section Header:
2121/// 1. length of section
2122/// 2. Dwarf version number
2123/// 3. address size.
2124///
2125/// Entries (one "entry" for each function that was inlined):
2126///
2127/// 1. offset into __debug_str section for MIPS linkage name, if exists;
2128///   otherwise offset into __debug_str for regular function name.
2129/// 2. offset into __debug_str section for regular function name.
2130/// 3. an unsigned LEB128 number indicating the number of distinct inlining
2131/// instances for the function.
2132///
2133/// The rest of the entry consists of a {die_offset, low_pc} pair for each
2134/// inlined instance; the die_offset points to the inlined_subroutine die in the
2135/// __debug_info section, and the low_pc is the starting address for the
2136/// inlining instance.
2137void DwarfDebug::emitDebugInlineInfo() {
2138  if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2139    return;
2140
2141  if (!FirstCU)
2142    return;
2143
2144  Asm->OutStreamer.SwitchSection(
2145                        Asm->getObjFileLowering().getDwarfDebugInlineSection());
2146
2147  Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2148  Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2149                           Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2150
2151  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2152
2153  Asm->OutStreamer.AddComment("Dwarf Version");
2154  Asm->EmitInt16(dwarf::DWARF_VERSION);
2155  Asm->OutStreamer.AddComment("Address Size (in bytes)");
2156  Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2157
2158  for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2159         E = InlinedSPNodes.end(); I != E; ++I) {
2160
2161    const MDNode *Node = *I;
2162    DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2163      = InlineInfo.find(Node);
2164    SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2165    DISubprogram SP(Node);
2166    StringRef LName = SP.getLinkageName();
2167    StringRef Name = SP.getName();
2168
2169    Asm->OutStreamer.AddComment("MIPS linkage name");
2170    if (LName.empty()) {
2171      Asm->OutStreamer.EmitBytes(Name, 0);
2172      Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2173    } else
2174      Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2175                             DwarfStrSectionSym);
2176
2177    Asm->OutStreamer.AddComment("Function name");
2178    Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2179    Asm->EmitULEB128(Labels.size(), "Inline count");
2180
2181    for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2182           LE = Labels.end(); LI != LE; ++LI) {
2183      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2184      Asm->EmitInt32(LI->second->getOffset());
2185
2186      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2187      Asm->OutStreamer.EmitSymbolValue(LI->first,
2188                                       Asm->getTargetData().getPointerSize(),0);
2189    }
2190  }
2191
2192  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2193}
2194