DwarfDebug.cpp revision b67bd33e8e2f29c3d6adb10c4f3a02c79c61af08 
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/Target/TargetData.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
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        // Check that DbgVariable for DV wasn't created earlier, when
1426        // findAbstractVariable() was called for inlined instance of DV.
1427        LLVMContext &Ctx = DV->getContext();
1428        DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1429        if (AbstractVariables.lookup(CleanDV))
1430          continue;
1431        if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1432          addScopeVariable(Scope, new DbgVariable(DV, NULL));
1433      }
1434    }
1435    if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1436      constructScopeDIE(TheCU, AScope);
1437  }
1438
1439  DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1440
1441  if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1442    TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1443                   dwarf::DW_FORM_flag, 1);
1444
1445  DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1446                                               MMI->getFrameMoves()));
1447
1448  // Clear debug info
1449  for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1450         I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1451    DeleteContainerPointers(I->second);
1452  ScopeVariables.clear();
1453  DeleteContainerPointers(CurrentFnArguments);
1454  UserVariables.clear();
1455  DbgValues.clear();
1456  AbstractVariables.clear();
1457  LabelsBeforeInsn.clear();
1458  LabelsAfterInsn.clear();
1459  PrevLabel = NULL;
1460}
1461
1462/// recordSourceLine - Register a source line with debug info. Returns the
1463/// unique label that was emitted and which provides correspondence to
1464/// the source line list.
1465void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1466                                  unsigned Flags) {
1467  StringRef Fn;
1468  StringRef Dir;
1469  unsigned Src = 1;
1470  if (S) {
1471    DIDescriptor Scope(S);
1472
1473    if (Scope.isCompileUnit()) {
1474      DICompileUnit CU(S);
1475      Fn = CU.getFilename();
1476      Dir = CU.getDirectory();
1477    } else if (Scope.isFile()) {
1478      DIFile F(S);
1479      Fn = F.getFilename();
1480      Dir = F.getDirectory();
1481    } else if (Scope.isSubprogram()) {
1482      DISubprogram SP(S);
1483      Fn = SP.getFilename();
1484      Dir = SP.getDirectory();
1485    } else if (Scope.isLexicalBlockFile()) {
1486      DILexicalBlockFile DBF(S);
1487      Fn = DBF.getFilename();
1488      Dir = DBF.getDirectory();
1489    } else if (Scope.isLexicalBlock()) {
1490      DILexicalBlock DB(S);
1491      Fn = DB.getFilename();
1492      Dir = DB.getDirectory();
1493    } else
1494      llvm_unreachable("Unexpected scope info");
1495
1496    Src = GetOrCreateSourceID(Fn, Dir);
1497  }
1498  Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1499}
1500
1501//===----------------------------------------------------------------------===//
1502// Emit Methods
1503//===----------------------------------------------------------------------===//
1504
1505/// computeSizeAndOffset - Compute the size and offset of a DIE.
1506///
1507unsigned
1508DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1509  // Get the children.
1510  const std::vector<DIE *> &Children = Die->getChildren();
1511
1512  // Record the abbreviation.
1513  assignAbbrevNumber(Die->getAbbrev());
1514
1515  // Get the abbreviation for this DIE.
1516  unsigned AbbrevNumber = Die->getAbbrevNumber();
1517  const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1518
1519  // Set DIE offset
1520  Die->setOffset(Offset);
1521
1522  // Start the size with the size of abbreviation code.
1523  Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1524
1525  const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1526  const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1527
1528  // Size the DIE attribute values.
1529  for (unsigned i = 0, N = Values.size(); i < N; ++i)
1530    // Size attribute value.
1531    Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1532
1533  // Size the DIE children if any.
1534  if (!Children.empty()) {
1535    assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1536           "Children flag not set");
1537
1538    for (unsigned j = 0, M = Children.size(); j < M; ++j)
1539      Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1540
1541    // End of children marker.
1542    Offset += sizeof(int8_t);
1543  }
1544
1545  Die->setSize(Offset - Die->getOffset());
1546  return Offset;
1547}
1548
1549/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1550///
1551void DwarfDebug::computeSizeAndOffsets() {
1552  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1553         E = CUMap.end(); I != E; ++I) {
1554    // Compute size of compile unit header.
1555    unsigned Offset =
1556      sizeof(int32_t) + // Length of Compilation Unit Info
1557      sizeof(int16_t) + // DWARF version number
1558      sizeof(int32_t) + // Offset Into Abbrev. Section
1559      sizeof(int8_t);   // Pointer Size (in bytes)
1560    computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1561  }
1562}
1563
1564/// EmitSectionLabels - Emit initial Dwarf sections with a label at
1565/// the start of each one.
1566void DwarfDebug::EmitSectionLabels() {
1567  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1568
1569  // Dwarf sections base addresses.
1570  DwarfInfoSectionSym =
1571    EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1572  DwarfAbbrevSectionSym =
1573    EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1574  EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1575
1576  if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1577    EmitSectionSym(Asm, MacroInfo);
1578
1579  EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1580  EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1581  EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1582  DwarfStrSectionSym =
1583    EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1584  DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1585                                             "debug_range");
1586
1587  DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1588                                           "section_debug_loc");
1589
1590  TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1591  EmitSectionSym(Asm, TLOF.getDataSection());
1592}
1593
1594/// emitDIE - Recursively emits a debug information entry.
1595///
1596void DwarfDebug::emitDIE(DIE *Die) {
1597  // Get the abbreviation for this DIE.
1598  unsigned AbbrevNumber = Die->getAbbrevNumber();
1599  const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1600
1601  // Emit the code (index) for the abbreviation.
1602  if (Asm->isVerbose())
1603    Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1604                                Twine::utohexstr(Die->getOffset()) + ":0x" +
1605                                Twine::utohexstr(Die->getSize()) + " " +
1606                                dwarf::TagString(Abbrev->getTag()));
1607  Asm->EmitULEB128(AbbrevNumber);
1608
1609  const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1610  const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1611
1612  // Emit the DIE attribute values.
1613  for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1614    unsigned Attr = AbbrevData[i].getAttribute();
1615    unsigned Form = AbbrevData[i].getForm();
1616    assert(Form && "Too many attributes for DIE (check abbreviation)");
1617
1618    if (Asm->isVerbose())
1619      Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1620
1621    switch (Attr) {
1622    case dwarf::DW_AT_abstract_origin: {
1623      DIEEntry *E = cast<DIEEntry>(Values[i]);
1624      DIE *Origin = E->getEntry();
1625      unsigned Addr = Origin->getOffset();
1626      Asm->EmitInt32(Addr);
1627      break;
1628    }
1629    case dwarf::DW_AT_ranges: {
1630      // DW_AT_range Value encodes offset in debug_range section.
1631      DIEInteger *V = cast<DIEInteger>(Values[i]);
1632
1633      if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1634        Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1635                                 V->getValue(),
1636                                 4);
1637      } else {
1638        Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1639                                       V->getValue(),
1640                                       DwarfDebugRangeSectionSym,
1641                                       4);
1642      }
1643      break;
1644    }
1645    case dwarf::DW_AT_location: {
1646      if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1647        if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1648          Asm->EmitLabelReference(L->getValue(), 4);
1649        else
1650          Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1651      } else {
1652        Values[i]->EmitValue(Asm, Form);
1653      }
1654      break;
1655    }
1656    case dwarf::DW_AT_accessibility: {
1657      if (Asm->isVerbose()) {
1658        DIEInteger *V = cast<DIEInteger>(Values[i]);
1659        Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1660      }
1661      Values[i]->EmitValue(Asm, Form);
1662      break;
1663    }
1664    default:
1665      // Emit an attribute using the defined form.
1666      Values[i]->EmitValue(Asm, Form);
1667      break;
1668    }
1669  }
1670
1671  // Emit the DIE children if any.
1672  if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1673    const std::vector<DIE *> &Children = Die->getChildren();
1674
1675    for (unsigned j = 0, M = Children.size(); j < M; ++j)
1676      emitDIE(Children[j]);
1677
1678    if (Asm->isVerbose())
1679      Asm->OutStreamer.AddComment("End Of Children Mark");
1680    Asm->EmitInt8(0);
1681  }
1682}
1683
1684/// emitDebugInfo - Emit the debug info section.
1685///
1686void DwarfDebug::emitDebugInfo() {
1687  // Start debug info section.
1688  Asm->OutStreamer.SwitchSection(
1689                            Asm->getObjFileLowering().getDwarfInfoSection());
1690  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1691         E = CUMap.end(); I != E; ++I) {
1692    CompileUnit *TheCU = I->second;
1693    DIE *Die = TheCU->getCUDie();
1694
1695    // Emit the compile units header.
1696    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1697                                                  TheCU->getID()));
1698
1699    // Emit size of content not including length itself
1700    unsigned ContentSize = Die->getSize() +
1701      sizeof(int16_t) + // DWARF version number
1702      sizeof(int32_t) + // Offset Into Abbrev. Section
1703      sizeof(int8_t);   // Pointer Size (in bytes)
1704
1705    Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1706    Asm->EmitInt32(ContentSize);
1707    Asm->OutStreamer.AddComment("DWARF version number");
1708    Asm->EmitInt16(dwarf::DWARF_VERSION);
1709    Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1710    Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1711                           DwarfAbbrevSectionSym);
1712    Asm->OutStreamer.AddComment("Address Size (in bytes)");
1713    Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1714
1715    emitDIE(Die);
1716    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1717  }
1718}
1719
1720/// emitAbbreviations - Emit the abbreviation section.
1721///
1722void DwarfDebug::emitAbbreviations() const {
1723  // Check to see if it is worth the effort.
1724  if (!Abbreviations.empty()) {
1725    // Start the debug abbrev section.
1726    Asm->OutStreamer.SwitchSection(
1727                            Asm->getObjFileLowering().getDwarfAbbrevSection());
1728
1729    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1730
1731    // For each abbrevation.
1732    for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1733      // Get abbreviation data
1734      const DIEAbbrev *Abbrev = Abbreviations[i];
1735
1736      // Emit the abbrevations code (base 1 index.)
1737      Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1738
1739      // Emit the abbreviations data.
1740      Abbrev->Emit(Asm);
1741    }
1742
1743    // Mark end of abbreviations.
1744    Asm->EmitULEB128(0, "EOM(3)");
1745
1746    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1747  }
1748}
1749
1750/// emitEndOfLineMatrix - Emit the last address of the section and the end of
1751/// the line matrix.
1752///
1753void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1754  // Define last address of section.
1755  Asm->OutStreamer.AddComment("Extended Op");
1756  Asm->EmitInt8(0);
1757
1758  Asm->OutStreamer.AddComment("Op size");
1759  Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1760  Asm->OutStreamer.AddComment("DW_LNE_set_address");
1761  Asm->EmitInt8(dwarf::DW_LNE_set_address);
1762
1763  Asm->OutStreamer.AddComment("Section end label");
1764
1765  Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1766                                   Asm->getTargetData().getPointerSize(),
1767                                   0/*AddrSpace*/);
1768
1769  // Mark end of matrix.
1770  Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1771  Asm->EmitInt8(0);
1772  Asm->EmitInt8(1);
1773  Asm->EmitInt8(1);
1774}
1775
1776/// emitAccelNames - Emit visible names into a hashed accelerator table
1777/// section.
1778void DwarfDebug::emitAccelNames() {
1779  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1780                                           dwarf::DW_FORM_data4));
1781  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1782         E = CUMap.end(); I != E; ++I) {
1783    CompileUnit *TheCU = I->second;
1784    const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1785    for (StringMap<std::vector<DIE*> >::const_iterator
1786           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1787      const char *Name = GI->getKeyData();
1788      const std::vector<DIE *> &Entities = GI->second;
1789      for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1790             DE = Entities.end(); DI != DE; ++DI)
1791        AT.AddName(Name, (*DI));
1792    }
1793  }
1794
1795  AT.FinalizeTable(Asm, "Names");
1796  Asm->OutStreamer.SwitchSection(
1797    Asm->getObjFileLowering().getDwarfAccelNamesSection());
1798  MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1799  Asm->OutStreamer.EmitLabel(SectionBegin);
1800
1801  // Emit the full data.
1802  AT.Emit(Asm, SectionBegin, this);
1803}
1804
1805/// emitAccelObjC - Emit objective C classes and categories into a hashed
1806/// accelerator table section.
1807void DwarfDebug::emitAccelObjC() {
1808  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1809                                           dwarf::DW_FORM_data4));
1810  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1811         E = CUMap.end(); I != E; ++I) {
1812    CompileUnit *TheCU = I->second;
1813    const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1814    for (StringMap<std::vector<DIE*> >::const_iterator
1815           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1816      const char *Name = GI->getKeyData();
1817      const std::vector<DIE *> &Entities = GI->second;
1818      for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1819             DE = Entities.end(); DI != DE; ++DI)
1820        AT.AddName(Name, (*DI));
1821    }
1822  }
1823
1824  AT.FinalizeTable(Asm, "ObjC");
1825  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1826                                 .getDwarfAccelObjCSection());
1827  MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1828  Asm->OutStreamer.EmitLabel(SectionBegin);
1829
1830  // Emit the full data.
1831  AT.Emit(Asm, SectionBegin, this);
1832}
1833
1834/// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1835/// table.
1836void DwarfDebug::emitAccelNamespaces() {
1837  DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1838                                           dwarf::DW_FORM_data4));
1839  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1840         E = CUMap.end(); I != E; ++I) {
1841    CompileUnit *TheCU = I->second;
1842    const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1843    for (StringMap<std::vector<DIE*> >::const_iterator
1844           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1845      const char *Name = GI->getKeyData();
1846      const std::vector<DIE *> &Entities = GI->second;
1847      for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1848             DE = Entities.end(); DI != DE; ++DI)
1849        AT.AddName(Name, (*DI));
1850    }
1851  }
1852
1853  AT.FinalizeTable(Asm, "namespac");
1854  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1855                                 .getDwarfAccelNamespaceSection());
1856  MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1857  Asm->OutStreamer.EmitLabel(SectionBegin);
1858
1859  // Emit the full data.
1860  AT.Emit(Asm, SectionBegin, this);
1861}
1862
1863/// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1864void DwarfDebug::emitAccelTypes() {
1865  std::vector<DwarfAccelTable::Atom> Atoms;
1866  Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1867                                        dwarf::DW_FORM_data4));
1868  Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1869                                        dwarf::DW_FORM_data2));
1870  Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1871                                        dwarf::DW_FORM_data1));
1872  DwarfAccelTable AT(Atoms);
1873  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1874         E = CUMap.end(); I != E; ++I) {
1875    CompileUnit *TheCU = I->second;
1876    const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1877      = TheCU->getAccelTypes();
1878    for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1879           GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1880      const char *Name = GI->getKeyData();
1881      const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1882      for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1883             = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1884        AT.AddName(Name, (*DI).first, (*DI).second);
1885    }
1886  }
1887
1888  AT.FinalizeTable(Asm, "types");
1889  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1890                                 .getDwarfAccelTypesSection());
1891  MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1892  Asm->OutStreamer.EmitLabel(SectionBegin);
1893
1894  // Emit the full data.
1895  AT.Emit(Asm, SectionBegin, this);
1896}
1897
1898void DwarfDebug::emitDebugPubTypes() {
1899  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1900         E = CUMap.end(); I != E; ++I) {
1901    CompileUnit *TheCU = I->second;
1902    // Start the dwarf pubtypes section.
1903    Asm->OutStreamer.SwitchSection(
1904      Asm->getObjFileLowering().getDwarfPubTypesSection());
1905    Asm->OutStreamer.AddComment("Length of Public Types Info");
1906    Asm->EmitLabelDifference(
1907      Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1908      Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1909
1910    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1911                                                  TheCU->getID()));
1912
1913    if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1914    Asm->EmitInt16(dwarf::DWARF_VERSION);
1915
1916    Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1917    Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1918                           DwarfInfoSectionSym);
1919
1920    Asm->OutStreamer.AddComment("Compilation Unit Length");
1921    Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1922                             Asm->GetTempSymbol("info_begin", TheCU->getID()),
1923                             4);
1924
1925    const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1926    for (StringMap<DIE*>::const_iterator
1927           GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1928      const char *Name = GI->getKeyData();
1929      DIE *Entity = GI->second;
1930
1931      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1932      Asm->EmitInt32(Entity->getOffset());
1933
1934      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1935      // Emit the name with a terminating null byte.
1936      Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1937    }
1938
1939    Asm->OutStreamer.AddComment("End Mark");
1940    Asm->EmitInt32(0);
1941    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1942                                                  TheCU->getID()));
1943  }
1944}
1945
1946/// emitDebugStr - Emit visible names into a debug str section.
1947///
1948void DwarfDebug::emitDebugStr() {
1949  // Check to see if it is worth the effort.
1950  if (StringPool.empty()) return;
1951
1952  // Start the dwarf str section.
1953  Asm->OutStreamer.SwitchSection(
1954                                Asm->getObjFileLowering().getDwarfStrSection());
1955
1956  // Get all of the string pool entries and put them in an array by their ID so
1957  // we can sort them.
1958  SmallVector<std::pair<unsigned,
1959      StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1960
1961  for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1962       I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1963    Entries.push_back(std::make_pair(I->second.second, &*I));
1964
1965  array_pod_sort(Entries.begin(), Entries.end());
1966
1967  for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1968    // Emit a label for reference from debug information entries.
1969    Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1970
1971    // Emit the string itself with a terminating null byte.
1972    Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1973                                         Entries[i].second->getKeyLength()+1),
1974                               0/*addrspace*/);
1975  }
1976}
1977
1978/// emitDebugLoc - Emit visible names into a debug loc section.
1979///
1980void DwarfDebug::emitDebugLoc() {
1981  if (DotDebugLocEntries.empty())
1982    return;
1983
1984  for (SmallVector<DotDebugLocEntry, 4>::iterator
1985         I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1986       I != E; ++I) {
1987    DotDebugLocEntry &Entry = *I;
1988    if (I + 1 != DotDebugLocEntries.end())
1989      Entry.Merge(I+1);
1990  }
1991
1992  // Start the dwarf loc section.
1993  Asm->OutStreamer.SwitchSection(
1994    Asm->getObjFileLowering().getDwarfLocSection());
1995  unsigned char Size = Asm->getTargetData().getPointerSize();
1996  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1997  unsigned index = 1;
1998  for (SmallVector<DotDebugLocEntry, 4>::iterator
1999         I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2000       I != E; ++I, ++index) {
2001    DotDebugLocEntry &Entry = *I;
2002    if (Entry.isMerged()) continue;
2003    if (Entry.isEmpty()) {
2004      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2005      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2006      Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2007    } else {
2008      Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2009      Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2010      DIVariable DV(Entry.Variable);
2011      Asm->OutStreamer.AddComment("Loc expr size");
2012      MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2013      MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2014      Asm->EmitLabelDifference(end, begin, 2);
2015      Asm->OutStreamer.EmitLabel(begin);
2016      if (Entry.isInt()) {
2017        DIBasicType BTy(DV.getType());
2018        if (BTy.Verify() &&
2019            (BTy.getEncoding()  == dwarf::DW_ATE_signed
2020             || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2021          Asm->OutStreamer.AddComment("DW_OP_consts");
2022          Asm->EmitInt8(dwarf::DW_OP_consts);
2023          Asm->EmitSLEB128(Entry.getInt());
2024        } else {
2025          Asm->OutStreamer.AddComment("DW_OP_constu");
2026          Asm->EmitInt8(dwarf::DW_OP_constu);
2027          Asm->EmitULEB128(Entry.getInt());
2028        }
2029      } else if (Entry.isLocation()) {
2030        if (!DV.hasComplexAddress())
2031          // Regular entry.
2032          Asm->EmitDwarfRegOp(Entry.Loc);
2033        else {
2034          // Complex address entry.
2035          unsigned N = DV.getNumAddrElements();
2036          unsigned i = 0;
2037          if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2038            if (Entry.Loc.getOffset()) {
2039              i = 2;
2040              Asm->EmitDwarfRegOp(Entry.Loc);
2041              Asm->OutStreamer.AddComment("DW_OP_deref");
2042              Asm->EmitInt8(dwarf::DW_OP_deref);
2043              Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2044              Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2045              Asm->EmitSLEB128(DV.getAddrElement(1));
2046            } else {
2047              // If first address element is OpPlus then emit
2048              // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2049              MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2050              Asm->EmitDwarfRegOp(Loc);
2051              i = 2;
2052            }
2053          } else {
2054            Asm->EmitDwarfRegOp(Entry.Loc);
2055          }
2056
2057          // Emit remaining complex address elements.
2058          for (; i < N; ++i) {
2059            uint64_t Element = DV.getAddrElement(i);
2060            if (Element == DIBuilder::OpPlus) {
2061              Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2062              Asm->EmitULEB128(DV.getAddrElement(++i));
2063            } else if (Element == DIBuilder::OpDeref) {
2064              if (!Entry.Loc.isReg())
2065                Asm->EmitInt8(dwarf::DW_OP_deref);
2066            } else
2067              llvm_unreachable("unknown Opcode found in complex address");
2068          }
2069        }
2070      }
2071      // else ... ignore constant fp. There is not any good way to
2072      // to represent them here in dwarf.
2073      Asm->OutStreamer.EmitLabel(end);
2074    }
2075  }
2076}
2077
2078/// EmitDebugARanges - Emit visible names into a debug aranges section.
2079///
2080void DwarfDebug::EmitDebugARanges() {
2081  // Start the dwarf aranges section.
2082  Asm->OutStreamer.SwitchSection(
2083                          Asm->getObjFileLowering().getDwarfARangesSection());
2084}
2085
2086/// emitDebugRanges - Emit visible names into a debug ranges section.
2087///
2088void DwarfDebug::emitDebugRanges() {
2089  // Start the dwarf ranges section.
2090  Asm->OutStreamer.SwitchSection(
2091    Asm->getObjFileLowering().getDwarfRangesSection());
2092  unsigned char Size = Asm->getTargetData().getPointerSize();
2093  for (SmallVector<const MCSymbol *, 8>::iterator
2094         I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2095       I != E; ++I) {
2096    if (*I)
2097      Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2098    else
2099      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2100  }
2101}
2102
2103/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2104///
2105void DwarfDebug::emitDebugMacInfo() {
2106  if (const MCSection *LineInfo =
2107      Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2108    // Start the dwarf macinfo section.
2109    Asm->OutStreamer.SwitchSection(LineInfo);
2110  }
2111}
2112
2113/// emitDebugInlineInfo - Emit inline info using following format.
2114/// Section Header:
2115/// 1. length of section
2116/// 2. Dwarf version number
2117/// 3. address size.
2118///
2119/// Entries (one "entry" for each function that was inlined):
2120///
2121/// 1. offset into __debug_str section for MIPS linkage name, if exists;
2122///   otherwise offset into __debug_str for regular function name.
2123/// 2. offset into __debug_str section for regular function name.
2124/// 3. an unsigned LEB128 number indicating the number of distinct inlining
2125/// instances for the function.
2126///
2127/// The rest of the entry consists of a {die_offset, low_pc} pair for each
2128/// inlined instance; the die_offset points to the inlined_subroutine die in the
2129/// __debug_info section, and the low_pc is the starting address for the
2130/// inlining instance.
2131void DwarfDebug::emitDebugInlineInfo() {
2132  if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2133    return;
2134
2135  if (!FirstCU)
2136    return;
2137
2138  Asm->OutStreamer.SwitchSection(
2139                        Asm->getObjFileLowering().getDwarfDebugInlineSection());
2140
2141  Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2142  Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2143                           Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2144
2145  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2146
2147  Asm->OutStreamer.AddComment("Dwarf Version");
2148  Asm->EmitInt16(dwarf::DWARF_VERSION);
2149  Asm->OutStreamer.AddComment("Address Size (in bytes)");
2150  Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2151
2152  for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2153         E = InlinedSPNodes.end(); I != E; ++I) {
2154
2155    const MDNode *Node = *I;
2156    DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2157      = InlineInfo.find(Node);
2158    SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2159    DISubprogram SP(Node);
2160    StringRef LName = SP.getLinkageName();
2161    StringRef Name = SP.getName();
2162
2163    Asm->OutStreamer.AddComment("MIPS linkage name");
2164    if (LName.empty())
2165      Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2166    else
2167      Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2168                             DwarfStrSectionSym);
2169
2170    Asm->OutStreamer.AddComment("Function name");
2171    Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2172    Asm->EmitULEB128(Labels.size(), "Inline count");
2173
2174    for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2175           LE = Labels.end(); LI != LE; ++LI) {
2176      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2177      Asm->EmitInt32(LI->second->getOffset());
2178
2179      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2180      Asm->OutStreamer.EmitSymbolValue(LI->first,
2181                                       Asm->getTargetData().getPointerSize(),0);
2182    }
2183  }
2184
2185  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2186}
2187