DwarfDebug.h revision c04d54527e1d7e8b50cefcde7563bcbc7425e978
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 "DIE.h" 19#include "llvm/ADT/DenseMap.h" 20#include "llvm/ADT/FoldingSet.h" 21#include "llvm/ADT/SmallPtrSet.h" 22#include "llvm/ADT/StringMap.h" 23#include "llvm/ADT/UniqueVector.h" 24#include "llvm/Support/Allocator.h" 25 26namespace llvm { 27 28class CompileUnit; 29class DbgConcreteScope; 30class DbgScope; 31class DbgVariable; 32class MachineFrameInfo; 33class MachineLocation; 34class MachineModuleInfo; 35class MCAsmInfo; 36class DIEAbbrev; 37class DIE; 38class DIEBlock; 39class DIEEntry; 40 41class DIEnumerator; 42class DIDescriptor; 43class DIVariable; 44class DIGlobal; 45class DIGlobalVariable; 46class DISubprogram; 47class DIBasicType; 48class DIDerivedType; 49class DIType; 50class DINameSpace; 51class DISubrange; 52class DICompositeType; 53 54//===----------------------------------------------------------------------===// 55/// SrcLineInfo - This class is used to record source line correspondence. 56/// 57class SrcLineInfo { 58 unsigned Line; // Source line number. 59 unsigned Column; // Source column. 60 unsigned SourceID; // Source ID number. 61 MCSymbol *Label; // Label in code ID number. 62public: 63 SrcLineInfo(unsigned L, unsigned C, unsigned S, MCSymbol *label) 64 : Line(L), Column(C), SourceID(S), Label(label) {} 65 66 // Accessors 67 unsigned getLine() const { return Line; } 68 unsigned getColumn() const { return Column; } 69 unsigned getSourceID() const { return SourceID; } 70 MCSymbol *getLabel() const { return Label; } 71}; 72 73class DwarfDebug { 74 /// Asm - Target of Dwarf emission. 75 AsmPrinter *Asm; 76 77 /// MMI - Collected machine module information. 78 MachineModuleInfo *MMI; 79 80 //===--------------------------------------------------------------------===// 81 // Attributes used to construct specific Dwarf sections. 82 // 83 84 /// ModuleCU - All DIEs are inserted in ModuleCU. 85 CompileUnit *ModuleCU; 86 87 /// AbbreviationsSet - Used to uniquely define abbreviations. 88 /// 89 FoldingSet<DIEAbbrev> AbbreviationsSet; 90 91 /// Abbreviations - A list of all the unique abbreviations in use. 92 /// 93 std::vector<DIEAbbrev *> Abbreviations; 94 95 /// DirectoryIdMap - Directory name to directory id map. 96 /// 97 StringMap<unsigned> DirectoryIdMap; 98 99 /// DirectoryNames - A list of directory names. 100 SmallVector<std::string, 8> DirectoryNames; 101 102 /// SourceFileIdMap - Source file name to source file id map. 103 /// 104 StringMap<unsigned> SourceFileIdMap; 105 106 /// SourceFileNames - A list of source file names. 107 SmallVector<std::string, 8> SourceFileNames; 108 109 /// SourceIdMap - Source id map, i.e. pair of directory id and source file 110 /// id mapped to a unique id. 111 DenseMap<std::pair<unsigned, unsigned>, unsigned> SourceIdMap; 112 113 /// SourceIds - Reverse map from source id to directory id + file id pair. 114 /// 115 SmallVector<std::pair<unsigned, unsigned>, 8> SourceIds; 116 117 /// Lines - List of source line correspondence. 118 std::vector<SrcLineInfo> Lines; 119 120 /// DIEBlocks - A list of all the DIEBlocks in use. 121 std::vector<DIEBlock *> DIEBlocks; 122 123 // DIEValueAllocator - All DIEValues are allocated through this allocator. 124 BumpPtrAllocator DIEValueAllocator; 125 126 /// StringPool - A String->Symbol mapping of strings used by indirect 127 /// references. 128 StringMap<std::pair<MCSymbol*, unsigned> > StringPool; 129 unsigned NextStringPoolNumber; 130 131 MCSymbol *getStringPoolEntry(StringRef Str); 132 133 /// SectionMap - Provides a unique id per text section. 134 /// 135 UniqueVector<const MCSection*> SectionMap; 136 137 /// SectionSourceLines - Tracks line numbers per text section. 138 /// 139 std::vector<std::vector<SrcLineInfo> > SectionSourceLines; 140 141 // CurrentFnDbgScope - Top level scope for the current function. 142 // 143 DbgScope *CurrentFnDbgScope; 144 145 /// DbgScopeMap - Tracks the scopes in the current function. Owns the 146 /// contained DbgScope*s. 147 /// 148 DenseMap<MDNode *, DbgScope *> DbgScopeMap; 149 150 /// ConcreteScopes - Tracks the concrete scopees in the current function. 151 /// These scopes are also included in DbgScopeMap. 152 DenseMap<MDNode *, DbgScope *> ConcreteScopes; 153 154 /// AbstractScopes - Tracks the abstract scopes a module. These scopes are 155 /// not included DbgScopeMap. AbstractScopes owns its DbgScope*s. 156 DenseMap<MDNode *, DbgScope *> AbstractScopes; 157 158 /// AbstractScopesList - Tracks abstract scopes constructed while processing 159 /// a function. This list is cleared during endFunction(). 160 SmallVector<DbgScope *, 4>AbstractScopesList; 161 162 /// AbstractVariables - Collection on abstract variables. Owned by the 163 /// DbgScopes in AbstractScopes. 164 DenseMap<MDNode *, DbgVariable *> AbstractVariables; 165 166 /// DbgValueStartMap - Tracks starting scope of variable DIEs. 167 /// If the scope of an object begins sometime after the low pc value for the 168 /// scope most closely enclosing the object, the object entry may have a 169 /// DW_AT_start_scope attribute. 170 DenseMap<const MachineInstr *, DbgVariable *> DbgValueStartMap; 171 172 /// InliendSubprogramDIEs - Collection of subprgram DIEs that are marked 173 /// (at the end of the module) as DW_AT_inline. 174 SmallPtrSet<DIE *, 4> InlinedSubprogramDIEs; 175 176 /// ContainingTypeMap - This map is used to keep track of subprogram DIEs that 177 /// need DW_AT_containing_type attribute. This attribute points to a DIE that 178 /// corresponds to the MDNode mapped with the subprogram DIE. 179 DenseMap<DIE *, MDNode *> ContainingTypeMap; 180 181 typedef SmallVector<DbgScope *, 2> ScopeVector; 182 SmallPtrSet<const MachineInstr *, 8> InsnsBeginScopeSet; 183 SmallPtrSet<const MachineInstr *, 8> InsnsEndScopeSet; 184 185 /// InlineInfo - Keep track of inlined functions and their location. This 186 /// information is used to populate debug_inlined section. 187 typedef std::pair<MCSymbol*, DIE *> InlineInfoLabels; 188 DenseMap<MDNode*, SmallVector<InlineInfoLabels, 4> > InlineInfo; 189 SmallVector<MDNode *, 4> InlinedSPNodes; 190 191 /// LabelsBeforeInsn - Maps instruction with label emitted before 192 /// instruction. 193 DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn; 194 195 /// LabelsAfterInsn - Maps instruction with label emitted after 196 /// instruction. 197 DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn; 198 199 SmallVector<const MCSymbol *, 8> DebugRangeSymbols; 200 201 /// weakDebugRangeSymbols - In cases where function bodies is not emitted 202 /// into .text section, use function begin marker as anchor for debug range 203 /// offsets. This map keeps track of such symbols and corresponding 204 /// function begin marker symbols. 205 DenseMap<const MCSymbol *, const MCSymbol *> WeakDebugRangeSymbols; 206 207 /// Previous instruction's location information. This is used to determine 208 /// label location to indicate scope boundries in dwarf debug info. 209 DebugLoc PrevInstLoc; 210 MCSymbol *PrevLabel; 211 212 struct FunctionDebugFrameInfo { 213 unsigned Number; 214 std::vector<MachineMove> Moves; 215 216 FunctionDebugFrameInfo(unsigned Num, const std::vector<MachineMove> &M) 217 : Number(Num), Moves(M) {} 218 }; 219 220 std::vector<FunctionDebugFrameInfo> DebugFrames; 221 222 // Section Symbols: these are assembler temporary labels that are emitted at 223 // the beginning of each supported dwarf section. These are used to form 224 // section offsets and are created by EmitSectionLabels. 225 MCSymbol *DwarfFrameSectionSym, *DwarfInfoSectionSym, *DwarfAbbrevSectionSym; 226 MCSymbol *DwarfStrSectionSym, *TextSectionSym, *DwarfDebugRangeSectionSym; 227 228 MCSymbol *FunctionBeginSym; 229private: 230 231 /// getSourceDirectoryAndFileIds - Return the directory and file ids that 232 /// maps to the source id. Source id starts at 1. 233 std::pair<unsigned, unsigned> 234 getSourceDirectoryAndFileIds(unsigned SId) const { 235 return SourceIds[SId-1]; 236 } 237 238 /// getNumSourceDirectories - Return the number of source directories in the 239 /// debug info. 240 unsigned getNumSourceDirectories() const { 241 return DirectoryNames.size(); 242 } 243 244 /// getSourceDirectoryName - Return the name of the directory corresponding 245 /// to the id. 246 const std::string &getSourceDirectoryName(unsigned Id) const { 247 return DirectoryNames[Id - 1]; 248 } 249 250 /// getSourceFileName - Return the name of the source file corresponding 251 /// to the id. 252 const std::string &getSourceFileName(unsigned Id) const { 253 return SourceFileNames[Id - 1]; 254 } 255 256 /// getNumSourceIds - Return the number of unique source ids. 257 unsigned getNumSourceIds() const { 258 return SourceIds.size(); 259 } 260 261 /// assignAbbrevNumber - Define a unique number for the abbreviation. 262 /// 263 void assignAbbrevNumber(DIEAbbrev &Abbrev); 264 265 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug 266 /// information entry. 267 DIEEntry *createDIEEntry(DIE *Entry); 268 269 /// addUInt - Add an unsigned integer attribute data and value. 270 /// 271 void addUInt(DIE *Die, unsigned Attribute, unsigned Form, uint64_t Integer); 272 273 /// addSInt - Add an signed integer attribute data and value. 274 /// 275 void addSInt(DIE *Die, unsigned Attribute, unsigned Form, int64_t Integer); 276 277 /// addString - Add a string attribute data and value. 278 /// 279 void addString(DIE *Die, unsigned Attribute, unsigned Form, 280 const StringRef Str); 281 282 /// addLabel - Add a Dwarf label attribute data and value. 283 /// 284 void addLabel(DIE *Die, unsigned Attribute, unsigned Form, 285 const MCSymbol *Label); 286 287 /// addDelta - Add a label delta attribute data and value. 288 /// 289 void addDelta(DIE *Die, unsigned Attribute, unsigned Form, 290 const MCSymbol *Hi, const MCSymbol *Lo); 291 292 /// addDIEEntry - Add a DIE attribute data and value. 293 /// 294 void addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form, DIE *Entry); 295 296 /// addBlock - Add block data. 297 /// 298 void addBlock(DIE *Die, unsigned Attribute, unsigned Form, DIEBlock *Block); 299 300 /// addSourceLine - Add location information to specified debug information 301 /// entry. 302 void addSourceLine(DIE *Die, const DIVariable *V); 303 void addSourceLine(DIE *Die, const DIGlobal *G); 304 void addSourceLine(DIE *Die, const DISubprogram *SP); 305 void addSourceLine(DIE *Die, const DIType *Ty); 306 void addSourceLine(DIE *Die, const DINameSpace *NS); 307 308 /// addAddress - Add an address attribute to a die based on the location 309 /// provided. 310 void addAddress(DIE *Die, unsigned Attribute, 311 const MachineLocation &Location); 312 313 /// addComplexAddress - Start with the address based on the location provided, 314 /// and generate the DWARF information necessary to find the actual variable 315 /// (navigating the extra location information encoded in the type) based on 316 /// the starting location. Add the DWARF information to the die. 317 /// 318 void addComplexAddress(DbgVariable *&DV, DIE *Die, unsigned Attribute, 319 const MachineLocation &Location); 320 321 // FIXME: Should be reformulated in terms of addComplexAddress. 322 /// addBlockByrefAddress - Start with the address based on the location 323 /// provided, and generate the DWARF information necessary to find the 324 /// actual Block variable (navigating the Block struct) based on the 325 /// starting location. Add the DWARF information to the die. Obsolete, 326 /// please use addComplexAddress instead. 327 /// 328 void addBlockByrefAddress(DbgVariable *&DV, DIE *Die, unsigned Attribute, 329 const MachineLocation &Location); 330 331 /// addToContextOwner - Add Die into the list of its context owner's children. 332 void addToContextOwner(DIE *Die, DIDescriptor Context); 333 334 /// addType - Add a new type attribute to the specified entity. 335 void addType(DIE *Entity, DIType Ty); 336 337 338 /// getOrCreateNameSpace - Create a DIE for DINameSpace. 339 DIE *getOrCreateNameSpace(DINameSpace NS); 340 341 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the 342 /// given DIType. 343 DIE *getOrCreateTypeDIE(DIType Ty); 344 345 void addPubTypes(DISubprogram SP); 346 347 /// constructTypeDIE - Construct basic type die from DIBasicType. 348 void constructTypeDIE(DIE &Buffer, 349 DIBasicType BTy); 350 351 /// constructTypeDIE - Construct derived type die from DIDerivedType. 352 void constructTypeDIE(DIE &Buffer, 353 DIDerivedType DTy); 354 355 /// constructTypeDIE - Construct type DIE from DICompositeType. 356 void constructTypeDIE(DIE &Buffer, 357 DICompositeType CTy); 358 359 /// constructSubrangeDIE - Construct subrange DIE from DISubrange. 360 void constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy); 361 362 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType. 363 void constructArrayTypeDIE(DIE &Buffer, 364 DICompositeType *CTy); 365 366 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator. 367 DIE *constructEnumTypeDIE(DIEnumerator ETy); 368 369 /// createGlobalVariableDIE - Create new DIE using GV. 370 DIE *createGlobalVariableDIE(const DIGlobalVariable &GV); 371 372 /// createMemberDIE - Create new member DIE. 373 DIE *createMemberDIE(const DIDerivedType &DT); 374 375 /// createSubprogramDIE - Create new DIE using SP. 376 DIE *createSubprogramDIE(const DISubprogram &SP, bool MakeDecl = false); 377 378 /// getOrCreateDbgScope - Create DbgScope for the scope. 379 DbgScope *getOrCreateDbgScope(MDNode *Scope, MDNode *InlinedAt); 380 381 DbgScope *getOrCreateAbstractScope(MDNode *N); 382 383 /// findAbstractVariable - Find abstract variable associated with Var. 384 DbgVariable *findAbstractVariable(DIVariable &Var, unsigned FrameIdx, 385 DebugLoc Loc); 386 DbgVariable *findAbstractVariable(DIVariable &Var, const MachineInstr *MI, 387 DebugLoc Loc); 388 389 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and 390 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes. 391 /// If there are global variables in this scope then create and insert 392 /// DIEs for these variables. 393 DIE *updateSubprogramScopeDIE(MDNode *SPNode); 394 395 /// constructLexicalScope - Construct new DW_TAG_lexical_block 396 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels. 397 DIE *constructLexicalScopeDIE(DbgScope *Scope); 398 399 /// constructInlinedScopeDIE - This scope represents inlined body of 400 /// a function. Construct DIE to represent this concrete inlined copy 401 /// of the function. 402 DIE *constructInlinedScopeDIE(DbgScope *Scope); 403 404 /// constructVariableDIE - Construct a DIE for the given DbgVariable. 405 DIE *constructVariableDIE(DbgVariable *DV, DbgScope *S); 406 407 /// constructScopeDIE - Construct a DIE for this scope. 408 DIE *constructScopeDIE(DbgScope *Scope); 409 410 /// EmitSectionLabels - Emit initial Dwarf sections with a label at 411 /// the start of each one. 412 void EmitSectionLabels(); 413 414 /// emitDIE - Recusively Emits a debug information entry. 415 /// 416 void emitDIE(DIE *Die); 417 418 /// computeSizeAndOffset - Compute the size and offset of a DIE. 419 /// 420 unsigned computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last); 421 422 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 423 /// 424 void computeSizeAndOffsets(); 425 426 /// EmitDebugInfo - Emit the debug info section. 427 /// 428 void emitDebugInfo(); 429 430 /// emitAbbreviations - Emit the abbreviation section. 431 /// 432 void emitAbbreviations() const; 433 434 /// emitEndOfLineMatrix - Emit the last address of the section and the end of 435 /// the line matrix. 436 /// 437 void emitEndOfLineMatrix(unsigned SectionEnd); 438 439 /// emitDebugLines - Emit source line information. 440 /// 441 void emitDebugLines(); 442 443 /// emitCommonDebugFrame - Emit common frame info into a debug frame section. 444 /// 445 void emitCommonDebugFrame(); 446 447 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame 448 /// section. 449 void emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo); 450 451 /// emitDebugPubNames - Emit visible names into a debug pubnames section. 452 /// 453 void emitDebugPubNames(); 454 455 /// emitDebugPubTypes - Emit visible types into a debug pubtypes section. 456 /// 457 void emitDebugPubTypes(); 458 459 /// emitDebugStr - Emit visible names into a debug str section. 460 /// 461 void emitDebugStr(); 462 463 /// emitDebugLoc - Emit visible names into a debug loc section. 464 /// 465 void emitDebugLoc(); 466 467 /// EmitDebugARanges - Emit visible names into a debug aranges section. 468 /// 469 void EmitDebugARanges(); 470 471 /// emitDebugRanges - Emit visible names into a debug ranges section. 472 /// 473 void emitDebugRanges(); 474 475 /// emitDebugMacInfo - Emit visible names into a debug macinfo section. 476 /// 477 void emitDebugMacInfo(); 478 479 /// emitDebugInlineInfo - Emit inline info using following format. 480 /// Section Header: 481 /// 1. length of section 482 /// 2. Dwarf version number 483 /// 3. address size. 484 /// 485 /// Entries (one "entry" for each function that was inlined): 486 /// 487 /// 1. offset into __debug_str section for MIPS linkage name, if exists; 488 /// otherwise offset into __debug_str for regular function name. 489 /// 2. offset into __debug_str section for regular function name. 490 /// 3. an unsigned LEB128 number indicating the number of distinct inlining 491 /// instances for the function. 492 /// 493 /// The rest of the entry consists of a {die_offset, low_pc} pair for each 494 /// inlined instance; the die_offset points to the inlined_subroutine die in 495 /// the __debug_info section, and the low_pc is the starting address for the 496 /// inlining instance. 497 void emitDebugInlineInfo(); 498 499 /// GetOrCreateSourceID - Look up the source id with the given directory and 500 /// source file names. If none currently exists, create a new id and insert it 501 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames 502 /// maps as well. 503 unsigned GetOrCreateSourceID(StringRef DirName, StringRef FileName); 504 505 void constructCompileUnit(MDNode *N); 506 507 void constructGlobalVariableDIE(MDNode *N); 508 509 void constructSubprogramDIE(MDNode *N); 510 511 // FIXME: This should go away in favor of complex addresses. 512 /// Find the type the programmer originally declared the variable to be 513 /// and return that type. Obsolete, use GetComplexAddrType instead. 514 /// 515 DIType getBlockByrefType(DIType Ty, std::string Name); 516 517 /// recordSourceLine - Register a source line with debug info. Returns the 518 /// unique label that was emitted and which provides correspondence to 519 /// the source line list. 520 MCSymbol *recordSourceLine(unsigned Line, unsigned Col, MDNode *Scope); 521 522 /// getSourceLineCount - Return the number of source lines in the debug 523 /// info. 524 unsigned getSourceLineCount() const { 525 return Lines.size(); 526 } 527 528 /// identifyScopeMarkers() - Indentify instructions that are marking 529 /// beginning of or end of a scope. 530 void identifyScopeMarkers(); 531 532 /// extractScopeInformation - Scan machine instructions in this function 533 /// and collect DbgScopes. Return true, if atleast one scope was found. 534 bool extractScopeInformation(); 535 536 /// collectVariableInfo - Populate DbgScope entries with variables' info. 537 void collectVariableInfo(); 538 539public: 540 //===--------------------------------------------------------------------===// 541 // Main entry points. 542 // 543 DwarfDebug(AsmPrinter *A, Module *M); 544 ~DwarfDebug(); 545 546 /// beginModule - Emit all Dwarf sections that should come prior to the 547 /// content. 548 void beginModule(Module *M); 549 550 /// endModule - Emit all Dwarf sections that should come after the content. 551 /// 552 void endModule(); 553 554 /// beginFunction - Gather pre-function debug information. Assumes being 555 /// emitted immediately after the function entry point. 556 void beginFunction(const MachineFunction *MF); 557 558 /// endFunction - Gather and emit post-function debug information. 559 /// 560 void endFunction(const MachineFunction *MF); 561 562 /// beginScope - Process beginning of a scope. 563 void beginScope(const MachineInstr *MI); 564 565 /// endScope - Prcess end of a scope. 566 void endScope(const MachineInstr *MI); 567}; 568} // End of namespace llvm 569 570#endif 571