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