DwarfDebug.cpp revision 4f455d6f258ae209291006e96b007111978fa1e0
1//===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===// 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#define DEBUG_TYPE "dwarfdebug" 15#include "DwarfDebug.h" 16#include "DIE.h" 17#include "DwarfCompileUnit.h" 18#include "llvm/Constants.h" 19#include "llvm/Module.h" 20#include "llvm/Instructions.h" 21#include "llvm/CodeGen/MachineFunction.h" 22#include "llvm/CodeGen/MachineModuleInfo.h" 23#include "llvm/MC/MCAsmInfo.h" 24#include "llvm/MC/MCSection.h" 25#include "llvm/MC/MCStreamer.h" 26#include "llvm/MC/MCSymbol.h" 27#include "llvm/Target/Mangler.h" 28#include "llvm/Target/TargetData.h" 29#include "llvm/Target/TargetFrameLowering.h" 30#include "llvm/Target/TargetLoweringObjectFile.h" 31#include "llvm/Target/TargetMachine.h" 32#include "llvm/Target/TargetRegisterInfo.h" 33#include "llvm/Target/TargetOptions.h" 34#include "llvm/Analysis/DebugInfo.h" 35#include "llvm/Analysis/DIBuilder.h" 36#include "llvm/ADT/Statistic.h" 37#include "llvm/ADT/STLExtras.h" 38#include "llvm/ADT/StringExtras.h" 39#include "llvm/Support/CommandLine.h" 40#include "llvm/Support/Debug.h" 41#include "llvm/Support/ErrorHandling.h" 42#include "llvm/Support/ValueHandle.h" 43#include "llvm/Support/FormattedStream.h" 44#include "llvm/Support/Timer.h" 45#include "llvm/Support/Path.h" 46using namespace llvm; 47 48static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden, 49 cl::desc("Print DbgScope information for each machine instruction")); 50 51static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print", 52 cl::Hidden, 53 cl::desc("Disable debug info printing")); 54 55static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden, 56 cl::desc("Make an absence of debug location information explicit."), 57 cl::init(false)); 58 59namespace { 60 const char *DWARFGroupName = "DWARF Emission"; 61 const char *DbgTimerName = "DWARF Debug Writer"; 62} // end anonymous namespace 63 64//===----------------------------------------------------------------------===// 65 66/// Configuration values for initial hash set sizes (log2). 67/// 68static const unsigned InitAbbreviationsSetSize = 9; // log2(512) 69 70namespace llvm { 71 72DIType DbgVariable::getType() const { 73 DIType Ty = Var.getType(); 74 // FIXME: isBlockByrefVariable should be reformulated in terms of complex 75 // addresses instead. 76 if (Var.isBlockByrefVariable()) { 77 /* Byref variables, in Blocks, are declared by the programmer as 78 "SomeType VarName;", but the compiler creates a 79 __Block_byref_x_VarName struct, and gives the variable VarName 80 either the struct, or a pointer to the struct, as its type. This 81 is necessary for various behind-the-scenes things the compiler 82 needs to do with by-reference variables in blocks. 83 84 However, as far as the original *programmer* is concerned, the 85 variable should still have type 'SomeType', as originally declared. 86 87 The following function dives into the __Block_byref_x_VarName 88 struct to find the original type of the variable. This will be 89 passed back to the code generating the type for the Debug 90 Information Entry for the variable 'VarName'. 'VarName' will then 91 have the original type 'SomeType' in its debug information. 92 93 The original type 'SomeType' will be the type of the field named 94 'VarName' inside the __Block_byref_x_VarName struct. 95 96 NOTE: In order for this to not completely fail on the debugger 97 side, the Debug Information Entry for the variable VarName needs to 98 have a DW_AT_location that tells the debugger how to unwind through 99 the pointers and __Block_byref_x_VarName struct to find the actual 100 value of the variable. The function addBlockByrefType does this. */ 101 DIType subType = Ty; 102 unsigned tag = Ty.getTag(); 103 104 if (tag == dwarf::DW_TAG_pointer_type) { 105 DIDerivedType DTy = DIDerivedType(Ty); 106 subType = DTy.getTypeDerivedFrom(); 107 } 108 109 DICompositeType blockStruct = DICompositeType(subType); 110 DIArray Elements = blockStruct.getTypeArray(); 111 112 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 113 DIDescriptor Element = Elements.getElement(i); 114 DIDerivedType DT = DIDerivedType(Element); 115 if (getName() == DT.getName()) 116 return (DT.getTypeDerivedFrom()); 117 } 118 return Ty; 119 } 120 return Ty; 121} 122 123//===----------------------------------------------------------------------===// 124/// DbgRange - This is used to track range of instructions with identical 125/// debug info scope. 126/// 127typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange; 128 129//===----------------------------------------------------------------------===// 130/// DbgScope - This class is used to track scope information. 131/// 132class DbgScope { 133 DbgScope *Parent; // Parent to this scope. 134 DIDescriptor Desc; // Debug info descriptor for scope. 135 // Location at which this scope is inlined. 136 AssertingVH<const MDNode> InlinedAtLocation; 137 bool AbstractScope; // Abstract Scope 138 const MachineInstr *LastInsn; // Last instruction of this scope. 139 const MachineInstr *FirstInsn; // First instruction of this scope. 140 unsigned DFSIn, DFSOut; 141 // Scopes defined in scope. Contents not owned. 142 SmallVector<DbgScope *, 4> Scopes; 143 // Variables declared in scope. Contents owned. 144 SmallVector<DbgVariable *, 8> Variables; 145 SmallVector<DbgRange, 4> Ranges; 146 // Private state for dump() 147 mutable unsigned IndentLevel; 148public: 149 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0) 150 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false), 151 LastInsn(0), FirstInsn(0), 152 DFSIn(0), DFSOut(0), IndentLevel(0) {} 153 virtual ~DbgScope(); 154 155 // Accessors. 156 DbgScope *getParent() const { return Parent; } 157 void setParent(DbgScope *P) { Parent = P; } 158 DIDescriptor getDesc() const { return Desc; } 159 const MDNode *getInlinedAt() const { return InlinedAtLocation; } 160 const MDNode *getScopeNode() const { return Desc; } 161 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; } 162 const SmallVector<DbgVariable *, 8> &getDbgVariables() { return Variables; } 163 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; } 164 165 /// openInsnRange - This scope covers instruction range starting from MI. 166 void openInsnRange(const MachineInstr *MI) { 167 if (!FirstInsn) 168 FirstInsn = MI; 169 170 if (Parent) 171 Parent->openInsnRange(MI); 172 } 173 174 /// extendInsnRange - Extend the current instruction range covered by 175 /// this scope. 176 void extendInsnRange(const MachineInstr *MI) { 177 assert (FirstInsn && "MI Range is not open!"); 178 LastInsn = MI; 179 if (Parent) 180 Parent->extendInsnRange(MI); 181 } 182 183 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected 184 /// until now. This is used when a new scope is encountered while walking 185 /// machine instructions. 186 void closeInsnRange(DbgScope *NewScope = NULL) { 187 assert (LastInsn && "Last insn missing!"); 188 Ranges.push_back(DbgRange(FirstInsn, LastInsn)); 189 FirstInsn = NULL; 190 LastInsn = NULL; 191 // If Parent dominates NewScope then do not close Parent's instruction 192 // range. 193 if (Parent && (!NewScope || !Parent->dominates(NewScope))) 194 Parent->closeInsnRange(NewScope); 195 } 196 197 void setAbstractScope() { AbstractScope = true; } 198 bool isAbstractScope() const { return AbstractScope; } 199 200 // Depth First Search support to walk and mainpluate DbgScope hierarchy. 201 unsigned getDFSOut() const { return DFSOut; } 202 void setDFSOut(unsigned O) { DFSOut = O; } 203 unsigned getDFSIn() const { return DFSIn; } 204 void setDFSIn(unsigned I) { DFSIn = I; } 205 bool dominates(const DbgScope *S) { 206 if (S == this) 207 return true; 208 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut()) 209 return true; 210 return false; 211 } 212 213 /// addScope - Add a scope to the scope. 214 /// 215 void addScope(DbgScope *S) { Scopes.push_back(S); } 216 217 /// addVariable - Add a variable to the scope. 218 /// 219 void addVariable(DbgVariable *V) { Variables.push_back(V); } 220 221#ifndef NDEBUG 222 void dump() const; 223#endif 224}; 225 226} // end llvm namespace 227 228#ifndef NDEBUG 229void DbgScope::dump() const { 230 raw_ostream &err = dbgs(); 231 err.indent(IndentLevel); 232 err << "DFSIn: " << DFSIn << " DFSOut: " << DFSOut << "\n"; 233 const MDNode *N = Desc; 234 N->dump(); 235 if (AbstractScope) 236 err << "Abstract Scope\n"; 237 238 IndentLevel += 2; 239 if (!Scopes.empty()) 240 err << "Children ...\n"; 241 for (unsigned i = 0, e = Scopes.size(); i != e; ++i) 242 if (Scopes[i] != this) 243 Scopes[i]->dump(); 244 245 IndentLevel -= 2; 246} 247#endif 248 249DbgScope::~DbgScope() { 250 for (unsigned j = 0, M = Variables.size(); j < M; ++j) 251 delete Variables[j]; 252} 253 254DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M) 255 : Asm(A), MMI(Asm->MMI), FirstCU(0), 256 AbbreviationsSet(InitAbbreviationsSetSize), 257 CurrentFnDbgScope(0), PrevLabel(NULL) { 258 NextStringPoolNumber = 0; 259 260 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0; 261 DwarfStrSectionSym = TextSectionSym = 0; 262 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0; 263 FunctionBeginSym = FunctionEndSym = 0; 264 { 265 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled); 266 beginModule(M); 267 } 268} 269DwarfDebug::~DwarfDebug() { 270} 271 272MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) { 273 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str]; 274 if (Entry.first) return Entry.first; 275 276 Entry.second = NextStringPoolNumber++; 277 return Entry.first = Asm->GetTempSymbol("string", Entry.second); 278} 279 280 281/// assignAbbrevNumber - Define a unique number for the abbreviation. 282/// 283void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) { 284 // Profile the node so that we can make it unique. 285 FoldingSetNodeID ID; 286 Abbrev.Profile(ID); 287 288 // Check the set for priors. 289 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev); 290 291 // If it's newly added. 292 if (InSet == &Abbrev) { 293 // Add to abbreviation list. 294 Abbreviations.push_back(&Abbrev); 295 296 // Assign the vector position + 1 as its number. 297 Abbrev.setNumber(Abbreviations.size()); 298 } else { 299 // Assign existing abbreviation number. 300 Abbrev.setNumber(InSet->getNumber()); 301 } 302} 303 304/// getRealLinkageName - If special LLVM prefix that is used to inform the asm 305/// printer to not emit usual symbol prefix before the symbol name is used then 306/// return linkage name after skipping this special LLVM prefix. 307static StringRef getRealLinkageName(StringRef LinkageName) { 308 char One = '\1'; 309 if (LinkageName.startswith(StringRef(&One, 1))) 310 return LinkageName.substr(1); 311 return LinkageName; 312} 313 314/// createSubprogramDIE - Create new DIE using SP. 315DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) { 316 CompileUnit *SPCU = getCompileUnit(SP); 317 DIE *SPDie = SPCU->getDIE(SP); 318 if (SPDie) 319 return SPDie; 320 321 SPDie = new DIE(dwarf::DW_TAG_subprogram); 322 323 // DW_TAG_inlined_subroutine may refer to this DIE. 324 SPCU->insertDIE(SP, SPDie); 325 326 // Add to context owner. 327 SPCU->addToContextOwner(SPDie, SP.getContext()); 328 329 // Add function template parameters. 330 SPCU->addTemplateParams(*SPDie, SP.getTemplateParams()); 331 332 StringRef LinkageName = SP.getLinkageName(); 333 if (!LinkageName.empty()) 334 SPCU->addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string, 335 getRealLinkageName(LinkageName)); 336 337 // If this DIE is going to refer declaration info using AT_specification 338 // then there is no need to add other attributes. 339 if (SP.getFunctionDeclaration().isSubprogram()) 340 return SPDie; 341 342 // Constructors and operators for anonymous aggregates do not have names. 343 if (!SP.getName().empty()) 344 SPCU->addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, 345 SP.getName()); 346 347 SPCU->addSourceLine(SPDie, SP); 348 349 if (SP.isPrototyped()) 350 SPCU->addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1); 351 352 // Add Return Type. 353 DICompositeType SPTy = SP.getType(); 354 DIArray Args = SPTy.getTypeArray(); 355 unsigned SPTag = SPTy.getTag(); 356 357 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type) 358 SPCU->addType(SPDie, SPTy); 359 else 360 SPCU->addType(SPDie, DIType(Args.getElement(0))); 361 362 unsigned VK = SP.getVirtuality(); 363 if (VK) { 364 SPCU->addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK); 365 DIEBlock *Block = SPCU->getDIEBlock(); 366 SPCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 367 SPCU->addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex()); 368 SPCU->addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block); 369 ContainingTypeMap.insert(std::make_pair(SPDie, 370 SP.getContainingType())); 371 } 372 373 if (!SP.isDefinition()) { 374 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 375 376 // Add arguments. Do not add arguments for subprogram definition. They will 377 // be handled while processing variables. 378 DICompositeType SPTy = SP.getType(); 379 DIArray Args = SPTy.getTypeArray(); 380 unsigned SPTag = SPTy.getTag(); 381 382 if (SPTag == dwarf::DW_TAG_subroutine_type) 383 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 384 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 385 DIType ATy = DIType(DIType(Args.getElement(i))); 386 SPCU->addType(Arg, ATy); 387 if (ATy.isArtificial()) 388 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 389 SPDie->addChild(Arg); 390 } 391 } 392 393 if (SP.isArtificial()) 394 SPCU->addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 395 396 if (!SP.isLocalToUnit()) 397 SPCU->addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 398 399 if (SP.isOptimized()) 400 SPCU->addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1); 401 402 if (unsigned isa = Asm->getISAEncoding()) { 403 SPCU->addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa); 404 } 405 406 return SPDie; 407} 408 409DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) { 410 assert(N && "Invalid Scope encoding!"); 411 412 DbgScope *AScope = AbstractScopes.lookup(N); 413 if (AScope) 414 return AScope; 415 416 DbgScope *Parent = NULL; 417 418 DIDescriptor Scope(N); 419 if (Scope.isLexicalBlock()) { 420 DILexicalBlock DB(N); 421 DIDescriptor ParentDesc = DB.getContext(); 422 Parent = getOrCreateAbstractScope(ParentDesc); 423 } 424 425 AScope = new DbgScope(Parent, DIDescriptor(N), NULL); 426 427 if (Parent) 428 Parent->addScope(AScope); 429 AScope->setAbstractScope(); 430 AbstractScopes[N] = AScope; 431 if (DIDescriptor(N).isSubprogram()) 432 AbstractScopesList.push_back(AScope); 433 return AScope; 434} 435 436/// isSubprogramContext - Return true if Context is either a subprogram 437/// or another context nested inside a subprogram. 438static bool isSubprogramContext(const MDNode *Context) { 439 if (!Context) 440 return false; 441 DIDescriptor D(Context); 442 if (D.isSubprogram()) 443 return true; 444 if (D.isType()) 445 return isSubprogramContext(DIType(Context).getContext()); 446 return false; 447} 448 449/// updateSubprogramScopeDIE - Find DIE for the given subprogram and 450/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes. 451/// If there are global variables in this scope then create and insert 452/// DIEs for these variables. 453DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) { 454 CompileUnit *SPCU = getCompileUnit(SPNode); 455 DIE *SPDie = SPCU->getDIE(SPNode); 456 457 assert(SPDie && "Unable to find subprogram DIE!"); 458 DISubprogram SP(SPNode); 459 460 DISubprogram SPDecl = SP.getFunctionDeclaration(); 461 if (SPDecl.isSubprogram()) 462 // Refer function declaration directly. 463 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4, 464 createSubprogramDIE(SPDecl)); 465 else { 466 // There is not any need to generate specification DIE for a function 467 // defined at compile unit level. If a function is defined inside another 468 // function then gdb prefers the definition at top level and but does not 469 // expect specification DIE in parent function. So avoid creating 470 // specification DIE for a function defined inside a function. 471 if (SP.isDefinition() && !SP.getContext().isCompileUnit() && 472 !SP.getContext().isFile() && 473 !isSubprogramContext(SP.getContext())) { 474 SPCU-> addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 475 476 // Add arguments. 477 DICompositeType SPTy = SP.getType(); 478 DIArray Args = SPTy.getTypeArray(); 479 unsigned SPTag = SPTy.getTag(); 480 if (SPTag == dwarf::DW_TAG_subroutine_type) 481 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 482 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 483 DIType ATy = DIType(DIType(Args.getElement(i))); 484 SPCU->addType(Arg, ATy); 485 if (ATy.isArtificial()) 486 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); 487 SPDie->addChild(Arg); 488 } 489 DIE *SPDeclDie = SPDie; 490 SPDie = new DIE(dwarf::DW_TAG_subprogram); 491 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4, 492 SPDeclDie); 493 SPCU->addDie(SPDie); 494 } 495 } 496 // Pick up abstract subprogram DIE. 497 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) { 498 SPDie = new DIE(dwarf::DW_TAG_subprogram); 499 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, 500 dwarf::DW_FORM_ref4, AbsSPDIE); 501 SPCU->addDie(SPDie); 502 } 503 504 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 505 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber())); 506 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, 507 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber())); 508 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 509 MachineLocation Location(RI->getFrameRegister(*Asm->MF)); 510 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location); 511 512 return SPDie; 513} 514 515/// constructLexicalScope - Construct new DW_TAG_lexical_block 516/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels. 517DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) { 518 519 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block); 520 if (Scope->isAbstractScope()) 521 return ScopeDIE; 522 523 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges(); 524 if (Ranges.empty()) 525 return 0; 526 527 CompileUnit *TheCU = getCompileUnit(Scope->getScopeNode()); 528 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(); 529 if (Ranges.size() > 1) { 530 // .debug_range section has not been laid out yet. Emit offset in 531 // .debug_range as a uint, size 4, for now. emitDIE will handle 532 // DW_AT_ranges appropriately. 533 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4, 534 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize()); 535 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(), 536 RE = Ranges.end(); RI != RE; ++RI) { 537 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first)); 538 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second)); 539 } 540 DebugRangeSymbols.push_back(NULL); 541 DebugRangeSymbols.push_back(NULL); 542 return ScopeDIE; 543 } 544 545 const MCSymbol *Start = getLabelBeforeInsn(RI->first); 546 const MCSymbol *End = getLabelAfterInsn(RI->second); 547 548 if (End == 0) return 0; 549 550 assert(Start->isDefined() && "Invalid starting label for an inlined scope!"); 551 assert(End->isDefined() && "Invalid end label for an inlined scope!"); 552 553 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start); 554 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End); 555 556 return ScopeDIE; 557} 558 559/// constructInlinedScopeDIE - This scope represents inlined body of 560/// a function. Construct DIE to represent this concrete inlined copy 561/// of the function. 562DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) { 563 564 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges(); 565 assert (Ranges.empty() == false 566 && "DbgScope does not have instruction markers!"); 567 568 // FIXME : .debug_inlined section specification does not clearly state how 569 // to emit inlined scope that is split into multiple instruction ranges. 570 // For now, use first instruction range and emit low_pc/high_pc pair and 571 // corresponding .debug_inlined section entry for this pair. 572 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(); 573 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first); 574 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second); 575 576 if (StartLabel == 0 || EndLabel == 0) { 577 assert (0 && "Unexpected Start and End labels for a inlined scope!"); 578 return 0; 579 } 580 assert(StartLabel->isDefined() && 581 "Invalid starting label for an inlined scope!"); 582 assert(EndLabel->isDefined() && 583 "Invalid end label for an inlined scope!"); 584 585 if (!Scope->getScopeNode()) 586 return NULL; 587 DIScope DS(Scope->getScopeNode()); 588 DISubprogram InlinedSP = getDISubprogram(DS); 589 CompileUnit *TheCU = getCompileUnit(InlinedSP); 590 DIE *OriginDIE = TheCU->getDIE(InlinedSP); 591 if (!OriginDIE) { 592 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram."); 593 return NULL; 594 } 595 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine); 596 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, 597 dwarf::DW_FORM_ref4, OriginDIE); 598 599 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel); 600 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel); 601 602 InlinedSubprogramDIEs.insert(OriginDIE); 603 604 // Track the start label for this inlined function. 605 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator 606 I = InlineInfo.find(InlinedSP); 607 608 if (I == InlineInfo.end()) { 609 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, 610 ScopeDIE)); 611 InlinedSPNodes.push_back(InlinedSP); 612 } else 613 I->second.push_back(std::make_pair(StartLabel, ScopeDIE)); 614 615 DILocation DL(Scope->getInlinedAt()); 616 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID()); 617 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber()); 618 619 return ScopeDIE; 620} 621 622/// isUnsignedDIType - Return true if type encoding is unsigned. 623static bool isUnsignedDIType(DIType Ty) { 624 DIDerivedType DTy(Ty); 625 if (DTy.Verify()) 626 return isUnsignedDIType(DTy.getTypeDerivedFrom()); 627 628 DIBasicType BTy(Ty); 629 if (BTy.Verify()) { 630 unsigned Encoding = BTy.getEncoding(); 631 if (Encoding == dwarf::DW_ATE_unsigned || 632 Encoding == dwarf::DW_ATE_unsigned_char) 633 return true; 634 } 635 return false; 636} 637 638/// constructVariableDIE - Construct a DIE for the given DbgVariable. 639DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) { 640 StringRef Name = DV->getName(); 641 if (Name.empty()) 642 return NULL; 643 644 // Translate tag to proper Dwarf tag. The result variable is dropped for 645 // now. 646 unsigned Tag; 647 switch (DV->getTag()) { 648 case dwarf::DW_TAG_return_variable: 649 return NULL; 650 case dwarf::DW_TAG_arg_variable: 651 Tag = dwarf::DW_TAG_formal_parameter; 652 break; 653 case dwarf::DW_TAG_auto_variable: // fall thru 654 default: 655 Tag = dwarf::DW_TAG_variable; 656 break; 657 } 658 659 // Define variable debug information entry. 660 DIE *VariableDie = new DIE(Tag); 661 CompileUnit *VariableCU = getCompileUnit(DV->getVariable()); 662 DIE *AbsDIE = NULL; 663 DenseMap<const DbgVariable *, const DbgVariable *>::iterator 664 V2AVI = VarToAbstractVarMap.find(DV); 665 if (V2AVI != VarToAbstractVarMap.end()) 666 AbsDIE = V2AVI->second->getDIE(); 667 668 if (AbsDIE) 669 VariableCU->addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, 670 dwarf::DW_FORM_ref4, AbsDIE); 671 else { 672 VariableCU->addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, 673 Name); 674 VariableCU->addSourceLine(VariableDie, DV->getVariable()); 675 676 // Add variable type. 677 VariableCU->addType(VariableDie, DV->getType()); 678 } 679 680 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial()) 681 VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial, 682 dwarf::DW_FORM_flag, 1); 683 else if (DIVariable(DV->getVariable()).isArtificial()) 684 VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial, 685 dwarf::DW_FORM_flag, 1); 686 687 if (Scope->isAbstractScope()) { 688 DV->setDIE(VariableDie); 689 return VariableDie; 690 } 691 692 // Add variable address. 693 694 unsigned Offset = DV->getDotDebugLocOffset(); 695 if (Offset != ~0U) { 696 VariableCU->addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4, 697 Asm->GetTempSymbol("debug_loc", Offset)); 698 DV->setDIE(VariableDie); 699 UseDotDebugLocEntry.insert(VariableDie); 700 return VariableDie; 701 } 702 703 // Check if variable is described by a DBG_VALUE instruction. 704 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI = 705 DbgVariableToDbgInstMap.find(DV); 706 if (DVI != DbgVariableToDbgInstMap.end()) { 707 const MachineInstr *DVInsn = DVI->second; 708 bool updated = false; 709 // FIXME : Handle getNumOperands != 3 710 if (DVInsn->getNumOperands() == 3) { 711 if (DVInsn->getOperand(0).isReg()) { 712 const MachineOperand RegOp = DVInsn->getOperand(0); 713 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 714 if (DVInsn->getOperand(1).isImm() && 715 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) { 716 unsigned FrameReg = 0; 717 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering(); 718 int Offset = 719 TFI->getFrameIndexReference(*Asm->MF, 720 DVInsn->getOperand(1).getImm(), 721 FrameReg); 722 MachineLocation Location(FrameReg, Offset); 723 VariableCU->addVariableAddress(DV, VariableDie, Location); 724 725 } else if (RegOp.getReg()) 726 VariableCU->addVariableAddress(DV, VariableDie, 727 MachineLocation(RegOp.getReg())); 728 updated = true; 729 } 730 else if (DVInsn->getOperand(0).isImm()) 731 updated = 732 VariableCU->addConstantValue(VariableDie, DVInsn->getOperand(0), 733 DV->getType()); 734 else if (DVInsn->getOperand(0).isFPImm()) 735 updated = 736 VariableCU->addConstantFPValue(VariableDie, DVInsn->getOperand(0)); 737 else if (DVInsn->getOperand(0).isCImm()) 738 updated = 739 VariableCU->addConstantValue(VariableDie, 740 DVInsn->getOperand(0).getCImm(), 741 isUnsignedDIType(DV->getType())); 742 } else { 743 VariableCU->addVariableAddress(DV, VariableDie, 744 Asm->getDebugValueLocation(DVInsn)); 745 updated = true; 746 } 747 if (!updated) { 748 // If variableDie is not updated then DBG_VALUE instruction does not 749 // have valid variable info. 750 delete VariableDie; 751 return NULL; 752 } 753 DV->setDIE(VariableDie); 754 return VariableDie; 755 } 756 757 // .. else use frame index, if available. 758 int FI = 0; 759 if (findVariableFrameIndex(DV, &FI)) { 760 unsigned FrameReg = 0; 761 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering(); 762 int Offset = 763 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg); 764 MachineLocation Location(FrameReg, Offset); 765 VariableCU->addVariableAddress(DV, VariableDie, Location); 766 } 767 768 DV->setDIE(VariableDie); 769 return VariableDie; 770 771} 772 773/// constructScopeDIE - Construct a DIE for this scope. 774DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) { 775 if (!Scope || !Scope->getScopeNode()) 776 return NULL; 777 778 SmallVector <DIE *, 8> Children; 779 780 // Collect arguments for current function. 781 if (Scope == CurrentFnDbgScope) 782 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i) 783 if (DbgVariable *ArgDV = CurrentFnArguments[i]) 784 if (DIE *Arg = constructVariableDIE(ArgDV, Scope)) 785 Children.push_back(Arg); 786 787 // Collect lexical scope childrens first. 788 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables(); 789 for (unsigned i = 0, N = Variables.size(); i < N; ++i) 790 if (DIE *Variable = constructVariableDIE(Variables[i], Scope)) 791 Children.push_back(Variable); 792 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes(); 793 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) 794 if (DIE *Nested = constructScopeDIE(Scopes[j])) 795 Children.push_back(Nested); 796 DIScope DS(Scope->getScopeNode()); 797 DIE *ScopeDIE = NULL; 798 if (Scope->getInlinedAt()) 799 ScopeDIE = constructInlinedScopeDIE(Scope); 800 else if (DS.isSubprogram()) { 801 ProcessedSPNodes.insert(DS); 802 if (Scope->isAbstractScope()) { 803 ScopeDIE = getCompileUnit(DS)->getDIE(DS); 804 // Note down abstract DIE. 805 if (ScopeDIE) 806 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE)); 807 } 808 else 809 ScopeDIE = updateSubprogramScopeDIE(DS); 810 } 811 else { 812 // There is no need to emit empty lexical block DIE. 813 if (Children.empty()) 814 return NULL; 815 ScopeDIE = constructLexicalScopeDIE(Scope); 816 } 817 818 if (!ScopeDIE) return NULL; 819 820 // Add children 821 for (SmallVector<DIE *, 8>::iterator I = Children.begin(), 822 E = Children.end(); I != E; ++I) 823 ScopeDIE->addChild(*I); 824 825 if (DS.isSubprogram()) 826 getCompileUnit(DS)->addPubTypes(DISubprogram(DS)); 827 828 return ScopeDIE; 829} 830 831/// GetOrCreateSourceID - Look up the source id with the given directory and 832/// source file names. If none currently exists, create a new id and insert it 833/// in the SourceIds map. This can update DirectoryNames and SourceFileNames 834/// maps as well. 835 836unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName, 837 StringRef DirName) { 838 // If FE did not provide a file name, then assume stdin. 839 if (FileName.empty()) 840 return GetOrCreateSourceID("<stdin>", StringRef()); 841 842 // MCStream expects full path name as filename. 843 if (!DirName.empty() && !sys::path::is_absolute(FileName)) { 844 SmallString<128> FullPathName = DirName; 845 sys::path::append(FullPathName, FileName); 846 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID. 847 return GetOrCreateSourceID(StringRef(FullPathName), StringRef()); 848 } 849 850 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName); 851 if (Entry.getValue()) 852 return Entry.getValue(); 853 854 unsigned SrcId = SourceIdMap.size(); 855 Entry.setValue(SrcId); 856 857 // Print out a .file directive to specify files for .loc directives. 858 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey()); 859 860 return SrcId; 861} 862 863/// constructCompileUnit - Create new CompileUnit for the given 864/// metadata node with tag DW_TAG_compile_unit. 865void DwarfDebug::constructCompileUnit(const MDNode *N) { 866 DICompileUnit DIUnit(N); 867 StringRef FN = DIUnit.getFilename(); 868 StringRef Dir = DIUnit.getDirectory(); 869 unsigned ID = GetOrCreateSourceID(FN, Dir); 870 871 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 872 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this); 873 NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string, 874 DIUnit.getProducer()); 875 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2, 876 DIUnit.getLanguage()); 877 NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN); 878 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This 879 // simplifies debug range entries. 880 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0); 881 // DW_AT_stmt_list is a offset of line number information for this 882 // compile unit in debug_line section. 883 if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset()) 884 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 885 Asm->GetTempSymbol("section_line")); 886 else 887 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0); 888 889 if (!Dir.empty()) 890 NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir); 891 if (DIUnit.isOptimized()) 892 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1); 893 894 StringRef Flags = DIUnit.getFlags(); 895 if (!Flags.empty()) 896 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags); 897 898 unsigned RVer = DIUnit.getRunTimeVersion(); 899 if (RVer) 900 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers, 901 dwarf::DW_FORM_data1, RVer); 902 903 if (!FirstCU) 904 FirstCU = NewCU; 905 CUMap.insert(std::make_pair(N, NewCU)); 906} 907 908/// getCompielUnit - Get CompileUnit DIE. 909CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const { 910 assert (N && "Invalid DwarfDebug::getCompileUnit argument!"); 911 DIDescriptor D(N); 912 const MDNode *CUNode = NULL; 913 if (D.isCompileUnit()) 914 CUNode = N; 915 else if (D.isSubprogram()) 916 CUNode = DISubprogram(N).getCompileUnit(); 917 else if (D.isType()) 918 CUNode = DIType(N).getCompileUnit(); 919 else if (D.isGlobalVariable()) 920 CUNode = DIGlobalVariable(N).getCompileUnit(); 921 else if (D.isVariable()) 922 CUNode = DIVariable(N).getCompileUnit(); 923 else if (D.isNameSpace()) 924 CUNode = DINameSpace(N).getCompileUnit(); 925 else if (D.isFile()) 926 CUNode = DIFile(N).getCompileUnit(); 927 else 928 return FirstCU; 929 930 DenseMap<const MDNode *, CompileUnit *>::const_iterator I 931 = CUMap.find(CUNode); 932 if (I == CUMap.end()) 933 return FirstCU; 934 return I->second; 935} 936 937// Return const exprssion if value is a GEP to access merged global 938// constant. e.g. 939// i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0) 940static const ConstantExpr *getMergedGlobalExpr(const Value *V) { 941 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V); 942 if (!CE || CE->getNumOperands() != 3 || 943 CE->getOpcode() != Instruction::GetElementPtr) 944 return NULL; 945 946 // First operand points to a global value. 947 if (!isa<GlobalValue>(CE->getOperand(0))) 948 return NULL; 949 950 // Second operand is zero. 951 const ConstantInt *CI = 952 dyn_cast_or_null<ConstantInt>(CE->getOperand(1)); 953 if (!CI || !CI->isZero()) 954 return NULL; 955 956 // Third operand is offset. 957 if (!isa<ConstantInt>(CE->getOperand(2))) 958 return NULL; 959 960 return CE; 961} 962 963/// constructGlobalVariableDIE - Construct global variable DIE. 964void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) { 965 DIGlobalVariable GV(N); 966 967 // If debug information is malformed then ignore it. 968 if (GV.Verify() == false) 969 return; 970 971 // Check for pre-existence. 972 CompileUnit *TheCU = getCompileUnit(N); 973 if (TheCU->getDIE(GV)) 974 return; 975 976 DIType GTy = GV.getType(); 977 DIE *VariableDIE = new DIE(GV.getTag()); 978 979 bool isGlobalVariable = GV.getGlobal() != NULL; 980 981 // Add name. 982 TheCU->addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, 983 GV.getDisplayName()); 984 StringRef LinkageName = GV.getLinkageName(); 985 if (!LinkageName.empty() && isGlobalVariable) 986 TheCU->addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, 987 dwarf::DW_FORM_string, 988 getRealLinkageName(LinkageName)); 989 // Add type. 990 TheCU->addType(VariableDIE, GTy); 991 992 // Add scoping info. 993 if (!GV.isLocalToUnit()) { 994 TheCU->addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 995 // Expose as global. 996 TheCU->addGlobal(GV.getName(), VariableDIE); 997 } 998 // Add line number info. 999 TheCU->addSourceLine(VariableDIE, GV); 1000 // Add to map. 1001 TheCU->insertDIE(N, VariableDIE); 1002 // Add to context owner. 1003 DIDescriptor GVContext = GV.getContext(); 1004 TheCU->addToContextOwner(VariableDIE, GVContext); 1005 // Add location. 1006 if (isGlobalVariable) { 1007 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1008 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 1009 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata, 1010 Asm->Mang->getSymbol(GV.getGlobal())); 1011 // Do not create specification DIE if context is either compile unit 1012 // or a subprogram. 1013 if (GV.isDefinition() && !GVContext.isCompileUnit() && 1014 !GVContext.isFile() && !isSubprogramContext(GVContext)) { 1015 // Create specification DIE. 1016 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable); 1017 TheCU->addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, 1018 dwarf::DW_FORM_ref4, VariableDIE); 1019 TheCU->addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block); 1020 TheCU->addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 1021 TheCU->addDie(VariableSpecDIE); 1022 } else { 1023 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block); 1024 } 1025 } else if (const ConstantInt *CI = 1026 dyn_cast_or_null<ConstantInt>(GV.getConstant())) 1027 TheCU->addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy)); 1028 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) { 1029 // GV is a merged global. 1030 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1031 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 1032 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata, 1033 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0)))); 1034 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2)); 1035 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1036 TheCU->addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue()); 1037 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 1038 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block); 1039 } 1040 1041 return; 1042} 1043 1044/// construct SubprogramDIE - Construct subprogram DIE. 1045void DwarfDebug::constructSubprogramDIE(const MDNode *N) { 1046 DISubprogram SP(N); 1047 1048 // Check for pre-existence. 1049 CompileUnit *TheCU = getCompileUnit(N); 1050 if (TheCU->getDIE(N)) 1051 return; 1052 1053 if (!SP.isDefinition()) 1054 // This is a method declaration which will be handled while constructing 1055 // class type. 1056 return; 1057 1058 DIE *SubprogramDie = createSubprogramDIE(SP); 1059 1060 // Add to map. 1061 TheCU->insertDIE(N, SubprogramDie); 1062 1063 // Add to context owner. 1064 TheCU->addToContextOwner(SubprogramDie, SP.getContext()); 1065 1066 // Expose as global. 1067 TheCU->addGlobal(SP.getName(), SubprogramDie); 1068 1069 return; 1070} 1071 1072/// beginModule - Emit all Dwarf sections that should come prior to the 1073/// content. Create global DIEs and emit initial debug info sections. 1074/// This is inovked by the target AsmPrinter. 1075void DwarfDebug::beginModule(Module *M) { 1076 if (DisableDebugInfoPrinting) 1077 return; 1078 1079 // If module has named metadata anchors then use them, otherwise scan the module 1080 // using debug info finder to collect debug info. 1081 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu"); 1082 if (CU_Nodes) { 1083 1084 NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv"); 1085 NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp"); 1086 if (!GV_Nodes && !SP_Nodes) 1087 // If there are not any global variables or any functions then 1088 // there is not any debug info in this module. 1089 return; 1090 1091 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) 1092 constructCompileUnit(CU_Nodes->getOperand(i)); 1093 1094 if (GV_Nodes) 1095 for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i) 1096 constructGlobalVariableDIE(GV_Nodes->getOperand(i)); 1097 1098 if (SP_Nodes) 1099 for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i) 1100 constructSubprogramDIE(SP_Nodes->getOperand(i)); 1101 1102 } else { 1103 1104 DebugInfoFinder DbgFinder; 1105 DbgFinder.processModule(*M); 1106 1107 bool HasDebugInfo = false; 1108 // Scan all the compile-units to see if there are any marked as the main unit. 1109 // if not, we do not generate debug info. 1110 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 1111 E = DbgFinder.compile_unit_end(); I != E; ++I) { 1112 if (DICompileUnit(*I).isMain()) { 1113 HasDebugInfo = true; 1114 break; 1115 } 1116 } 1117 if (!HasDebugInfo) return; 1118 1119 // Create all the compile unit DIEs. 1120 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(), 1121 E = DbgFinder.compile_unit_end(); I != E; ++I) 1122 constructCompileUnit(*I); 1123 1124 // Create DIEs for each global variable. 1125 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(), 1126 E = DbgFinder.global_variable_end(); I != E; ++I) 1127 constructGlobalVariableDIE(*I); 1128 1129 // Create DIEs for each subprogram. 1130 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(), 1131 E = DbgFinder.subprogram_end(); I != E; ++I) 1132 constructSubprogramDIE(*I); 1133 } 1134 1135 // Tell MMI that we have debug info. 1136 MMI->setDebugInfoAvailability(true); 1137 1138 // Emit initial sections. 1139 EmitSectionLabels(); 1140 1141 //getOrCreateTypeDIE 1142 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum")) 1143 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 1144 DIType Ty(NMD->getOperand(i)); 1145 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty); 1146 } 1147 1148 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty")) 1149 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 1150 DIType Ty(NMD->getOperand(i)); 1151 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty); 1152 } 1153 1154 // Prime section data. 1155 SectionMap.insert(Asm->getObjFileLowering().getTextSection()); 1156} 1157 1158/// endModule - Emit all Dwarf sections that should come after the content. 1159/// 1160void DwarfDebug::endModule() { 1161 if (!FirstCU) return; 1162 const Module *M = MMI->getModule(); 1163 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap; 1164 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) { 1165 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) { 1166 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue; 1167 DISubprogram SP(AllSPs->getOperand(SI)); 1168 if (!SP.Verify()) continue; 1169 1170 // Collect info for variables that were optimized out. 1171 if (!SP.isDefinition()) continue; 1172 StringRef FName = SP.getLinkageName(); 1173 if (FName.empty()) 1174 FName = SP.getName(); 1175 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName); 1176 if (!NMD) continue; 1177 unsigned E = NMD->getNumOperands(); 1178 if (!E) continue; 1179 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL); 1180 DeadFnScopeMap[SP] = Scope; 1181 for (unsigned I = 0; I != E; ++I) { 1182 DIVariable DV(NMD->getOperand(I)); 1183 if (!DV.Verify()) continue; 1184 Scope->addVariable(new DbgVariable(DV)); 1185 } 1186 1187 // Construct subprogram DIE and add variables DIEs. 1188 constructSubprogramDIE(SP); 1189 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP); 1190 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables(); 1191 for (unsigned i = 0, N = Variables.size(); i < N; ++i) { 1192 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope); 1193 if (VariableDIE) 1194 ScopeDIE->addChild(VariableDIE); 1195 } 1196 } 1197 } 1198 1199 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 1200 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(), 1201 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) { 1202 DIE *ISP = *AI; 1203 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 1204 } 1205 1206 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(), 1207 CE = ContainingTypeMap.end(); CI != CE; ++CI) { 1208 DIE *SPDie = CI->first; 1209 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second); 1210 if (!N) continue; 1211 DIE *NDie = getCompileUnit(N)->getDIE(N); 1212 if (!NDie) continue; 1213 getCompileUnit(N)->addDIEEntry(SPDie, dwarf::DW_AT_containing_type, 1214 dwarf::DW_FORM_ref4, NDie); 1215 } 1216 1217 // Standard sections final addresses. 1218 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 1219 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end")); 1220 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 1221 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end")); 1222 1223 // End text sections. 1224 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) { 1225 Asm->OutStreamer.SwitchSection(SectionMap[i]); 1226 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i)); 1227 } 1228 1229 // Compute DIE offsets and sizes. 1230 computeSizeAndOffsets(); 1231 1232 // Emit all the DIEs into a debug info section 1233 emitDebugInfo(); 1234 1235 // Corresponding abbreviations into a abbrev section. 1236 emitAbbreviations(); 1237 1238 // Emit info into a debug pubnames section. 1239 emitDebugPubNames(); 1240 1241 // Emit info into a debug pubtypes section. 1242 emitDebugPubTypes(); 1243 1244 // Emit info into a debug loc section. 1245 emitDebugLoc(); 1246 1247 // Emit info into a debug aranges section. 1248 EmitDebugARanges(); 1249 1250 // Emit info into a debug ranges section. 1251 emitDebugRanges(); 1252 1253 // Emit info into a debug macinfo section. 1254 emitDebugMacInfo(); 1255 1256 // Emit inline info. 1257 emitDebugInlineInfo(); 1258 1259 // Emit info into a debug str section. 1260 emitDebugStr(); 1261 1262 // clean up. 1263 DeleteContainerSeconds(DeadFnScopeMap); 1264 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 1265 E = CUMap.end(); I != E; ++I) 1266 delete I->second; 1267 FirstCU = NULL; // Reset for the next Module, if any. 1268} 1269 1270/// findAbstractVariable - Find abstract variable, if any, associated with Var. 1271DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var, 1272 DebugLoc ScopeLoc) { 1273 1274 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var); 1275 if (AbsDbgVariable) 1276 return AbsDbgVariable; 1277 1278 LLVMContext &Ctx = Var->getContext(); 1279 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx)); 1280 if (!Scope) 1281 return NULL; 1282 1283 AbsDbgVariable = new DbgVariable(Var); 1284 Scope->addVariable(AbsDbgVariable); 1285 AbstractVariables[Var] = AbsDbgVariable; 1286 return AbsDbgVariable; 1287} 1288 1289/// addCurrentFnArgument - If Var is an current function argument that add 1290/// it in CurrentFnArguments list. 1291bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF, 1292 DbgVariable *Var, DbgScope *Scope) { 1293 if (Scope != CurrentFnDbgScope) 1294 return false; 1295 DIVariable DV = Var->getVariable(); 1296 if (DV.getTag() != dwarf::DW_TAG_arg_variable) 1297 return false; 1298 unsigned ArgNo = DV.getArgNumber(); 1299 if (ArgNo == 0) 1300 return false; 1301 1302 size_t Size = CurrentFnArguments.size(); 1303 if (Size == 0) 1304 CurrentFnArguments.resize(MF->getFunction()->arg_size()); 1305 // llvm::Function argument size is not good indicator of how many 1306 // arguments does the function have at source level. 1307 if (ArgNo > Size) 1308 CurrentFnArguments.resize(ArgNo * 2); 1309 CurrentFnArguments[ArgNo - 1] = Var; 1310 return true; 1311} 1312 1313/// collectVariableInfoFromMMITable - Collect variable information from 1314/// side table maintained by MMI. 1315void 1316DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF, 1317 SmallPtrSet<const MDNode *, 16> &Processed) { 1318 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 1319 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 1320 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 1321 VE = VMap.end(); VI != VE; ++VI) { 1322 const MDNode *Var = VI->first; 1323 if (!Var) continue; 1324 Processed.insert(Var); 1325 DIVariable DV(Var); 1326 const std::pair<unsigned, DebugLoc> &VP = VI->second; 1327 1328 DbgScope *Scope = 0; 1329 if (const MDNode *IA = VP.second.getInlinedAt(Ctx)) 1330 Scope = ConcreteScopes.lookup(IA); 1331 if (Scope == 0) 1332 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx)); 1333 1334 // If variable scope is not found then skip this variable. 1335 if (Scope == 0) 1336 continue; 1337 1338 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second); 1339 DbgVariable *RegVar = new DbgVariable(DV); 1340 recordVariableFrameIndex(RegVar, VP.first); 1341 if (!addCurrentFnArgument(MF, RegVar, Scope)) 1342 Scope->addVariable(RegVar); 1343 if (AbsDbgVariable) { 1344 recordVariableFrameIndex(AbsDbgVariable, VP.first); 1345 VarToAbstractVarMap[RegVar] = AbsDbgVariable; 1346 } 1347 } 1348} 1349 1350/// isDbgValueInDefinedReg - Return true if debug value, encoded by 1351/// DBG_VALUE instruction, is in a defined reg. 1352static bool isDbgValueInDefinedReg(const MachineInstr *MI) { 1353 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 1354 return MI->getNumOperands() == 3 && 1355 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() && 1356 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0; 1357} 1358 1359/// getDebugLocEntry - Get .debug_loc entry for the instraction range starting 1360/// at MI. 1361static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm, 1362 const MCSymbol *FLabel, 1363 const MCSymbol *SLabel, 1364 const MachineInstr *MI) { 1365 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata(); 1366 1367 if (MI->getNumOperands() != 3) { 1368 MachineLocation MLoc = Asm->getDebugValueLocation(MI); 1369 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var); 1370 } 1371 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) { 1372 MachineLocation MLoc; 1373 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm()); 1374 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var); 1375 } 1376 if (MI->getOperand(0).isImm()) 1377 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm()); 1378 if (MI->getOperand(0).isFPImm()) 1379 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm()); 1380 if (MI->getOperand(0).isCImm()) 1381 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm()); 1382 1383 assert (0 && "Unexpected 3 operand DBG_VALUE instruction!"); 1384 return DotDebugLocEntry(); 1385} 1386 1387/// collectVariableInfo - Populate DbgScope entries with variables' info. 1388void 1389DwarfDebug::collectVariableInfo(const MachineFunction *MF, 1390 SmallPtrSet<const MDNode *, 16> &Processed) { 1391 1392 /// collection info from MMI table. 1393 collectVariableInfoFromMMITable(MF, Processed); 1394 1395 for (SmallVectorImpl<const MDNode*>::const_iterator 1396 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE; 1397 ++UVI) { 1398 const MDNode *Var = *UVI; 1399 if (Processed.count(Var)) 1400 continue; 1401 1402 // History contains relevant DBG_VALUE instructions for Var and instructions 1403 // clobbering it. 1404 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var]; 1405 if (History.empty()) 1406 continue; 1407 const MachineInstr *MInsn = History.front(); 1408 1409 DIVariable DV(Var); 1410 DbgScope *Scope = NULL; 1411 if (DV.getTag() == dwarf::DW_TAG_arg_variable && 1412 DISubprogram(DV.getContext()).describes(MF->getFunction())) 1413 Scope = CurrentFnDbgScope; 1414 else 1415 Scope = findDbgScope(MInsn); 1416 // If variable scope is not found then skip this variable. 1417 if (!Scope) 1418 continue; 1419 1420 Processed.insert(DV); 1421 assert(MInsn->isDebugValue() && "History must begin with debug value"); 1422 DbgVariable *RegVar = new DbgVariable(DV); 1423 if (!addCurrentFnArgument(MF, RegVar, Scope)) 1424 Scope->addVariable(RegVar); 1425 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) { 1426 DbgVariableToDbgInstMap[AbsVar] = MInsn; 1427 VarToAbstractVarMap[RegVar] = AbsVar; 1428 } 1429 1430 // Simple ranges that are fully coalesced. 1431 if (History.size() <= 1 || (History.size() == 2 && 1432 MInsn->isIdenticalTo(History.back()))) { 1433 DbgVariableToDbgInstMap[RegVar] = MInsn; 1434 continue; 1435 } 1436 1437 // handle multiple DBG_VALUE instructions describing one variable. 1438 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size()); 1439 1440 for (SmallVectorImpl<const MachineInstr*>::const_iterator 1441 HI = History.begin(), HE = History.end(); HI != HE; ++HI) { 1442 const MachineInstr *Begin = *HI; 1443 assert(Begin->isDebugValue() && "Invalid History entry"); 1444 1445 // Check if DBG_VALUE is truncating a range. 1446 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() 1447 && !Begin->getOperand(0).getReg()) 1448 continue; 1449 1450 // Compute the range for a register location. 1451 const MCSymbol *FLabel = getLabelBeforeInsn(Begin); 1452 const MCSymbol *SLabel = 0; 1453 1454 if (HI + 1 == HE) 1455 // If Begin is the last instruction in History then its value is valid 1456 // until the end of the function. 1457 SLabel = FunctionEndSym; 1458 else { 1459 const MachineInstr *End = HI[1]; 1460 DEBUG(dbgs() << "DotDebugLoc Pair:\n" 1461 << "\t" << *Begin << "\t" << *End << "\n"); 1462 if (End->isDebugValue()) 1463 SLabel = getLabelBeforeInsn(End); 1464 else { 1465 // End is a normal instruction clobbering the range. 1466 SLabel = getLabelAfterInsn(End); 1467 assert(SLabel && "Forgot label after clobber instruction"); 1468 ++HI; 1469 } 1470 } 1471 1472 // The value is valid until the next DBG_VALUE or clobber. 1473 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin)); 1474 } 1475 DotDebugLocEntries.push_back(DotDebugLocEntry()); 1476 } 1477 1478 // Collect info for variables that were optimized out. 1479 const Function *F = MF->getFunction(); 1480 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) { 1481 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 1482 DIVariable DV(cast<MDNode>(NMD->getOperand(i))); 1483 if (!DV || !Processed.insert(DV)) 1484 continue; 1485 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext()); 1486 if (Scope) 1487 Scope->addVariable(new DbgVariable(DV)); 1488 } 1489 } 1490} 1491 1492/// getLabelBeforeInsn - Return Label preceding the instruction. 1493const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) { 1494 MCSymbol *Label = LabelsBeforeInsn.lookup(MI); 1495 assert(Label && "Didn't insert label before instruction"); 1496 return Label; 1497} 1498 1499/// getLabelAfterInsn - Return Label immediately following the instruction. 1500const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) { 1501 return LabelsAfterInsn.lookup(MI); 1502} 1503 1504/// beginInstruction - Process beginning of an instruction. 1505void DwarfDebug::beginInstruction(const MachineInstr *MI) { 1506 // Check if source location changes, but ignore DBG_VALUE locations. 1507 if (!MI->isDebugValue()) { 1508 DebugLoc DL = MI->getDebugLoc(); 1509 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) { 1510 unsigned Flags = DWARF2_FLAG_IS_STMT; 1511 PrevInstLoc = DL; 1512 if (DL == PrologEndLoc) { 1513 Flags |= DWARF2_FLAG_PROLOGUE_END; 1514 PrologEndLoc = DebugLoc(); 1515 } 1516 if (!DL.isUnknown()) { 1517 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext()); 1518 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags); 1519 } else 1520 recordSourceLine(0, 0, 0, 0); 1521 } 1522 } 1523 1524 // Insert labels where requested. 1525 DenseMap<const MachineInstr*, MCSymbol*>::iterator I = 1526 LabelsBeforeInsn.find(MI); 1527 1528 // No label needed. 1529 if (I == LabelsBeforeInsn.end()) 1530 return; 1531 1532 // Label already assigned. 1533 if (I->second) 1534 return; 1535 1536 if (!PrevLabel) { 1537 PrevLabel = MMI->getContext().CreateTempSymbol(); 1538 Asm->OutStreamer.EmitLabel(PrevLabel); 1539 } 1540 I->second = PrevLabel; 1541} 1542 1543/// endInstruction - Process end of an instruction. 1544void DwarfDebug::endInstruction(const MachineInstr *MI) { 1545 // Don't create a new label after DBG_VALUE instructions. 1546 // They don't generate code. 1547 if (!MI->isDebugValue()) 1548 PrevLabel = 0; 1549 1550 DenseMap<const MachineInstr*, MCSymbol*>::iterator I = 1551 LabelsAfterInsn.find(MI); 1552 1553 // No label needed. 1554 if (I == LabelsAfterInsn.end()) 1555 return; 1556 1557 // Label already assigned. 1558 if (I->second) 1559 return; 1560 1561 // We need a label after this instruction. 1562 if (!PrevLabel) { 1563 PrevLabel = MMI->getContext().CreateTempSymbol(); 1564 Asm->OutStreamer.EmitLabel(PrevLabel); 1565 } 1566 I->second = PrevLabel; 1567} 1568 1569/// getOrCreateDbgScope - Create DbgScope for the scope. 1570DbgScope *DwarfDebug::getOrCreateDbgScope(DebugLoc DL) { 1571 LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 1572 MDNode *Scope = NULL; 1573 MDNode *InlinedAt = NULL; 1574 DL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx); 1575 1576 if (!InlinedAt) { 1577 DbgScope *WScope = DbgScopeMap.lookup(Scope); 1578 if (WScope) 1579 return WScope; 1580 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL); 1581 DbgScopeMap.insert(std::make_pair(Scope, WScope)); 1582 if (DIDescriptor(Scope).isLexicalBlock()) { 1583 DbgScope *Parent = 1584 getOrCreateDbgScope(DebugLoc::getFromDILexicalBlock(Scope)); 1585 WScope->setParent(Parent); 1586 Parent->addScope(WScope); 1587 } else if (DIDescriptor(Scope).isSubprogram() 1588 && DISubprogram(Scope).describes(Asm->MF->getFunction())) 1589 CurrentFnDbgScope = WScope; 1590 1591 return WScope; 1592 } 1593 1594 getOrCreateAbstractScope(Scope); 1595 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt); 1596 if (WScope) 1597 return WScope; 1598 1599 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt); 1600 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope)); 1601 DbgScope *Parent = 1602 getOrCreateDbgScope(DebugLoc::getFromDILocation(InlinedAt)); 1603 WScope->setParent(Parent); 1604 Parent->addScope(WScope); 1605 1606 ConcreteScopes[InlinedAt] = WScope; 1607 1608 return WScope; 1609} 1610 1611/// calculateDominanceGraph - Calculate dominance graph for DbgScope 1612/// hierarchy. 1613static void calculateDominanceGraph(DbgScope *Scope) { 1614 assert (Scope && "Unable to calculate scop edominance graph!"); 1615 SmallVector<DbgScope *, 4> WorkStack; 1616 WorkStack.push_back(Scope); 1617 unsigned Counter = 0; 1618 while (!WorkStack.empty()) { 1619 DbgScope *WS = WorkStack.back(); 1620 const SmallVector<DbgScope *, 4> &Children = WS->getScopes(); 1621 bool visitedChildren = false; 1622 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 1623 SE = Children.end(); SI != SE; ++SI) { 1624 DbgScope *ChildScope = *SI; 1625 if (!ChildScope->getDFSOut()) { 1626 WorkStack.push_back(ChildScope); 1627 visitedChildren = true; 1628 ChildScope->setDFSIn(++Counter); 1629 break; 1630 } 1631 } 1632 if (!visitedChildren) { 1633 WorkStack.pop_back(); 1634 WS->setDFSOut(++Counter); 1635 } 1636 } 1637} 1638 1639/// printDbgScopeInfo - Print DbgScope info for each machine instruction. 1640static 1641void printDbgScopeInfo(const MachineFunction *MF, 1642 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap) 1643{ 1644#ifndef NDEBUG 1645 LLVMContext &Ctx = MF->getFunction()->getContext(); 1646 unsigned PrevDFSIn = 0; 1647 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 1648 I != E; ++I) { 1649 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 1650 II != IE; ++II) { 1651 const MachineInstr *MInsn = II; 1652 MDNode *Scope = NULL; 1653 MDNode *InlinedAt = NULL; 1654 1655 // Check if instruction has valid location information. 1656 DebugLoc MIDL = MInsn->getDebugLoc(); 1657 if (!MIDL.isUnknown()) { 1658 MIDL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx); 1659 dbgs() << " [ "; 1660 if (InlinedAt) 1661 dbgs() << "*"; 1662 DenseMap<const MachineInstr *, DbgScope *>::iterator DI = 1663 MI2ScopeMap.find(MInsn); 1664 if (DI != MI2ScopeMap.end()) { 1665 DbgScope *S = DI->second; 1666 dbgs() << S->getDFSIn(); 1667 PrevDFSIn = S->getDFSIn(); 1668 } else 1669 dbgs() << PrevDFSIn; 1670 } else 1671 dbgs() << " [ x" << PrevDFSIn; 1672 dbgs() << " ]"; 1673 MInsn->dump(); 1674 } 1675 dbgs() << "\n"; 1676 } 1677#endif 1678} 1679/// extractScopeInformation - Scan machine instructions in this function 1680/// and collect DbgScopes. Return true, if at least one scope was found. 1681bool DwarfDebug::extractScopeInformation() { 1682 // If scope information was extracted using .dbg intrinsics then there is not 1683 // any need to extract these information by scanning each instruction. 1684 if (!DbgScopeMap.empty()) 1685 return false; 1686 1687 // Scan each instruction and create scopes. First build working set of scopes. 1688 SmallVector<DbgRange, 4> MIRanges; 1689 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap; 1690 DebugLoc PrevDL; 1691 const MachineInstr *RangeBeginMI = NULL; 1692 const MachineInstr *PrevMI = NULL; 1693 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 1694 I != E; ++I) { 1695 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 1696 II != IE; ++II) { 1697 const MachineInstr *MInsn = II; 1698 1699 // Check if instruction has valid location information. 1700 const DebugLoc MIDL = MInsn->getDebugLoc(); 1701 if (MIDL.isUnknown()) { 1702 PrevMI = MInsn; 1703 continue; 1704 } 1705 1706 // If scope has not changed then skip this instruction. 1707 if (MIDL == PrevDL) { 1708 PrevMI = MInsn; 1709 continue; 1710 } 1711 1712 // Ignore DBG_VALUE. It does not contribute any instruction in output. 1713 if (MInsn->isDebugValue()) 1714 continue; 1715 1716 if (RangeBeginMI) { 1717 // If we have alread seen a beginning of a instruction range and 1718 // current instruction scope does not match scope of first instruction 1719 // in this range then create a new instruction range. 1720 DEBUG(dbgs() << "Creating new instruction range :\n"); 1721 DEBUG(dbgs() << "Begin Range at " << *RangeBeginMI); 1722 DEBUG(dbgs() << "End Range at " << *PrevMI); 1723 DEBUG(dbgs() << "Next Range starting at " << *MInsn); 1724 DEBUG(dbgs() << "------------------------\n"); 1725 DbgRange R(RangeBeginMI, PrevMI); 1726 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL); 1727 MIRanges.push_back(R); 1728 } 1729 1730 // This is a beginning of a new instruction range. 1731 RangeBeginMI = MInsn; 1732 1733 // Reset previous markers. 1734 PrevMI = MInsn; 1735 PrevDL = MIDL; 1736 } 1737 } 1738 1739 // Create last instruction range. 1740 if (RangeBeginMI && PrevMI && !PrevDL.isUnknown()) { 1741 DbgRange R(RangeBeginMI, PrevMI); 1742 MIRanges.push_back(R); 1743 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL); 1744 } 1745 1746 if (!CurrentFnDbgScope) 1747 return false; 1748 1749 calculateDominanceGraph(CurrentFnDbgScope); 1750 if (PrintDbgScope) 1751 printDbgScopeInfo(Asm->MF, MI2ScopeMap); 1752 1753 // Find ranges of instructions covered by each DbgScope; 1754 DbgScope *PrevDbgScope = NULL; 1755 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(), 1756 RE = MIRanges.end(); RI != RE; ++RI) { 1757 const DbgRange &R = *RI; 1758 DbgScope *S = MI2ScopeMap.lookup(R.first); 1759 assert (S && "Lost DbgScope for a machine instruction!"); 1760 if (PrevDbgScope && !PrevDbgScope->dominates(S)) 1761 PrevDbgScope->closeInsnRange(S); 1762 S->openInsnRange(R.first); 1763 S->extendInsnRange(R.second); 1764 PrevDbgScope = S; 1765 } 1766 1767 if (PrevDbgScope) 1768 PrevDbgScope->closeInsnRange(); 1769 1770 identifyScopeMarkers(); 1771 1772 return !DbgScopeMap.empty(); 1773} 1774 1775/// identifyScopeMarkers() - 1776/// Each DbgScope has first instruction and last instruction to mark beginning 1777/// and end of a scope respectively. Create an inverse map that list scopes 1778/// starts (and ends) with an instruction. One instruction may start (or end) 1779/// multiple scopes. Ignore scopes that are not reachable. 1780void DwarfDebug::identifyScopeMarkers() { 1781 SmallVector<DbgScope *, 4> WorkList; 1782 WorkList.push_back(CurrentFnDbgScope); 1783 while (!WorkList.empty()) { 1784 DbgScope *S = WorkList.pop_back_val(); 1785 1786 const SmallVector<DbgScope *, 4> &Children = S->getScopes(); 1787 if (!Children.empty()) 1788 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 1789 SE = Children.end(); SI != SE; ++SI) 1790 WorkList.push_back(*SI); 1791 1792 if (S->isAbstractScope()) 1793 continue; 1794 1795 const SmallVector<DbgRange, 4> &Ranges = S->getRanges(); 1796 if (Ranges.empty()) 1797 continue; 1798 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(), 1799 RE = Ranges.end(); RI != RE; ++RI) { 1800 assert(RI->first && "DbgRange does not have first instruction!"); 1801 assert(RI->second && "DbgRange does not have second instruction!"); 1802 requestLabelBeforeInsn(RI->first); 1803 requestLabelAfterInsn(RI->second); 1804 } 1805 } 1806} 1807 1808/// getScopeNode - Get MDNode for DebugLoc's scope. 1809static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) { 1810 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx)) 1811 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx); 1812 return DL.getScope(Ctx); 1813} 1814 1815/// getFnDebugLoc - Walk up the scope chain of given debug loc and find 1816/// line number info for the function. 1817static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) { 1818 const MDNode *Scope = getScopeNode(DL, Ctx); 1819 DISubprogram SP = getDISubprogram(Scope); 1820 if (SP.Verify()) 1821 return DebugLoc::get(SP.getLineNumber(), 0, SP); 1822 return DebugLoc(); 1823} 1824 1825/// beginFunction - Gather pre-function debug information. Assumes being 1826/// emitted immediately after the function entry point. 1827void DwarfDebug::beginFunction(const MachineFunction *MF) { 1828 if (!MMI->hasDebugInfo()) return; 1829 if (!extractScopeInformation()) return; 1830 1831 FunctionBeginSym = Asm->GetTempSymbol("func_begin", 1832 Asm->getFunctionNumber()); 1833 // Assumes in correct section after the entry point. 1834 Asm->OutStreamer.EmitLabel(FunctionBeginSym); 1835 1836 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned"); 1837 1838 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 1839 /// LiveUserVar - Map physreg numbers to the MDNode they contain. 1840 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs()); 1841 1842 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 1843 I != E; ++I) { 1844 bool AtBlockEntry = true; 1845 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 1846 II != IE; ++II) { 1847 const MachineInstr *MI = II; 1848 1849 if (MI->isDebugValue()) { 1850 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!"); 1851 1852 // Keep track of user variables. 1853 const MDNode *Var = 1854 MI->getOperand(MI->getNumOperands() - 1).getMetadata(); 1855 1856 // Variable is in a register, we need to check for clobbers. 1857 if (isDbgValueInDefinedReg(MI)) 1858 LiveUserVar[MI->getOperand(0).getReg()] = Var; 1859 1860 // Check the history of this variable. 1861 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var]; 1862 if (History.empty()) { 1863 UserVariables.push_back(Var); 1864 // The first mention of a function argument gets the FunctionBeginSym 1865 // label, so arguments are visible when breaking at function entry. 1866 DIVariable DV(Var); 1867 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable && 1868 DISubprogram(getDISubprogram(DV.getContext())) 1869 .describes(MF->getFunction())) 1870 LabelsBeforeInsn[MI] = FunctionBeginSym; 1871 } else { 1872 // We have seen this variable before. Try to coalesce DBG_VALUEs. 1873 const MachineInstr *Prev = History.back(); 1874 if (Prev->isDebugValue()) { 1875 // Coalesce identical entries at the end of History. 1876 if (History.size() >= 2 && 1877 Prev->isIdenticalTo(History[History.size() - 2])) { 1878 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n" 1879 << "\t" << *Prev 1880 << "\t" << *History[History.size() - 2] << "\n"); 1881 History.pop_back(); 1882 } 1883 1884 // Terminate old register assignments that don't reach MI; 1885 MachineFunction::const_iterator PrevMBB = Prev->getParent(); 1886 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) && 1887 isDbgValueInDefinedReg(Prev)) { 1888 // Previous register assignment needs to terminate at the end of 1889 // its basic block. 1890 MachineBasicBlock::const_iterator LastMI = 1891 PrevMBB->getLastNonDebugInstr(); 1892 if (LastMI == PrevMBB->end()) { 1893 // Drop DBG_VALUE for empty range. 1894 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n" 1895 << "\t" << *Prev << "\n"); 1896 History.pop_back(); 1897 } 1898 else { 1899 // Terminate after LastMI. 1900 History.push_back(LastMI); 1901 } 1902 } 1903 } 1904 } 1905 History.push_back(MI); 1906 } else { 1907 // Not a DBG_VALUE instruction. 1908 if (!MI->isLabel()) 1909 AtBlockEntry = false; 1910 1911 // First known non DBG_VALUE location marks beginning of function 1912 // body. 1913 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()) 1914 PrologEndLoc = MI->getDebugLoc(); 1915 1916 // Check if the instruction clobbers any registers with debug vars. 1917 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(), 1918 MOE = MI->operands_end(); MOI != MOE; ++MOI) { 1919 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg()) 1920 continue; 1921 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg()); 1922 unsigned Reg = *AI; ++AI) { 1923 const MDNode *Var = LiveUserVar[Reg]; 1924 if (!Var) 1925 continue; 1926 // Reg is now clobbered. 1927 LiveUserVar[Reg] = 0; 1928 1929 // Was MD last defined by a DBG_VALUE referring to Reg? 1930 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var); 1931 if (HistI == DbgValues.end()) 1932 continue; 1933 SmallVectorImpl<const MachineInstr*> &History = HistI->second; 1934 if (History.empty()) 1935 continue; 1936 const MachineInstr *Prev = History.back(); 1937 // Sanity-check: Register assignments are terminated at the end of 1938 // their block. 1939 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent()) 1940 continue; 1941 // Is the variable still in Reg? 1942 if (!isDbgValueInDefinedReg(Prev) || 1943 Prev->getOperand(0).getReg() != Reg) 1944 continue; 1945 // Var is clobbered. Make sure the next instruction gets a label. 1946 History.push_back(MI); 1947 } 1948 } 1949 } 1950 } 1951 } 1952 1953 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end(); 1954 I != E; ++I) { 1955 SmallVectorImpl<const MachineInstr*> &History = I->second; 1956 if (History.empty()) 1957 continue; 1958 1959 // Make sure the final register assignments are terminated. 1960 const MachineInstr *Prev = History.back(); 1961 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) { 1962 const MachineBasicBlock *PrevMBB = Prev->getParent(); 1963 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr(); 1964 if (LastMI == PrevMBB->end()) 1965 // Drop DBG_VALUE for empty range. 1966 History.pop_back(); 1967 else { 1968 // Terminate after LastMI. 1969 History.push_back(LastMI); 1970 } 1971 } 1972 // Request labels for the full history. 1973 for (unsigned i = 0, e = History.size(); i != e; ++i) { 1974 const MachineInstr *MI = History[i]; 1975 if (MI->isDebugValue()) 1976 requestLabelBeforeInsn(MI); 1977 else 1978 requestLabelAfterInsn(MI); 1979 } 1980 } 1981 1982 PrevInstLoc = DebugLoc(); 1983 PrevLabel = FunctionBeginSym; 1984 1985 // Record beginning of function. 1986 if (!PrologEndLoc.isUnknown()) { 1987 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc, 1988 MF->getFunction()->getContext()); 1989 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(), 1990 FnStartDL.getScope(MF->getFunction()->getContext()), 1991 DWARF2_FLAG_IS_STMT); 1992 } 1993} 1994 1995/// endFunction - Gather and emit post-function debug information. 1996/// 1997void DwarfDebug::endFunction(const MachineFunction *MF) { 1998 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return; 1999 2000 if (CurrentFnDbgScope) { 2001 2002 // Define end label for subprogram. 2003 FunctionEndSym = Asm->GetTempSymbol("func_end", 2004 Asm->getFunctionNumber()); 2005 // Assumes in correct section after the entry point. 2006 Asm->OutStreamer.EmitLabel(FunctionEndSym); 2007 2008 SmallPtrSet<const MDNode *, 16> ProcessedVars; 2009 collectVariableInfo(MF, ProcessedVars); 2010 2011 // Construct abstract scopes. 2012 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(), 2013 AE = AbstractScopesList.end(); AI != AE; ++AI) { 2014 DISubprogram SP((*AI)->getScopeNode()); 2015 if (SP.Verify()) { 2016 // Collect info for variables that were optimized out. 2017 StringRef FName = SP.getLinkageName(); 2018 if (FName.empty()) 2019 FName = SP.getName(); 2020 if (NamedMDNode *NMD = 2021 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) { 2022 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2023 DIVariable DV(cast<MDNode>(NMD->getOperand(i))); 2024 if (!DV || !ProcessedVars.insert(DV)) 2025 continue; 2026 DbgScope *Scope = AbstractScopes.lookup(DV.getContext()); 2027 if (Scope) 2028 Scope->addVariable(new DbgVariable(DV)); 2029 } 2030 } 2031 } 2032 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0) 2033 constructScopeDIE(*AI); 2034 } 2035 2036 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope); 2037 2038 if (!DisableFramePointerElim(*MF)) 2039 getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE, 2040 dwarf::DW_AT_APPLE_omit_frame_ptr, 2041 dwarf::DW_FORM_flag, 1); 2042 2043 2044 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(), 2045 MMI->getFrameMoves())); 2046 } 2047 2048 // Clear debug info 2049 CurrentFnDbgScope = NULL; 2050 DeleteContainerPointers(CurrentFnArguments); 2051 DbgVariableToFrameIndexMap.clear(); 2052 VarToAbstractVarMap.clear(); 2053 DbgVariableToDbgInstMap.clear(); 2054 DeleteContainerSeconds(DbgScopeMap); 2055 UserVariables.clear(); 2056 DbgValues.clear(); 2057 ConcreteScopes.clear(); 2058 DeleteContainerSeconds(AbstractScopes); 2059 AbstractScopesList.clear(); 2060 AbstractVariables.clear(); 2061 LabelsBeforeInsn.clear(); 2062 LabelsAfterInsn.clear(); 2063 PrevLabel = NULL; 2064} 2065 2066/// recordVariableFrameIndex - Record a variable's index. 2067void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) { 2068 assert (V && "Invalid DbgVariable!"); 2069 DbgVariableToFrameIndexMap[V] = Index; 2070} 2071 2072/// findVariableFrameIndex - Return true if frame index for the variable 2073/// is found. Update FI to hold value of the index. 2074bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) { 2075 assert (V && "Invalid DbgVariable!"); 2076 DenseMap<const DbgVariable *, int>::iterator I = 2077 DbgVariableToFrameIndexMap.find(V); 2078 if (I == DbgVariableToFrameIndexMap.end()) 2079 return false; 2080 *FI = I->second; 2081 return true; 2082} 2083 2084/// findDbgScope - Find DbgScope for the debug loc attached with an 2085/// instruction. 2086DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) { 2087 DbgScope *Scope = NULL; 2088 LLVMContext &Ctx = 2089 MInsn->getParent()->getParent()->getFunction()->getContext(); 2090 DebugLoc DL = MInsn->getDebugLoc(); 2091 2092 if (DL.isUnknown()) 2093 return Scope; 2094 2095 if (const MDNode *IA = DL.getInlinedAt(Ctx)) 2096 Scope = ConcreteScopes.lookup(IA); 2097 if (Scope == 0) 2098 Scope = DbgScopeMap.lookup(DL.getScope(Ctx)); 2099 2100 return Scope; 2101} 2102 2103 2104/// recordSourceLine - Register a source line with debug info. Returns the 2105/// unique label that was emitted and which provides correspondence to 2106/// the source line list. 2107void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S, 2108 unsigned Flags) { 2109 StringRef Fn; 2110 StringRef Dir; 2111 unsigned Src = 1; 2112 if (S) { 2113 DIDescriptor Scope(S); 2114 2115 if (Scope.isCompileUnit()) { 2116 DICompileUnit CU(S); 2117 Fn = CU.getFilename(); 2118 Dir = CU.getDirectory(); 2119 } else if (Scope.isFile()) { 2120 DIFile F(S); 2121 Fn = F.getFilename(); 2122 Dir = F.getDirectory(); 2123 } else if (Scope.isSubprogram()) { 2124 DISubprogram SP(S); 2125 Fn = SP.getFilename(); 2126 Dir = SP.getDirectory(); 2127 } else if (Scope.isLexicalBlock()) { 2128 DILexicalBlock DB(S); 2129 Fn = DB.getFilename(); 2130 Dir = DB.getDirectory(); 2131 } else 2132 assert(0 && "Unexpected scope info"); 2133 2134 Src = GetOrCreateSourceID(Fn, Dir); 2135 } 2136 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 2137 0, 0, Fn); 2138} 2139 2140//===----------------------------------------------------------------------===// 2141// Emit Methods 2142//===----------------------------------------------------------------------===// 2143 2144/// computeSizeAndOffset - Compute the size and offset of a DIE. 2145/// 2146unsigned 2147DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) { 2148 // Get the children. 2149 const std::vector<DIE *> &Children = Die->getChildren(); 2150 2151 // If not last sibling and has children then add sibling offset attribute. 2152 if (!Last && !Children.empty()) 2153 Die->addSiblingOffset(DIEValueAllocator); 2154 2155 // Record the abbreviation. 2156 assignAbbrevNumber(Die->getAbbrev()); 2157 2158 // Get the abbreviation for this DIE. 2159 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2160 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2161 2162 // Set DIE offset 2163 Die->setOffset(Offset); 2164 2165 // Start the size with the size of abbreviation code. 2166 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 2167 2168 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2169 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2170 2171 // Size the DIE attribute values. 2172 for (unsigned i = 0, N = Values.size(); i < N; ++i) 2173 // Size attribute value. 2174 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm()); 2175 2176 // Size the DIE children if any. 2177 if (!Children.empty()) { 2178 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 2179 "Children flag not set"); 2180 2181 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2182 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M); 2183 2184 // End of children marker. 2185 Offset += sizeof(int8_t); 2186 } 2187 2188 Die->setSize(Offset - Die->getOffset()); 2189 return Offset; 2190} 2191 2192/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 2193/// 2194void DwarfDebug::computeSizeAndOffsets() { 2195 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2196 E = CUMap.end(); I != E; ++I) { 2197 // Compute size of compile unit header. 2198 unsigned Offset = 2199 sizeof(int32_t) + // Length of Compilation Unit Info 2200 sizeof(int16_t) + // DWARF version number 2201 sizeof(int32_t) + // Offset Into Abbrev. Section 2202 sizeof(int8_t); // Pointer Size (in bytes) 2203 computeSizeAndOffset(I->second->getCUDie(), Offset, true); 2204 } 2205} 2206 2207/// EmitSectionSym - Switch to the specified MCSection and emit an assembler 2208/// temporary label to it if SymbolStem is specified. 2209static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section, 2210 const char *SymbolStem = 0) { 2211 Asm->OutStreamer.SwitchSection(Section); 2212 if (!SymbolStem) return 0; 2213 2214 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem); 2215 Asm->OutStreamer.EmitLabel(TmpSym); 2216 return TmpSym; 2217} 2218 2219/// EmitSectionLabels - Emit initial Dwarf sections with a label at 2220/// the start of each one. 2221void DwarfDebug::EmitSectionLabels() { 2222 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 2223 2224 // Dwarf sections base addresses. 2225 DwarfInfoSectionSym = 2226 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info"); 2227 DwarfAbbrevSectionSym = 2228 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev"); 2229 EmitSectionSym(Asm, TLOF.getDwarfARangesSection()); 2230 2231 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection()) 2232 EmitSectionSym(Asm, MacroInfo); 2233 2234 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line"); 2235 EmitSectionSym(Asm, TLOF.getDwarfLocSection()); 2236 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection()); 2237 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection()); 2238 DwarfStrSectionSym = 2239 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str"); 2240 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(), 2241 "debug_range"); 2242 2243 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(), 2244 "section_debug_loc"); 2245 2246 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin"); 2247 EmitSectionSym(Asm, TLOF.getDataSection()); 2248} 2249 2250/// emitDIE - Recusively Emits a debug information entry. 2251/// 2252void DwarfDebug::emitDIE(DIE *Die) { 2253 // Get the abbreviation for this DIE. 2254 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2255 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2256 2257 // Emit the code (index) for the abbreviation. 2258 if (Asm->isVerbose()) 2259 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 2260 Twine::utohexstr(Die->getOffset()) + ":0x" + 2261 Twine::utohexstr(Die->getSize()) + " " + 2262 dwarf::TagString(Abbrev->getTag())); 2263 Asm->EmitULEB128(AbbrevNumber); 2264 2265 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2266 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2267 2268 // Emit the DIE attribute values. 2269 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 2270 unsigned Attr = AbbrevData[i].getAttribute(); 2271 unsigned Form = AbbrevData[i].getForm(); 2272 assert(Form && "Too many attributes for DIE (check abbreviation)"); 2273 2274 if (Asm->isVerbose()) 2275 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 2276 2277 switch (Attr) { 2278 case dwarf::DW_AT_sibling: 2279 Asm->EmitInt32(Die->getSiblingOffset()); 2280 break; 2281 case dwarf::DW_AT_abstract_origin: { 2282 DIEEntry *E = cast<DIEEntry>(Values[i]); 2283 DIE *Origin = E->getEntry(); 2284 unsigned Addr = Origin->getOffset(); 2285 Asm->EmitInt32(Addr); 2286 break; 2287 } 2288 case dwarf::DW_AT_ranges: { 2289 // DW_AT_range Value encodes offset in debug_range section. 2290 DIEInteger *V = cast<DIEInteger>(Values[i]); 2291 2292 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) { 2293 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym, 2294 V->getValue(), 2295 4); 2296 } else { 2297 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym, 2298 V->getValue(), 2299 DwarfDebugRangeSectionSym, 2300 4); 2301 } 2302 break; 2303 } 2304 case dwarf::DW_AT_location: { 2305 if (UseDotDebugLocEntry.count(Die) != 0) { 2306 DIELabel *L = cast<DIELabel>(Values[i]); 2307 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4); 2308 } else 2309 Values[i]->EmitValue(Asm, Form); 2310 break; 2311 } 2312 case dwarf::DW_AT_accessibility: { 2313 if (Asm->isVerbose()) { 2314 DIEInteger *V = cast<DIEInteger>(Values[i]); 2315 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue())); 2316 } 2317 Values[i]->EmitValue(Asm, Form); 2318 break; 2319 } 2320 default: 2321 // Emit an attribute using the defined form. 2322 Values[i]->EmitValue(Asm, Form); 2323 break; 2324 } 2325 } 2326 2327 // Emit the DIE children if any. 2328 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 2329 const std::vector<DIE *> &Children = Die->getChildren(); 2330 2331 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2332 emitDIE(Children[j]); 2333 2334 if (Asm->isVerbose()) 2335 Asm->OutStreamer.AddComment("End Of Children Mark"); 2336 Asm->EmitInt8(0); 2337 } 2338} 2339 2340/// emitDebugInfo - Emit the debug info section. 2341/// 2342void DwarfDebug::emitDebugInfo() { 2343 // Start debug info section. 2344 Asm->OutStreamer.SwitchSection( 2345 Asm->getObjFileLowering().getDwarfInfoSection()); 2346 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2347 E = CUMap.end(); I != E; ++I) { 2348 CompileUnit *TheCU = I->second; 2349 DIE *Die = TheCU->getCUDie(); 2350 2351 // Emit the compile units header. 2352 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin", 2353 TheCU->getID())); 2354 2355 // Emit size of content not including length itself 2356 unsigned ContentSize = Die->getSize() + 2357 sizeof(int16_t) + // DWARF version number 2358 sizeof(int32_t) + // Offset Into Abbrev. Section 2359 sizeof(int8_t); // Pointer Size (in bytes) 2360 2361 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 2362 Asm->EmitInt32(ContentSize); 2363 Asm->OutStreamer.AddComment("DWARF version number"); 2364 Asm->EmitInt16(dwarf::DWARF_VERSION); 2365 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 2366 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"), 2367 DwarfAbbrevSectionSym); 2368 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 2369 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 2370 2371 emitDIE(Die); 2372 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID())); 2373 } 2374} 2375 2376/// emitAbbreviations - Emit the abbreviation section. 2377/// 2378void DwarfDebug::emitAbbreviations() const { 2379 // Check to see if it is worth the effort. 2380 if (!Abbreviations.empty()) { 2381 // Start the debug abbrev section. 2382 Asm->OutStreamer.SwitchSection( 2383 Asm->getObjFileLowering().getDwarfAbbrevSection()); 2384 2385 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin")); 2386 2387 // For each abbrevation. 2388 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { 2389 // Get abbreviation data 2390 const DIEAbbrev *Abbrev = Abbreviations[i]; 2391 2392 // Emit the abbrevations code (base 1 index.) 2393 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 2394 2395 // Emit the abbreviations data. 2396 Abbrev->Emit(Asm); 2397 } 2398 2399 // Mark end of abbreviations. 2400 Asm->EmitULEB128(0, "EOM(3)"); 2401 2402 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end")); 2403 } 2404} 2405 2406/// emitEndOfLineMatrix - Emit the last address of the section and the end of 2407/// the line matrix. 2408/// 2409void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 2410 // Define last address of section. 2411 Asm->OutStreamer.AddComment("Extended Op"); 2412 Asm->EmitInt8(0); 2413 2414 Asm->OutStreamer.AddComment("Op size"); 2415 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1); 2416 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 2417 Asm->EmitInt8(dwarf::DW_LNE_set_address); 2418 2419 Asm->OutStreamer.AddComment("Section end label"); 2420 2421 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd), 2422 Asm->getTargetData().getPointerSize(), 2423 0/*AddrSpace*/); 2424 2425 // Mark end of matrix. 2426 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 2427 Asm->EmitInt8(0); 2428 Asm->EmitInt8(1); 2429 Asm->EmitInt8(1); 2430} 2431 2432/// emitDebugPubNames - Emit visible names into a debug pubnames section. 2433/// 2434void DwarfDebug::emitDebugPubNames() { 2435 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2436 E = CUMap.end(); I != E; ++I) { 2437 CompileUnit *TheCU = I->second; 2438 // Start the dwarf pubnames section. 2439 Asm->OutStreamer.SwitchSection( 2440 Asm->getObjFileLowering().getDwarfPubNamesSection()); 2441 2442 Asm->OutStreamer.AddComment("Length of Public Names Info"); 2443 Asm->EmitLabelDifference( 2444 Asm->GetTempSymbol("pubnames_end", TheCU->getID()), 2445 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4); 2446 2447 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", 2448 TheCU->getID())); 2449 2450 Asm->OutStreamer.AddComment("DWARF Version"); 2451 Asm->EmitInt16(dwarf::DWARF_VERSION); 2452 2453 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2454 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 2455 DwarfInfoSectionSym); 2456 2457 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2458 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 2459 Asm->GetTempSymbol("info_begin", TheCU->getID()), 2460 4); 2461 2462 const StringMap<DIE*> &Globals = TheCU->getGlobals(); 2463 for (StringMap<DIE*>::const_iterator 2464 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2465 const char *Name = GI->getKeyData(); 2466 DIE *Entity = GI->second; 2467 2468 Asm->OutStreamer.AddComment("DIE offset"); 2469 Asm->EmitInt32(Entity->getOffset()); 2470 2471 if (Asm->isVerbose()) 2472 Asm->OutStreamer.AddComment("External Name"); 2473 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0); 2474 } 2475 2476 Asm->OutStreamer.AddComment("End Mark"); 2477 Asm->EmitInt32(0); 2478 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", 2479 TheCU->getID())); 2480 } 2481} 2482 2483void DwarfDebug::emitDebugPubTypes() { 2484 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2485 E = CUMap.end(); I != E; ++I) { 2486 CompileUnit *TheCU = I->second; 2487 // Start the dwarf pubnames section. 2488 Asm->OutStreamer.SwitchSection( 2489 Asm->getObjFileLowering().getDwarfPubTypesSection()); 2490 Asm->OutStreamer.AddComment("Length of Public Types Info"); 2491 Asm->EmitLabelDifference( 2492 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()), 2493 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4); 2494 2495 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin", 2496 TheCU->getID())); 2497 2498 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version"); 2499 Asm->EmitInt16(dwarf::DWARF_VERSION); 2500 2501 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2502 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 2503 DwarfInfoSectionSym); 2504 2505 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2506 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 2507 Asm->GetTempSymbol("info_begin", TheCU->getID()), 2508 4); 2509 2510 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes(); 2511 for (StringMap<DIE*>::const_iterator 2512 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2513 const char *Name = GI->getKeyData(); 2514 DIE * Entity = GI->second; 2515 2516 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 2517 Asm->EmitInt32(Entity->getOffset()); 2518 2519 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name"); 2520 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0); 2521 } 2522 2523 Asm->OutStreamer.AddComment("End Mark"); 2524 Asm->EmitInt32(0); 2525 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end", 2526 TheCU->getID())); 2527 } 2528} 2529 2530/// emitDebugStr - Emit visible names into a debug str section. 2531/// 2532void DwarfDebug::emitDebugStr() { 2533 // Check to see if it is worth the effort. 2534 if (StringPool.empty()) return; 2535 2536 // Start the dwarf str section. 2537 Asm->OutStreamer.SwitchSection( 2538 Asm->getObjFileLowering().getDwarfStrSection()); 2539 2540 // Get all of the string pool entries and put them in an array by their ID so 2541 // we can sort them. 2542 SmallVector<std::pair<unsigned, 2543 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 2544 2545 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 2546 I = StringPool.begin(), E = StringPool.end(); I != E; ++I) 2547 Entries.push_back(std::make_pair(I->second.second, &*I)); 2548 2549 array_pod_sort(Entries.begin(), Entries.end()); 2550 2551 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2552 // Emit a label for reference from debug information entries. 2553 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 2554 2555 // Emit the string itself. 2556 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/); 2557 } 2558} 2559 2560/// emitDebugLoc - Emit visible names into a debug loc section. 2561/// 2562void DwarfDebug::emitDebugLoc() { 2563 if (DotDebugLocEntries.empty()) 2564 return; 2565 2566 for (SmallVector<DotDebugLocEntry, 4>::iterator 2567 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 2568 I != E; ++I) { 2569 DotDebugLocEntry &Entry = *I; 2570 if (I + 1 != DotDebugLocEntries.end()) 2571 Entry.Merge(I+1); 2572 } 2573 2574 // Start the dwarf loc section. 2575 Asm->OutStreamer.SwitchSection( 2576 Asm->getObjFileLowering().getDwarfLocSection()); 2577 unsigned char Size = Asm->getTargetData().getPointerSize(); 2578 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0)); 2579 unsigned index = 1; 2580 for (SmallVector<DotDebugLocEntry, 4>::iterator 2581 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 2582 I != E; ++I, ++index) { 2583 DotDebugLocEntry &Entry = *I; 2584 if (Entry.isMerged()) continue; 2585 if (Entry.isEmpty()) { 2586 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 2587 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 2588 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index)); 2589 } else { 2590 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0); 2591 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0); 2592 DIVariable DV(Entry.Variable); 2593 Asm->OutStreamer.AddComment("Loc expr size"); 2594 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol(); 2595 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol(); 2596 Asm->EmitLabelDifference(end, begin, 2); 2597 Asm->OutStreamer.EmitLabel(begin); 2598 if (Entry.isInt()) { 2599 DIBasicType BTy(DV.getType()); 2600 if (BTy.Verify() && 2601 (BTy.getEncoding() == dwarf::DW_ATE_signed 2602 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) { 2603 Asm->OutStreamer.AddComment("DW_OP_consts"); 2604 Asm->EmitInt8(dwarf::DW_OP_consts); 2605 Asm->EmitSLEB128(Entry.getInt()); 2606 } else { 2607 Asm->OutStreamer.AddComment("DW_OP_constu"); 2608 Asm->EmitInt8(dwarf::DW_OP_constu); 2609 Asm->EmitULEB128(Entry.getInt()); 2610 } 2611 } else if (Entry.isLocation()) { 2612 if (!DV.hasComplexAddress()) 2613 // Regular entry. 2614 Asm->EmitDwarfRegOp(Entry.Loc); 2615 else { 2616 // Complex address entry. 2617 unsigned N = DV.getNumAddrElements(); 2618 unsigned i = 0; 2619 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) { 2620 if (Entry.Loc.getOffset()) { 2621 i = 2; 2622 Asm->EmitDwarfRegOp(Entry.Loc); 2623 Asm->OutStreamer.AddComment("DW_OP_deref"); 2624 Asm->EmitInt8(dwarf::DW_OP_deref); 2625 Asm->OutStreamer.AddComment("DW_OP_plus_uconst"); 2626 Asm->EmitInt8(dwarf::DW_OP_plus_uconst); 2627 Asm->EmitSLEB128(DV.getAddrElement(1)); 2628 } else { 2629 // If first address element is OpPlus then emit 2630 // DW_OP_breg + Offset instead of DW_OP_reg + Offset. 2631 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1)); 2632 Asm->EmitDwarfRegOp(Loc); 2633 i = 2; 2634 } 2635 } else { 2636 Asm->EmitDwarfRegOp(Entry.Loc); 2637 } 2638 2639 // Emit remaining complex address elements. 2640 for (; i < N; ++i) { 2641 uint64_t Element = DV.getAddrElement(i); 2642 if (Element == DIBuilder::OpPlus) { 2643 Asm->EmitInt8(dwarf::DW_OP_plus_uconst); 2644 Asm->EmitULEB128(DV.getAddrElement(++i)); 2645 } else if (Element == DIBuilder::OpDeref) 2646 Asm->EmitInt8(dwarf::DW_OP_deref); 2647 else llvm_unreachable("unknown Opcode found in complex address"); 2648 } 2649 } 2650 } 2651 // else ... ignore constant fp. There is not any good way to 2652 // to represent them here in dwarf. 2653 Asm->OutStreamer.EmitLabel(end); 2654 } 2655 } 2656} 2657 2658/// EmitDebugARanges - Emit visible names into a debug aranges section. 2659/// 2660void DwarfDebug::EmitDebugARanges() { 2661 // Start the dwarf aranges section. 2662 Asm->OutStreamer.SwitchSection( 2663 Asm->getObjFileLowering().getDwarfARangesSection()); 2664} 2665 2666/// emitDebugRanges - Emit visible names into a debug ranges section. 2667/// 2668void DwarfDebug::emitDebugRanges() { 2669 // Start the dwarf ranges section. 2670 Asm->OutStreamer.SwitchSection( 2671 Asm->getObjFileLowering().getDwarfRangesSection()); 2672 unsigned char Size = Asm->getTargetData().getPointerSize(); 2673 for (SmallVector<const MCSymbol *, 8>::iterator 2674 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end(); 2675 I != E; ++I) { 2676 if (*I) 2677 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0); 2678 else 2679 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 2680 } 2681} 2682 2683/// emitDebugMacInfo - Emit visible names into a debug macinfo section. 2684/// 2685void DwarfDebug::emitDebugMacInfo() { 2686 if (const MCSection *LineInfo = 2687 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 2688 // Start the dwarf macinfo section. 2689 Asm->OutStreamer.SwitchSection(LineInfo); 2690 } 2691} 2692 2693/// emitDebugInlineInfo - Emit inline info using following format. 2694/// Section Header: 2695/// 1. length of section 2696/// 2. Dwarf version number 2697/// 3. address size. 2698/// 2699/// Entries (one "entry" for each function that was inlined): 2700/// 2701/// 1. offset into __debug_str section for MIPS linkage name, if exists; 2702/// otherwise offset into __debug_str for regular function name. 2703/// 2. offset into __debug_str section for regular function name. 2704/// 3. an unsigned LEB128 number indicating the number of distinct inlining 2705/// instances for the function. 2706/// 2707/// The rest of the entry consists of a {die_offset, low_pc} pair for each 2708/// inlined instance; the die_offset points to the inlined_subroutine die in the 2709/// __debug_info section, and the low_pc is the starting address for the 2710/// inlining instance. 2711void DwarfDebug::emitDebugInlineInfo() { 2712 if (!Asm->MAI->doesDwarfUsesInlineInfoSection()) 2713 return; 2714 2715 if (!FirstCU) 2716 return; 2717 2718 Asm->OutStreamer.SwitchSection( 2719 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 2720 2721 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry"); 2722 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1), 2723 Asm->GetTempSymbol("debug_inlined_begin", 1), 4); 2724 2725 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1)); 2726 2727 Asm->OutStreamer.AddComment("Dwarf Version"); 2728 Asm->EmitInt16(dwarf::DWARF_VERSION); 2729 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 2730 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 2731 2732 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(), 2733 E = InlinedSPNodes.end(); I != E; ++I) { 2734 2735 const MDNode *Node = *I; 2736 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II 2737 = InlineInfo.find(Node); 2738 SmallVector<InlineInfoLabels, 4> &Labels = II->second; 2739 DISubprogram SP(Node); 2740 StringRef LName = SP.getLinkageName(); 2741 StringRef Name = SP.getName(); 2742 2743 Asm->OutStreamer.AddComment("MIPS linkage name"); 2744 if (LName.empty()) { 2745 Asm->OutStreamer.EmitBytes(Name, 0); 2746 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator. 2747 } else 2748 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)), 2749 DwarfStrSectionSym); 2750 2751 Asm->OutStreamer.AddComment("Function name"); 2752 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym); 2753 Asm->EmitULEB128(Labels.size(), "Inline count"); 2754 2755 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(), 2756 LE = Labels.end(); LI != LE; ++LI) { 2757 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 2758 Asm->EmitInt32(LI->second->getOffset()); 2759 2760 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc"); 2761 Asm->OutStreamer.EmitSymbolValue(LI->first, 2762 Asm->getTargetData().getPointerSize(),0); 2763 } 2764 } 2765 2766 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1)); 2767} 2768