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