DwarfDebug.cpp revision 9ec87b3c86151d065b58a1f4f94c37034aae97da 
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/ADT/STLExtras.h"
20#include "llvm/ADT/Statistic.h"
21#include "llvm/ADT/StringExtras.h"
22#include "llvm/ADT/Triple.h"
23#include "llvm/CodeGen/MachineFunction.h"
24#include "llvm/CodeGen/MachineModuleInfo.h"
25#include "llvm/Constants.h"
26#include "llvm/DIBuilder.h"
27#include "llvm/DataLayout.h"
28#include "llvm/DebugInfo.h"
29#include "llvm/Instructions.h"
30#include "llvm/MC/MCAsmInfo.h"
31#include "llvm/MC/MCSection.h"
32#include "llvm/MC/MCStreamer.h"
33#include "llvm/MC/MCSymbol.h"
34#include "llvm/Module.h"
35#include "llvm/Support/CommandLine.h"
36#include "llvm/Support/Debug.h"
37#include "llvm/Support/ErrorHandling.h"
38#include "llvm/Support/FormattedStream.h"
39#include "llvm/Support/Path.h"
40#include "llvm/Support/Timer.h"
41#include "llvm/Support/ValueHandle.h"
42#include "llvm/Target/TargetFrameLowering.h"
43#include "llvm/Target/TargetLoweringObjectFile.h"
44#include "llvm/Target/TargetMachine.h"
45#include "llvm/Target/TargetOptions.h"
46#include "llvm/Target/TargetRegisterInfo.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), GlobalCUIndexCount(0), FissionCU(0) {
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  // Call this to emit a .file directive if it wasn't emitted for the source
619  // file this CU comes from yet.
620  getOrCreateSourceID(FN, CompilationDir);
621
622  DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
623  CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
624                                       DIUnit.getLanguage(), Die, Asm, this);
625  NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
626  NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
627                 DIUnit.getLanguage());
628  NewCU->addString(Die, dwarf::DW_AT_name, FN);
629  // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
630  // into an entity.
631  NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
632  // DW_AT_stmt_list is a offset of line number information for this
633  // compile unit in debug_line section.
634  if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
635    NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
636                    Asm->GetTempSymbol("section_line"));
637  else
638    NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
639
640  if (!CompilationDir.empty())
641    NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
642  if (DIUnit.isOptimized())
643    NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
644
645  StringRef Flags = DIUnit.getFlags();
646  if (!Flags.empty())
647    NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
648
649  if (unsigned RVer = DIUnit.getRunTimeVersion())
650    NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
651            dwarf::DW_FORM_data1, RVer);
652
653  if (!FirstCU)
654    FirstCU = NewCU;
655  if (useDwarfFission() && !FissionCU)
656    FissionCU = constructFissionCU(N);
657
658  CUMap.insert(std::make_pair(N, NewCU));
659  return NewCU;
660}
661
662// Construct subprogram DIE.
663void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
664                                        const MDNode *N) {
665  CompileUnit *&CURef = SPMap[N];
666  if (CURef)
667    return;
668  CURef = TheCU;
669
670  DISubprogram SP(N);
671  if (!SP.isDefinition())
672    // This is a method declaration which will be handled while constructing
673    // class type.
674    return;
675
676  DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
677
678  // Add to map.
679  TheCU->insertDIE(N, SubprogramDie);
680
681  // Add to context owner.
682  TheCU->addToContextOwner(SubprogramDie, SP.getContext());
683
684  return;
685}
686
687// Collect debug info from named mdnodes such as llvm.dbg.enum and llvm.dbg.ty.
688void DwarfDebug::collectInfoFromNamedMDNodes(const Module *M) {
689  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
690    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
691      const MDNode *N = NMD->getOperand(i);
692      if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
693        constructSubprogramDIE(CU, N);
694    }
695
696  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
697    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
698      const MDNode *N = NMD->getOperand(i);
699      if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
700        CU->createGlobalVariableDIE(N);
701    }
702
703  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
704    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
705      DIType Ty(NMD->getOperand(i));
706      if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
707        CU->getOrCreateTypeDIE(Ty);
708    }
709
710  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
711    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
712      DIType Ty(NMD->getOperand(i));
713      if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
714        CU->getOrCreateTypeDIE(Ty);
715    }
716}
717
718// Collect debug info using DebugInfoFinder.
719// FIXME - Remove this when dragonegg switches to DIBuilder.
720bool DwarfDebug::collectLegacyDebugInfo(const Module *M) {
721  DebugInfoFinder DbgFinder;
722  DbgFinder.processModule(*M);
723
724  bool HasDebugInfo = false;
725  // Scan all the compile-units to see if there are any marked as the main
726  // unit. If not, we do not generate debug info.
727  for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
728         E = DbgFinder.compile_unit_end(); I != E; ++I) {
729    if (DICompileUnit(*I).isMain()) {
730      HasDebugInfo = true;
731      break;
732    }
733  }
734  if (!HasDebugInfo) return false;
735
736  // Create all the compile unit DIEs.
737  for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
738         E = DbgFinder.compile_unit_end(); I != E; ++I)
739    constructCompileUnit(*I);
740
741  // Create DIEs for each global variable.
742  for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
743         E = DbgFinder.global_variable_end(); I != E; ++I) {
744    const MDNode *N = *I;
745    if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
746      CU->createGlobalVariableDIE(N);
747  }
748
749  // Create DIEs for each subprogram.
750  for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
751         E = DbgFinder.subprogram_end(); I != E; ++I) {
752    const MDNode *N = *I;
753    if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
754      constructSubprogramDIE(CU, N);
755  }
756
757  return HasDebugInfo;
758}
759
760// Emit all Dwarf sections that should come prior to the content. Create
761// global DIEs and emit initial debug info sections. This is invoked by
762// the target AsmPrinter.
763void DwarfDebug::beginModule() {
764  if (DisableDebugInfoPrinting)
765    return;
766
767  const Module *M = MMI->getModule();
768
769  // If module has named metadata anchors then use them, otherwise scan the
770  // module using debug info finder to collect debug info.
771  NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
772  if (CU_Nodes) {
773    for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
774      DICompileUnit CUNode(CU_Nodes->getOperand(i));
775      CompileUnit *CU = constructCompileUnit(CUNode);
776      DIArray GVs = CUNode.getGlobalVariables();
777      for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
778        CU->createGlobalVariableDIE(GVs.getElement(i));
779      DIArray SPs = CUNode.getSubprograms();
780      for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
781        constructSubprogramDIE(CU, SPs.getElement(i));
782      DIArray EnumTypes = CUNode.getEnumTypes();
783      for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
784        CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
785      DIArray RetainedTypes = CUNode.getRetainedTypes();
786      for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
787        CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
788    }
789  } else if (!collectLegacyDebugInfo(M))
790    return;
791
792  collectInfoFromNamedMDNodes(M);
793
794  // Tell MMI that we have debug info.
795  MMI->setDebugInfoAvailability(true);
796
797  // Prime section data.
798  SectionMap.insert(Asm->getObjFileLowering().getTextSection());
799}
800
801// Attach DW_AT_inline attribute with inlined subprogram DIEs.
802void DwarfDebug::computeInlinedDIEs() {
803  // Attach DW_AT_inline attribute with inlined subprogram DIEs.
804  for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
805         AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
806    DIE *ISP = *AI;
807    FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
808  }
809  for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
810         AE = AbstractSPDies.end(); AI != AE; ++AI) {
811    DIE *ISP = AI->second;
812    if (InlinedSubprogramDIEs.count(ISP))
813      continue;
814    FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
815  }
816}
817
818// Collect info for variables that were optimized out.
819void DwarfDebug::collectDeadVariables() {
820  const Module *M = MMI->getModule();
821  DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
822
823  if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
824    for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
825      DICompileUnit TheCU(CU_Nodes->getOperand(i));
826      DIArray Subprograms = TheCU.getSubprograms();
827      for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
828        DISubprogram SP(Subprograms.getElement(i));
829        if (ProcessedSPNodes.count(SP) != 0) continue;
830        if (!SP.Verify()) continue;
831        if (!SP.isDefinition()) continue;
832        DIArray Variables = SP.getVariables();
833        if (Variables.getNumElements() == 0) continue;
834
835        LexicalScope *Scope =
836          new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
837        DeadFnScopeMap[SP] = Scope;
838
839        // Construct subprogram DIE and add variables DIEs.
840        CompileUnit *SPCU = CUMap.lookup(TheCU);
841        assert(SPCU && "Unable to find Compile Unit!");
842        constructSubprogramDIE(SPCU, SP);
843        DIE *ScopeDIE = SPCU->getDIE(SP);
844        for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
845          DIVariable DV(Variables.getElement(vi));
846          if (!DV.Verify()) continue;
847          DbgVariable *NewVar = new DbgVariable(DV, NULL);
848          if (DIE *VariableDIE =
849              SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
850            ScopeDIE->addChild(VariableDIE);
851        }
852      }
853    }
854  }
855  DeleteContainerSeconds(DeadFnScopeMap);
856}
857
858void DwarfDebug::finalizeModuleInfo() {
859  // Collect info for variables that were optimized out.
860  collectDeadVariables();
861
862  // Attach DW_AT_inline attribute with inlined subprogram DIEs.
863  computeInlinedDIEs();
864
865  // Emit DW_AT_containing_type attribute to connect types with their
866  // vtable holding type.
867  for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
868         CUE = CUMap.end(); CUI != CUE; ++CUI) {
869    CompileUnit *TheCU = CUI->second;
870    TheCU->constructContainingTypeDIEs();
871  }
872
873   // Compute DIE offsets and sizes.
874  computeSizeAndOffsets();
875}
876
877void DwarfDebug::endSections() {
878  // Standard sections final addresses.
879  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
880  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
881  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
882  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
883
884  // End text sections.
885  for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
886    Asm->OutStreamer.SwitchSection(SectionMap[I]);
887    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
888  }
889}
890
891// Emit all Dwarf sections that should come after the content.
892void DwarfDebug::endModule() {
893
894  if (!FirstCU) return;
895
896  // End any existing sections.
897  // TODO: Does this need to happen?
898  endSections();
899
900  // Finalize the debug info for the module.
901  finalizeModuleInfo();
902
903  // Emit initial sections.
904  emitSectionLabels();
905
906  if (!useDwarfFission()) {
907    // Emit all the DIEs into a debug info section.
908    emitDebugInfo();
909
910    // Corresponding abbreviations into a abbrev section.
911    emitAbbreviations();
912
913    // Emit info into a debug loc section.
914    emitDebugLoc();
915
916    // Emit info into a debug aranges section.
917    emitDebugARanges();
918
919    // Emit info into a debug ranges section.
920    emitDebugRanges();
921
922    // Emit info into a debug macinfo section.
923    emitDebugMacInfo();
924
925    // Emit inline info.
926    // TODO: When we don't need the option anymore we
927    // can remove all of the code that this section
928    // depends upon.
929    if (useDarwinGDBCompat())
930      emitDebugInlineInfo();
931  } else {
932    // TODO: Fill this in for Fission sections and separate
933    // out information into new sections.
934
935    // Emit the debug info section and compile units.
936    emitDebugInfo();
937    emitDebugInfoDWO();
938
939    // Corresponding abbreviations into a abbrev section.
940    emitAbbreviations();
941
942    // Emit info into a debug loc section.
943    emitDebugLoc();
944
945    // Emit info into a debug aranges section.
946    emitDebugARanges();
947
948    // Emit info into a debug ranges section.
949    emitDebugRanges();
950
951    // Emit info into a debug macinfo section.
952    emitDebugMacInfo();
953
954    // Emit inline info.
955    // TODO: When we don't need the option anymore we
956    // can remove all of the code that this section
957    // depends upon.
958    if (useDarwinGDBCompat())
959      emitDebugInlineInfo();
960  }
961
962  // Emit info into the dwarf accelerator table sections.
963  if (useDwarfAccelTables()) {
964    emitAccelNames();
965    emitAccelObjC();
966    emitAccelNamespaces();
967    emitAccelTypes();
968  }
969
970  // Emit info into a debug pubtypes section.
971  // TODO: When we don't need the option anymore we can
972  // remove all of the code that adds to the table.
973  if (useDarwinGDBCompat())
974    emitDebugPubTypes();
975
976  // Finally emit string information into a string table.
977  emitDebugStr();
978
979  // clean up.
980  SPMap.clear();
981  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
982         E = CUMap.end(); I != E; ++I)
983    delete I->second;
984
985  delete FissionCU;
986
987  // Reset these for the next Module if we have one.
988  FirstCU = NULL;
989  FissionCU = NULL;
990}
991
992// Find abstract variable, if any, associated with Var.
993DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
994                                              DebugLoc ScopeLoc) {
995  LLVMContext &Ctx = DV->getContext();
996  // More then one inlined variable corresponds to one abstract variable.
997  DIVariable Var = cleanseInlinedVariable(DV, Ctx);
998  DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
999  if (AbsDbgVariable)
1000    return AbsDbgVariable;
1001
1002  LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1003  if (!Scope)
1004    return NULL;
1005
1006  AbsDbgVariable = new DbgVariable(Var, NULL);
1007  addScopeVariable(Scope, AbsDbgVariable);
1008  AbstractVariables[Var] = AbsDbgVariable;
1009  return AbsDbgVariable;
1010}
1011
1012// If Var is a current function argument then add it to CurrentFnArguments list.
1013bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1014                                      DbgVariable *Var, LexicalScope *Scope) {
1015  if (!LScopes.isCurrentFunctionScope(Scope))
1016    return false;
1017  DIVariable DV = Var->getVariable();
1018  if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1019    return false;
1020  unsigned ArgNo = DV.getArgNumber();
1021  if (ArgNo == 0)
1022    return false;
1023
1024  size_t Size = CurrentFnArguments.size();
1025  if (Size == 0)
1026    CurrentFnArguments.resize(MF->getFunction()->arg_size());
1027  // llvm::Function argument size is not good indicator of how many
1028  // arguments does the function have at source level.
1029  if (ArgNo > Size)
1030    CurrentFnArguments.resize(ArgNo * 2);
1031  CurrentFnArguments[ArgNo - 1] = Var;
1032  return true;
1033}
1034
1035// Collect variable information from side table maintained by MMI.
1036void
1037DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1038                                   SmallPtrSet<const MDNode *, 16> &Processed) {
1039  MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1040  for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1041         VE = VMap.end(); VI != VE; ++VI) {
1042    const MDNode *Var = VI->first;
1043    if (!Var) continue;
1044    Processed.insert(Var);
1045    DIVariable DV(Var);
1046    const std::pair<unsigned, DebugLoc> &VP = VI->second;
1047
1048    LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1049
1050    // If variable scope is not found then skip this variable.
1051    if (Scope == 0)
1052      continue;
1053
1054    DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1055    DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1056    RegVar->setFrameIndex(VP.first);
1057    if (!addCurrentFnArgument(MF, RegVar, Scope))
1058      addScopeVariable(Scope, RegVar);
1059    if (AbsDbgVariable)
1060      AbsDbgVariable->setFrameIndex(VP.first);
1061  }
1062}
1063
1064// Return true if debug value, encoded by DBG_VALUE instruction, is in a
1065// defined reg.
1066static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1067  assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1068  return MI->getNumOperands() == 3 &&
1069         MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1070         MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1071}
1072
1073// Get .debug_loc entry for the instruction range starting at MI.
1074static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1075                                         const MCSymbol *FLabel,
1076                                         const MCSymbol *SLabel,
1077                                         const MachineInstr *MI) {
1078  const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1079
1080  if (MI->getNumOperands() != 3) {
1081    MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1082    return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1083  }
1084  if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1085    MachineLocation MLoc;
1086    MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1087    return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1088  }
1089  if (MI->getOperand(0).isImm())
1090    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1091  if (MI->getOperand(0).isFPImm())
1092    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1093  if (MI->getOperand(0).isCImm())
1094    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1095
1096  llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1097}
1098
1099// Find variables for each lexical scope.
1100void
1101DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1102                                SmallPtrSet<const MDNode *, 16> &Processed) {
1103
1104  // collection info from MMI table.
1105  collectVariableInfoFromMMITable(MF, Processed);
1106
1107  for (SmallVectorImpl<const MDNode*>::const_iterator
1108         UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1109         ++UVI) {
1110    const MDNode *Var = *UVI;
1111    if (Processed.count(Var))
1112      continue;
1113
1114    // History contains relevant DBG_VALUE instructions for Var and instructions
1115    // clobbering it.
1116    SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1117    if (History.empty())
1118      continue;
1119    const MachineInstr *MInsn = History.front();
1120
1121    DIVariable DV(Var);
1122    LexicalScope *Scope = NULL;
1123    if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1124        DISubprogram(DV.getContext()).describes(MF->getFunction()))
1125      Scope = LScopes.getCurrentFunctionScope();
1126    else {
1127      if (DV.getVersion() <= LLVMDebugVersion9)
1128        Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1129      else {
1130        if (MDNode *IA = DV.getInlinedAt())
1131          Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1132        else
1133          Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1134      }
1135    }
1136    // If variable scope is not found then skip this variable.
1137    if (!Scope)
1138      continue;
1139
1140    Processed.insert(DV);
1141    assert(MInsn->isDebugValue() && "History must begin with debug value");
1142    DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1143    DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1144    if (!addCurrentFnArgument(MF, RegVar, Scope))
1145      addScopeVariable(Scope, RegVar);
1146    if (AbsVar)
1147      AbsVar->setMInsn(MInsn);
1148
1149    // Simplify ranges that are fully coalesced.
1150    if (History.size() <= 1 || (History.size() == 2 &&
1151                                MInsn->isIdenticalTo(History.back()))) {
1152      RegVar->setMInsn(MInsn);
1153      continue;
1154    }
1155
1156    // handle multiple DBG_VALUE instructions describing one variable.
1157    RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1158
1159    for (SmallVectorImpl<const MachineInstr*>::const_iterator
1160           HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1161      const MachineInstr *Begin = *HI;
1162      assert(Begin->isDebugValue() && "Invalid History entry");
1163
1164      // Check if DBG_VALUE is truncating a range.
1165      if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1166          && !Begin->getOperand(0).getReg())
1167        continue;
1168
1169      // Compute the range for a register location.
1170      const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1171      const MCSymbol *SLabel = 0;
1172
1173      if (HI + 1 == HE)
1174        // If Begin is the last instruction in History then its value is valid
1175        // until the end of the function.
1176        SLabel = FunctionEndSym;
1177      else {
1178        const MachineInstr *End = HI[1];
1179        DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1180              << "\t" << *Begin << "\t" << *End << "\n");
1181        if (End->isDebugValue())
1182          SLabel = getLabelBeforeInsn(End);
1183        else {
1184          // End is a normal instruction clobbering the range.
1185          SLabel = getLabelAfterInsn(End);
1186          assert(SLabel && "Forgot label after clobber instruction");
1187          ++HI;
1188        }
1189      }
1190
1191      // The value is valid until the next DBG_VALUE or clobber.
1192      DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1193                                                    Begin));
1194    }
1195    DotDebugLocEntries.push_back(DotDebugLocEntry());
1196  }
1197
1198  // Collect info for variables that were optimized out.
1199  LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1200  DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1201  for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1202    DIVariable DV(Variables.getElement(i));
1203    if (!DV || !DV.Verify() || !Processed.insert(DV))
1204      continue;
1205    if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1206      addScopeVariable(Scope, new DbgVariable(DV, NULL));
1207  }
1208}
1209
1210// Return Label preceding the instruction.
1211const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1212  MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1213  assert(Label && "Didn't insert label before instruction");
1214  return Label;
1215}
1216
1217// Return Label immediately following the instruction.
1218const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1219  return LabelsAfterInsn.lookup(MI);
1220}
1221
1222// Process beginning of an instruction.
1223void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1224  // Check if source location changes, but ignore DBG_VALUE locations.
1225  if (!MI->isDebugValue()) {
1226    DebugLoc DL = MI->getDebugLoc();
1227    if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1228      unsigned Flags = 0;
1229      PrevInstLoc = DL;
1230      if (DL == PrologEndLoc) {
1231        Flags |= DWARF2_FLAG_PROLOGUE_END;
1232        PrologEndLoc = DebugLoc();
1233      }
1234      if (PrologEndLoc.isUnknown())
1235        Flags |= DWARF2_FLAG_IS_STMT;
1236
1237      if (!DL.isUnknown()) {
1238        const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1239        recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1240      } else
1241        recordSourceLine(0, 0, 0, 0);
1242    }
1243  }
1244
1245  // Insert labels where requested.
1246  DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1247    LabelsBeforeInsn.find(MI);
1248
1249  // No label needed.
1250  if (I == LabelsBeforeInsn.end())
1251    return;
1252
1253  // Label already assigned.
1254  if (I->second)
1255    return;
1256
1257  if (!PrevLabel) {
1258    PrevLabel = MMI->getContext().CreateTempSymbol();
1259    Asm->OutStreamer.EmitLabel(PrevLabel);
1260  }
1261  I->second = PrevLabel;
1262}
1263
1264// Process end of an instruction.
1265void DwarfDebug::endInstruction(const MachineInstr *MI) {
1266  // Don't create a new label after DBG_VALUE instructions.
1267  // They don't generate code.
1268  if (!MI->isDebugValue())
1269    PrevLabel = 0;
1270
1271  DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1272    LabelsAfterInsn.find(MI);
1273
1274  // No label needed.
1275  if (I == LabelsAfterInsn.end())
1276    return;
1277
1278  // Label already assigned.
1279  if (I->second)
1280    return;
1281
1282  // We need a label after this instruction.
1283  if (!PrevLabel) {
1284    PrevLabel = MMI->getContext().CreateTempSymbol();
1285    Asm->OutStreamer.EmitLabel(PrevLabel);
1286  }
1287  I->second = PrevLabel;
1288}
1289
1290// Each LexicalScope has first instruction and last instruction to mark
1291// beginning and end of a scope respectively. Create an inverse map that list
1292// scopes starts (and ends) with an instruction. One instruction may start (or
1293// end) multiple scopes. Ignore scopes that are not reachable.
1294void DwarfDebug::identifyScopeMarkers() {
1295  SmallVector<LexicalScope *, 4> WorkList;
1296  WorkList.push_back(LScopes.getCurrentFunctionScope());
1297  while (!WorkList.empty()) {
1298    LexicalScope *S = WorkList.pop_back_val();
1299
1300    const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1301    if (!Children.empty())
1302      for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1303             SE = Children.end(); SI != SE; ++SI)
1304        WorkList.push_back(*SI);
1305
1306    if (S->isAbstractScope())
1307      continue;
1308
1309    const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1310    if (Ranges.empty())
1311      continue;
1312    for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1313           RE = Ranges.end(); RI != RE; ++RI) {
1314      assert(RI->first && "InsnRange does not have first instruction!");
1315      assert(RI->second && "InsnRange does not have second instruction!");
1316      requestLabelBeforeInsn(RI->first);
1317      requestLabelAfterInsn(RI->second);
1318    }
1319  }
1320}
1321
1322// Get MDNode for DebugLoc's scope.
1323static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1324  if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1325    return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1326  return DL.getScope(Ctx);
1327}
1328
1329// Walk up the scope chain of given debug loc and find line number info
1330// for the function.
1331static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1332  const MDNode *Scope = getScopeNode(DL, Ctx);
1333  DISubprogram SP = getDISubprogram(Scope);
1334  if (SP.Verify()) {
1335    // Check for number of operands since the compatibility is
1336    // cheap here.
1337    if (SP->getNumOperands() > 19)
1338      return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1339    else
1340      return DebugLoc::get(SP.getLineNumber(), 0, SP);
1341  }
1342
1343  return DebugLoc();
1344}
1345
1346// Gather pre-function debug information.  Assumes being called immediately
1347// after the function entry point has been emitted.
1348void DwarfDebug::beginFunction(const MachineFunction *MF) {
1349  if (!MMI->hasDebugInfo()) return;
1350  LScopes.initialize(*MF);
1351  if (LScopes.empty()) return;
1352  identifyScopeMarkers();
1353
1354  FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1355                                        Asm->getFunctionNumber());
1356  // Assumes in correct section after the entry point.
1357  Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1358
1359  assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1360
1361  const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1362  // LiveUserVar - Map physreg numbers to the MDNode they contain.
1363  std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1364
1365  for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1366       I != E; ++I) {
1367    bool AtBlockEntry = true;
1368    for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1369         II != IE; ++II) {
1370      const MachineInstr *MI = II;
1371
1372      if (MI->isDebugValue()) {
1373        assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1374
1375        // Keep track of user variables.
1376        const MDNode *Var =
1377          MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1378
1379        // Variable is in a register, we need to check for clobbers.
1380        if (isDbgValueInDefinedReg(MI))
1381          LiveUserVar[MI->getOperand(0).getReg()] = Var;
1382
1383        // Check the history of this variable.
1384        SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1385        if (History.empty()) {
1386          UserVariables.push_back(Var);
1387          // The first mention of a function argument gets the FunctionBeginSym
1388          // label, so arguments are visible when breaking at function entry.
1389          DIVariable DV(Var);
1390          if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1391              DISubprogram(getDISubprogram(DV.getContext()))
1392                .describes(MF->getFunction()))
1393            LabelsBeforeInsn[MI] = FunctionBeginSym;
1394        } else {
1395          // We have seen this variable before. Try to coalesce DBG_VALUEs.
1396          const MachineInstr *Prev = History.back();
1397          if (Prev->isDebugValue()) {
1398            // Coalesce identical entries at the end of History.
1399            if (History.size() >= 2 &&
1400                Prev->isIdenticalTo(History[History.size() - 2])) {
1401              DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1402                    << "\t" << *Prev
1403                    << "\t" << *History[History.size() - 2] << "\n");
1404              History.pop_back();
1405            }
1406
1407            // Terminate old register assignments that don't reach MI;
1408            MachineFunction::const_iterator PrevMBB = Prev->getParent();
1409            if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1410                isDbgValueInDefinedReg(Prev)) {
1411              // Previous register assignment needs to terminate at the end of
1412              // its basic block.
1413              MachineBasicBlock::const_iterator LastMI =
1414                PrevMBB->getLastNonDebugInstr();
1415              if (LastMI == PrevMBB->end()) {
1416                // Drop DBG_VALUE for empty range.
1417                DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1418                      << "\t" << *Prev << "\n");
1419                History.pop_back();
1420              }
1421              else {
1422                // Terminate after LastMI.
1423                History.push_back(LastMI);
1424              }
1425            }
1426          }
1427        }
1428        History.push_back(MI);
1429      } else {
1430        // Not a DBG_VALUE instruction.
1431        if (!MI->isLabel())
1432          AtBlockEntry = false;
1433
1434        // First known non-DBG_VALUE and non-frame setup location marks
1435        // the beginning of the function body.
1436        if (!MI->getFlag(MachineInstr::FrameSetup) &&
1437            (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1438          PrologEndLoc = MI->getDebugLoc();
1439
1440        // Check if the instruction clobbers any registers with debug vars.
1441        for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1442               MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1443          if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1444            continue;
1445          for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1446               AI.isValid(); ++AI) {
1447            unsigned Reg = *AI;
1448            const MDNode *Var = LiveUserVar[Reg];
1449            if (!Var)
1450              continue;
1451            // Reg is now clobbered.
1452            LiveUserVar[Reg] = 0;
1453
1454            // Was MD last defined by a DBG_VALUE referring to Reg?
1455            DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1456            if (HistI == DbgValues.end())
1457              continue;
1458            SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1459            if (History.empty())
1460              continue;
1461            const MachineInstr *Prev = History.back();
1462            // Sanity-check: Register assignments are terminated at the end of
1463            // their block.
1464            if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1465              continue;
1466            // Is the variable still in Reg?
1467            if (!isDbgValueInDefinedReg(Prev) ||
1468                Prev->getOperand(0).getReg() != Reg)
1469              continue;
1470            // Var is clobbered. Make sure the next instruction gets a label.
1471            History.push_back(MI);
1472          }
1473        }
1474      }
1475    }
1476  }
1477
1478  for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1479       I != E; ++I) {
1480    SmallVectorImpl<const MachineInstr*> &History = I->second;
1481    if (History.empty())
1482      continue;
1483
1484    // Make sure the final register assignments are terminated.
1485    const MachineInstr *Prev = History.back();
1486    if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1487      const MachineBasicBlock *PrevMBB = Prev->getParent();
1488      MachineBasicBlock::const_iterator LastMI =
1489        PrevMBB->getLastNonDebugInstr();
1490      if (LastMI == PrevMBB->end())
1491        // Drop DBG_VALUE for empty range.
1492        History.pop_back();
1493      else {
1494        // Terminate after LastMI.
1495        History.push_back(LastMI);
1496      }
1497    }
1498    // Request labels for the full history.
1499    for (unsigned i = 0, e = History.size(); i != e; ++i) {
1500      const MachineInstr *MI = History[i];
1501      if (MI->isDebugValue())
1502        requestLabelBeforeInsn(MI);
1503      else
1504        requestLabelAfterInsn(MI);
1505    }
1506  }
1507
1508  PrevInstLoc = DebugLoc();
1509  PrevLabel = FunctionBeginSym;
1510
1511  // Record beginning of function.
1512  if (!PrologEndLoc.isUnknown()) {
1513    DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1514                                       MF->getFunction()->getContext());
1515    recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1516                     FnStartDL.getScope(MF->getFunction()->getContext()),
1517    // We'd like to list the prologue as "not statements" but GDB behaves
1518    // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1519                     DWARF2_FLAG_IS_STMT);
1520  }
1521}
1522
1523void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1524//  SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1525  ScopeVariables[LS].push_back(Var);
1526//  Vars.push_back(Var);
1527}
1528
1529// Gather and emit post-function debug information.
1530void DwarfDebug::endFunction(const MachineFunction *MF) {
1531  if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1532
1533  // Define end label for subprogram.
1534  FunctionEndSym = Asm->GetTempSymbol("func_end",
1535                                      Asm->getFunctionNumber());
1536  // Assumes in correct section after the entry point.
1537  Asm->OutStreamer.EmitLabel(FunctionEndSym);
1538
1539  SmallPtrSet<const MDNode *, 16> ProcessedVars;
1540  collectVariableInfo(MF, ProcessedVars);
1541
1542  LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1543  CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1544  assert(TheCU && "Unable to find compile unit!");
1545
1546  // Construct abstract scopes.
1547  ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1548  for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1549    LexicalScope *AScope = AList[i];
1550    DISubprogram SP(AScope->getScopeNode());
1551    if (SP.Verify()) {
1552      // Collect info for variables that were optimized out.
1553      DIArray Variables = SP.getVariables();
1554      for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1555        DIVariable DV(Variables.getElement(i));
1556        if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1557          continue;
1558        // Check that DbgVariable for DV wasn't created earlier, when
1559        // findAbstractVariable() was called for inlined instance of DV.
1560        LLVMContext &Ctx = DV->getContext();
1561        DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1562        if (AbstractVariables.lookup(CleanDV))
1563          continue;
1564        if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1565          addScopeVariable(Scope, new DbgVariable(DV, NULL));
1566      }
1567    }
1568    if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1569      constructScopeDIE(TheCU, AScope);
1570  }
1571
1572  DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1573
1574  if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1575    TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1576
1577  DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1578                                               MMI->getFrameMoves()));
1579
1580  // Clear debug info
1581  for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1582         I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1583    DeleteContainerPointers(I->second);
1584  ScopeVariables.clear();
1585  DeleteContainerPointers(CurrentFnArguments);
1586  UserVariables.clear();
1587  DbgValues.clear();
1588  AbstractVariables.clear();
1589  LabelsBeforeInsn.clear();
1590  LabelsAfterInsn.clear();
1591  PrevLabel = NULL;
1592}
1593
1594// Register a source line with debug info. Returns the  unique label that was
1595// emitted and which provides correspondence to the source line list.
1596void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1597                                  unsigned Flags) {
1598  StringRef Fn;
1599  StringRef Dir;
1600  unsigned Src = 1;
1601  if (S) {
1602    DIDescriptor Scope(S);
1603
1604    if (Scope.isCompileUnit()) {
1605      DICompileUnit CU(S);
1606      Fn = CU.getFilename();
1607      Dir = CU.getDirectory();
1608    } else if (Scope.isFile()) {
1609      DIFile F(S);
1610      Fn = F.getFilename();
1611      Dir = F.getDirectory();
1612    } else if (Scope.isSubprogram()) {
1613      DISubprogram SP(S);
1614      Fn = SP.getFilename();
1615      Dir = SP.getDirectory();
1616    } else if (Scope.isLexicalBlockFile()) {
1617      DILexicalBlockFile DBF(S);
1618      Fn = DBF.getFilename();
1619      Dir = DBF.getDirectory();
1620    } else if (Scope.isLexicalBlock()) {
1621      DILexicalBlock DB(S);
1622      Fn = DB.getFilename();
1623      Dir = DB.getDirectory();
1624    } else
1625      llvm_unreachable("Unexpected scope info");
1626
1627    Src = getOrCreateSourceID(Fn, Dir);
1628  }
1629  Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1630}
1631
1632//===----------------------------------------------------------------------===//
1633// Emit Methods
1634//===----------------------------------------------------------------------===//
1635
1636// Compute the size and offset of a DIE.
1637unsigned
1638DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1639  // Get the children.
1640  const std::vector<DIE *> &Children = Die->getChildren();
1641
1642  // Record the abbreviation.
1643  assignAbbrevNumber(Die->getAbbrev());
1644
1645  // Get the abbreviation for this DIE.
1646  unsigned AbbrevNumber = Die->getAbbrevNumber();
1647  const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1648
1649  // Set DIE offset
1650  Die->setOffset(Offset);
1651
1652  // Start the size with the size of abbreviation code.
1653  Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1654
1655  const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1656  const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1657
1658  // Size the DIE attribute values.
1659  for (unsigned i = 0, N = Values.size(); i < N; ++i)
1660    // Size attribute value.
1661    Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1662
1663  // Size the DIE children if any.
1664  if (!Children.empty()) {
1665    assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1666           "Children flag not set");
1667
1668    for (unsigned j = 0, M = Children.size(); j < M; ++j)
1669      Offset = computeSizeAndOffset(Children[j], Offset);
1670
1671    // End of children marker.
1672    Offset += sizeof(int8_t);
1673  }
1674
1675  Die->setSize(Offset - Die->getOffset());
1676  return Offset;
1677}
1678
1679// Compute the size and offset of all the DIEs.
1680void DwarfDebug::computeSizeAndOffsets() {
1681  if (FissionCU) {
1682    unsigned Offset =
1683      sizeof(int32_t) + // Length of Compilation Unit Info
1684      sizeof(int16_t) + // DWARF version number
1685      sizeof(int32_t) + // Offset Into Abbrev. Section
1686      sizeof(int8_t);   // Pointer Size (in bytes)
1687
1688    computeSizeAndOffset(FissionCU->getCUDie(), Offset);
1689  }
1690  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1691         E = CUMap.end(); I != E; ++I) {
1692    // Compute size of compile unit header.
1693    unsigned Offset =
1694      sizeof(int32_t) + // Length of Compilation Unit Info
1695      sizeof(int16_t) + // DWARF version number
1696      sizeof(int32_t) + // Offset Into Abbrev. Section
1697      sizeof(int8_t);   // Pointer Size (in bytes)
1698    computeSizeAndOffset(I->second->getCUDie(), Offset);
1699  }
1700}
1701
1702// Emit initial Dwarf sections with a label at the start of each one.
1703void DwarfDebug::emitSectionLabels() {
1704  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1705
1706  // Dwarf sections base addresses.
1707  DwarfInfoSectionSym =
1708    emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1709  DwarfAbbrevSectionSym =
1710    emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1711  emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1712
1713  if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1714    emitSectionSym(Asm, MacroInfo);
1715
1716  emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1717  emitSectionSym(Asm, TLOF.getDwarfLocSection());
1718  emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1719  DwarfStrSectionSym =
1720    emitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1721  DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1722                                             "debug_range");
1723
1724  DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1725                                           "section_debug_loc");
1726
1727  TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1728  emitSectionSym(Asm, TLOF.getDataSection());
1729}
1730
1731// Recursively emits a debug information entry.
1732void DwarfDebug::emitDIE(DIE *Die) {
1733  // Get the abbreviation for this DIE.
1734  unsigned AbbrevNumber = Die->getAbbrevNumber();
1735  const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1736
1737  // Emit the code (index) for the abbreviation.
1738  if (Asm->isVerbose())
1739    Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1740                                Twine::utohexstr(Die->getOffset()) + ":0x" +
1741                                Twine::utohexstr(Die->getSize()) + " " +
1742                                dwarf::TagString(Abbrev->getTag()));
1743  Asm->EmitULEB128(AbbrevNumber);
1744
1745  const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1746  const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1747
1748  // Emit the DIE attribute values.
1749  for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1750    unsigned Attr = AbbrevData[i].getAttribute();
1751    unsigned Form = AbbrevData[i].getForm();
1752    assert(Form && "Too many attributes for DIE (check abbreviation)");
1753
1754    if (Asm->isVerbose())
1755      Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1756
1757    switch (Attr) {
1758    case dwarf::DW_AT_abstract_origin: {
1759      DIEEntry *E = cast<DIEEntry>(Values[i]);
1760      DIE *Origin = E->getEntry();
1761      unsigned Addr = Origin->getOffset();
1762      Asm->EmitInt32(Addr);
1763      break;
1764    }
1765    case dwarf::DW_AT_ranges: {
1766      // DW_AT_range Value encodes offset in debug_range section.
1767      DIEInteger *V = cast<DIEInteger>(Values[i]);
1768
1769      if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1770        Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1771                                 V->getValue(),
1772                                 4);
1773      } else {
1774        Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1775                                       V->getValue(),
1776                                       DwarfDebugRangeSectionSym,
1777                                       4);
1778      }
1779      break;
1780    }
1781    case dwarf::DW_AT_location: {
1782      if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1783        if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1784          Asm->EmitLabelReference(L->getValue(), 4);
1785        else
1786          Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1787      } else {
1788        Values[i]->EmitValue(Asm, Form);
1789      }
1790      break;
1791    }
1792    case dwarf::DW_AT_accessibility: {
1793      if (Asm->isVerbose()) {
1794        DIEInteger *V = cast<DIEInteger>(Values[i]);
1795        Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1796      }
1797      Values[i]->EmitValue(Asm, Form);
1798      break;
1799    }
1800    default:
1801      // Emit an attribute using the defined form.
1802      Values[i]->EmitValue(Asm, Form);
1803      break;
1804    }
1805  }
1806
1807  // Emit the DIE children if any.
1808  if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1809    const std::vector<DIE *> &Children = Die->getChildren();
1810
1811    for (unsigned j = 0, M = Children.size(); j < M; ++j)
1812      emitDIE(Children[j]);
1813
1814    if (Asm->isVerbose())
1815      Asm->OutStreamer.AddComment("End Of Children Mark");
1816    Asm->EmitInt8(0);
1817  }
1818}
1819
1820void DwarfDebug::emitCompileUnits(const MCSection *Section) {
1821  Asm->OutStreamer.SwitchSection(Section);
1822  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1823         E = CUMap.end(); I != E; ++I) {
1824    CompileUnit *TheCU = I->second;
1825    DIE *Die = TheCU->getCUDie();
1826
1827    // Emit the compile units header.
1828    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1829                                                  TheCU->getUniqueID()));
1830
1831    // Emit size of content not including length itself
1832    unsigned ContentSize = Die->getSize() +
1833      sizeof(int16_t) + // DWARF version number
1834      sizeof(int32_t) + // Offset Into Abbrev. Section
1835      sizeof(int8_t);   // Pointer Size (in bytes)
1836
1837    Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1838    Asm->EmitInt32(ContentSize);
1839    Asm->OutStreamer.AddComment("DWARF version number");
1840    Asm->EmitInt16(dwarf::DWARF_VERSION);
1841    Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1842    Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1843                           DwarfAbbrevSectionSym);
1844    Asm->OutStreamer.AddComment("Address Size (in bytes)");
1845    Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1846
1847    emitDIE(Die);
1848    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end",
1849                                                  TheCU->getUniqueID()));
1850  }
1851}
1852
1853// Emit the debug info section.
1854void DwarfDebug::emitDebugInfo() {
1855  if (!useDwarfFission())
1856    emitCompileUnits(Asm->getObjFileLowering().getDwarfInfoSection());
1857  else
1858    emitFissionSkeletonCU(Asm->getObjFileLowering().getDwarfInfoSection());
1859}
1860
1861// Emit the abbreviation section.
1862void DwarfDebug::emitAbbreviations() {
1863  // Check to see if it is worth the effort.
1864  if (!Abbreviations.empty()) {
1865    // Start the debug abbrev section.
1866    Asm->OutStreamer.SwitchSection(
1867                            Asm->getObjFileLowering().getDwarfAbbrevSection());
1868
1869    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1870
1871    // For each abbrevation.
1872    for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1873      // Get abbreviation data
1874      const DIEAbbrev *Abbrev = Abbreviations[i];
1875
1876      // Emit the abbrevations code (base 1 index.)
1877      Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1878
1879      // Emit the abbreviations data.
1880      Abbrev->Emit(Asm);
1881    }
1882
1883    // Mark end of abbreviations.
1884    Asm->EmitULEB128(0, "EOM(3)");
1885
1886    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1887  }
1888}
1889
1890// Emit the last address of the section and the end of the line matrix.
1891void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1892  // Define last address of section.
1893  Asm->OutStreamer.AddComment("Extended Op");
1894  Asm->EmitInt8(0);
1895
1896  Asm->OutStreamer.AddComment("Op size");
1897  Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1898  Asm->OutStreamer.AddComment("DW_LNE_set_address");
1899  Asm->EmitInt8(dwarf::DW_LNE_set_address);
1900
1901  Asm->OutStreamer.AddComment("Section end label");
1902
1903  Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1904                                   Asm->getDataLayout().getPointerSize(),
1905                                   0/*AddrSpace*/);
1906
1907  // Mark end of matrix.
1908  Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1909  Asm->EmitInt8(0);
1910  Asm->EmitInt8(1);
1911  Asm->EmitInt8(1);
1912}
1913
1914// Emit visible names into a hashed accelerator table section.
1915void DwarfDebug::emitAccelNames() {
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->getAccelNames();
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, "Names");
1933  Asm->OutStreamer.SwitchSection(
1934    Asm->getObjFileLowering().getDwarfAccelNamesSection());
1935  MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1936  Asm->OutStreamer.EmitLabel(SectionBegin);
1937
1938  // Emit the full data.
1939  AT.Emit(Asm, SectionBegin, this);
1940}
1941
1942// Emit objective C classes and categories into a hashed accelerator table section.
1943void DwarfDebug::emitAccelObjC() {
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->getAccelObjC();
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, "ObjC");
1961  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1962                                 .getDwarfAccelObjCSection());
1963  MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1964  Asm->OutStreamer.EmitLabel(SectionBegin);
1965
1966  // Emit the full data.
1967  AT.Emit(Asm, SectionBegin, this);
1968}
1969
1970// Emit namespace dies into a hashed accelerator table.
1971void DwarfDebug::emitAccelNamespaces() {
1972  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1973                                           dwarf::DW_FORM_data4));
1974  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1975         E = CUMap.end(); I != E; ++I) {
1976    CompileUnit *TheCU = I->second;
1977    const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1978    for (StringMap<std::vector<DIE*> >::const_iterator
1979           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1980      const char *Name = GI->getKeyData();
1981      const std::vector<DIE *> &Entities = GI->second;
1982      for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1983             DE = Entities.end(); DI != DE; ++DI)
1984        AT.AddName(Name, (*DI));
1985    }
1986  }
1987
1988  AT.FinalizeTable(Asm, "namespac");
1989  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1990                                 .getDwarfAccelNamespaceSection());
1991  MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1992  Asm->OutStreamer.EmitLabel(SectionBegin);
1993
1994  // Emit the full data.
1995  AT.Emit(Asm, SectionBegin, this);
1996}
1997
1998// Emit type dies into a hashed accelerator table.
1999void DwarfDebug::emitAccelTypes() {
2000  std::vector<DwarfAccelTable::Atom> Atoms;
2001  Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2002                                        dwarf::DW_FORM_data4));
2003  Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2004                                        dwarf::DW_FORM_data2));
2005  Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2006                                        dwarf::DW_FORM_data1));
2007  DwarfAccelTable AT(Atoms);
2008  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2009         E = CUMap.end(); I != E; ++I) {
2010    CompileUnit *TheCU = I->second;
2011    const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2012      = TheCU->getAccelTypes();
2013    for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2014           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2015      const char *Name = GI->getKeyData();
2016      const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2017      for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2018             = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2019        AT.AddName(Name, (*DI).first, (*DI).second);
2020    }
2021  }
2022
2023  AT.FinalizeTable(Asm, "types");
2024  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2025                                 .getDwarfAccelTypesSection());
2026  MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2027  Asm->OutStreamer.EmitLabel(SectionBegin);
2028
2029  // Emit the full data.
2030  AT.Emit(Asm, SectionBegin, this);
2031}
2032
2033void DwarfDebug::emitDebugPubTypes() {
2034  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2035         E = CUMap.end(); I != E; ++I) {
2036    CompileUnit *TheCU = I->second;
2037    // Start the dwarf pubtypes section.
2038    Asm->OutStreamer.SwitchSection(
2039      Asm->getObjFileLowering().getDwarfPubTypesSection());
2040    Asm->OutStreamer.AddComment("Length of Public Types Info");
2041    Asm->EmitLabelDifference(
2042      Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2043      Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2044
2045    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2046                                                  TheCU->getUniqueID()));
2047
2048    if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2049    Asm->EmitInt16(dwarf::DWARF_VERSION);
2050
2051    Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2052    Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin",
2053                                              TheCU->getUniqueID()),
2054                           DwarfInfoSectionSym);
2055
2056    Asm->OutStreamer.AddComment("Compilation Unit Length");
2057    Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end",
2058                                                TheCU->getUniqueID()),
2059                             Asm->GetTempSymbol("info_begin",
2060                                                TheCU->getUniqueID()),
2061                             4);
2062
2063    const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2064    for (StringMap<DIE*>::const_iterator
2065           GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2066      const char *Name = GI->getKeyData();
2067      DIE *Entity = GI->second;
2068
2069      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2070      Asm->EmitInt32(Entity->getOffset());
2071
2072      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2073      // Emit the name with a terminating null byte.
2074      Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2075    }
2076
2077    Asm->OutStreamer.AddComment("End Mark");
2078    Asm->EmitInt32(0);
2079    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2080                                                  TheCU->getUniqueID()));
2081  }
2082}
2083
2084// Emit visible names into a debug str section.
2085void DwarfDebug::emitDebugStr() {
2086  // Check to see if it is worth the effort.
2087  if (StringPool.empty()) return;
2088
2089  // Start the dwarf str section.
2090  Asm->OutStreamer.SwitchSection(
2091                                Asm->getObjFileLowering().getDwarfStrSection());
2092
2093  // Get all of the string pool entries and put them in an array by their ID so
2094  // we can sort them.
2095  SmallVector<std::pair<unsigned,
2096      StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2097
2098  for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2099       I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2100    Entries.push_back(std::make_pair(I->second.second, &*I));
2101
2102  array_pod_sort(Entries.begin(), Entries.end());
2103
2104  for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2105    // Emit a label for reference from debug information entries.
2106    Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2107
2108    // Emit the string itself with a terminating null byte.
2109    Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2110                                         Entries[i].second->getKeyLength()+1),
2111                               0/*addrspace*/);
2112  }
2113}
2114
2115// Emit visible names into a debug loc section.
2116void DwarfDebug::emitDebugLoc() {
2117  if (DotDebugLocEntries.empty())
2118    return;
2119
2120  for (SmallVector<DotDebugLocEntry, 4>::iterator
2121         I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2122       I != E; ++I) {
2123    DotDebugLocEntry &Entry = *I;
2124    if (I + 1 != DotDebugLocEntries.end())
2125      Entry.Merge(I+1);
2126  }
2127
2128  // Start the dwarf loc section.
2129  Asm->OutStreamer.SwitchSection(
2130    Asm->getObjFileLowering().getDwarfLocSection());
2131  unsigned char Size = Asm->getDataLayout().getPointerSize();
2132  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2133  unsigned index = 1;
2134  for (SmallVector<DotDebugLocEntry, 4>::iterator
2135         I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2136       I != E; ++I, ++index) {
2137    DotDebugLocEntry &Entry = *I;
2138    if (Entry.isMerged()) continue;
2139    if (Entry.isEmpty()) {
2140      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2141      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2142      Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2143    } else {
2144      Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2145      Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2146      DIVariable DV(Entry.Variable);
2147      Asm->OutStreamer.AddComment("Loc expr size");
2148      MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2149      MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2150      Asm->EmitLabelDifference(end, begin, 2);
2151      Asm->OutStreamer.EmitLabel(begin);
2152      if (Entry.isInt()) {
2153        DIBasicType BTy(DV.getType());
2154        if (BTy.Verify() &&
2155            (BTy.getEncoding()  == dwarf::DW_ATE_signed
2156             || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2157          Asm->OutStreamer.AddComment("DW_OP_consts");
2158          Asm->EmitInt8(dwarf::DW_OP_consts);
2159          Asm->EmitSLEB128(Entry.getInt());
2160        } else {
2161          Asm->OutStreamer.AddComment("DW_OP_constu");
2162          Asm->EmitInt8(dwarf::DW_OP_constu);
2163          Asm->EmitULEB128(Entry.getInt());
2164        }
2165      } else if (Entry.isLocation()) {
2166        if (!DV.hasComplexAddress())
2167          // Regular entry.
2168          Asm->EmitDwarfRegOp(Entry.Loc);
2169        else {
2170          // Complex address entry.
2171          unsigned N = DV.getNumAddrElements();
2172          unsigned i = 0;
2173          if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2174            if (Entry.Loc.getOffset()) {
2175              i = 2;
2176              Asm->EmitDwarfRegOp(Entry.Loc);
2177              Asm->OutStreamer.AddComment("DW_OP_deref");
2178              Asm->EmitInt8(dwarf::DW_OP_deref);
2179              Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2180              Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2181              Asm->EmitSLEB128(DV.getAddrElement(1));
2182            } else {
2183              // If first address element is OpPlus then emit
2184              // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2185              MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2186              Asm->EmitDwarfRegOp(Loc);
2187              i = 2;
2188            }
2189          } else {
2190            Asm->EmitDwarfRegOp(Entry.Loc);
2191          }
2192
2193          // Emit remaining complex address elements.
2194          for (; i < N; ++i) {
2195            uint64_t Element = DV.getAddrElement(i);
2196            if (Element == DIBuilder::OpPlus) {
2197              Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2198              Asm->EmitULEB128(DV.getAddrElement(++i));
2199            } else if (Element == DIBuilder::OpDeref) {
2200              if (!Entry.Loc.isReg())
2201                Asm->EmitInt8(dwarf::DW_OP_deref);
2202            } else
2203              llvm_unreachable("unknown Opcode found in complex address");
2204          }
2205        }
2206      }
2207      // else ... ignore constant fp. There is not any good way to
2208      // to represent them here in dwarf.
2209      Asm->OutStreamer.EmitLabel(end);
2210    }
2211  }
2212}
2213
2214// Emit visible names into a debug aranges section.
2215void DwarfDebug::emitDebugARanges() {
2216  // Start the dwarf aranges section.
2217  Asm->OutStreamer.SwitchSection(
2218                          Asm->getObjFileLowering().getDwarfARangesSection());
2219}
2220
2221// Emit visible names into a debug ranges section.
2222void DwarfDebug::emitDebugRanges() {
2223  // Start the dwarf ranges section.
2224  Asm->OutStreamer.SwitchSection(
2225    Asm->getObjFileLowering().getDwarfRangesSection());
2226  unsigned char Size = Asm->getDataLayout().getPointerSize();
2227  for (SmallVector<const MCSymbol *, 8>::iterator
2228         I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2229       I != E; ++I) {
2230    if (*I)
2231      Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2232    else
2233      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2234  }
2235}
2236
2237// Emit visible names into a debug macinfo section.
2238void DwarfDebug::emitDebugMacInfo() {
2239  if (const MCSection *LineInfo =
2240      Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2241    // Start the dwarf macinfo section.
2242    Asm->OutStreamer.SwitchSection(LineInfo);
2243  }
2244}
2245
2246// Emit inline info using following format.
2247// Section Header:
2248// 1. length of section
2249// 2. Dwarf version number
2250// 3. address size.
2251//
2252// Entries (one "entry" for each function that was inlined):
2253//
2254// 1. offset into __debug_str section for MIPS linkage name, if exists;
2255//   otherwise offset into __debug_str for regular function name.
2256// 2. offset into __debug_str section for regular function name.
2257// 3. an unsigned LEB128 number indicating the number of distinct inlining
2258// instances for the function.
2259//
2260// The rest of the entry consists of a {die_offset, low_pc} pair for each
2261// inlined instance; the die_offset points to the inlined_subroutine die in the
2262// __debug_info section, and the low_pc is the starting address for the
2263// inlining instance.
2264void DwarfDebug::emitDebugInlineInfo() {
2265  if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2266    return;
2267
2268  if (!FirstCU)
2269    return;
2270
2271  Asm->OutStreamer.SwitchSection(
2272                        Asm->getObjFileLowering().getDwarfDebugInlineSection());
2273
2274  Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2275  Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2276                           Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2277
2278  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2279
2280  Asm->OutStreamer.AddComment("Dwarf Version");
2281  Asm->EmitInt16(dwarf::DWARF_VERSION);
2282  Asm->OutStreamer.AddComment("Address Size (in bytes)");
2283  Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2284
2285  for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2286         E = InlinedSPNodes.end(); I != E; ++I) {
2287
2288    const MDNode *Node = *I;
2289    DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2290      = InlineInfo.find(Node);
2291    SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2292    DISubprogram SP(Node);
2293    StringRef LName = SP.getLinkageName();
2294    StringRef Name = SP.getName();
2295
2296    Asm->OutStreamer.AddComment("MIPS linkage name");
2297    if (LName.empty())
2298      Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2299    else
2300      Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2301                             DwarfStrSectionSym);
2302
2303    Asm->OutStreamer.AddComment("Function name");
2304    Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2305    Asm->EmitULEB128(Labels.size(), "Inline count");
2306
2307    for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2308           LE = Labels.end(); LI != LE; ++LI) {
2309      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2310      Asm->EmitInt32(LI->second->getOffset());
2311
2312      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2313      Asm->OutStreamer.EmitSymbolValue(LI->first,
2314                                       Asm->getDataLayout().getPointerSize(),0);
2315    }
2316  }
2317
2318  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2319}
2320
2321// DWARF5 Experimental Fission emitters.
2322
2323// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2324// DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2325// DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2326// DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2327CompileUnit *DwarfDebug::constructFissionCU(const MDNode *N) {
2328  DICompileUnit DIUnit(N);
2329  StringRef FN = DIUnit.getFilename();
2330  CompilationDir = DIUnit.getDirectory();
2331
2332  DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2333  CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2334                                       DIUnit.getLanguage(), Die, Asm, this);
2335  // FIXME: This should be the .dwo file.
2336  NewCU->addString(Die, dwarf::DW_AT_GNU_dwo_name, FN);
2337
2338  // FIXME: We also need DW_AT_addr_base and DW_AT_dwo_id.
2339
2340  // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2341  // into an entity.
2342  NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2343  // DW_AT_stmt_list is a offset of line number information for this
2344  // compile unit in debug_line section.
2345  if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2346    NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
2347                    Asm->GetTempSymbol("section_line"));
2348  else
2349    NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
2350
2351  if (!CompilationDir.empty())
2352    NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2353
2354  return NewCU;
2355}
2356
2357void DwarfDebug::emitFissionSkeletonCU(const MCSection *Section) {
2358  Asm->OutStreamer.SwitchSection(Section);
2359  DIE *Die = FissionCU->getCUDie();
2360
2361  // Emit the compile units header.
2362  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("skel_info_begin",
2363                                                FissionCU->getUniqueID()));
2364
2365  // Emit size of content not including length itself
2366  unsigned ContentSize = Die->getSize() +
2367    sizeof(int16_t) + // DWARF version number
2368    sizeof(int32_t) + // Offset Into Abbrev. Section
2369    sizeof(int8_t);   // Pointer Size (in bytes)
2370
2371  Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2372  Asm->EmitInt32(ContentSize);
2373  Asm->OutStreamer.AddComment("DWARF version number");
2374  Asm->EmitInt16(dwarf::DWARF_VERSION);
2375  Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2376  Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2377                         DwarfAbbrevSectionSym);
2378  Asm->OutStreamer.AddComment("Address Size (in bytes)");
2379  Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2380
2381  emitDIE(Die);
2382  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("skel_info_end",
2383                                                FissionCU->getUniqueID()));
2384
2385
2386}
2387
2388// Emit the .debug_info.dwo section for fission. This contains the compile
2389// units that would normally be in debug_info.
2390void DwarfDebug::emitDebugInfoDWO() {
2391  assert(useDwarfFission() && "Got fission?");
2392  emitCompileUnits(Asm->getObjFileLowering().getDwarfInfoDWOSection());
2393}
2394