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