DwarfDebug.h revision 7ee5f5d61f18deda7412fdff4c2729c59a436b27
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 // Holders for the various debug information flags that we might need to 320 // have exposed. See accessor functions below for description. 321 bool IsDarwinGDBCompat; 322 bool HasDwarfAccelTables; 323 bool HasDwarfFission; 324private: 325 326 /// assignAbbrevNumber - Define a unique number for the abbreviation. 327 /// 328 void assignAbbrevNumber(DIEAbbrev &Abbrev); 329 330 void addScopeVariable(LexicalScope *LS, DbgVariable *Var); 331 332 /// findAbstractVariable - Find abstract variable associated with Var. 333 DbgVariable *findAbstractVariable(DIVariable &Var, DebugLoc Loc); 334 335 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and 336 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes. 337 /// If there are global variables in this scope then create and insert 338 /// DIEs for these variables. 339 DIE *updateSubprogramScopeDIE(CompileUnit *SPCU, const MDNode *SPNode); 340 341 /// constructLexicalScope - Construct new DW_TAG_lexical_block 342 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels. 343 DIE *constructLexicalScopeDIE(CompileUnit *TheCU, LexicalScope *Scope); 344 345 /// constructInlinedScopeDIE - This scope represents inlined body of 346 /// a function. Construct DIE to represent this concrete inlined copy 347 /// of the function. 348 DIE *constructInlinedScopeDIE(CompileUnit *TheCU, LexicalScope *Scope); 349 350 /// constructScopeDIE - Construct a DIE for this scope. 351 DIE *constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope); 352 353 /// EmitSectionLabels - Emit initial Dwarf sections with a label at 354 /// the start of each one. 355 void emitSectionLabels(); 356 357 /// emitDIE - Recursively Emits a debug information entry. 358 /// 359 void emitDIE(DIE *Die); 360 361 /// computeSizeAndOffset - Compute the size and offset of a DIE given 362 /// an incoming Offset. 363 /// 364 unsigned computeSizeAndOffset(DIE *Die, unsigned Offset); 365 366 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 367 /// 368 void computeSizeAndOffsets(); 369 370 /// EmitDebugInfo - Emit the debug info section. 371 /// 372 void emitDebugInfo(); 373 374 /// emitAbbreviations - Emit the abbreviation section. 375 /// 376 void emitAbbreviations(); 377 378 /// emitEndOfLineMatrix - Emit the last address of the section and the end of 379 /// the line matrix. 380 /// 381 void emitEndOfLineMatrix(unsigned SectionEnd); 382 383 /// emitAccelNames - Emit visible names into a hashed accelerator table 384 /// section. 385 void emitAccelNames(); 386 387 /// emitAccelObjC - Emit objective C classes and categories into a hashed 388 /// accelerator table section. 389 void emitAccelObjC(); 390 391 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator 392 /// table. 393 void emitAccelNamespaces(); 394 395 /// emitAccelTypes() - Emit type dies into a hashed accelerator table. 396 /// 397 void emitAccelTypes(); 398 399 /// emitDebugPubTypes - Emit visible types into a debug pubtypes section. 400 /// 401 void emitDebugPubTypes(); 402 403 /// emitDebugStr - Emit visible names into a debug str section. 404 /// 405 void emitDebugStr(); 406 407 /// emitDebugLoc - Emit visible names into a debug loc section. 408 /// 409 void emitDebugLoc(); 410 411 /// EmitDebugARanges - Emit visible names into a debug aranges section. 412 /// 413 void emitDebugARanges(); 414 415 /// emitDebugRanges - Emit visible names into a debug ranges section. 416 /// 417 void emitDebugRanges(); 418 419 /// emitDebugMacInfo - Emit visible names into a debug macinfo section. 420 /// 421 void emitDebugMacInfo(); 422 423 /// emitDebugInlineInfo - Emit inline info using following format. 424 /// Section Header: 425 /// 1. length of section 426 /// 2. Dwarf version number 427 /// 3. address size. 428 /// 429 /// Entries (one "entry" for each function that was inlined): 430 /// 431 /// 1. offset into __debug_str section for MIPS linkage name, if exists; 432 /// otherwise offset into __debug_str for regular function name. 433 /// 2. offset into __debug_str section for regular function name. 434 /// 3. an unsigned LEB128 number indicating the number of distinct inlining 435 /// instances for the function. 436 /// 437 /// The rest of the entry consists of a {die_offset, low_pc} pair for each 438 /// inlined instance; the die_offset points to the inlined_subroutine die in 439 /// the __debug_info section, and the low_pc is the starting address for the 440 /// inlining instance. 441 void emitDebugInlineInfo(); 442 443 /// constructCompileUnit - Create new CompileUnit for the given 444 /// metadata node with tag DW_TAG_compile_unit. 445 CompileUnit *constructCompileUnit(const MDNode *N); 446 447 /// construct SubprogramDIE - Construct subprogram DIE. 448 void constructSubprogramDIE(CompileUnit *TheCU, const MDNode *N); 449 450 /// recordSourceLine - Register a source line with debug info. Returns the 451 /// unique label that was emitted and which provides correspondence to 452 /// the source line list. 453 void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope, 454 unsigned Flags); 455 456 /// identifyScopeMarkers() - Indentify instructions that are marking the 457 /// beginning of or ending of a scope. 458 void identifyScopeMarkers(); 459 460 /// addCurrentFnArgument - If Var is an current function argument that add 461 /// it in CurrentFnArguments list. 462 bool addCurrentFnArgument(const MachineFunction *MF, 463 DbgVariable *Var, LexicalScope *Scope); 464 465 /// collectVariableInfo - Populate LexicalScope entries with variables' info. 466 void collectVariableInfo(const MachineFunction *, 467 SmallPtrSet<const MDNode *, 16> &ProcessedVars); 468 469 /// collectVariableInfoFromMMITable - Collect variable information from 470 /// side table maintained by MMI. 471 void collectVariableInfoFromMMITable(const MachineFunction * MF, 472 SmallPtrSet<const MDNode *, 16> &P); 473 474 /// requestLabelBeforeInsn - Ensure that a label will be emitted before MI. 475 void requestLabelBeforeInsn(const MachineInstr *MI) { 476 LabelsBeforeInsn.insert(std::make_pair(MI, (MCSymbol*)0)); 477 } 478 479 /// getLabelBeforeInsn - Return Label preceding the instruction. 480 const MCSymbol *getLabelBeforeInsn(const MachineInstr *MI); 481 482 /// requestLabelAfterInsn - Ensure that a label will be emitted after MI. 483 void requestLabelAfterInsn(const MachineInstr *MI) { 484 LabelsAfterInsn.insert(std::make_pair(MI, (MCSymbol*)0)); 485 } 486 487 /// getLabelAfterInsn - Return Label immediately following the instruction. 488 const MCSymbol *getLabelAfterInsn(const MachineInstr *MI); 489 490public: 491 //===--------------------------------------------------------------------===// 492 // Main entry points. 493 // 494 DwarfDebug(AsmPrinter *A, Module *M); 495 ~DwarfDebug(); 496 497 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such 498 /// as llvm.dbg.enum and llvm.dbg.ty 499 void collectInfoFromNamedMDNodes(const Module *M); 500 501 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder. 502 /// FIXME - Remove this when DragonEgg switches to DIBuilder. 503 bool collectLegacyDebugInfo(const Module *M); 504 505 /// beginModule - Emit all Dwarf sections that should come prior to the 506 /// content. 507 void beginModule(); 508 509 /// endModule - Emit all Dwarf sections that should come after the content. 510 /// 511 void endModule(); 512 513 /// beginFunction - Gather pre-function debug information. Assumes being 514 /// emitted immediately after the function entry point. 515 void beginFunction(const MachineFunction *MF); 516 517 /// endFunction - Gather and emit post-function debug information. 518 /// 519 void endFunction(const MachineFunction *MF); 520 521 /// beginInstruction - Process beginning of an instruction. 522 void beginInstruction(const MachineInstr *MI); 523 524 /// endInstruction - Prcess end of an instruction. 525 void endInstruction(const MachineInstr *MI); 526 527 /// getOrCreateSourceID - Look up the source id with the given directory and 528 /// source file names. If none currently exists, create a new id and insert it 529 /// in the SourceIds map. 530 unsigned getOrCreateSourceID(StringRef DirName, StringRef FullName); 531 532 /// getStringPool - returns the entry into the start of the pool. 533 MCSymbol *getStringPool(); 534 535 /// getStringPoolEntry - returns an entry into the string pool with the given 536 /// string text. 537 MCSymbol *getStringPoolEntry(StringRef Str); 538 539 /// useDarwinGDBCompat - returns whether or not to limit some of our debug 540 /// output to the limitations of darwin gdb. 541 bool useDarwinGDBCompat() { return IsDarwinGDBCompat; } 542 543 // Experimental DWARF5 features. 544 545 /// useDwarfAccelTables - returns whether or not to emit tables that 546 /// dwarf consumers can use to accelerate lookup. 547 bool useDwarfAccelTables() { return HasDwarfAccelTables; } 548 549 /// useDwarfFission - returns whether or not to change the current debug 550 /// info for the fission proposal support. 551 bool useDwarfFission() { return HasDwarfFission; } 552}; 553} // End of namespace llvm 554 555#endif 556