lib/CodeGen/AsmPrinter/DwarfDebug.h

   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 "llvm/Analysis/DebugInfo.h"
  20 #include "DIE.h"
  21 #include "llvm/ADT/DenseMap.h"
  22 #include "llvm/ADT/FoldingSet.h"
  23 #include "llvm/ADT/SmallPtrSet.h"
  24 #include "llvm/ADT/StringMap.h"
  25 #include "llvm/ADT/UniqueVector.h"
  26 #include "llvm/Support/Allocator.h"
  27 #include "llvm/Support/DebugLoc.h"
  28
  29 namespace llvm {
  30
  31 class CompileUnit;
  32 class DbgConcreteScope;
  33 class DbgScope;
  34 class DbgVariable;
  35 class MachineFrameInfo;
  36 class MachineModuleInfo;
  37 class MachineOperand;
  38 class MCAsmInfo;
  39 class DIEAbbrev;
  40 class DIE;
  41 class DIEBlock;
  42 class DIEEntry;
  43
  44 //===----------------------------------------------------------------------===//
  45 /// SrcLineInfo - This class is used to record source line correspondence.
  46 ///
  47 class SrcLineInfo {
  48   unsigned Line;                     // Source line number.
  49   unsigned Column;                   // Source column.
  50   unsigned SourceID;                 // Source ID number.
  51   MCSymbol *Label;                   // Label in code ID number.
  52 public:
  53   SrcLineInfo(unsigned L, unsigned C, unsigned S, MCSymbol *label)
  54     : Line(L), Column(C), SourceID(S), Label(label) {}
  55
  56   // Accessors
  57   unsigned getLine() const { return Line; }
  58   unsigned getColumn() const { return Column; }
  59   unsigned getSourceID() const { return SourceID; }
  60   MCSymbol *getLabel() const { return Label; }
  61 };
  62
  63 /// DotDebugLocEntry - This struct describes location entries emitted in
  64 /// .debug_loc section.
  65 typedef struct DotDebugLocEntry {
  66   const MCSymbol *Begin;
  67   const MCSymbol *End;
  68   MachineLocation Loc;
  69   bool Merged;
  70   DotDebugLocEntry() : Begin(0), End(0), Merged(false) {}
  71   DotDebugLocEntry(const MCSymbol *B, const MCSymbol *E, MachineLocation &L)
  72     : Begin(B), End(E), Loc(L), Merged(false) {}
  73   /// Empty entries are also used as a trigger to emit temp label. Such
  74   /// labels are referenced is used to find debug_loc offset for a given DIE.
  75   bool isEmpty() { return Begin == 0 && End == 0; }
  76   bool isMerged() { return Merged; }
  77   void Merge(DotDebugLocEntry *Next) {
  78     if (!(Begin && Loc == Next->Loc && End == Next->Begin))
  79       return;
  80     Next->Begin = Begin;
  81     Merged = true;
  82   }
  83 } DotDebugLocEntry;
  84
  85 //===----------------------------------------------------------------------===//
  86 /// DbgVariable - This class is used to track local variable information.
  87 ///
  88 class DbgVariable {
  89   DIVariable Var;                    // Variable Descriptor.
  90   DIE *TheDIE;                       // Variable DIE.
  91   unsigned DotDebugLocOffset;        // Offset in DotDebugLocEntries.
  92 public:
  93   // AbsVar may be NULL.
  94   DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
  95
  96   // Accessors.
  97   DIVariable getVariable()           const { return Var; }
  98   void setDIE(DIE *D)                      { TheDIE = D; }
  99   DIE *getDIE()                      const { return TheDIE; }
 100   void setDotDebugLocOffset(unsigned O)    { DotDebugLocOffset = O; }
 101   unsigned getDotDebugLocOffset()    const { return DotDebugLocOffset; }
 102   StringRef getName()                const { return Var.getName(); }
 103   unsigned getTag()                  const { return Var.getTag(); }
 104   bool variableHasComplexAddress()   const {
 105     assert(Var.Verify() && "Invalid complex DbgVariable!");
 106     return Var.hasComplexAddress();
 107   }
 108   bool isBlockByrefVariable()        const {
 109     assert(Var.Verify() && "Invalid complex DbgVariable!");
 110     return Var.isBlockByrefVariable();
 111   }
 112   unsigned getNumAddrElements()      const {
 113     assert(Var.Verify() && "Invalid complex DbgVariable!");
 114     return Var.getNumAddrElements();
 115   }
 116   uint64_t getAddrElement(unsigned i) const {
 117     return Var.getAddrElement(i);
 118   }
 119   DIType getType() const;
 120 };
 121
 122 class DwarfDebug {
 123   /// Asm - Target of Dwarf emission.
 124   AsmPrinter *Asm;
 125
 126   /// MMI - Collected machine module information.
 127   MachineModuleInfo *MMI;
 128
 129   //===--------------------------------------------------------------------===//
 130   // Attributes used to construct specific Dwarf sections.
 131   //
 132
 133   CompileUnit *FirstCU;
 134   DenseMap <const MDNode *, CompileUnit *> CUMap;
 135
 136   /// AbbreviationsSet - Used to uniquely define abbreviations.
 137   ///
 138   FoldingSet<DIEAbbrev> AbbreviationsSet;
 139
 140   /// Abbreviations - A list of all the unique abbreviations in use.
 141   ///
 142   std::vector<DIEAbbrev *> Abbreviations;
 143
 144   /// SourceIdMap - Source id map, i.e. pair of directory id and source file
 145   /// id mapped to a unique id.
 146   StringMap<unsigned> SourceIdMap;
 147
 148   /// StringPool - A String->Symbol mapping of strings used by indirect
 149   /// references.
 150   StringMap<std::pair<MCSymbol*, unsigned> > StringPool;
 151   unsigned NextStringPoolNumber;
 152
 153   MCSymbol *getStringPoolEntry(StringRef Str);
 154
 155   /// SectionMap - Provides a unique id per text section.
 156   ///
 157   UniqueVector<const MCSection*> SectionMap;
 158
 159   /// CurrentFnDbgScope - Top level scope for the current function.
 160   ///
 161   DbgScope *CurrentFnDbgScope;
 162
 163   /// CurrentFnArguments - List of Arguments (DbgValues) for current function.
 164   SmallVector<DbgVariable *, 8> CurrentFnArguments;
 165
 166   /// DbgScopeMap - Tracks the scopes in the current function.  Owns the
 167   /// contained DbgScope*s.
 168   ///
 169   DenseMap<const MDNode *, DbgScope *> DbgScopeMap;
 170
 171   /// ConcreteScopes - Tracks the concrete scopees in the current function.
 172   /// These scopes are also included in DbgScopeMap.
 173   DenseMap<const MDNode *, DbgScope *> ConcreteScopes;
 174
 175   /// AbstractScopes - Tracks the abstract scopes a module. These scopes are
 176   /// not included DbgScopeMap.  AbstractScopes owns its DbgScope*s.
 177   DenseMap<const MDNode *, DbgScope *> AbstractScopes;
 178
 179   /// AbstractSPDies - Collection of abstract subprogram DIEs.
 180   DenseMap<const MDNode *, DIE *> AbstractSPDies;
 181
 182   /// AbstractScopesList - Tracks abstract scopes constructed while processing
 183   /// a function. This list is cleared during endFunction().
 184   SmallVector<DbgScope *, 4>AbstractScopesList;
 185
 186   /// AbstractVariables - Collection on abstract variables.  Owned by the
 187   /// DbgScopes in AbstractScopes.
 188   DenseMap<const MDNode *, DbgVariable *> AbstractVariables;
 189
 190   /// DbgVariableToFrameIndexMap - Tracks frame index used to find
 191   /// variable's value.
 192   DenseMap<const DbgVariable *, int> DbgVariableToFrameIndexMap;
 193
 194   /// DbgVariableToDbgInstMap - Maps DbgVariable to corresponding DBG_VALUE
 195   /// machine instruction.
 196   DenseMap<const DbgVariable *, const MachineInstr *> DbgVariableToDbgInstMap;
 197
 198   /// DotDebugLocEntries - Collection of DotDebugLocEntry.
 199   SmallVector<DotDebugLocEntry, 4> DotDebugLocEntries;
 200
 201   /// UseDotDebugLocEntry - DW_AT_location attributes for the DIEs in this set
 202   /// idetifies corresponding .debug_loc entry offset.
 203   SmallPtrSet<const DIE *, 4> UseDotDebugLocEntry;
 204
 205   /// VarToAbstractVarMap - Maps DbgVariable with corresponding Abstract
 206   /// DbgVariable, if any.
 207   DenseMap<const DbgVariable *, const DbgVariable *> VarToAbstractVarMap;
 208
 209   /// InliendSubprogramDIEs - Collection of subprgram DIEs that are marked
 210   /// (at the end of the module) as DW_AT_inline.
 211   SmallPtrSet<DIE *, 4> InlinedSubprogramDIEs;
 212
 213   /// ContainingTypeMap - This map is used to keep track of subprogram DIEs that
 214   /// need DW_AT_containing_type attribute. This attribute points to a DIE that
 215   /// corresponds to the MDNode mapped with the subprogram DIE.
 216   DenseMap<DIE *, const MDNode *> ContainingTypeMap;
 217
 218   /// InlineInfo - Keep track of inlined functions and their location.  This
 219   /// information is used to populate debug_inlined section.
 220   typedef std::pair<const MCSymbol *, DIE *> InlineInfoLabels;
 221   DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> > InlineInfo;
 222   SmallVector<const MDNode *, 4> InlinedSPNodes;
 223
 224   // ProcessedSPNodes - This is a collection of subprogram MDNodes that
 225   // are processed to create DIEs.
 226   SmallPtrSet<const MDNode *, 16> ProcessedSPNodes;
 227
 228   /// LabelsBeforeInsn - Maps instruction with label emitted before
 229   /// instruction.
 230   DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn;
 231
 232   /// LabelsAfterInsn - Maps instruction with label emitted after
 233   /// instruction.
 234   DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn;
 235
 236   /// UserVariables - Every user variable mentioned by a DBG_VALUE instruction
 237   /// in order of appearance.
 238   SmallVector<const MDNode*, 8> UserVariables;
 239
 240   /// DbgValues - For each user variable, keep a list of DBG_VALUE
 241   /// instructions in order. The list can also contain normal instructions that
 242   /// clobber the previous DBG_VALUE.
 243   typedef DenseMap<const MDNode*, SmallVector<const MachineInstr*, 4> >
 244     DbgValueHistoryMap;
 245   DbgValueHistoryMap DbgValues;
 246
 247   SmallVector<const MCSymbol *, 8> DebugRangeSymbols;
 248
 249   /// Previous instruction's location information. This is used to determine
 250   /// label location to indicate scope boundries in dwarf debug info.
 251   DebugLoc PrevInstLoc;
 252   MCSymbol *PrevLabel;
 253
 254   struct FunctionDebugFrameInfo {
 255     unsigned Number;
 256     std::vector<MachineMove> Moves;
 257
 258     FunctionDebugFrameInfo(unsigned Num, const std::vector<MachineMove> &M)
 259       : Number(Num), Moves(M) {}
 260   };
 261
 262   std::vector<FunctionDebugFrameInfo> DebugFrames;
 263
 264   // DIEValueAllocator - All DIEValues are allocated through this allocator.
 265   BumpPtrAllocator DIEValueAllocator;
 266
 267   // Section Symbols: these are assembler temporary labels that are emitted at
 268   // the beginning of each supported dwarf section.  These are used to form
 269   // section offsets and are created by EmitSectionLabels.
 270   MCSymbol *DwarfFrameSectionSym, *DwarfInfoSectionSym, *DwarfAbbrevSectionSym;
 271   MCSymbol *DwarfStrSectionSym, *TextSectionSym, *DwarfDebugRangeSectionSym;
 272   MCSymbol *DwarfDebugLocSectionSym;
 273   MCSymbol *FunctionBeginSym, *FunctionEndSym;
 274
 275 private:
 276
 277   /// assignAbbrevNumber - Define a unique number for the abbreviation.
 278   ///
 279   void assignAbbrevNumber(DIEAbbrev &Abbrev);
 280
 281   /// getOrCreateDbgScope - Create DbgScope for the scope.
 282   DbgScope *getOrCreateDbgScope(const MDNode *Scope, const MDNode *InlinedAt);
 283
 284   DbgScope *getOrCreateAbstractScope(const MDNode *N);
 285
 286   /// findAbstractVariable - Find abstract variable associated with Var.
 287   DbgVariable *findAbstractVariable(DIVariable &Var, DebugLoc Loc);
 288
 289   /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
 290   /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
 291   /// If there are global variables in this scope then create and insert
 292   /// DIEs for these variables.
 293   DIE *updateSubprogramScopeDIE(const MDNode *SPNode);
 294
 295   /// constructLexicalScope - Construct new DW_TAG_lexical_block
 296   /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
 297   DIE *constructLexicalScopeDIE(DbgScope *Scope);
 298
 299   /// constructInlinedScopeDIE - This scope represents inlined body of
 300   /// a function. Construct DIE to represent this concrete inlined copy
 301   /// of the function.
 302   DIE *constructInlinedScopeDIE(DbgScope *Scope);
 303
 304   /// constructVariableDIE - Construct a DIE for the given DbgVariable.
 305   DIE *constructVariableDIE(DbgVariable *DV, DbgScope *S);
 306
 307   /// constructScopeDIE - Construct a DIE for this scope.
 308   DIE *constructScopeDIE(DbgScope *Scope);
 309
 310   /// EmitSectionLabels - Emit initial Dwarf sections with a label at
 311   /// the start of each one.
 312   void EmitSectionLabels();
 313
 314   /// emitDIE - Recusively Emits a debug information entry.
 315   ///
 316   void emitDIE(DIE *Die);
 317
 318   /// computeSizeAndOffset - Compute the size and offset of a DIE.
 319   ///
 320   unsigned computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last);
 321
 322   /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
 323   ///
 324   void computeSizeAndOffsets();
 325
 326   /// EmitDebugInfo - Emit the debug info section.
 327   ///
 328   void emitDebugInfo();
 329
 330   /// emitAbbreviations - Emit the abbreviation section.
 331   ///
 332   void emitAbbreviations() const;
 333
 334   /// emitEndOfLineMatrix - Emit the last address of the section and the end of
 335   /// the line matrix.
 336   ///
 337   void emitEndOfLineMatrix(unsigned SectionEnd);
 338
 339   /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
 340   ///
 341   void emitCommonDebugFrame();
 342
 343   /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
 344   /// section.
 345   void emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo);
 346
 347   /// emitDebugPubNames - Emit visible names into a debug pubnames section.
 348   ///
 349   void emitDebugPubNames();
 350
 351   /// emitDebugPubTypes - Emit visible types into a debug pubtypes section.
 352   ///
 353   void emitDebugPubTypes();
 354
 355   /// emitDebugStr - Emit visible names into a debug str section.
 356   ///
 357   void emitDebugStr();
 358
 359   /// emitDebugLoc - Emit visible names into a debug loc section.
 360   ///
 361   void emitDebugLoc();
 362
 363   /// EmitDebugARanges - Emit visible names into a debug aranges section.
 364   ///
 365   void EmitDebugARanges();
 366
 367   /// emitDebugRanges - Emit visible names into a debug ranges section.
 368   ///
 369   void emitDebugRanges();
 370
 371   /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
 372   ///
 373   void emitDebugMacInfo();
 374
 375   /// emitDebugInlineInfo - Emit inline info using following format.
 376   /// Section Header:
 377   /// 1. length of section
 378   /// 2. Dwarf version number
 379   /// 3. address size.
 380   ///
 381   /// Entries (one "entry" for each function that was inlined):
 382   ///
 383   /// 1. offset into __debug_str section for MIPS linkage name, if exists;
 384   ///   otherwise offset into __debug_str for regular function name.
 385   /// 2. offset into __debug_str section for regular function name.
 386   /// 3. an unsigned LEB128 number indicating the number of distinct inlining
 387   /// instances for the function.
 388   ///
 389   /// The rest of the entry consists of a {die_offset, low_pc}  pair for each
 390   /// inlined instance; the die_offset points to the inlined_subroutine die in
 391   /// the __debug_info section, and the low_pc is the starting address  for the
 392   ///  inlining instance.
 393   void emitDebugInlineInfo();
 394
 395   /// constructCompileUnit - Create new CompileUnit for the given
 396   /// metadata node with tag DW_TAG_compile_unit.
 397   void constructCompileUnit(const MDNode *N);
 398
 399   /// getCompielUnit - Get CompileUnit DIE.
 400   CompileUnit *getCompileUnit(const MDNode *N) const;
 401
 402   /// constructGlobalVariableDIE - Construct global variable DIE.
 403   void constructGlobalVariableDIE(const MDNode *N);
 404
 405   /// construct SubprogramDIE - Construct subprogram DIE.
 406   void constructSubprogramDIE(const MDNode *N);
 407
 408   /// recordSourceLine - Register a source line with debug info. Returns the
 409   /// unique label that was emitted and which provides correspondence to
 410   /// the source line list.
 411   void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope);
 412
 413   /// recordVariableFrameIndex - Record a variable's index.
 414   void recordVariableFrameIndex(const DbgVariable *V, int Index);
 415
 416   /// findVariableFrameIndex - Return true if frame index for the variable
 417   /// is found. Update FI to hold value of the index.
 418   bool findVariableFrameIndex(const DbgVariable *V, int *FI);
 419
 420   /// findDbgScope - Find DbgScope for the debug loc attached with an
 421   /// instruction.
 422   DbgScope *findDbgScope(const MachineInstr *MI);
 423
 424   /// identifyScopeMarkers() - Indentify instructions that are marking
 425   /// beginning of or end of a scope.
 426   void identifyScopeMarkers();
 427
 428   /// extractScopeInformation - Scan machine instructions in this function
 429   /// and collect DbgScopes. Return true, if atleast one scope was found.
 430   bool extractScopeInformation();
 431
 432   /// addCurrentFnArgument - If Var is an current function argument that add
 433   /// it in CurrentFnArguments list.
 434   bool addCurrentFnArgument(const MachineFunction *MF,
 435                             DbgVariable *Var, DbgScope *Scope);
 436
 437   /// collectVariableInfo - Populate DbgScope entries with variables' info.
 438   void collectVariableInfo(const MachineFunction *,
 439                            SmallPtrSet<const MDNode *, 16> &ProcessedVars);
 440
 441   /// collectVariableInfoFromMMITable - Collect variable information from
 442   /// side table maintained by MMI.
 443   void collectVariableInfoFromMMITable(const MachineFunction * MF,
 444                                        SmallPtrSet<const MDNode *, 16> &P);
 445
 446   /// requestLabelBeforeInsn - Ensure that a label will be emitted before MI.
 447   void requestLabelBeforeInsn(const MachineInstr *MI) {
 448     LabelsBeforeInsn.insert(std::make_pair(MI, (MCSymbol*)0));
 449   }
 450
 451   /// getLabelBeforeInsn - Return Label preceding the instruction.
 452   const MCSymbol *getLabelBeforeInsn(const MachineInstr *MI);
 453
 454   /// requestLabelAfterInsn - Ensure that a label will be emitted after MI.
 455   void requestLabelAfterInsn(const MachineInstr *MI) {
 456     LabelsAfterInsn.insert(std::make_pair(MI, (MCSymbol*)0));
 457   }
 458
 459   /// getLabelAfterInsn - Return Label immediately following the instruction.
 460   const MCSymbol *getLabelAfterInsn(const MachineInstr *MI);
 461
 462 public:
 463   //===--------------------------------------------------------------------===//
 464   // Main entry points.
 465   //
 466   DwarfDebug(AsmPrinter *A, Module *M);
 467   ~DwarfDebug();
 468
 469   /// beginModule - Emit all Dwarf sections that should come prior to the
 470   /// content.
 471   void beginModule(Module *M);
 472
 473   /// endModule - Emit all Dwarf sections that should come after the content.
 474   ///
 475   void endModule();
 476
 477   /// beginFunction - Gather pre-function debug information.  Assumes being
 478   /// emitted immediately after the function entry point.
 479   void beginFunction(const MachineFunction *MF);
 480
 481   /// endFunction - Gather and emit post-function debug information.
 482   ///
 483   void endFunction(const MachineFunction *MF);
 484
 485   /// beginInstruction - Process beginning of an instruction.
 486   void beginInstruction(const MachineInstr *MI);
 487
 488   /// endInstruction - Prcess end of an instruction.
 489   void endInstruction(const MachineInstr *MI);
 490
 491   /// GetOrCreateSourceID - Look up the source id with the given directory and
 492   /// source file names. If none currently exists, create a new id and insert it
 493   /// in the SourceIds map.
 494   unsigned GetOrCreateSourceID(StringRef DirName, StringRef FullName);
 495
 496   /// createSubprogramDIE - Create new DIE using SP.
 497   DIE *createSubprogramDIE(DISubprogram SP);
 498 };
 499 } // End of namespace llvm
 500
 501 #endif