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