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