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