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