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