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