DwarfDebug.cpp revision abbb200feb492cb1951d089eb8d9e596db38c38c 
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  // Add name to the name table, we do this here because we're guaranteed
446  // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
447  addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
448
449  return ScopeDIE;
450}
451
452/// constructScopeDIE - Construct a DIE for this scope.
453DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
454  if (!Scope || !Scope->getScopeNode())
455    return NULL;
456
457  SmallVector<DIE *, 8> Children;
458
459  // Collect arguments for current function.
460  if (LScopes.isCurrentFunctionScope(Scope))
461    for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
462      if (DbgVariable *ArgDV = CurrentFnArguments[i])
463        if (DIE *Arg =
464            TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
465          Children.push_back(Arg);
466
467  // Collect lexical scope children first.
468  const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
469  for (unsigned i = 0, N = Variables.size(); i < N; ++i)
470    if (DIE *Variable =
471        TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
472      Children.push_back(Variable);
473  const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
474  for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
475    if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
476      Children.push_back(Nested);
477  DIScope DS(Scope->getScopeNode());
478  DIE *ScopeDIE = NULL;
479  if (Scope->getInlinedAt())
480    ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
481  else if (DS.isSubprogram()) {
482    ProcessedSPNodes.insert(DS);
483    if (Scope->isAbstractScope()) {
484      ScopeDIE = TheCU->getDIE(DS);
485      // Note down abstract DIE.
486      if (ScopeDIE)
487        AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
488    }
489    else
490      ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
491  }
492  else {
493    // There is no need to emit empty lexical block DIE.
494    if (Children.empty())
495      return NULL;
496    ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
497  }
498
499  if (!ScopeDIE) return NULL;
500
501  // Add children
502  for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
503         E = Children.end(); I != E; ++I)
504    ScopeDIE->addChild(*I);
505
506  if (DS.isSubprogram())
507    TheCU->addPubTypes(DISubprogram(DS));
508
509  return ScopeDIE;
510}
511
512/// GetOrCreateSourceID - Look up the source id with the given directory and
513/// source file names. If none currently exists, create a new id and insert it
514/// in the SourceIds map. This can update DirectoryNames and SourceFileNames
515/// maps as well.
516unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
517                                         StringRef DirName) {
518  // If FE did not provide a file name, then assume stdin.
519  if (FileName.empty())
520    return GetOrCreateSourceID("<stdin>", StringRef());
521
522  // TODO: this might not belong here. See if we can factor this better.
523  if (DirName == CompilationDir)
524    DirName = "";
525
526  unsigned SrcId = SourceIdMap.size()+1;
527  std::pair<std::string, std::string> SourceName =
528      std::make_pair(FileName, DirName);
529  std::pair<std::pair<std::string, std::string>, unsigned> Entry =
530      make_pair(SourceName, SrcId);
531
532  std::map<std::pair<std::string, std::string>, unsigned>::iterator I;
533  bool NewlyInserted;
534  tie(I, NewlyInserted) = SourceIdMap.insert(Entry);
535  if (!NewlyInserted)
536    return I->second;
537
538  // Print out a .file directive to specify files for .loc directives.
539  Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.first.second,
540                                          Entry.first.first);
541
542  return SrcId;
543}
544
545/// constructCompileUnit - Create new CompileUnit for the given
546/// metadata node with tag DW_TAG_compile_unit.
547CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
548  DICompileUnit DIUnit(N);
549  StringRef FN = DIUnit.getFilename();
550  CompilationDir = DIUnit.getDirectory();
551  unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
552
553  DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
554  CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
555  NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
556  NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
557                 DIUnit.getLanguage());
558  NewCU->addString(Die, dwarf::DW_AT_name, FN);
559  // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
560  // simplifies debug range entries.
561  NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
562  // DW_AT_stmt_list is a offset of line number information for this
563  // compile unit in debug_line section.
564  if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
565    NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
566                    Asm->GetTempSymbol("section_line"));
567  else
568    NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
569
570  if (!CompilationDir.empty())
571    NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
572  if (DIUnit.isOptimized())
573    NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
574
575  StringRef Flags = DIUnit.getFlags();
576  if (!Flags.empty())
577    NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
578
579  if (unsigned RVer = DIUnit.getRunTimeVersion())
580    NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
581            dwarf::DW_FORM_data1, RVer);
582
583  if (!FirstCU)
584    FirstCU = NewCU;
585  CUMap.insert(std::make_pair(N, NewCU));
586  return NewCU;
587}
588
589/// construct SubprogramDIE - Construct subprogram DIE.
590void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
591                                        const MDNode *N) {
592  CompileUnit *&CURef = SPMap[N];
593  if (CURef)
594    return;
595  CURef = TheCU;
596
597  DISubprogram SP(N);
598  if (!SP.isDefinition())
599    // This is a method declaration which will be handled while constructing
600    // class type.
601    return;
602
603  DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
604
605  // Add to map.
606  TheCU->insertDIE(N, SubprogramDie);
607
608  // Add to context owner.
609  TheCU->addToContextOwner(SubprogramDie, SP.getContext());
610
611  return;
612}
613
614/// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
615/// as llvm.dbg.enum and llvm.dbg.ty
616void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
617  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
618    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
619      const MDNode *N = NMD->getOperand(i);
620      if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
621        constructSubprogramDIE(CU, N);
622    }
623
624  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
625    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
626      const MDNode *N = NMD->getOperand(i);
627      if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
628        CU->createGlobalVariableDIE(N);
629    }
630
631  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
632    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
633      DIType Ty(NMD->getOperand(i));
634      if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
635        CU->getOrCreateTypeDIE(Ty);
636    }
637
638  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
639    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
640      DIType Ty(NMD->getOperand(i));
641      if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
642        CU->getOrCreateTypeDIE(Ty);
643    }
644}
645
646/// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
647/// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
648bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
649  DebugInfoFinder DbgFinder;
650  DbgFinder.processModule(*M);
651
652  bool HasDebugInfo = false;
653  // Scan all the compile-units to see if there are any marked as the main
654  // unit. If not, we do not generate debug info.
655  for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
656         E = DbgFinder.compile_unit_end(); I != E; ++I) {
657    if (DICompileUnit(*I).isMain()) {
658      HasDebugInfo = true;
659      break;
660    }
661  }
662  if (!HasDebugInfo) return false;
663
664  // Create all the compile unit DIEs.
665  for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
666         E = DbgFinder.compile_unit_end(); I != E; ++I)
667    constructCompileUnit(*I);
668
669  // Create DIEs for each global variable.
670  for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
671         E = DbgFinder.global_variable_end(); I != E; ++I) {
672    const MDNode *N = *I;
673    if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
674      CU->createGlobalVariableDIE(N);
675  }
676
677  // Create DIEs for each subprogram.
678  for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
679         E = DbgFinder.subprogram_end(); I != E; ++I) {
680    const MDNode *N = *I;
681    if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
682      constructSubprogramDIE(CU, N);
683  }
684
685  return HasDebugInfo;
686}
687
688/// beginModule - Emit all Dwarf sections that should come prior to the
689/// content. Create global DIEs and emit initial debug info sections.
690/// This is invoked by the target AsmPrinter.
691void DwarfDebug::beginModule(Module *M) {
692  if (DisableDebugInfoPrinting)
693    return;
694
695  // If module has named metadata anchors then use them, otherwise scan the
696  // module using debug info finder to collect debug info.
697  NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
698  if (CU_Nodes) {
699    for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
700      DICompileUnit CUNode(CU_Nodes->getOperand(i));
701      CompileUnit *CU = constructCompileUnit(CUNode);
702      DIArray GVs = CUNode.getGlobalVariables();
703      for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
704        CU->createGlobalVariableDIE(GVs.getElement(i));
705      DIArray SPs = CUNode.getSubprograms();
706      for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
707        constructSubprogramDIE(CU, SPs.getElement(i));
708      DIArray EnumTypes = CUNode.getEnumTypes();
709      for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
710        CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
711      DIArray RetainedTypes = CUNode.getRetainedTypes();
712      for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
713        CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
714    }
715  } else if (!collectLegacyDebugInfo(M))
716    return;
717
718  collectInfoFromNamedMDNodes(M);
719
720  // Tell MMI that we have debug info.
721  MMI->setDebugInfoAvailability(true);
722
723  // Emit initial sections.
724  EmitSectionLabels();
725
726  // Prime section data.
727  SectionMap.insert(Asm->getObjFileLowering().getTextSection());
728}
729
730/// endModule - Emit all Dwarf sections that should come after the content.
731///
732void DwarfDebug::endModule() {
733  if (!FirstCU) return;
734  const Module *M = MMI->getModule();
735  DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
736
737  // Collect info for variables that were optimized out.
738  if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
739    for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
740      DICompileUnit TheCU(CU_Nodes->getOperand(i));
741      DIArray Subprograms = TheCU.getSubprograms();
742      for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
743        DISubprogram SP(Subprograms.getElement(i));
744        if (ProcessedSPNodes.count(SP) != 0) continue;
745        if (!SP.Verify()) continue;
746        if (!SP.isDefinition()) continue;
747        DIArray Variables = SP.getVariables();
748        if (Variables.getNumElements() == 0) continue;
749
750        LexicalScope *Scope =
751          new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
752        DeadFnScopeMap[SP] = Scope;
753
754        // Construct subprogram DIE and add variables DIEs.
755        CompileUnit *SPCU = CUMap.lookup(TheCU);
756        assert(SPCU && "Unable to find Compile Unit!");
757        constructSubprogramDIE(SPCU, SP);
758        DIE *ScopeDIE = SPCU->getDIE(SP);
759        for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
760          DIVariable DV(Variables.getElement(vi));
761          if (!DV.Verify()) continue;
762          DbgVariable *NewVar = new DbgVariable(DV, NULL);
763          if (DIE *VariableDIE =
764              SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
765            ScopeDIE->addChild(VariableDIE);
766        }
767      }
768    }
769  }
770
771  // Attach DW_AT_inline attribute with inlined subprogram DIEs.
772  for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
773         AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
774    DIE *ISP = *AI;
775    FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
776  }
777  for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
778         AE = AbstractSPDies.end(); AI != AE; ++AI) {
779    DIE *ISP = AI->second;
780    if (InlinedSubprogramDIEs.count(ISP))
781      continue;
782    FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
783  }
784
785  // Emit DW_AT_containing_type attribute to connect types with their
786  // vtable holding type.
787  for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
788         CUE = CUMap.end(); CUI != CUE; ++CUI) {
789    CompileUnit *TheCU = CUI->second;
790    TheCU->constructContainingTypeDIEs();
791  }
792
793  // Standard sections final addresses.
794  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
795  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
796  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
797  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
798
799  // End text sections.
800  for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
801    Asm->OutStreamer.SwitchSection(SectionMap[i]);
802    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
803  }
804
805  // Compute DIE offsets and sizes.
806  computeSizeAndOffsets();
807
808  // Emit all the DIEs into a debug info section
809  emitDebugInfo();
810
811  // Corresponding abbreviations into a abbrev section.
812  emitAbbreviations();
813
814  // Emit info into a dwarf accelerator table sections.
815  if (DwarfAccelTables) {
816    emitAccelNames();
817    emitAccelObjC();
818    emitAccelNamespaces();
819    emitAccelTypes();
820  }
821
822  // Emit info into a debug pubtypes section.
823  emitDebugPubTypes();
824
825  // Emit info into a debug loc section.
826  emitDebugLoc();
827
828  // Emit info into a debug aranges section.
829  EmitDebugARanges();
830
831  // Emit info into a debug ranges section.
832  emitDebugRanges();
833
834  // Emit info into a debug macinfo section.
835  emitDebugMacInfo();
836
837  // Emit inline info.
838  emitDebugInlineInfo();
839
840  // Emit info into a debug str section.
841  emitDebugStr();
842
843  // clean up.
844  DeleteContainerSeconds(DeadFnScopeMap);
845  SPMap.clear();
846  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
847         E = CUMap.end(); I != E; ++I)
848    delete I->second;
849  FirstCU = NULL;  // Reset for the next Module, if any.
850}
851
852/// findAbstractVariable - Find abstract variable, if any, associated with Var.
853DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
854                                              DebugLoc ScopeLoc) {
855  LLVMContext &Ctx = DV->getContext();
856  // More then one inlined variable corresponds to one abstract variable.
857  DIVariable Var = cleanseInlinedVariable(DV, Ctx);
858  DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
859  if (AbsDbgVariable)
860    return AbsDbgVariable;
861
862  LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
863  if (!Scope)
864    return NULL;
865
866  AbsDbgVariable = new DbgVariable(Var, NULL);
867  addScopeVariable(Scope, AbsDbgVariable);
868  AbstractVariables[Var] = AbsDbgVariable;
869  return AbsDbgVariable;
870}
871
872/// addCurrentFnArgument - If Var is a current function argument then add
873/// it to CurrentFnArguments list.
874bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
875                                      DbgVariable *Var, LexicalScope *Scope) {
876  if (!LScopes.isCurrentFunctionScope(Scope))
877    return false;
878  DIVariable DV = Var->getVariable();
879  if (DV.getTag() != dwarf::DW_TAG_arg_variable)
880    return false;
881  unsigned ArgNo = DV.getArgNumber();
882  if (ArgNo == 0)
883    return false;
884
885  size_t Size = CurrentFnArguments.size();
886  if (Size == 0)
887    CurrentFnArguments.resize(MF->getFunction()->arg_size());
888  // llvm::Function argument size is not good indicator of how many
889  // arguments does the function have at source level.
890  if (ArgNo > Size)
891    CurrentFnArguments.resize(ArgNo * 2);
892  CurrentFnArguments[ArgNo - 1] = Var;
893  return true;
894}
895
896/// collectVariableInfoFromMMITable - Collect variable information from
897/// side table maintained by MMI.
898void
899DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
900                                   SmallPtrSet<const MDNode *, 16> &Processed) {
901  MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
902  for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
903         VE = VMap.end(); VI != VE; ++VI) {
904    const MDNode *Var = VI->first;
905    if (!Var) continue;
906    Processed.insert(Var);
907    DIVariable DV(Var);
908    const std::pair<unsigned, DebugLoc> &VP = VI->second;
909
910    LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
911
912    // If variable scope is not found then skip this variable.
913    if (Scope == 0)
914      continue;
915
916    DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
917    DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
918    RegVar->setFrameIndex(VP.first);
919    if (!addCurrentFnArgument(MF, RegVar, Scope))
920      addScopeVariable(Scope, RegVar);
921    if (AbsDbgVariable)
922      AbsDbgVariable->setFrameIndex(VP.first);
923  }
924}
925
926/// isDbgValueInDefinedReg - Return true if debug value, encoded by
927/// DBG_VALUE instruction, is in a defined reg.
928static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
929  assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
930  return MI->getNumOperands() == 3 &&
931         MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
932         MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
933}
934
935/// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
936/// at MI.
937static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
938                                         const MCSymbol *FLabel,
939                                         const MCSymbol *SLabel,
940                                         const MachineInstr *MI) {
941  const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
942
943  if (MI->getNumOperands() != 3) {
944    MachineLocation MLoc = Asm->getDebugValueLocation(MI);
945    return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
946  }
947  if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
948    MachineLocation MLoc;
949    MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
950    return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
951  }
952  if (MI->getOperand(0).isImm())
953    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
954  if (MI->getOperand(0).isFPImm())
955    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
956  if (MI->getOperand(0).isCImm())
957    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
958
959  assert(0 && "Unexpected 3 operand DBG_VALUE instruction!");
960  return DotDebugLocEntry();
961}
962
963/// collectVariableInfo - Find variables for each lexical scope.
964void
965DwarfDebug::collectVariableInfo(const MachineFunction *MF,
966                                SmallPtrSet<const MDNode *, 16> &Processed) {
967
968  /// collection info from MMI table.
969  collectVariableInfoFromMMITable(MF, Processed);
970
971  for (SmallVectorImpl<const MDNode*>::const_iterator
972         UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
973         ++UVI) {
974    const MDNode *Var = *UVI;
975    if (Processed.count(Var))
976      continue;
977
978    // History contains relevant DBG_VALUE instructions for Var and instructions
979    // clobbering it.
980    SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
981    if (History.empty())
982      continue;
983    const MachineInstr *MInsn = History.front();
984
985    DIVariable DV(Var);
986    LexicalScope *Scope = NULL;
987    if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
988        DISubprogram(DV.getContext()).describes(MF->getFunction()))
989      Scope = LScopes.getCurrentFunctionScope();
990    else {
991      if (DV.getVersion() <= LLVMDebugVersion9)
992        Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
993      else {
994        if (MDNode *IA = DV.getInlinedAt())
995          Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
996        else
997          Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
998      }
999    }
1000    // If variable scope is not found then skip this variable.
1001    if (!Scope)
1002      continue;
1003
1004    Processed.insert(DV);
1005    assert(MInsn->isDebugValue() && "History must begin with debug value");
1006    DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1007    DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1008    if (!addCurrentFnArgument(MF, RegVar, Scope))
1009      addScopeVariable(Scope, RegVar);
1010    if (AbsVar)
1011      AbsVar->setMInsn(MInsn);
1012
1013    // Simple ranges that are fully coalesced.
1014    if (History.size() <= 1 || (History.size() == 2 &&
1015                                MInsn->isIdenticalTo(History.back()))) {
1016      RegVar->setMInsn(MInsn);
1017      continue;
1018    }
1019
1020    // handle multiple DBG_VALUE instructions describing one variable.
1021    RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1022
1023    for (SmallVectorImpl<const MachineInstr*>::const_iterator
1024           HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1025      const MachineInstr *Begin = *HI;
1026      assert(Begin->isDebugValue() && "Invalid History entry");
1027
1028      // Check if DBG_VALUE is truncating a range.
1029      if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1030          && !Begin->getOperand(0).getReg())
1031        continue;
1032
1033      // Compute the range for a register location.
1034      const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1035      const MCSymbol *SLabel = 0;
1036
1037      if (HI + 1 == HE)
1038        // If Begin is the last instruction in History then its value is valid
1039        // until the end of the function.
1040        SLabel = FunctionEndSym;
1041      else {
1042        const MachineInstr *End = HI[1];
1043        DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1044              << "\t" << *Begin << "\t" << *End << "\n");
1045        if (End->isDebugValue())
1046          SLabel = getLabelBeforeInsn(End);
1047        else {
1048          // End is a normal instruction clobbering the range.
1049          SLabel = getLabelAfterInsn(End);
1050          assert(SLabel && "Forgot label after clobber instruction");
1051          ++HI;
1052        }
1053      }
1054
1055      // The value is valid until the next DBG_VALUE or clobber.
1056      DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1057                                                    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 (!MF->getTarget().Options.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<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1767    for (StringMap<std::vector<DIE*> >::const_iterator
1768           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1769      const char *Name = GI->getKeyData();
1770      std::vector<DIE *> Entities = GI->second;
1771      for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1772             DE = Entities.end(); DI != DE; ++DI)
1773        AT.AddName(Name, (*DI));
1774    }
1775  }
1776
1777  AT.FinalizeTable(Asm, "Names");
1778  Asm->OutStreamer.SwitchSection(
1779    Asm->getObjFileLowering().getDwarfAccelNamesSection());
1780  MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1781  Asm->OutStreamer.EmitLabel(SectionBegin);
1782
1783  // Emit the full data.
1784  AT.Emit(Asm, SectionBegin, this);
1785}
1786
1787/// emitAccelObjC - Emit objective C classes and categories into a hashed
1788/// accelerator table section.
1789void DwarfDebug::emitAccelObjC() {
1790  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1791                                           dwarf::DW_FORM_data4));
1792  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1793         E = CUMap.end(); I != E; ++I) {
1794    CompileUnit *TheCU = I->second;
1795    const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1796    for (StringMap<std::vector<DIE*> >::const_iterator
1797           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1798      const char *Name = GI->getKeyData();
1799      std::vector<DIE *> Entities = GI->second;
1800      for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1801             DE = Entities.end(); DI != DE; ++DI)
1802        AT.AddName(Name, (*DI));
1803    }
1804  }
1805
1806  AT.FinalizeTable(Asm, "ObjC");
1807  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1808                                 .getDwarfAccelObjCSection());
1809  MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1810  Asm->OutStreamer.EmitLabel(SectionBegin);
1811
1812  // Emit the full data.
1813  AT.Emit(Asm, SectionBegin, this);
1814}
1815
1816/// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1817/// table.
1818void DwarfDebug::emitAccelNamespaces() {
1819  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1820                                           dwarf::DW_FORM_data4));
1821  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1822         E = CUMap.end(); I != E; ++I) {
1823    CompileUnit *TheCU = I->second;
1824    const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1825    for (StringMap<std::vector<DIE*> >::const_iterator
1826           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1827      const char *Name = GI->getKeyData();
1828      std::vector<DIE *> Entities = GI->second;
1829      for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1830             DE = Entities.end(); DI != DE; ++DI)
1831        AT.AddName(Name, (*DI));
1832    }
1833  }
1834
1835  AT.FinalizeTable(Asm, "namespac");
1836  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1837                                 .getDwarfAccelNamespaceSection());
1838  MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1839  Asm->OutStreamer.EmitLabel(SectionBegin);
1840
1841  // Emit the full data.
1842  AT.Emit(Asm, SectionBegin, this);
1843}
1844
1845/// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1846void DwarfDebug::emitAccelTypes() {
1847  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1848                                           dwarf::DW_FORM_data4));
1849  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1850         E = CUMap.end(); I != E; ++I) {
1851    CompileUnit *TheCU = I->second;
1852    const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelTypes();
1853    for (StringMap<std::vector<DIE*> >::const_iterator
1854           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1855      const char *Name = GI->getKeyData();
1856      std::vector<DIE *> Entities = GI->second;
1857      for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1858             DE= Entities.end(); DI !=DE; ++DI)
1859        AT.AddName(Name, (*DI));
1860    }
1861  }
1862
1863  AT.FinalizeTable(Asm, "types");
1864  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1865                                 .getDwarfAccelTypesSection());
1866  MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1867  Asm->OutStreamer.EmitLabel(SectionBegin);
1868
1869  // Emit the full data.
1870  AT.Emit(Asm, SectionBegin, this);
1871}
1872
1873void DwarfDebug::emitDebugPubTypes() {
1874  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1875         E = CUMap.end(); I != E; ++I) {
1876    CompileUnit *TheCU = I->second;
1877    // Start the dwarf pubtypes section.
1878    Asm->OutStreamer.SwitchSection(
1879      Asm->getObjFileLowering().getDwarfPubTypesSection());
1880    Asm->OutStreamer.AddComment("Length of Public Types Info");
1881    Asm->EmitLabelDifference(
1882      Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1883      Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1884
1885    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1886                                                  TheCU->getID()));
1887
1888    if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1889    Asm->EmitInt16(dwarf::DWARF_VERSION);
1890
1891    Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1892    Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1893                           DwarfInfoSectionSym);
1894
1895    Asm->OutStreamer.AddComment("Compilation Unit Length");
1896    Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1897                             Asm->GetTempSymbol("info_begin", TheCU->getID()),
1898                             4);
1899
1900    const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1901    for (StringMap<DIE*>::const_iterator
1902           GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1903      const char *Name = GI->getKeyData();
1904      DIE *Entity = GI->second;
1905
1906      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1907      Asm->EmitInt32(Entity->getOffset());
1908
1909      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1910      // Emit the name with a terminating null byte.
1911      Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1912    }
1913
1914    Asm->OutStreamer.AddComment("End Mark");
1915    Asm->EmitInt32(0);
1916    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1917                                                  TheCU->getID()));
1918  }
1919}
1920
1921/// emitDebugStr - Emit visible names into a debug str section.
1922///
1923void DwarfDebug::emitDebugStr() {
1924  // Check to see if it is worth the effort.
1925  if (StringPool.empty()) return;
1926
1927  // Start the dwarf str section.
1928  Asm->OutStreamer.SwitchSection(
1929                                Asm->getObjFileLowering().getDwarfStrSection());
1930
1931  // Get all of the string pool entries and put them in an array by their ID so
1932  // we can sort them.
1933  SmallVector<std::pair<unsigned,
1934      StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1935
1936  for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1937       I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1938    Entries.push_back(std::make_pair(I->second.second, &*I));
1939
1940  array_pod_sort(Entries.begin(), Entries.end());
1941
1942  for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1943    // Emit a label for reference from debug information entries.
1944    Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1945
1946    // Emit the string itself with a terminating null byte.
1947    Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1948                                         Entries[i].second->getKeyLength()+1),
1949                               0/*addrspace*/);
1950  }
1951}
1952
1953/// emitDebugLoc - Emit visible names into a debug loc section.
1954///
1955void DwarfDebug::emitDebugLoc() {
1956  if (DotDebugLocEntries.empty())
1957    return;
1958
1959  for (SmallVector<DotDebugLocEntry, 4>::iterator
1960         I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1961       I != E; ++I) {
1962    DotDebugLocEntry &Entry = *I;
1963    if (I + 1 != DotDebugLocEntries.end())
1964      Entry.Merge(I+1);
1965  }
1966
1967  // Start the dwarf loc section.
1968  Asm->OutStreamer.SwitchSection(
1969    Asm->getObjFileLowering().getDwarfLocSection());
1970  unsigned char Size = Asm->getTargetData().getPointerSize();
1971  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1972  unsigned index = 1;
1973  for (SmallVector<DotDebugLocEntry, 4>::iterator
1974         I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1975       I != E; ++I, ++index) {
1976    DotDebugLocEntry &Entry = *I;
1977    if (Entry.isMerged()) continue;
1978    if (Entry.isEmpty()) {
1979      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1980      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1981      Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1982    } else {
1983      Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1984      Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1985      DIVariable DV(Entry.Variable);
1986      Asm->OutStreamer.AddComment("Loc expr size");
1987      MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1988      MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1989      Asm->EmitLabelDifference(end, begin, 2);
1990      Asm->OutStreamer.EmitLabel(begin);
1991      if (Entry.isInt()) {
1992        DIBasicType BTy(DV.getType());
1993        if (BTy.Verify() &&
1994            (BTy.getEncoding()  == dwarf::DW_ATE_signed
1995             || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1996          Asm->OutStreamer.AddComment("DW_OP_consts");
1997          Asm->EmitInt8(dwarf::DW_OP_consts);
1998          Asm->EmitSLEB128(Entry.getInt());
1999        } else {
2000          Asm->OutStreamer.AddComment("DW_OP_constu");
2001          Asm->EmitInt8(dwarf::DW_OP_constu);
2002          Asm->EmitULEB128(Entry.getInt());
2003        }
2004      } else if (Entry.isLocation()) {
2005        if (!DV.hasComplexAddress())
2006          // Regular entry.
2007          Asm->EmitDwarfRegOp(Entry.Loc);
2008        else {
2009          // Complex address entry.
2010          unsigned N = DV.getNumAddrElements();
2011          unsigned i = 0;
2012          if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2013            if (Entry.Loc.getOffset()) {
2014              i = 2;
2015              Asm->EmitDwarfRegOp(Entry.Loc);
2016              Asm->OutStreamer.AddComment("DW_OP_deref");
2017              Asm->EmitInt8(dwarf::DW_OP_deref);
2018              Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2019              Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2020              Asm->EmitSLEB128(DV.getAddrElement(1));
2021            } else {
2022              // If first address element is OpPlus then emit
2023              // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2024              MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2025              Asm->EmitDwarfRegOp(Loc);
2026              i = 2;
2027            }
2028          } else {
2029            Asm->EmitDwarfRegOp(Entry.Loc);
2030          }
2031
2032          // Emit remaining complex address elements.
2033          for (; i < N; ++i) {
2034            uint64_t Element = DV.getAddrElement(i);
2035            if (Element == DIBuilder::OpPlus) {
2036              Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2037              Asm->EmitULEB128(DV.getAddrElement(++i));
2038            } else if (Element == DIBuilder::OpDeref)
2039              Asm->EmitInt8(dwarf::DW_OP_deref);
2040            else llvm_unreachable("unknown Opcode found in complex address");
2041          }
2042        }
2043      }
2044      // else ... ignore constant fp. There is not any good way to
2045      // to represent them here in dwarf.
2046      Asm->OutStreamer.EmitLabel(end);
2047    }
2048  }
2049}
2050
2051/// EmitDebugARanges - Emit visible names into a debug aranges section.
2052///
2053void DwarfDebug::EmitDebugARanges() {
2054  // Start the dwarf aranges section.
2055  Asm->OutStreamer.SwitchSection(
2056                          Asm->getObjFileLowering().getDwarfARangesSection());
2057}
2058
2059/// emitDebugRanges - Emit visible names into a debug ranges section.
2060///
2061void DwarfDebug::emitDebugRanges() {
2062  // Start the dwarf ranges section.
2063  Asm->OutStreamer.SwitchSection(
2064    Asm->getObjFileLowering().getDwarfRangesSection());
2065  unsigned char Size = Asm->getTargetData().getPointerSize();
2066  for (SmallVector<const MCSymbol *, 8>::iterator
2067         I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2068       I != E; ++I) {
2069    if (*I)
2070      Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2071    else
2072      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2073  }
2074}
2075
2076/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2077///
2078void DwarfDebug::emitDebugMacInfo() {
2079  if (const MCSection *LineInfo =
2080      Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2081    // Start the dwarf macinfo section.
2082    Asm->OutStreamer.SwitchSection(LineInfo);
2083  }
2084}
2085
2086/// emitDebugInlineInfo - Emit inline info using following format.
2087/// Section Header:
2088/// 1. length of section
2089/// 2. Dwarf version number
2090/// 3. address size.
2091///
2092/// Entries (one "entry" for each function that was inlined):
2093///
2094/// 1. offset into __debug_str section for MIPS linkage name, if exists;
2095///   otherwise offset into __debug_str for regular function name.
2096/// 2. offset into __debug_str section for regular function name.
2097/// 3. an unsigned LEB128 number indicating the number of distinct inlining
2098/// instances for the function.
2099///
2100/// The rest of the entry consists of a {die_offset, low_pc} pair for each
2101/// inlined instance; the die_offset points to the inlined_subroutine die in the
2102/// __debug_info section, and the low_pc is the starting address for the
2103/// inlining instance.
2104void DwarfDebug::emitDebugInlineInfo() {
2105  if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2106    return;
2107
2108  if (!FirstCU)
2109    return;
2110
2111  Asm->OutStreamer.SwitchSection(
2112                        Asm->getObjFileLowering().getDwarfDebugInlineSection());
2113
2114  Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2115  Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2116                           Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2117
2118  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2119
2120  Asm->OutStreamer.AddComment("Dwarf Version");
2121  Asm->EmitInt16(dwarf::DWARF_VERSION);
2122  Asm->OutStreamer.AddComment("Address Size (in bytes)");
2123  Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2124
2125  for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2126         E = InlinedSPNodes.end(); I != E; ++I) {
2127
2128    const MDNode *Node = *I;
2129    DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2130      = InlineInfo.find(Node);
2131    SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2132    DISubprogram SP(Node);
2133    StringRef LName = SP.getLinkageName();
2134    StringRef Name = SP.getName();
2135
2136    Asm->OutStreamer.AddComment("MIPS linkage name");
2137    if (LName.empty()) {
2138      Asm->OutStreamer.EmitBytes(Name, 0);
2139      Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2140    } else
2141      Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2142                             DwarfStrSectionSym);
2143
2144    Asm->OutStreamer.AddComment("Function name");
2145    Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2146    Asm->EmitULEB128(Labels.size(), "Inline count");
2147
2148    for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2149           LE = Labels.end(); LI != LE; ++LI) {
2150      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2151      Asm->EmitInt32(LI->second->getOffset());
2152
2153      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2154      Asm->OutStreamer.EmitSymbolValue(LI->first,
2155                                       Asm->getTargetData().getPointerSize(),0);
2156    }
2157  }
2158
2159  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2160}
2161