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