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