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