DwarfDebug.h revision 8162574aaafff760abf04ec780c24b45b6d9cfdb
1//===-- llvm/CodeGen/DwarfDebug.h - Dwarf Debug Framework ------*- C++ -*--===//
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#ifndef CODEGEN_ASMPRINTER_DWARFDEBUG_H__
15#define CODEGEN_ASMPRINTER_DWARFDEBUG_H__
16
17#include "llvm/CodeGen/AsmPrinter.h"
18#include "llvm/CodeGen/MachineLocation.h"
19#include "DIE.h"
20#include "llvm/ADT/DenseMap.h"
21#include "llvm/ADT/FoldingSet.h"
22#include "llvm/ADT/SmallPtrSet.h"
23#include "llvm/ADT/StringMap.h"
24#include "llvm/ADT/UniqueVector.h"
25#include "llvm/Support/Allocator.h"
26
27namespace llvm {
28
29class CompileUnit;
30class DbgConcreteScope;
31class DbgScope;
32class DbgVariable;
33class MachineFrameInfo;
34class MachineModuleInfo;
35class MachineOperand;
36class MCAsmInfo;
37class DIEAbbrev;
38class DIE;
39class DIEBlock;
40class DIEEntry;
41
42class DIEnumerator;
43class DIDescriptor;
44class DIVariable;
45class DIGlobal;
46class DIGlobalVariable;
47class DISubprogram;
48class DIBasicType;
49class DIDerivedType;
50class DIType;
51class DINameSpace;
52class DISubrange;
53class DICompositeType;
54
55//===----------------------------------------------------------------------===//
56/// SrcLineInfo - This class is used to record source line correspondence.
57///
58class SrcLineInfo {
59  unsigned Line;                     // Source line number.
60  unsigned Column;                   // Source column.
61  unsigned SourceID;                 // Source ID number.
62  MCSymbol *Label;                   // Label in code ID number.
63public:
64  SrcLineInfo(unsigned L, unsigned C, unsigned S, MCSymbol *label)
65    : Line(L), Column(C), SourceID(S), Label(label) {}
66
67  // Accessors
68  unsigned getLine() const { return Line; }
69  unsigned getColumn() const { return Column; }
70  unsigned getSourceID() const { return SourceID; }
71  MCSymbol *getLabel() const { return Label; }
72};
73
74class DwarfDebug {
75  /// Asm - Target of Dwarf emission.
76  AsmPrinter *Asm;
77
78  /// MMI - Collected machine module information.
79  MachineModuleInfo *MMI;
80
81  //===--------------------------------------------------------------------===//
82  // Attributes used to construct specific Dwarf sections.
83  //
84
85  CompileUnit *FirstCU;
86  DenseMap <const MDNode *, CompileUnit *> CUMap;
87
88  /// AbbreviationsSet - Used to uniquely define abbreviations.
89  ///
90  FoldingSet<DIEAbbrev> AbbreviationsSet;
91
92  /// Abbreviations - A list of all the unique abbreviations in use.
93  ///
94  std::vector<DIEAbbrev *> Abbreviations;
95
96  /// DirectoryIdMap - Directory name to directory id map.
97  ///
98  StringMap<unsigned> DirectoryIdMap;
99
100  /// DirectoryNames - A list of directory names.
101  SmallVector<std::string, 8> DirectoryNames;
102
103  /// SourceFileIdMap - Source file name to source file id map.
104  ///
105  StringMap<unsigned> SourceFileIdMap;
106
107  /// SourceFileNames - A list of source file names.
108  SmallVector<std::string, 8> SourceFileNames;
109
110  /// SourceIdMap - Source id map, i.e. pair of directory id and source file
111  /// id mapped to a unique id.
112  DenseMap<std::pair<unsigned, unsigned>, unsigned> SourceIdMap;
113
114  /// SourceIds - Reverse map from source id to directory id + file id pair.
115  ///
116  SmallVector<std::pair<unsigned, unsigned>, 8> SourceIds;
117
118  /// Lines - List of source line correspondence.
119  std::vector<SrcLineInfo> Lines;
120
121  /// DIEBlocks - A list of all the DIEBlocks in use.
122  std::vector<DIEBlock *> DIEBlocks;
123
124  // DIEValueAllocator - All DIEValues are allocated through this allocator.
125  BumpPtrAllocator DIEValueAllocator;
126
127  /// StringPool - A String->Symbol mapping of strings used by indirect
128  /// references.
129  StringMap<std::pair<MCSymbol*, unsigned> > StringPool;
130  unsigned NextStringPoolNumber;
131
132  MCSymbol *getStringPoolEntry(StringRef Str);
133
134  /// SectionMap - Provides a unique id per text section.
135  ///
136  UniqueVector<const MCSection*> SectionMap;
137
138  /// SectionSourceLines - Tracks line numbers per text section.
139  ///
140  std::vector<std::vector<SrcLineInfo> > SectionSourceLines;
141
142  // CurrentFnDbgScope - Top level scope for the current function.
143  //
144  DbgScope *CurrentFnDbgScope;
145
146  /// DbgScopeMap - Tracks the scopes in the current function.  Owns the
147  /// contained DbgScope*s.
148  ///
149  DenseMap<const MDNode *, DbgScope *> DbgScopeMap;
150
151  /// ConcreteScopes - Tracks the concrete scopees in the current function.
152  /// These scopes are also included in DbgScopeMap.
153  DenseMap<const MDNode *, DbgScope *> ConcreteScopes;
154
155  /// AbstractScopes - Tracks the abstract scopes a module. These scopes are
156  /// not included DbgScopeMap.  AbstractScopes owns its DbgScope*s.
157  DenseMap<const MDNode *, DbgScope *> AbstractScopes;
158
159  /// AbstractSPDies - Collection of abstract subprogram DIEs.
160  DenseMap<const MDNode *, DIE *> AbstractSPDies;
161
162  /// AbstractScopesList - Tracks abstract scopes constructed while processing
163  /// a function. This list is cleared during endFunction().
164  SmallVector<DbgScope *, 4>AbstractScopesList;
165
166  /// AbstractVariables - Collection on abstract variables.  Owned by the
167  /// DbgScopes in AbstractScopes.
168  DenseMap<const MDNode *, DbgVariable *> AbstractVariables;
169
170  /// DbgVariableToFrameIndexMap - Tracks frame index used to find
171  /// variable's value.
172  DenseMap<const DbgVariable *, int> DbgVariableToFrameIndexMap;
173
174  /// DbgVariableToDbgInstMap - Maps DbgVariable to corresponding DBG_VALUE
175  /// machine instruction.
176  DenseMap<const DbgVariable *, const MachineInstr *> DbgVariableToDbgInstMap;
177
178  /// DbgVariableLabelsMap - Maps DbgVariable to corresponding MCSymbol.
179  DenseMap<const DbgVariable *, const MCSymbol *> DbgVariableLabelsMap;
180
181  /// DotDebugLocEntry - This struct describes location entries emitted in
182  /// .debug_loc section.
183  typedef struct DotDebugLocEntry {
184    const MCSymbol *Begin;
185    const MCSymbol *End;
186    MachineLocation Loc;
187    DotDebugLocEntry() : Begin(0), End(0) {}
188    DotDebugLocEntry(const MCSymbol *B, const MCSymbol *E,
189                  MachineLocation &L) : Begin(B), End(E), Loc(L) {}
190    /// Empty entries are also used as a trigger to emit temp label. Such
191    /// labels are referenced is used to find debug_loc offset for a given DIE.
192    bool isEmpty() { return Begin == 0 && End == 0; }
193  } DotDebugLocEntry;
194
195  /// DotDebugLocEntries - Collection of DotDebugLocEntry.
196  SmallVector<DotDebugLocEntry, 4> DotDebugLocEntries;
197
198  /// UseDotDebugLocEntry - DW_AT_location attributes for the DIEs in this set
199  /// idetifies corresponding .debug_loc entry offset.
200  SmallPtrSet<const DIE *, 4> UseDotDebugLocEntry;
201
202  /// VarToAbstractVarMap - Maps DbgVariable with corresponding Abstract
203  /// DbgVariable, if any.
204  DenseMap<const DbgVariable *, const DbgVariable *> VarToAbstractVarMap;
205
206  /// InliendSubprogramDIEs - Collection of subprgram DIEs that are marked
207  /// (at the end of the module) as DW_AT_inline.
208  SmallPtrSet<DIE *, 4> InlinedSubprogramDIEs;
209
210  /// ContainingTypeMap - This map is used to keep track of subprogram DIEs that
211  /// need DW_AT_containing_type attribute. This attribute points to a DIE that
212  /// corresponds to the MDNode mapped with the subprogram DIE.
213  DenseMap<DIE *, const MDNode *> ContainingTypeMap;
214
215  typedef SmallVector<DbgScope *, 2> ScopeVector;
216
217  SmallPtrSet<const MachineInstr *, 8> InsnsEndScopeSet;
218
219  /// InlineInfo - Keep track of inlined functions and their location.  This
220  /// information is used to populate debug_inlined section.
221  typedef std::pair<const MCSymbol *, DIE *> InlineInfoLabels;
222  DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> > InlineInfo;
223  SmallVector<const MDNode *, 4> InlinedSPNodes;
224
225  // ProcessedSPNodes - This is a collection of subprogram MDNodes that
226  // are processed to create DIEs.
227  SmallPtrSet<const MDNode *, 16> ProcessedSPNodes;
228
229  /// LabelsBeforeInsn - Maps instruction with label emitted before
230  /// instruction.
231  DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn;
232
233  /// LabelsAfterInsn - Maps instruction with label emitted after
234  /// instruction.
235  DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn;
236
237  /// insnNeedsLabel - Collection of instructions that need a label to mark
238  /// a debuggging information entity.
239  SmallPtrSet<const MachineInstr *, 8> InsnNeedsLabel;
240
241  SmallVector<const MCSymbol *, 8> DebugRangeSymbols;
242
243  /// Previous instruction's location information. This is used to determine
244  /// label location to indicate scope boundries in dwarf debug info.
245  DebugLoc PrevInstLoc;
246  MCSymbol *PrevLabel;
247
248  struct FunctionDebugFrameInfo {
249    unsigned Number;
250    std::vector<MachineMove> Moves;
251
252    FunctionDebugFrameInfo(unsigned Num, const std::vector<MachineMove> &M)
253      : Number(Num), Moves(M) {}
254  };
255
256  std::vector<FunctionDebugFrameInfo> DebugFrames;
257
258  // Section Symbols: these are assembler temporary labels that are emitted at
259  // the beginning of each supported dwarf section.  These are used to form
260  // section offsets and are created by EmitSectionLabels.
261  MCSymbol *DwarfFrameSectionSym, *DwarfInfoSectionSym, *DwarfAbbrevSectionSym;
262  MCSymbol *DwarfStrSectionSym, *TextSectionSym, *DwarfDebugRangeSectionSym;
263  MCSymbol *DwarfDebugLocSectionSym;
264  MCSymbol *DwarfDebugLineSectionSym, *CurrentLineSectionSym;
265  MCSymbol *FunctionBeginSym, *FunctionEndSym;
266
267  DIEInteger *DIEIntegerOne;
268private:
269
270  /// getSourceDirectoryAndFileIds - Return the directory and file ids that
271  /// maps to the source id. Source id starts at 1.
272  std::pair<unsigned, unsigned>
273  getSourceDirectoryAndFileIds(unsigned SId) const {
274    return SourceIds[SId-1];
275  }
276
277  /// getNumSourceDirectories - Return the number of source directories in the
278  /// debug info.
279  unsigned getNumSourceDirectories() const {
280    return DirectoryNames.size();
281  }
282
283  /// getSourceDirectoryName - Return the name of the directory corresponding
284  /// to the id.
285  const std::string &getSourceDirectoryName(unsigned Id) const {
286    return DirectoryNames[Id - 1];
287  }
288
289  /// getSourceFileName - Return the name of the source file corresponding
290  /// to the id.
291  const std::string &getSourceFileName(unsigned Id) const {
292    return SourceFileNames[Id - 1];
293  }
294
295  /// getNumSourceIds - Return the number of unique source ids.
296  unsigned getNumSourceIds() const {
297    return SourceIds.size();
298  }
299
300  /// assignAbbrevNumber - Define a unique number for the abbreviation.
301  ///
302  void assignAbbrevNumber(DIEAbbrev &Abbrev);
303
304  /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
305  /// information entry.
306  DIEEntry *createDIEEntry(DIE *Entry);
307
308  /// addUInt - Add an unsigned integer attribute data and value.
309  ///
310  void addUInt(DIE *Die, unsigned Attribute, unsigned Form, uint64_t Integer);
311
312  /// addSInt - Add an signed integer attribute data and value.
313  ///
314  void addSInt(DIE *Die, unsigned Attribute, unsigned Form, int64_t Integer);
315
316  /// addString - Add a string attribute data and value.
317  ///
318  void addString(DIE *Die, unsigned Attribute, unsigned Form,
319                 const StringRef Str);
320
321  /// addLabel - Add a Dwarf label attribute data and value.
322  ///
323  void addLabel(DIE *Die, unsigned Attribute, unsigned Form,
324                const MCSymbol *Label);
325
326  /// addDelta - Add a label delta attribute data and value.
327  ///
328  void addDelta(DIE *Die, unsigned Attribute, unsigned Form,
329                const MCSymbol *Hi, const MCSymbol *Lo);
330
331  /// addDIEEntry - Add a DIE attribute data and value.
332  ///
333  void addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form, DIE *Entry);
334
335  /// addBlock - Add block data.
336  ///
337  void addBlock(DIE *Die, unsigned Attribute, unsigned Form, DIEBlock *Block);
338
339  /// addSourceLine - Add location information to specified debug information
340  /// entry.
341  void addSourceLine(DIE *Die, const DIVariable V);
342  void addSourceLine(DIE *Die, const DIGlobalVariable G);
343  void addSourceLine(DIE *Die, const DISubprogram SP);
344  void addSourceLine(DIE *Die, const DIType Ty);
345  void addSourceLine(DIE *Die, const DINameSpace NS);
346
347  /// addAddress - Add an address attribute to a die based on the location
348  /// provided.
349  void addAddress(DIE *Die, unsigned Attribute,
350                  const MachineLocation &Location);
351
352  /// addRegisterAddress - Add register location entry in variable DIE.
353  bool addRegisterAddress(DIE *Die, const MCSymbol *VS, const MachineOperand &MO);
354
355  /// addConstantValue - Add constant value entry in variable DIE.
356  bool addConstantValue(DIE *Die, const MCSymbol *VS, const MachineOperand &MO);
357
358  /// addConstantFPValue - Add constant value entry in variable DIE.
359  bool addConstantFPValue(DIE *Die, const MCSymbol *VS, const MachineOperand &MO);
360
361  /// addComplexAddress - Start with the address based on the location provided,
362  /// and generate the DWARF information necessary to find the actual variable
363  /// (navigating the extra location information encoded in the type) based on
364  /// the starting location.  Add the DWARF information to the die.
365  ///
366  void addComplexAddress(DbgVariable *&DV, DIE *Die, unsigned Attribute,
367                         const MachineLocation &Location);
368
369  // FIXME: Should be reformulated in terms of addComplexAddress.
370  /// addBlockByrefAddress - Start with the address based on the location
371  /// provided, and generate the DWARF information necessary to find the
372  /// actual Block variable (navigating the Block struct) based on the
373  /// starting location.  Add the DWARF information to the die.  Obsolete,
374  /// please use addComplexAddress instead.
375  ///
376  void addBlockByrefAddress(DbgVariable *&DV, DIE *Die, unsigned Attribute,
377                            const MachineLocation &Location);
378
379  /// addToContextOwner - Add Die into the list of its context owner's children.
380  void addToContextOwner(DIE *Die, DIDescriptor Context);
381
382  /// addType - Add a new type attribute to the specified entity.
383  void addType(DIE *Entity, DIType Ty);
384
385
386  /// getOrCreateNameSpace - Create a DIE for DINameSpace.
387  DIE *getOrCreateNameSpace(DINameSpace NS);
388
389  /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
390  /// given DIType.
391  DIE *getOrCreateTypeDIE(DIType Ty);
392
393  void addPubTypes(DISubprogram SP);
394
395  /// constructTypeDIE - Construct basic type die from DIBasicType.
396  void constructTypeDIE(DIE &Buffer,
397                        DIBasicType BTy);
398
399  /// constructTypeDIE - Construct derived type die from DIDerivedType.
400  void constructTypeDIE(DIE &Buffer,
401                        DIDerivedType DTy);
402
403  /// constructTypeDIE - Construct type DIE from DICompositeType.
404  void constructTypeDIE(DIE &Buffer,
405                        DICompositeType CTy);
406
407  /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
408  void constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy);
409
410  /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
411  void constructArrayTypeDIE(DIE &Buffer,
412                             DICompositeType *CTy);
413
414  /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
415  DIE *constructEnumTypeDIE(DIEnumerator ETy);
416
417  /// createGlobalVariableDIE - Create new DIE using GV.
418  DIE *createGlobalVariableDIE(const DIGlobalVariable &GV);
419
420  /// createMemberDIE - Create new member DIE.
421  DIE *createMemberDIE(const DIDerivedType &DT);
422
423  /// createSubprogramDIE - Create new DIE using SP.
424  DIE *createSubprogramDIE(const DISubprogram &SP, bool MakeDecl = false);
425
426  /// getOrCreateDbgScope - Create DbgScope for the scope.
427  DbgScope *getOrCreateDbgScope(const MDNode *Scope, const MDNode *InlinedAt);
428
429  DbgScope *getOrCreateAbstractScope(const MDNode *N);
430
431  /// findAbstractVariable - Find abstract variable associated with Var.
432  DbgVariable *findAbstractVariable(DIVariable &Var, DebugLoc Loc);
433
434  /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
435  /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
436  /// If there are global variables in this scope then create and insert
437  /// DIEs for these variables.
438  DIE *updateSubprogramScopeDIE(const MDNode *SPNode);
439
440  /// constructLexicalScope - Construct new DW_TAG_lexical_block
441  /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
442  DIE *constructLexicalScopeDIE(DbgScope *Scope);
443
444  /// constructInlinedScopeDIE - This scope represents inlined body of
445  /// a function. Construct DIE to represent this concrete inlined copy
446  /// of the function.
447  DIE *constructInlinedScopeDIE(DbgScope *Scope);
448
449  /// constructVariableDIE - Construct a DIE for the given DbgVariable.
450  DIE *constructVariableDIE(DbgVariable *DV, DbgScope *S);
451
452  /// constructScopeDIE - Construct a DIE for this scope.
453  DIE *constructScopeDIE(DbgScope *Scope);
454
455  /// EmitSectionLabels - Emit initial Dwarf sections with a label at
456  /// the start of each one.
457  void EmitSectionLabels();
458
459  /// emitDIE - Recusively Emits a debug information entry.
460  ///
461  void emitDIE(DIE *Die);
462
463  /// computeSizeAndOffset - Compute the size and offset of a DIE.
464  ///
465  unsigned computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last);
466
467  /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
468  ///
469  void computeSizeAndOffsets();
470
471  /// EmitDebugInfo - Emit the debug info section.
472  ///
473  void emitDebugInfo();
474
475  /// emitAbbreviations - Emit the abbreviation section.
476  ///
477  void emitAbbreviations() const;
478
479  /// emitEndOfLineMatrix - Emit the last address of the section and the end of
480  /// the line matrix.
481  ///
482  void emitEndOfLineMatrix(unsigned SectionEnd);
483
484  /// emitDebugLines - Emit source line information.
485  ///
486  void emitDebugLines();
487
488  /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
489  ///
490  void emitCommonDebugFrame();
491
492  /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
493  /// section.
494  void emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo);
495
496  /// emitDebugPubNames - Emit visible names into a debug pubnames section.
497  ///
498  void emitDebugPubNames();
499
500  /// emitDebugPubTypes - Emit visible types into a debug pubtypes section.
501  ///
502  void emitDebugPubTypes();
503
504  /// emitDebugStr - Emit visible names into a debug str section.
505  ///
506  void emitDebugStr();
507
508  /// emitDebugLoc - Emit visible names into a debug loc section.
509  ///
510  void emitDebugLoc();
511
512  /// EmitDebugARanges - Emit visible names into a debug aranges section.
513  ///
514  void EmitDebugARanges();
515
516  /// emitDebugRanges - Emit visible names into a debug ranges section.
517  ///
518  void emitDebugRanges();
519
520  /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
521  ///
522  void emitDebugMacInfo();
523
524  /// emitDebugInlineInfo - Emit inline info using following format.
525  /// Section Header:
526  /// 1. length of section
527  /// 2. Dwarf version number
528  /// 3. address size.
529  ///
530  /// Entries (one "entry" for each function that was inlined):
531  ///
532  /// 1. offset into __debug_str section for MIPS linkage name, if exists;
533  ///   otherwise offset into __debug_str for regular function name.
534  /// 2. offset into __debug_str section for regular function name.
535  /// 3. an unsigned LEB128 number indicating the number of distinct inlining
536  /// instances for the function.
537  ///
538  /// The rest of the entry consists of a {die_offset, low_pc}  pair for each
539  /// inlined instance; the die_offset points to the inlined_subroutine die in
540  /// the __debug_info section, and the low_pc is the starting address  for the
541  ///  inlining instance.
542  void emitDebugInlineInfo();
543
544  /// GetOrCreateSourceID - Look up the source id with the given directory and
545  /// source file names. If none currently exists, create a new id and insert it
546  /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
547  /// maps as well.
548  unsigned GetOrCreateSourceID(StringRef DirName, StringRef FileName);
549
550  /// constructCompileUnit - Create new CompileUnit for the given
551  /// metadata node with tag DW_TAG_compile_unit.
552  void constructCompileUnit(const MDNode *N);
553
554  /// getCompielUnit - Get CompileUnit DIE.
555  CompileUnit *getCompileUnit(const MDNode *N) const;
556
557  /// constructGlobalVariableDIE - Construct global variable DIE.
558  void constructGlobalVariableDIE(const MDNode *N);
559
560  /// construct SubprogramDIE - Construct subprogram DIE.
561  void constructSubprogramDIE(const MDNode *N);
562
563  // FIXME: This should go away in favor of complex addresses.
564  /// Find the type the programmer originally declared the variable to be
565  /// and return that type.  Obsolete, use GetComplexAddrType instead.
566  ///
567  DIType getBlockByrefType(DIType Ty, std::string Name);
568
569  /// recordSourceLine - Register a source line with debug info. Returns the
570  /// unique label that was emitted and which provides correspondence to
571  /// the source line list.
572  MCSymbol *recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope);
573
574  /// getSourceLineCount - Return the number of source lines in the debug
575  /// info.
576  unsigned getSourceLineCount() const {
577    return Lines.size();
578  }
579
580  /// recordVariableFrameIndex - Record a variable's index.
581  void recordVariableFrameIndex(const DbgVariable *V, int Index);
582
583  /// findVariableFrameIndex - Return true if frame index for the variable
584  /// is found. Update FI to hold value of the index.
585  bool findVariableFrameIndex(const DbgVariable *V, int *FI);
586
587  /// findVariableLabel - Find MCSymbol for the variable.
588  const MCSymbol *findVariableLabel(const DbgVariable *V);
589
590  /// findDbgScope - Find DbgScope for the debug loc attached with an
591  /// instruction.
592  DbgScope *findDbgScope(const MachineInstr *MI);
593
594  /// identifyScopeMarkers() - Indentify instructions that are marking
595  /// beginning of or end of a scope.
596  void identifyScopeMarkers();
597
598  /// extractScopeInformation - Scan machine instructions in this function
599  /// and collect DbgScopes. Return true, if atleast one scope was found.
600  bool extractScopeInformation();
601
602  /// collectVariableInfo - Populate DbgScope entries with variables' info.
603  void collectVariableInfo(const MachineFunction *,
604                           SmallPtrSet<const MDNode *, 16> &ProcessedVars);
605
606  /// collectVariableInfoFromMMITable - Collect variable information from
607  /// side table maintained by MMI.
608  void collectVariableInfoFromMMITable(const MachineFunction * MF,
609                                       SmallPtrSet<const MDNode *, 16> &P);
610public:
611  //===--------------------------------------------------------------------===//
612  // Main entry points.
613  //
614  DwarfDebug(AsmPrinter *A, Module *M);
615  ~DwarfDebug();
616
617  /// beginModule - Emit all Dwarf sections that should come prior to the
618  /// content.
619  void beginModule(Module *M);
620
621  /// endModule - Emit all Dwarf sections that should come after the content.
622  ///
623  void endModule();
624
625  /// beginFunction - Gather pre-function debug information.  Assumes being
626  /// emitted immediately after the function entry point.
627  void beginFunction(const MachineFunction *MF);
628
629  /// endFunction - Gather and emit post-function debug information.
630  ///
631  void endFunction(const MachineFunction *MF);
632
633  /// getLabelBeforeInsn - Return Label preceding the instruction.
634  const MCSymbol *getLabelBeforeInsn(const MachineInstr *MI);
635
636  /// getLabelAfterInsn - Return Label immediately following the instruction.
637  const MCSymbol *getLabelAfterInsn(const MachineInstr *MI);
638
639  /// beginScope - Process beginning of a scope.
640  void beginScope(const MachineInstr *MI);
641
642  /// endScope - Prcess end of a scope.
643  void endScope(const MachineInstr *MI);
644};
645} // End of namespace llvm
646
647#endif
648