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