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