DwarfDebug.cpp revision 3655a21b15e135927826eeb1917b42299ac95d67 
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(CompileUnit *SPCU,
186                                          const MDNode *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(CompileUnit *TheCU,
250                                          LexicalScope *Scope) {
251
252  DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
253  if (Scope->isAbstractScope())
254    return ScopeDIE;
255
256  const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
257  if (Ranges.empty())
258    return 0;
259
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(CompileUnit *TheCU,
296                                          LexicalScope *Scope) {
297
298  const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
299  assert (Ranges.empty() == false
300          && "LexicalScope does not have instruction markers!");
301
302  if (!Scope->getScopeNode())
303    return NULL;
304  DIScope DS(Scope->getScopeNode());
305  DISubprogram InlinedSP = getDISubprogram(DS);
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/// constructScopeDIE - Construct a DIE for this scope.
375DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
376  if (!Scope || !Scope->getScopeNode())
377    return NULL;
378
379  SmallVector <DIE *, 8> Children;
380
381  // Collect arguments for current function.
382  if (LScopes.isCurrentFunctionScope(Scope))
383    for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
384      if (DbgVariable *ArgDV = CurrentFnArguments[i])
385        if (DIE *Arg =
386            TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
387          Children.push_back(Arg);
388
389  // Collect lexical scope childrens first.
390  const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
391  for (unsigned i = 0, N = Variables.size(); i < N; ++i)
392    if (DIE *Variable =
393        TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
394      Children.push_back(Variable);
395  const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
396  for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
397    if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
398      Children.push_back(Nested);
399  DIScope DS(Scope->getScopeNode());
400  DIE *ScopeDIE = NULL;
401  if (Scope->getInlinedAt())
402    ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
403  else if (DS.isSubprogram()) {
404    ProcessedSPNodes.insert(DS);
405    if (Scope->isAbstractScope()) {
406      ScopeDIE = TheCU->getDIE(DS);
407      // Note down abstract DIE.
408      if (ScopeDIE)
409        AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
410    }
411    else
412      ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
413  }
414  else {
415    // There is no need to emit empty lexical block DIE.
416    if (Children.empty())
417      return NULL;
418    ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
419  }
420
421  if (!ScopeDIE) return NULL;
422
423  // Add children
424  for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
425         E = Children.end(); I != E; ++I)
426    ScopeDIE->addChild(*I);
427
428  if (DS.isSubprogram())
429   TheCU->addPubTypes(DISubprogram(DS));
430
431 return ScopeDIE;
432}
433
434/// GetOrCreateSourceID - Look up the source id with the given directory and
435/// source file names. If none currently exists, create a new id and insert it
436/// in the SourceIds map. This can update DirectoryNames and SourceFileNames
437/// maps as well.
438
439unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
440                                         StringRef DirName) {
441  // If FE did not provide a file name, then assume stdin.
442  if (FileName.empty())
443    return GetOrCreateSourceID("<stdin>", StringRef());
444
445  // MCStream expects full path name as filename.
446  if (!DirName.empty() && !sys::path::is_absolute(FileName)) {
447    SmallString<128> FullPathName = DirName;
448    sys::path::append(FullPathName, FileName);
449    // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
450    return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
451  }
452
453  StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
454  if (Entry.getValue())
455    return Entry.getValue();
456
457  unsigned SrcId = SourceIdMap.size();
458  Entry.setValue(SrcId);
459
460  // Print out a .file directive to specify files for .loc directives.
461  Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
462
463  return SrcId;
464}
465
466/// constructCompileUnit - Create new CompileUnit for the given
467/// metadata node with tag DW_TAG_compile_unit.
468void DwarfDebug::constructCompileUnit(const MDNode *N) {
469  DICompileUnit DIUnit(N);
470  StringRef FN = DIUnit.getFilename();
471  StringRef Dir = DIUnit.getDirectory();
472  unsigned ID = GetOrCreateSourceID(FN, Dir);
473
474  DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
475  CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
476  NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
477                   DIUnit.getProducer());
478  NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
479                 DIUnit.getLanguage());
480  NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
481  // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
482  // simplifies debug range entries.
483  NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
484  // DW_AT_stmt_list is a offset of line number information for this
485  // compile unit in debug_line section.
486  if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
487    NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
488                    Asm->GetTempSymbol("section_line"));
489  else
490    NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
491
492  if (!Dir.empty())
493    NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
494  if (DIUnit.isOptimized())
495    NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
496
497  StringRef Flags = DIUnit.getFlags();
498  if (!Flags.empty())
499    NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string,
500                     Flags);
501
502  unsigned RVer = DIUnit.getRunTimeVersion();
503  if (RVer)
504    NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
505            dwarf::DW_FORM_data1, RVer);
506
507  if (!FirstCU)
508    FirstCU = NewCU;
509  CUMap.insert(std::make_pair(N, NewCU));
510}
511
512/// getCompileUnit - Get CompileUnit DIE.
513CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
514  assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
515  DIDescriptor D(N);
516  const MDNode *CUNode = NULL;
517  if (D.isCompileUnit())
518    CUNode = N;
519  else if (D.isSubprogram())
520    CUNode = DISubprogram(N).getCompileUnit();
521  else if (D.isType())
522    CUNode = DIType(N).getCompileUnit();
523  else if (D.isGlobalVariable())
524    CUNode = DIGlobalVariable(N).getCompileUnit();
525  else if (D.isVariable())
526    CUNode = DIVariable(N).getCompileUnit();
527  else if (D.isNameSpace())
528    CUNode = DINameSpace(N).getCompileUnit();
529  else if (D.isFile())
530    CUNode = DIFile(N).getCompileUnit();
531  else
532    return FirstCU;
533
534  DenseMap<const MDNode *, CompileUnit *>::const_iterator I
535    = CUMap.find(CUNode);
536  if (I == CUMap.end())
537    return FirstCU;
538  return I->second;
539}
540
541/// constructGlobalVariableDIE - Construct global variable DIE.
542void DwarfDebug::constructGlobalVariableDIE(CompileUnit *TheCU,
543                                            const MDNode *N) {
544  DIGlobalVariable GV(N);
545
546  // If debug information is malformed then ignore it.
547  if (GV.Verify() == false)
548    return;
549
550  TheCU->createGlobalVariableDIE(N);
551  return;
552}
553
554/// construct SubprogramDIE - Construct subprogram DIE.
555void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
556                                        const MDNode *N) {
557  DISubprogram SP(N);
558  if (!SP.isDefinition())
559    // This is a method declaration which will be handled while constructing
560    // class type.
561    return;
562
563  DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
564
565  // Add to map.
566  TheCU->insertDIE(N, SubprogramDie);
567
568  // Add to context owner.
569  TheCU->addToContextOwner(SubprogramDie, SP.getContext());
570
571  // Expose as global.
572  TheCU->addGlobal(SP.getName(), SubprogramDie);
573
574  return;
575}
576
577/// beginModule - Emit all Dwarf sections that should come prior to the
578/// content. Create global DIEs and emit initial debug info sections.
579/// This is invoked by the target AsmPrinter.
580void DwarfDebug::beginModule(Module *M) {
581  if (DisableDebugInfoPrinting)
582    return;
583
584  // If module has named metadata anchors then use them, otherwise scan the
585  // module using debug info finder to collect debug info.
586  NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
587  if (CU_Nodes) {
588
589    NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv");
590    NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp");
591    if (!GV_Nodes && !SP_Nodes)
592      // If there are not any global variables or any functions then
593      // there is not any debug info in this module.
594      return;
595
596    for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
597      constructCompileUnit(CU_Nodes->getOperand(i));
598
599    if (GV_Nodes)
600      for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i) {
601        const MDNode *N = GV_Nodes->getOperand(i);
602        constructGlobalVariableDIE(getCompileUnit(N), N);
603      }
604
605    if (SP_Nodes)
606      for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i) {
607        const MDNode *N = SP_Nodes->getOperand(i);
608        constructSubprogramDIE(getCompileUnit(N), N);
609      }
610
611  } else {
612
613    DebugInfoFinder DbgFinder;
614    DbgFinder.processModule(*M);
615
616    bool HasDebugInfo = false;
617    // Scan all the compile-units to see if there are any marked as the main
618    // unit. If not, we do not generate debug info.
619    for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
620           E = DbgFinder.compile_unit_end(); I != E; ++I) {
621      if (DICompileUnit(*I).isMain()) {
622        HasDebugInfo = true;
623        break;
624      }
625    }
626    if (!HasDebugInfo) return;
627
628    // Create all the compile unit DIEs.
629    for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
630           E = DbgFinder.compile_unit_end(); I != E; ++I)
631      constructCompileUnit(*I);
632
633    // Create DIEs for each global variable.
634    for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
635           E = DbgFinder.global_variable_end(); I != E; ++I) {
636      const MDNode *N = *I;
637      if (DIGlobalVariable(N).getVersion() <= LLVMDebugVersion9)
638        constructGlobalVariableDIE(getCompileUnit(N), N);
639    }
640
641    // Create DIEs for each subprogram.
642    for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
643           E = DbgFinder.subprogram_end(); I != E; ++I) {
644      const MDNode *N = *I;
645      constructSubprogramDIE(getCompileUnit(N), N);
646    }
647  }
648
649  // Tell MMI that we have debug info.
650  MMI->setDebugInfoAvailability(true);
651
652  // Emit initial sections.
653  EmitSectionLabels();
654
655  //getOrCreateTypeDIE
656  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
657    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
658      DIType Ty(NMD->getOperand(i));
659      getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
660    }
661
662  if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
663    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
664      DIType Ty(NMD->getOperand(i));
665      getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
666    }
667
668  // Prime section data.
669  SectionMap.insert(Asm->getObjFileLowering().getTextSection());
670}
671
672/// endModule - Emit all Dwarf sections that should come after the content.
673///
674void DwarfDebug::endModule() {
675  if (!FirstCU) return;
676  const Module *M = MMI->getModule();
677  DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
678  if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
679    for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
680      if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
681      DISubprogram SP(AllSPs->getOperand(SI));
682      if (!SP.Verify()) continue;
683
684      // Collect info for variables that were optimized out.
685      if (!SP.isDefinition()) continue;
686      StringRef FName = SP.getLinkageName();
687      if (FName.empty())
688        FName = SP.getName();
689      NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
690      if (!NMD) continue;
691      unsigned E = NMD->getNumOperands();
692      if (!E) continue;
693      LexicalScope *Scope = new LexicalScope(NULL, DIDescriptor(SP), NULL,
694                                             false);
695      DeadFnScopeMap[SP] = Scope;
696      SmallVector<DbgVariable, 8> Variables;
697      for (unsigned I = 0; I != E; ++I) {
698        DIVariable DV(NMD->getOperand(I));
699        if (!DV.Verify()) continue;
700        Variables.push_back(DbgVariable(DV, NULL));
701      }
702
703      // Construct subprogram DIE and add variables DIEs.
704      CompileUnit *SPCU = getCompileUnit(SP);
705      constructSubprogramDIE(SPCU, SP);
706      DIE *ScopeDIE = SPCU->getDIE(SP);
707      for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
708        if (DIE *VariableDIE =
709            SPCU->constructVariableDIE(&Variables[i], Scope->isAbstractScope()))
710          ScopeDIE->addChild(VariableDIE);
711      }
712    }
713  }
714
715  // Attach DW_AT_inline attribute with inlined subprogram DIEs.
716  for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
717         AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
718    DIE *ISP = *AI;
719    FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
720  }
721
722  // Emit DW_AT_containing_type attribute to connect types with their
723  // vtable holding type.
724  for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
725         CUE = CUMap.end(); CUI != CUE; ++CUI) {
726    CompileUnit *TheCU = CUI->second;
727    TheCU->constructContainingTypeDIEs();
728  }
729
730  // Standard sections final addresses.
731  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
732  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
733  Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
734  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
735
736  // End text sections.
737  for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
738    Asm->OutStreamer.SwitchSection(SectionMap[i]);
739    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
740  }
741
742  // Compute DIE offsets and sizes.
743  computeSizeAndOffsets();
744
745  // Emit all the DIEs into a debug info section
746  emitDebugInfo();
747
748  // Corresponding abbreviations into a abbrev section.
749  emitAbbreviations();
750
751  // Emit info into a debug pubnames section.
752  emitDebugPubNames();
753
754  // Emit info into a debug pubtypes section.
755  emitDebugPubTypes();
756
757  // Emit info into a debug loc section.
758  emitDebugLoc();
759
760  // Emit info into a debug aranges section.
761  EmitDebugARanges();
762
763  // Emit info into a debug ranges section.
764  emitDebugRanges();
765
766  // Emit info into a debug macinfo section.
767  emitDebugMacInfo();
768
769  // Emit inline info.
770  emitDebugInlineInfo();
771
772  // Emit info into a debug str section.
773  emitDebugStr();
774
775  // clean up.
776  DeleteContainerSeconds(DeadFnScopeMap);
777  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
778         E = CUMap.end(); I != E; ++I)
779    delete I->second;
780  FirstCU = NULL;  // Reset for the next Module, if any.
781}
782
783/// findAbstractVariable - Find abstract variable, if any, associated with Var.
784DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
785                                              DebugLoc ScopeLoc) {
786  LLVMContext &Ctx = DV->getContext();
787  // More then one inlined variable corresponds to one abstract variable.
788  DIVariable Var = cleanseInlinedVariable(DV, Ctx);
789  DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
790  if (AbsDbgVariable)
791    return AbsDbgVariable;
792
793  LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
794  if (!Scope)
795    return NULL;
796
797  AbsDbgVariable = new DbgVariable(Var, NULL);
798  addScopeVariable(Scope, AbsDbgVariable);
799  AbstractVariables[Var] = AbsDbgVariable;
800  return AbsDbgVariable;
801}
802
803/// addCurrentFnArgument - If Var is a current function argument then add
804/// it to CurrentFnArguments list.
805bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
806                                      DbgVariable *Var, LexicalScope *Scope) {
807  if (!LScopes.isCurrentFunctionScope(Scope))
808    return false;
809  DIVariable DV = Var->getVariable();
810  if (DV.getTag() != dwarf::DW_TAG_arg_variable)
811    return false;
812  unsigned ArgNo = DV.getArgNumber();
813  if (ArgNo == 0)
814    return false;
815
816  size_t Size = CurrentFnArguments.size();
817  if (Size == 0)
818    CurrentFnArguments.resize(MF->getFunction()->arg_size());
819  // llvm::Function argument size is not good indicator of how many
820  // arguments does the function have at source level.
821  if (ArgNo > Size)
822    CurrentFnArguments.resize(ArgNo * 2);
823  CurrentFnArguments[ArgNo - 1] = Var;
824  return true;
825}
826
827/// collectVariableInfoFromMMITable - Collect variable information from
828/// side table maintained by MMI.
829void
830DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
831                                   SmallPtrSet<const MDNode *, 16> &Processed) {
832  MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
833  for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
834         VE = VMap.end(); VI != VE; ++VI) {
835    const MDNode *Var = VI->first;
836    if (!Var) continue;
837    Processed.insert(Var);
838    DIVariable DV(Var);
839    const std::pair<unsigned, DebugLoc> &VP = VI->second;
840
841    LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
842
843    // If variable scope is not found then skip this variable.
844    if (Scope == 0)
845      continue;
846
847    DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
848    DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
849    RegVar->setFrameIndex(VP.first);
850    if (!addCurrentFnArgument(MF, RegVar, Scope))
851      addScopeVariable(Scope, RegVar);
852    if (AbsDbgVariable)
853      AbsDbgVariable->setFrameIndex(VP.first);
854  }
855}
856
857/// isDbgValueInDefinedReg - Return true if debug value, encoded by
858/// DBG_VALUE instruction, is in a defined reg.
859static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
860  assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
861  return MI->getNumOperands() == 3 &&
862         MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
863         MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
864}
865
866/// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
867/// at MI.
868static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
869                                         const MCSymbol *FLabel,
870                                         const MCSymbol *SLabel,
871                                         const MachineInstr *MI) {
872  const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
873
874  if (MI->getNumOperands() != 3) {
875    MachineLocation MLoc = Asm->getDebugValueLocation(MI);
876    return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
877  }
878  if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
879    MachineLocation MLoc;
880    MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
881    return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
882  }
883  if (MI->getOperand(0).isImm())
884    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
885  if (MI->getOperand(0).isFPImm())
886    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
887  if (MI->getOperand(0).isCImm())
888    return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
889
890  assert (0 && "Unexpected 3 operand DBG_VALUE instruction!");
891  return DotDebugLocEntry();
892}
893
894/// collectVariableInfo - Find variables for each lexical scope.
895void
896DwarfDebug::collectVariableInfo(const MachineFunction *MF,
897                                SmallPtrSet<const MDNode *, 16> &Processed) {
898
899  /// collection info from MMI table.
900  collectVariableInfoFromMMITable(MF, Processed);
901
902  for (SmallVectorImpl<const MDNode*>::const_iterator
903         UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
904         ++UVI) {
905    const MDNode *Var = *UVI;
906    if (Processed.count(Var))
907      continue;
908
909    // History contains relevant DBG_VALUE instructions for Var and instructions
910    // clobbering it.
911    SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
912    if (History.empty())
913      continue;
914    const MachineInstr *MInsn = History.front();
915
916    DIVariable DV(Var);
917    LexicalScope *Scope = NULL;
918    if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
919        DISubprogram(DV.getContext()).describes(MF->getFunction()))
920      Scope = LScopes.getCurrentFunctionScope();
921    else {
922      if (DV.getVersion() <= LLVMDebugVersion9)
923        Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
924      else {
925        if (MDNode *IA = DV.getInlinedAt())
926          Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
927        else
928          Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
929      }
930    }
931    // If variable scope is not found then skip this variable.
932    if (!Scope)
933      continue;
934
935    Processed.insert(DV);
936    assert(MInsn->isDebugValue() && "History must begin with debug value");
937    DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
938    DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
939    if (!addCurrentFnArgument(MF, RegVar, Scope))
940      addScopeVariable(Scope, RegVar);
941    if (AbsVar)
942      AbsVar->setMInsn(MInsn);
943
944    // Simple ranges that are fully coalesced.
945    if (History.size() <= 1 || (History.size() == 2 &&
946                                MInsn->isIdenticalTo(History.back()))) {
947      RegVar->setMInsn(MInsn);
948      continue;
949    }
950
951    // handle multiple DBG_VALUE instructions describing one variable.
952    RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
953
954    for (SmallVectorImpl<const MachineInstr*>::const_iterator
955           HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
956      const MachineInstr *Begin = *HI;
957      assert(Begin->isDebugValue() && "Invalid History entry");
958
959      // Check if DBG_VALUE is truncating a range.
960      if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
961          && !Begin->getOperand(0).getReg())
962        continue;
963
964      // Compute the range for a register location.
965      const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
966      const MCSymbol *SLabel = 0;
967
968      if (HI + 1 == HE)
969        // If Begin is the last instruction in History then its value is valid
970        // until the end of the function.
971        SLabel = FunctionEndSym;
972      else {
973        const MachineInstr *End = HI[1];
974        DEBUG(dbgs() << "DotDebugLoc Pair:\n"
975              << "\t" << *Begin << "\t" << *End << "\n");
976        if (End->isDebugValue())
977          SLabel = getLabelBeforeInsn(End);
978        else {
979          // End is a normal instruction clobbering the range.
980          SLabel = getLabelAfterInsn(End);
981          assert(SLabel && "Forgot label after clobber instruction");
982          ++HI;
983        }
984      }
985
986      // The value is valid until the next DBG_VALUE or clobber.
987      DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
988    }
989    DotDebugLocEntries.push_back(DotDebugLocEntry());
990  }
991
992  // Collect info for variables that were optimized out.
993  const Function *F = MF->getFunction();
994  if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
995    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
996      DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
997      if (!DV || !Processed.insert(DV))
998        continue;
999      if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1000        addScopeVariable(Scope, new DbgVariable(DV, NULL));
1001    }
1002  }
1003}
1004
1005/// getLabelBeforeInsn - Return Label preceding the instruction.
1006const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1007  MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1008  assert(Label && "Didn't insert label before instruction");
1009  return Label;
1010}
1011
1012/// getLabelAfterInsn - Return Label immediately following the instruction.
1013const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1014  return LabelsAfterInsn.lookup(MI);
1015}
1016
1017/// beginInstruction - Process beginning of an instruction.
1018void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1019  // Check if source location changes, but ignore DBG_VALUE locations.
1020  if (!MI->isDebugValue()) {
1021    DebugLoc DL = MI->getDebugLoc();
1022    if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1023      unsigned Flags = DWARF2_FLAG_IS_STMT;
1024      PrevInstLoc = DL;
1025      if (DL == PrologEndLoc) {
1026        Flags |= DWARF2_FLAG_PROLOGUE_END;
1027        PrologEndLoc = DebugLoc();
1028      }
1029      if (!DL.isUnknown()) {
1030        const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1031        recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1032      } else
1033        recordSourceLine(0, 0, 0, 0);
1034    }
1035  }
1036
1037  // Insert labels where requested.
1038  DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1039    LabelsBeforeInsn.find(MI);
1040
1041  // No label needed.
1042  if (I == LabelsBeforeInsn.end())
1043    return;
1044
1045  // Label already assigned.
1046  if (I->second)
1047    return;
1048
1049  if (!PrevLabel) {
1050    PrevLabel = MMI->getContext().CreateTempSymbol();
1051    Asm->OutStreamer.EmitLabel(PrevLabel);
1052  }
1053  I->second = PrevLabel;
1054}
1055
1056/// endInstruction - Process end of an instruction.
1057void DwarfDebug::endInstruction(const MachineInstr *MI) {
1058  // Don't create a new label after DBG_VALUE instructions.
1059  // They don't generate code.
1060  if (!MI->isDebugValue())
1061    PrevLabel = 0;
1062
1063  DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1064    LabelsAfterInsn.find(MI);
1065
1066  // No label needed.
1067  if (I == LabelsAfterInsn.end())
1068    return;
1069
1070  // Label already assigned.
1071  if (I->second)
1072    return;
1073
1074  // We need a label after this instruction.
1075  if (!PrevLabel) {
1076    PrevLabel = MMI->getContext().CreateTempSymbol();
1077    Asm->OutStreamer.EmitLabel(PrevLabel);
1078  }
1079  I->second = PrevLabel;
1080}
1081
1082/// identifyScopeMarkers() -
1083/// Each LexicalScope has first instruction and last instruction to mark
1084/// beginning and end of a scope respectively. Create an inverse map that list
1085/// scopes starts (and ends) with an instruction. One instruction may start (or
1086/// end) multiple scopes. Ignore scopes that are not reachable.
1087void DwarfDebug::identifyScopeMarkers() {
1088  SmallVector<LexicalScope *, 4> WorkList;
1089  WorkList.push_back(LScopes.getCurrentFunctionScope());
1090  while (!WorkList.empty()) {
1091    LexicalScope *S = WorkList.pop_back_val();
1092
1093    const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1094    if (!Children.empty())
1095      for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1096             SE = Children.end(); SI != SE; ++SI)
1097        WorkList.push_back(*SI);
1098
1099    if (S->isAbstractScope())
1100      continue;
1101
1102    const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1103    if (Ranges.empty())
1104      continue;
1105    for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1106           RE = Ranges.end(); RI != RE; ++RI) {
1107      assert(RI->first && "InsnRange does not have first instruction!");
1108      assert(RI->second && "InsnRange does not have second instruction!");
1109      requestLabelBeforeInsn(RI->first);
1110      requestLabelAfterInsn(RI->second);
1111    }
1112  }
1113}
1114
1115/// getScopeNode - Get MDNode for DebugLoc's scope.
1116static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1117  if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1118    return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1119  return DL.getScope(Ctx);
1120}
1121
1122/// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1123/// line number  info for the function.
1124static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1125  const MDNode *Scope = getScopeNode(DL, Ctx);
1126  DISubprogram SP = getDISubprogram(Scope);
1127  if (SP.Verify())
1128    return DebugLoc::get(SP.getLineNumber(), 0, SP);
1129  return DebugLoc();
1130}
1131
1132/// beginFunction - Gather pre-function debug information.  Assumes being
1133/// emitted immediately after the function entry point.
1134void DwarfDebug::beginFunction(const MachineFunction *MF) {
1135  if (!MMI->hasDebugInfo()) return;
1136  LScopes.initialize(*MF);
1137  if (LScopes.empty()) return;
1138  identifyScopeMarkers();
1139
1140  FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1141                                        Asm->getFunctionNumber());
1142  // Assumes in correct section after the entry point.
1143  Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1144
1145  assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1146
1147  const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1148  /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1149  std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1150
1151  for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1152       I != E; ++I) {
1153    bool AtBlockEntry = true;
1154    for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1155         II != IE; ++II) {
1156      const MachineInstr *MI = II;
1157
1158      if (MI->isDebugValue()) {
1159        assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1160
1161        // Keep track of user variables.
1162        const MDNode *Var =
1163          MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1164
1165        // Variable is in a register, we need to check for clobbers.
1166        if (isDbgValueInDefinedReg(MI))
1167          LiveUserVar[MI->getOperand(0).getReg()] = Var;
1168
1169        // Check the history of this variable.
1170        SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1171        if (History.empty()) {
1172          UserVariables.push_back(Var);
1173          // The first mention of a function argument gets the FunctionBeginSym
1174          // label, so arguments are visible when breaking at function entry.
1175          DIVariable DV(Var);
1176          if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1177              DISubprogram(getDISubprogram(DV.getContext()))
1178                .describes(MF->getFunction()))
1179            LabelsBeforeInsn[MI] = FunctionBeginSym;
1180        } else {
1181          // We have seen this variable before. Try to coalesce DBG_VALUEs.
1182          const MachineInstr *Prev = History.back();
1183          if (Prev->isDebugValue()) {
1184            // Coalesce identical entries at the end of History.
1185            if (History.size() >= 2 &&
1186                Prev->isIdenticalTo(History[History.size() - 2])) {
1187              DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1188                    << "\t" << *Prev
1189                    << "\t" << *History[History.size() - 2] << "\n");
1190              History.pop_back();
1191            }
1192
1193            // Terminate old register assignments that don't reach MI;
1194            MachineFunction::const_iterator PrevMBB = Prev->getParent();
1195            if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1196                isDbgValueInDefinedReg(Prev)) {
1197              // Previous register assignment needs to terminate at the end of
1198              // its basic block.
1199              MachineBasicBlock::const_iterator LastMI =
1200                PrevMBB->getLastNonDebugInstr();
1201              if (LastMI == PrevMBB->end()) {
1202                // Drop DBG_VALUE for empty range.
1203                DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1204                      << "\t" << *Prev << "\n");
1205                History.pop_back();
1206              }
1207              else {
1208                // Terminate after LastMI.
1209                History.push_back(LastMI);
1210              }
1211            }
1212          }
1213        }
1214        History.push_back(MI);
1215      } else {
1216        // Not a DBG_VALUE instruction.
1217        if (!MI->isLabel())
1218          AtBlockEntry = false;
1219
1220        // First known non DBG_VALUE location marks beginning of function
1221        // body.
1222        if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1223          PrologEndLoc = MI->getDebugLoc();
1224
1225        // Check if the instruction clobbers any registers with debug vars.
1226        for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1227               MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1228          if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1229            continue;
1230          for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1231               unsigned Reg = *AI; ++AI) {
1232            const MDNode *Var = LiveUserVar[Reg];
1233            if (!Var)
1234              continue;
1235            // Reg is now clobbered.
1236            LiveUserVar[Reg] = 0;
1237
1238            // Was MD last defined by a DBG_VALUE referring to Reg?
1239            DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1240            if (HistI == DbgValues.end())
1241              continue;
1242            SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1243            if (History.empty())
1244              continue;
1245            const MachineInstr *Prev = History.back();
1246            // Sanity-check: Register assignments are terminated at the end of
1247            // their block.
1248            if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1249              continue;
1250            // Is the variable still in Reg?
1251            if (!isDbgValueInDefinedReg(Prev) ||
1252                Prev->getOperand(0).getReg() != Reg)
1253              continue;
1254            // Var is clobbered. Make sure the next instruction gets a label.
1255            History.push_back(MI);
1256          }
1257        }
1258      }
1259    }
1260  }
1261
1262  for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1263       I != E; ++I) {
1264    SmallVectorImpl<const MachineInstr*> &History = I->second;
1265    if (History.empty())
1266      continue;
1267
1268    // Make sure the final register assignments are terminated.
1269    const MachineInstr *Prev = History.back();
1270    if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1271      const MachineBasicBlock *PrevMBB = Prev->getParent();
1272      MachineBasicBlock::const_iterator LastMI =
1273        PrevMBB->getLastNonDebugInstr();
1274      if (LastMI == PrevMBB->end())
1275        // Drop DBG_VALUE for empty range.
1276        History.pop_back();
1277      else {
1278        // Terminate after LastMI.
1279        History.push_back(LastMI);
1280      }
1281    }
1282    // Request labels for the full history.
1283    for (unsigned i = 0, e = History.size(); i != e; ++i) {
1284      const MachineInstr *MI = History[i];
1285      if (MI->isDebugValue())
1286        requestLabelBeforeInsn(MI);
1287      else
1288        requestLabelAfterInsn(MI);
1289    }
1290  }
1291
1292  PrevInstLoc = DebugLoc();
1293  PrevLabel = FunctionBeginSym;
1294
1295  // Record beginning of function.
1296  if (!PrologEndLoc.isUnknown()) {
1297    DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1298                                       MF->getFunction()->getContext());
1299    recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1300                     FnStartDL.getScope(MF->getFunction()->getContext()),
1301                     DWARF2_FLAG_IS_STMT);
1302  }
1303}
1304
1305void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1306//  SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1307  ScopeVariables[LS].push_back(Var);
1308//  Vars.push_back(Var);
1309}
1310
1311/// endFunction - Gather and emit post-function debug information.
1312///
1313void DwarfDebug::endFunction(const MachineFunction *MF) {
1314  if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1315
1316  // Define end label for subprogram.
1317  FunctionEndSym = Asm->GetTempSymbol("func_end",
1318                                      Asm->getFunctionNumber());
1319  // Assumes in correct section after the entry point.
1320  Asm->OutStreamer.EmitLabel(FunctionEndSym);
1321
1322  SmallPtrSet<const MDNode *, 16> ProcessedVars;
1323  collectVariableInfo(MF, ProcessedVars);
1324
1325  LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1326  CompileUnit *TheCU = getCompileUnit(FnScope->getScopeNode());
1327
1328  // Construct abstract scopes.
1329  ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1330  for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1331    LexicalScope *AScope = AList[i];
1332    DISubprogram SP(AScope->getScopeNode());
1333    if (SP.Verify()) {
1334      // Collect info for variables that were optimized out.
1335      StringRef FName = SP.getLinkageName();
1336      if (FName.empty())
1337        FName = SP.getName();
1338      if (NamedMDNode *NMD =
1339          getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
1340        for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1341          DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1342          if (!DV || !ProcessedVars.insert(DV))
1343            continue;
1344          if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1345            addScopeVariable(Scope, new DbgVariable(DV, NULL));
1346        }
1347      }
1348    }
1349    if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1350      constructScopeDIE(TheCU, AScope);
1351  }
1352
1353  DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1354
1355  if (!DisableFramePointerElim(*MF))
1356    TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1357                   dwarf::DW_FORM_flag, 1);
1358
1359  DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1360                                               MMI->getFrameMoves()));
1361
1362  // Clear debug info
1363  for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1364         I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1365    DeleteContainerPointers(I->second);
1366  ScopeVariables.clear();
1367  DeleteContainerPointers(CurrentFnArguments);
1368  UserVariables.clear();
1369  DbgValues.clear();
1370  AbstractVariables.clear();
1371  LabelsBeforeInsn.clear();
1372  LabelsAfterInsn.clear();
1373  PrevLabel = NULL;
1374}
1375
1376/// recordSourceLine - Register a source line with debug info. Returns the
1377/// unique label that was emitted and which provides correspondence to
1378/// the source line list.
1379void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1380                                  unsigned Flags) {
1381  StringRef Fn;
1382  StringRef Dir;
1383  unsigned Src = 1;
1384  if (S) {
1385    DIDescriptor Scope(S);
1386
1387    if (Scope.isCompileUnit()) {
1388      DICompileUnit CU(S);
1389      Fn = CU.getFilename();
1390      Dir = CU.getDirectory();
1391    } else if (Scope.isFile()) {
1392      DIFile F(S);
1393      Fn = F.getFilename();
1394      Dir = F.getDirectory();
1395    } else if (Scope.isSubprogram()) {
1396      DISubprogram SP(S);
1397      Fn = SP.getFilename();
1398      Dir = SP.getDirectory();
1399    } else if (Scope.isLexicalBlock()) {
1400      DILexicalBlock DB(S);
1401      Fn = DB.getFilename();
1402      Dir = DB.getDirectory();
1403    } else
1404      assert(0 && "Unexpected scope info");
1405
1406    Src = GetOrCreateSourceID(Fn, Dir);
1407  }
1408  Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1409}
1410
1411//===----------------------------------------------------------------------===//
1412// Emit Methods
1413//===----------------------------------------------------------------------===//
1414
1415/// computeSizeAndOffset - Compute the size and offset of a DIE.
1416///
1417unsigned
1418DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1419  // Get the children.
1420  const std::vector<DIE *> &Children = Die->getChildren();
1421
1422  // If not last sibling and has children then add sibling offset attribute.
1423  if (!Last && !Children.empty())
1424    Die->addSiblingOffset(DIEValueAllocator);
1425
1426  // Record the abbreviation.
1427  assignAbbrevNumber(Die->getAbbrev());
1428
1429  // Get the abbreviation for this DIE.
1430  unsigned AbbrevNumber = Die->getAbbrevNumber();
1431  const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1432
1433  // Set DIE offset
1434  Die->setOffset(Offset);
1435
1436  // Start the size with the size of abbreviation code.
1437  Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1438
1439  const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1440  const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1441
1442  // Size the DIE attribute values.
1443  for (unsigned i = 0, N = Values.size(); i < N; ++i)
1444    // Size attribute value.
1445    Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1446
1447  // Size the DIE children if any.
1448  if (!Children.empty()) {
1449    assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1450           "Children flag not set");
1451
1452    for (unsigned j = 0, M = Children.size(); j < M; ++j)
1453      Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1454
1455    // End of children marker.
1456    Offset += sizeof(int8_t);
1457  }
1458
1459  Die->setSize(Offset - Die->getOffset());
1460  return Offset;
1461}
1462
1463/// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1464///
1465void DwarfDebug::computeSizeAndOffsets() {
1466  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1467         E = CUMap.end(); I != E; ++I) {
1468    // Compute size of compile unit header.
1469    unsigned Offset =
1470      sizeof(int32_t) + // Length of Compilation Unit Info
1471      sizeof(int16_t) + // DWARF version number
1472      sizeof(int32_t) + // Offset Into Abbrev. Section
1473      sizeof(int8_t);   // Pointer Size (in bytes)
1474    computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1475  }
1476}
1477
1478/// EmitSectionSym - Switch to the specified MCSection and emit an assembler
1479/// temporary label to it if SymbolStem is specified.
1480static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
1481                                const char *SymbolStem = 0) {
1482  Asm->OutStreamer.SwitchSection(Section);
1483  if (!SymbolStem) return 0;
1484
1485  MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
1486  Asm->OutStreamer.EmitLabel(TmpSym);
1487  return TmpSym;
1488}
1489
1490/// EmitSectionLabels - Emit initial Dwarf sections with a label at
1491/// the start of each one.
1492void DwarfDebug::EmitSectionLabels() {
1493  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1494
1495  // Dwarf sections base addresses.
1496  DwarfInfoSectionSym =
1497    EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1498  DwarfAbbrevSectionSym =
1499    EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1500  EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1501
1502  if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1503    EmitSectionSym(Asm, MacroInfo);
1504
1505  EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1506  EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1507  EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1508  EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1509  DwarfStrSectionSym =
1510    EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1511  DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1512                                             "debug_range");
1513
1514  DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1515                                           "section_debug_loc");
1516
1517  TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1518  EmitSectionSym(Asm, TLOF.getDataSection());
1519}
1520
1521/// emitDIE - Recursively emits a debug information entry.
1522///
1523void DwarfDebug::emitDIE(DIE *Die) {
1524  // Get the abbreviation for this DIE.
1525  unsigned AbbrevNumber = Die->getAbbrevNumber();
1526  const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1527
1528  // Emit the code (index) for the abbreviation.
1529  if (Asm->isVerbose())
1530    Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1531                                Twine::utohexstr(Die->getOffset()) + ":0x" +
1532                                Twine::utohexstr(Die->getSize()) + " " +
1533                                dwarf::TagString(Abbrev->getTag()));
1534  Asm->EmitULEB128(AbbrevNumber);
1535
1536  const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1537  const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1538
1539  // Emit the DIE attribute values.
1540  for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1541    unsigned Attr = AbbrevData[i].getAttribute();
1542    unsigned Form = AbbrevData[i].getForm();
1543    assert(Form && "Too many attributes for DIE (check abbreviation)");
1544
1545    if (Asm->isVerbose())
1546      Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1547
1548    switch (Attr) {
1549    case dwarf::DW_AT_sibling:
1550      Asm->EmitInt32(Die->getSiblingOffset());
1551      break;
1552    case dwarf::DW_AT_abstract_origin: {
1553      DIEEntry *E = cast<DIEEntry>(Values[i]);
1554      DIE *Origin = E->getEntry();
1555      unsigned Addr = Origin->getOffset();
1556      Asm->EmitInt32(Addr);
1557      break;
1558    }
1559    case dwarf::DW_AT_ranges: {
1560      // DW_AT_range Value encodes offset in debug_range section.
1561      DIEInteger *V = cast<DIEInteger>(Values[i]);
1562
1563      if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1564        Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1565                                 V->getValue(),
1566                                 4);
1567      } else {
1568        Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1569                                       V->getValue(),
1570                                       DwarfDebugRangeSectionSym,
1571                                       4);
1572      }
1573      break;
1574    }
1575    case dwarf::DW_AT_location: {
1576      if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1577        Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1578      else
1579        Values[i]->EmitValue(Asm, Form);
1580      break;
1581    }
1582    case dwarf::DW_AT_accessibility: {
1583      if (Asm->isVerbose()) {
1584        DIEInteger *V = cast<DIEInteger>(Values[i]);
1585        Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1586      }
1587      Values[i]->EmitValue(Asm, Form);
1588      break;
1589    }
1590    default:
1591      // Emit an attribute using the defined form.
1592      Values[i]->EmitValue(Asm, Form);
1593      break;
1594    }
1595  }
1596
1597  // Emit the DIE children if any.
1598  if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1599    const std::vector<DIE *> &Children = Die->getChildren();
1600
1601    for (unsigned j = 0, M = Children.size(); j < M; ++j)
1602      emitDIE(Children[j]);
1603
1604    if (Asm->isVerbose())
1605      Asm->OutStreamer.AddComment("End Of Children Mark");
1606    Asm->EmitInt8(0);
1607  }
1608}
1609
1610/// emitDebugInfo - Emit the debug info section.
1611///
1612void DwarfDebug::emitDebugInfo() {
1613  // Start debug info section.
1614  Asm->OutStreamer.SwitchSection(
1615                            Asm->getObjFileLowering().getDwarfInfoSection());
1616  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1617         E = CUMap.end(); I != E; ++I) {
1618    CompileUnit *TheCU = I->second;
1619    DIE *Die = TheCU->getCUDie();
1620
1621    // Emit the compile units header.
1622    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1623                                                  TheCU->getID()));
1624
1625    // Emit size of content not including length itself
1626    unsigned ContentSize = Die->getSize() +
1627      sizeof(int16_t) + // DWARF version number
1628      sizeof(int32_t) + // Offset Into Abbrev. Section
1629      sizeof(int8_t);   // Pointer Size (in bytes)
1630
1631    Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1632    Asm->EmitInt32(ContentSize);
1633    Asm->OutStreamer.AddComment("DWARF version number");
1634    Asm->EmitInt16(dwarf::DWARF_VERSION);
1635    Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1636    Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1637                           DwarfAbbrevSectionSym);
1638    Asm->OutStreamer.AddComment("Address Size (in bytes)");
1639    Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1640
1641    emitDIE(Die);
1642    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1643  }
1644}
1645
1646/// emitAbbreviations - Emit the abbreviation section.
1647///
1648void DwarfDebug::emitAbbreviations() const {
1649  // Check to see if it is worth the effort.
1650  if (!Abbreviations.empty()) {
1651    // Start the debug abbrev section.
1652    Asm->OutStreamer.SwitchSection(
1653                            Asm->getObjFileLowering().getDwarfAbbrevSection());
1654
1655    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1656
1657    // For each abbrevation.
1658    for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1659      // Get abbreviation data
1660      const DIEAbbrev *Abbrev = Abbreviations[i];
1661
1662      // Emit the abbrevations code (base 1 index.)
1663      Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1664
1665      // Emit the abbreviations data.
1666      Abbrev->Emit(Asm);
1667    }
1668
1669    // Mark end of abbreviations.
1670    Asm->EmitULEB128(0, "EOM(3)");
1671
1672    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1673  }
1674}
1675
1676/// emitEndOfLineMatrix - Emit the last address of the section and the end of
1677/// the line matrix.
1678///
1679void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1680  // Define last address of section.
1681  Asm->OutStreamer.AddComment("Extended Op");
1682  Asm->EmitInt8(0);
1683
1684  Asm->OutStreamer.AddComment("Op size");
1685  Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1686  Asm->OutStreamer.AddComment("DW_LNE_set_address");
1687  Asm->EmitInt8(dwarf::DW_LNE_set_address);
1688
1689  Asm->OutStreamer.AddComment("Section end label");
1690
1691  Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1692                                   Asm->getTargetData().getPointerSize(),
1693                                   0/*AddrSpace*/);
1694
1695  // Mark end of matrix.
1696  Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1697  Asm->EmitInt8(0);
1698  Asm->EmitInt8(1);
1699  Asm->EmitInt8(1);
1700}
1701
1702/// emitDebugPubNames - Emit visible names into a debug pubnames section.
1703///
1704void DwarfDebug::emitDebugPubNames() {
1705  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1706         E = CUMap.end(); I != E; ++I) {
1707    CompileUnit *TheCU = I->second;
1708    // Start the dwarf pubnames section.
1709    Asm->OutStreamer.SwitchSection(
1710      Asm->getObjFileLowering().getDwarfPubNamesSection());
1711
1712    Asm->OutStreamer.AddComment("Length of Public Names Info");
1713    Asm->EmitLabelDifference(
1714      Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
1715      Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
1716
1717    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
1718                                                  TheCU->getID()));
1719
1720    Asm->OutStreamer.AddComment("DWARF Version");
1721    Asm->EmitInt16(dwarf::DWARF_VERSION);
1722
1723    Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1724    Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1725                           DwarfInfoSectionSym);
1726
1727    Asm->OutStreamer.AddComment("Compilation Unit Length");
1728    Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1729                             Asm->GetTempSymbol("info_begin", TheCU->getID()),
1730                             4);
1731
1732    const StringMap<DIE*> &Globals = TheCU->getGlobals();
1733    for (StringMap<DIE*>::const_iterator
1734           GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1735      const char *Name = GI->getKeyData();
1736      DIE *Entity = GI->second;
1737
1738      Asm->OutStreamer.AddComment("DIE offset");
1739      Asm->EmitInt32(Entity->getOffset());
1740
1741      if (Asm->isVerbose())
1742        Asm->OutStreamer.AddComment("External Name");
1743      Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
1744    }
1745
1746    Asm->OutStreamer.AddComment("End Mark");
1747    Asm->EmitInt32(0);
1748    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
1749                                                  TheCU->getID()));
1750  }
1751}
1752
1753void DwarfDebug::emitDebugPubTypes() {
1754  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1755         E = CUMap.end(); I != E; ++I) {
1756    CompileUnit *TheCU = I->second;
1757    // Start the dwarf pubnames section.
1758    Asm->OutStreamer.SwitchSection(
1759      Asm->getObjFileLowering().getDwarfPubTypesSection());
1760    Asm->OutStreamer.AddComment("Length of Public Types Info");
1761    Asm->EmitLabelDifference(
1762      Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1763      Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1764
1765    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1766                                                  TheCU->getID()));
1767
1768    if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1769    Asm->EmitInt16(dwarf::DWARF_VERSION);
1770
1771    Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1772    Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1773                           DwarfInfoSectionSym);
1774
1775    Asm->OutStreamer.AddComment("Compilation Unit Length");
1776    Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1777                             Asm->GetTempSymbol("info_begin", TheCU->getID()),
1778                             4);
1779
1780    const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1781    for (StringMap<DIE*>::const_iterator
1782           GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1783      const char *Name = GI->getKeyData();
1784      DIE *Entity = GI->second;
1785
1786      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1787      Asm->EmitInt32(Entity->getOffset());
1788
1789      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1790      Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1791    }
1792
1793    Asm->OutStreamer.AddComment("End Mark");
1794    Asm->EmitInt32(0);
1795    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1796                                                  TheCU->getID()));
1797  }
1798}
1799
1800/// emitDebugStr - Emit visible names into a debug str section.
1801///
1802void DwarfDebug::emitDebugStr() {
1803  // Check to see if it is worth the effort.
1804  if (StringPool.empty()) return;
1805
1806  // Start the dwarf str section.
1807  Asm->OutStreamer.SwitchSection(
1808                                Asm->getObjFileLowering().getDwarfStrSection());
1809
1810  // Get all of the string pool entries and put them in an array by their ID so
1811  // we can sort them.
1812  SmallVector<std::pair<unsigned,
1813      StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1814
1815  for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1816       I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1817    Entries.push_back(std::make_pair(I->second.second, &*I));
1818
1819  array_pod_sort(Entries.begin(), Entries.end());
1820
1821  for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1822    // Emit a label for reference from debug information entries.
1823    Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1824
1825    // Emit the string itself.
1826    Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
1827  }
1828}
1829
1830/// emitDebugLoc - Emit visible names into a debug loc section.
1831///
1832void DwarfDebug::emitDebugLoc() {
1833  if (DotDebugLocEntries.empty())
1834    return;
1835
1836  for (SmallVector<DotDebugLocEntry, 4>::iterator
1837         I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1838       I != E; ++I) {
1839    DotDebugLocEntry &Entry = *I;
1840    if (I + 1 != DotDebugLocEntries.end())
1841      Entry.Merge(I+1);
1842  }
1843
1844  // Start the dwarf loc section.
1845  Asm->OutStreamer.SwitchSection(
1846    Asm->getObjFileLowering().getDwarfLocSection());
1847  unsigned char Size = Asm->getTargetData().getPointerSize();
1848  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1849  unsigned index = 1;
1850  for (SmallVector<DotDebugLocEntry, 4>::iterator
1851         I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1852       I != E; ++I, ++index) {
1853    DotDebugLocEntry &Entry = *I;
1854    if (Entry.isMerged()) continue;
1855    if (Entry.isEmpty()) {
1856      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1857      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1858      Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1859    } else {
1860      Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1861      Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1862      DIVariable DV(Entry.Variable);
1863      Asm->OutStreamer.AddComment("Loc expr size");
1864      MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1865      MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1866      Asm->EmitLabelDifference(end, begin, 2);
1867      Asm->OutStreamer.EmitLabel(begin);
1868      if (Entry.isInt()) {
1869        DIBasicType BTy(DV.getType());
1870        if (BTy.Verify() &&
1871            (BTy.getEncoding()  == dwarf::DW_ATE_signed
1872             || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1873          Asm->OutStreamer.AddComment("DW_OP_consts");
1874          Asm->EmitInt8(dwarf::DW_OP_consts);
1875          Asm->EmitSLEB128(Entry.getInt());
1876        } else {
1877          Asm->OutStreamer.AddComment("DW_OP_constu");
1878          Asm->EmitInt8(dwarf::DW_OP_constu);
1879          Asm->EmitULEB128(Entry.getInt());
1880        }
1881      } else if (Entry.isLocation()) {
1882        if (!DV.hasComplexAddress())
1883          // Regular entry.
1884          Asm->EmitDwarfRegOp(Entry.Loc);
1885        else {
1886          // Complex address entry.
1887          unsigned N = DV.getNumAddrElements();
1888          unsigned i = 0;
1889          if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1890            if (Entry.Loc.getOffset()) {
1891              i = 2;
1892              Asm->EmitDwarfRegOp(Entry.Loc);
1893              Asm->OutStreamer.AddComment("DW_OP_deref");
1894              Asm->EmitInt8(dwarf::DW_OP_deref);
1895              Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
1896              Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
1897              Asm->EmitSLEB128(DV.getAddrElement(1));
1898            } else {
1899              // If first address element is OpPlus then emit
1900              // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
1901              MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
1902              Asm->EmitDwarfRegOp(Loc);
1903              i = 2;
1904            }
1905          } else {
1906            Asm->EmitDwarfRegOp(Entry.Loc);
1907          }
1908
1909          // Emit remaining complex address elements.
1910          for (; i < N; ++i) {
1911            uint64_t Element = DV.getAddrElement(i);
1912            if (Element == DIBuilder::OpPlus) {
1913              Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
1914              Asm->EmitULEB128(DV.getAddrElement(++i));
1915            } else if (Element == DIBuilder::OpDeref)
1916              Asm->EmitInt8(dwarf::DW_OP_deref);
1917            else llvm_unreachable("unknown Opcode found in complex address");
1918          }
1919        }
1920      }
1921      // else ... ignore constant fp. There is not any good way to
1922      // to represent them here in dwarf.
1923      Asm->OutStreamer.EmitLabel(end);
1924    }
1925  }
1926}
1927
1928/// EmitDebugARanges - Emit visible names into a debug aranges section.
1929///
1930void DwarfDebug::EmitDebugARanges() {
1931  // Start the dwarf aranges section.
1932  Asm->OutStreamer.SwitchSection(
1933                          Asm->getObjFileLowering().getDwarfARangesSection());
1934}
1935
1936/// emitDebugRanges - Emit visible names into a debug ranges section.
1937///
1938void DwarfDebug::emitDebugRanges() {
1939  // Start the dwarf ranges section.
1940  Asm->OutStreamer.SwitchSection(
1941    Asm->getObjFileLowering().getDwarfRangesSection());
1942  unsigned char Size = Asm->getTargetData().getPointerSize();
1943  for (SmallVector<const MCSymbol *, 8>::iterator
1944         I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
1945       I != E; ++I) {
1946    if (*I)
1947      Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
1948    else
1949      Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1950  }
1951}
1952
1953/// emitDebugMacInfo - Emit visible names into a debug macinfo section.
1954///
1955void DwarfDebug::emitDebugMacInfo() {
1956  if (const MCSection *LineInfo =
1957      Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
1958    // Start the dwarf macinfo section.
1959    Asm->OutStreamer.SwitchSection(LineInfo);
1960  }
1961}
1962
1963/// emitDebugInlineInfo - Emit inline info using following format.
1964/// Section Header:
1965/// 1. length of section
1966/// 2. Dwarf version number
1967/// 3. address size.
1968///
1969/// Entries (one "entry" for each function that was inlined):
1970///
1971/// 1. offset into __debug_str section for MIPS linkage name, if exists;
1972///   otherwise offset into __debug_str for regular function name.
1973/// 2. offset into __debug_str section for regular function name.
1974/// 3. an unsigned LEB128 number indicating the number of distinct inlining
1975/// instances for the function.
1976///
1977/// The rest of the entry consists of a {die_offset, low_pc} pair for each
1978/// inlined instance; the die_offset points to the inlined_subroutine die in the
1979/// __debug_info section, and the low_pc is the starting address for the
1980/// inlining instance.
1981void DwarfDebug::emitDebugInlineInfo() {
1982  if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
1983    return;
1984
1985  if (!FirstCU)
1986    return;
1987
1988  Asm->OutStreamer.SwitchSection(
1989                        Asm->getObjFileLowering().getDwarfDebugInlineSection());
1990
1991  Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
1992  Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
1993                           Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
1994
1995  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
1996
1997  Asm->OutStreamer.AddComment("Dwarf Version");
1998  Asm->EmitInt16(dwarf::DWARF_VERSION);
1999  Asm->OutStreamer.AddComment("Address Size (in bytes)");
2000  Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2001
2002  for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2003         E = InlinedSPNodes.end(); I != E; ++I) {
2004
2005    const MDNode *Node = *I;
2006    DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2007      = InlineInfo.find(Node);
2008    SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2009    DISubprogram SP(Node);
2010    StringRef LName = SP.getLinkageName();
2011    StringRef Name = SP.getName();
2012
2013    Asm->OutStreamer.AddComment("MIPS linkage name");
2014    if (LName.empty()) {
2015      Asm->OutStreamer.EmitBytes(Name, 0);
2016      Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2017    } else
2018      Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2019                             DwarfStrSectionSym);
2020
2021    Asm->OutStreamer.AddComment("Function name");
2022    Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2023    Asm->EmitULEB128(Labels.size(), "Inline count");
2024
2025    for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2026           LE = Labels.end(); LI != LE; ++LI) {
2027      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2028      Asm->EmitInt32(LI->second->getOffset());
2029
2030      if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2031      Asm->OutStreamer.EmitSymbolValue(LI->first,
2032                                       Asm->getTargetData().getPointerSize(),0);
2033    }
2034  }
2035
2036  Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2037}
2038