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