DwarfDebug.cpp revision 3737b89098a6aa954d7742277d218f293d38956a
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 &DV, 1272 DebugLoc ScopeLoc) { 1273 LLVMContext &Ctx = DV->getContext(); 1274 1275 // More then one inlined variable corresponds to one abstract variable. 1276 DIVariable Var = cleanseInlinedVariable(DV, Ctx); 1277 1278 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var); 1279 if (AbsDbgVariable) 1280 return AbsDbgVariable; 1281 1282 1283 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx)); 1284 if (!Scope) 1285 return NULL; 1286 1287 AbsDbgVariable = new DbgVariable(Var); 1288 Scope->addVariable(AbsDbgVariable); 1289 AbstractVariables[Var] = AbsDbgVariable; 1290 return AbsDbgVariable; 1291} 1292 1293/// addCurrentFnArgument - If Var is an current function argument that add 1294/// it in CurrentFnArguments list. 1295bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF, 1296 DbgVariable *Var, DbgScope *Scope) { 1297 if (Scope != CurrentFnDbgScope) 1298 return false; 1299 DIVariable DV = Var->getVariable(); 1300 if (DV.getTag() != dwarf::DW_TAG_arg_variable) 1301 return false; 1302 unsigned ArgNo = DV.getArgNumber(); 1303 if (ArgNo == 0) 1304 return false; 1305 1306 size_t Size = CurrentFnArguments.size(); 1307 if (Size == 0) 1308 CurrentFnArguments.resize(MF->getFunction()->arg_size()); 1309 // llvm::Function argument size is not good indicator of how many 1310 // arguments does the function have at source level. 1311 if (ArgNo > Size) 1312 CurrentFnArguments.resize(ArgNo * 2); 1313 CurrentFnArguments[ArgNo - 1] = Var; 1314 return true; 1315} 1316 1317/// collectVariableInfoFromMMITable - Collect variable information from 1318/// side table maintained by MMI. 1319void 1320DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF, 1321 SmallPtrSet<const MDNode *, 16> &Processed) { 1322 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 1323 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 1324 VE = VMap.end(); VI != VE; ++VI) { 1325 const MDNode *Var = VI->first; 1326 if (!Var) continue; 1327 Processed.insert(Var); 1328 DIVariable DV(Var); 1329 const std::pair<unsigned, DebugLoc> &VP = VI->second; 1330 1331 DbgScope *Scope = findDbgScope(VP.second); 1332 1333 // If variable scope is not found then skip this variable. 1334 if (Scope == 0) 1335 continue; 1336 1337 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second); 1338 DbgVariable *RegVar = new DbgVariable(DV); 1339 recordVariableFrameIndex(RegVar, VP.first); 1340 if (!addCurrentFnArgument(MF, RegVar, Scope)) 1341 Scope->addVariable(RegVar); 1342 if (AbsDbgVariable) { 1343 recordVariableFrameIndex(AbsDbgVariable, VP.first); 1344 VarToAbstractVarMap[RegVar] = AbsDbgVariable; 1345 } 1346 } 1347} 1348 1349/// isDbgValueInDefinedReg - Return true if debug value, encoded by 1350/// DBG_VALUE instruction, is in a defined reg. 1351static bool isDbgValueInDefinedReg(const MachineInstr *MI) { 1352 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 1353 return MI->getNumOperands() == 3 && 1354 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() && 1355 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0; 1356} 1357 1358/// getDebugLocEntry - Get .debug_loc entry for the instraction range starting 1359/// at MI. 1360static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm, 1361 const MCSymbol *FLabel, 1362 const MCSymbol *SLabel, 1363 const MachineInstr *MI) { 1364 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata(); 1365 1366 if (MI->getNumOperands() != 3) { 1367 MachineLocation MLoc = Asm->getDebugValueLocation(MI); 1368 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var); 1369 } 1370 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) { 1371 MachineLocation MLoc; 1372 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm()); 1373 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var); 1374 } 1375 if (MI->getOperand(0).isImm()) 1376 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm()); 1377 if (MI->getOperand(0).isFPImm()) 1378 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm()); 1379 if (MI->getOperand(0).isCImm()) 1380 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm()); 1381 1382 assert (0 && "Unexpected 3 operand DBG_VALUE instruction!"); 1383 return DotDebugLocEntry(); 1384} 1385 1386/// collectVariableInfo - Populate DbgScope entries with variables' info. 1387void 1388DwarfDebug::collectVariableInfo(const MachineFunction *MF, 1389 SmallPtrSet<const MDNode *, 16> &Processed) { 1390 1391 /// collection info from MMI table. 1392 collectVariableInfoFromMMITable(MF, Processed); 1393 1394 for (SmallVectorImpl<const MDNode*>::const_iterator 1395 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE; 1396 ++UVI) { 1397 const MDNode *Var = *UVI; 1398 if (Processed.count(Var)) 1399 continue; 1400 1401 // History contains relevant DBG_VALUE instructions for Var and instructions 1402 // clobbering it. 1403 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var]; 1404 if (History.empty()) 1405 continue; 1406 const MachineInstr *MInsn = History.front(); 1407 1408 DIVariable DV(Var); 1409 DbgScope *Scope = NULL; 1410 if (DV.getTag() == dwarf::DW_TAG_arg_variable && 1411 DISubprogram(DV.getContext()).describes(MF->getFunction())) 1412 Scope = CurrentFnDbgScope; 1413 else { 1414 if (DV.getVersion() <= LLVMDebugVersion9) 1415 Scope = findDbgScope(MInsn->getDebugLoc()); 1416 else { 1417 if (MDNode *IA = DV.getInlinedAt()) 1418 Scope = InlinedDbgScopeMap.lookup(DebugLoc::getFromDILocation(IA)); 1419 else 1420 Scope = DbgScopeMap.lookup(cast<MDNode>(DV->getOperand(1))); 1421 } 1422 } 1423 // If variable scope is not found then skip this variable. 1424 if (!Scope) 1425 continue; 1426 1427 Processed.insert(DV); 1428 assert(MInsn->isDebugValue() && "History must begin with debug value"); 1429 DbgVariable *RegVar = new DbgVariable(DV); 1430 if (!addCurrentFnArgument(MF, RegVar, Scope)) 1431 Scope->addVariable(RegVar); 1432 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) { 1433 DbgVariableToDbgInstMap[AbsVar] = MInsn; 1434 VarToAbstractVarMap[RegVar] = AbsVar; 1435 } 1436 1437 // Simple ranges that are fully coalesced. 1438 if (History.size() <= 1 || (History.size() == 2 && 1439 MInsn->isIdenticalTo(History.back()))) { 1440 DbgVariableToDbgInstMap[RegVar] = MInsn; 1441 continue; 1442 } 1443 1444 // handle multiple DBG_VALUE instructions describing one variable. 1445 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size()); 1446 1447 for (SmallVectorImpl<const MachineInstr*>::const_iterator 1448 HI = History.begin(), HE = History.end(); HI != HE; ++HI) { 1449 const MachineInstr *Begin = *HI; 1450 assert(Begin->isDebugValue() && "Invalid History entry"); 1451 1452 // Check if DBG_VALUE is truncating a range. 1453 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() 1454 && !Begin->getOperand(0).getReg()) 1455 continue; 1456 1457 // Compute the range for a register location. 1458 const MCSymbol *FLabel = getLabelBeforeInsn(Begin); 1459 const MCSymbol *SLabel = 0; 1460 1461 if (HI + 1 == HE) 1462 // If Begin is the last instruction in History then its value is valid 1463 // until the end of the function. 1464 SLabel = FunctionEndSym; 1465 else { 1466 const MachineInstr *End = HI[1]; 1467 DEBUG(dbgs() << "DotDebugLoc Pair:\n" 1468 << "\t" << *Begin << "\t" << *End << "\n"); 1469 if (End->isDebugValue()) 1470 SLabel = getLabelBeforeInsn(End); 1471 else { 1472 // End is a normal instruction clobbering the range. 1473 SLabel = getLabelAfterInsn(End); 1474 assert(SLabel && "Forgot label after clobber instruction"); 1475 ++HI; 1476 } 1477 } 1478 1479 // The value is valid until the next DBG_VALUE or clobber. 1480 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin)); 1481 } 1482 DotDebugLocEntries.push_back(DotDebugLocEntry()); 1483 } 1484 1485 // Collect info for variables that were optimized out. 1486 const Function *F = MF->getFunction(); 1487 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) { 1488 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 1489 DIVariable DV(cast<MDNode>(NMD->getOperand(i))); 1490 if (!DV || !Processed.insert(DV)) 1491 continue; 1492 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext()); 1493 if (Scope) 1494 Scope->addVariable(new DbgVariable(DV)); 1495 } 1496 } 1497} 1498 1499/// getLabelBeforeInsn - Return Label preceding the instruction. 1500const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) { 1501 MCSymbol *Label = LabelsBeforeInsn.lookup(MI); 1502 assert(Label && "Didn't insert label before instruction"); 1503 return Label; 1504} 1505 1506/// getLabelAfterInsn - Return Label immediately following the instruction. 1507const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) { 1508 return LabelsAfterInsn.lookup(MI); 1509} 1510 1511/// beginInstruction - Process beginning of an instruction. 1512void DwarfDebug::beginInstruction(const MachineInstr *MI) { 1513 // Check if source location changes, but ignore DBG_VALUE locations. 1514 if (!MI->isDebugValue()) { 1515 DebugLoc DL = MI->getDebugLoc(); 1516 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) { 1517 unsigned Flags = DWARF2_FLAG_IS_STMT; 1518 PrevInstLoc = DL; 1519 if (DL == PrologEndLoc) { 1520 Flags |= DWARF2_FLAG_PROLOGUE_END; 1521 PrologEndLoc = DebugLoc(); 1522 } 1523 if (!DL.isUnknown()) { 1524 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext()); 1525 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags); 1526 } else 1527 recordSourceLine(0, 0, 0, 0); 1528 } 1529 } 1530 1531 // Insert labels where requested. 1532 DenseMap<const MachineInstr*, MCSymbol*>::iterator I = 1533 LabelsBeforeInsn.find(MI); 1534 1535 // No label needed. 1536 if (I == LabelsBeforeInsn.end()) 1537 return; 1538 1539 // Label already assigned. 1540 if (I->second) 1541 return; 1542 1543 if (!PrevLabel) { 1544 PrevLabel = MMI->getContext().CreateTempSymbol(); 1545 Asm->OutStreamer.EmitLabel(PrevLabel); 1546 } 1547 I->second = PrevLabel; 1548} 1549 1550/// endInstruction - Process end of an instruction. 1551void DwarfDebug::endInstruction(const MachineInstr *MI) { 1552 // Don't create a new label after DBG_VALUE instructions. 1553 // They don't generate code. 1554 if (!MI->isDebugValue()) 1555 PrevLabel = 0; 1556 1557 DenseMap<const MachineInstr*, MCSymbol*>::iterator I = 1558 LabelsAfterInsn.find(MI); 1559 1560 // No label needed. 1561 if (I == LabelsAfterInsn.end()) 1562 return; 1563 1564 // Label already assigned. 1565 if (I->second) 1566 return; 1567 1568 // We need a label after this instruction. 1569 if (!PrevLabel) { 1570 PrevLabel = MMI->getContext().CreateTempSymbol(); 1571 Asm->OutStreamer.EmitLabel(PrevLabel); 1572 } 1573 I->second = PrevLabel; 1574} 1575 1576/// getOrCreateRegularScope - Create regular DbgScope. 1577DbgScope *DwarfDebug::getOrCreateRegularScope(MDNode *Scope) { 1578 DbgScope *WScope = DbgScopeMap.lookup(Scope); 1579 if (WScope) 1580 return WScope; 1581 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL); 1582 DbgScopeMap.insert(std::make_pair(Scope, WScope)); 1583 if (DIDescriptor(Scope).isLexicalBlock()) { 1584 DbgScope *Parent = 1585 getOrCreateDbgScope(DebugLoc::getFromDILexicalBlock(Scope)); 1586 WScope->setParent(Parent); 1587 Parent->addScope(WScope); 1588 } else if (DIDescriptor(Scope).isSubprogram() 1589 && DISubprogram(Scope).describes(Asm->MF->getFunction())) 1590 CurrentFnDbgScope = WScope; 1591 1592 return WScope; 1593} 1594 1595/// getOrCreateInlinedScope - Create inlined scope. 1596DbgScope *DwarfDebug::getOrCreateInlinedScope(MDNode *Scope, MDNode *InlinedAt){ 1597 DbgScope *InlinedScope = DbgScopeMap.lookup(InlinedAt); 1598 if (InlinedScope) 1599 return InlinedScope; 1600 1601 InlinedScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt); 1602 DebugLoc InlinedLoc = DebugLoc::getFromDILocation(InlinedAt); 1603 InlinedDbgScopeMap[InlinedLoc] = InlinedScope; 1604 DbgScopeMap[InlinedAt] = InlinedScope; 1605 DbgScope *Parent = getOrCreateDbgScope(InlinedLoc); 1606 InlinedScope->setParent(Parent); 1607 Parent->addScope(InlinedScope); 1608 return InlinedScope; 1609} 1610 1611/// getOrCreateDbgScope - Create DbgScope for the scope. 1612DbgScope *DwarfDebug::getOrCreateDbgScope(DebugLoc DL) { 1613 LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 1614 MDNode *Scope = NULL; 1615 MDNode *InlinedAt = NULL; 1616 DL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx); 1617 if (!InlinedAt) 1618 return getOrCreateRegularScope(Scope); 1619 1620 // Create an abstract scope for inlined function. 1621 getOrCreateAbstractScope(Scope); 1622 // Create an inlined scope for inlined function. 1623 return getOrCreateInlinedScope(Scope, InlinedAt); 1624} 1625 1626/// calculateDominanceGraph - Calculate dominance graph for DbgScope 1627/// hierarchy. 1628static void calculateDominanceGraph(DbgScope *Scope) { 1629 assert (Scope && "Unable to calculate scop edominance graph!"); 1630 SmallVector<DbgScope *, 4> WorkStack; 1631 WorkStack.push_back(Scope); 1632 unsigned Counter = 0; 1633 while (!WorkStack.empty()) { 1634 DbgScope *WS = WorkStack.back(); 1635 const SmallVector<DbgScope *, 4> &Children = WS->getScopes(); 1636 bool visitedChildren = false; 1637 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 1638 SE = Children.end(); SI != SE; ++SI) { 1639 DbgScope *ChildScope = *SI; 1640 if (!ChildScope->getDFSOut()) { 1641 WorkStack.push_back(ChildScope); 1642 visitedChildren = true; 1643 ChildScope->setDFSIn(++Counter); 1644 break; 1645 } 1646 } 1647 if (!visitedChildren) { 1648 WorkStack.pop_back(); 1649 WS->setDFSOut(++Counter); 1650 } 1651 } 1652} 1653 1654/// printDbgScopeInfo - Print DbgScope info for each machine instruction. 1655static 1656void printDbgScopeInfo(const MachineFunction *MF, 1657 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap) 1658{ 1659#ifndef NDEBUG 1660 LLVMContext &Ctx = MF->getFunction()->getContext(); 1661 unsigned PrevDFSIn = 0; 1662 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 1663 I != E; ++I) { 1664 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 1665 II != IE; ++II) { 1666 const MachineInstr *MInsn = II; 1667 MDNode *Scope = NULL; 1668 MDNode *InlinedAt = NULL; 1669 1670 // Check if instruction has valid location information. 1671 DebugLoc MIDL = MInsn->getDebugLoc(); 1672 if (!MIDL.isUnknown()) { 1673 MIDL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx); 1674 dbgs() << " [ "; 1675 if (InlinedAt) 1676 dbgs() << "*"; 1677 DenseMap<const MachineInstr *, DbgScope *>::iterator DI = 1678 MI2ScopeMap.find(MInsn); 1679 if (DI != MI2ScopeMap.end()) { 1680 DbgScope *S = DI->second; 1681 dbgs() << S->getDFSIn(); 1682 PrevDFSIn = S->getDFSIn(); 1683 } else 1684 dbgs() << PrevDFSIn; 1685 } else 1686 dbgs() << " [ x" << PrevDFSIn; 1687 dbgs() << " ]"; 1688 MInsn->dump(); 1689 } 1690 dbgs() << "\n"; 1691 } 1692#endif 1693} 1694/// extractScopeInformation - Scan machine instructions in this function 1695/// and collect DbgScopes. Return true, if at least one scope was found. 1696bool DwarfDebug::extractScopeInformation() { 1697 // If scope information was extracted using .dbg intrinsics then there is not 1698 // any need to extract these information by scanning each instruction. 1699 if (!DbgScopeMap.empty()) 1700 return false; 1701 1702 // Scan each instruction and create scopes. First build working set of scopes. 1703 SmallVector<DbgRange, 4> MIRanges; 1704 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap; 1705 DebugLoc PrevDL; 1706 const MachineInstr *RangeBeginMI = NULL; 1707 const MachineInstr *PrevMI = NULL; 1708 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end(); 1709 I != E; ++I) { 1710 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 1711 II != IE; ++II) { 1712 const MachineInstr *MInsn = II; 1713 1714 // Check if instruction has valid location information. 1715 const DebugLoc MIDL = MInsn->getDebugLoc(); 1716 if (MIDL.isUnknown()) { 1717 PrevMI = MInsn; 1718 continue; 1719 } 1720 1721 // If scope has not changed then skip this instruction. 1722 if (MIDL == PrevDL) { 1723 PrevMI = MInsn; 1724 continue; 1725 } 1726 1727 // Ignore DBG_VALUE. It does not contribute any instruction in output. 1728 if (MInsn->isDebugValue()) 1729 continue; 1730 1731 if (RangeBeginMI) { 1732 // If we have alread seen a beginning of a instruction range and 1733 // current instruction scope does not match scope of first instruction 1734 // in this range then create a new instruction range. 1735 DEBUG(dbgs() << "Creating new instruction range :\n"); 1736 DEBUG(dbgs() << "Begin Range at " << *RangeBeginMI); 1737 DEBUG(dbgs() << "End Range at " << *PrevMI); 1738 DEBUG(dbgs() << "Next Range starting at " << *MInsn); 1739 DEBUG(dbgs() << "------------------------\n"); 1740 DbgRange R(RangeBeginMI, PrevMI); 1741 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL); 1742 MIRanges.push_back(R); 1743 } 1744 1745 // This is a beginning of a new instruction range. 1746 RangeBeginMI = MInsn; 1747 1748 // Reset previous markers. 1749 PrevMI = MInsn; 1750 PrevDL = MIDL; 1751 } 1752 } 1753 1754 // Create last instruction range. 1755 if (RangeBeginMI && PrevMI && !PrevDL.isUnknown()) { 1756 DbgRange R(RangeBeginMI, PrevMI); 1757 MIRanges.push_back(R); 1758 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL); 1759 } 1760 1761 if (!CurrentFnDbgScope) 1762 return false; 1763 1764 calculateDominanceGraph(CurrentFnDbgScope); 1765 if (PrintDbgScope) 1766 printDbgScopeInfo(Asm->MF, MI2ScopeMap); 1767 1768 // Find ranges of instructions covered by each DbgScope; 1769 DbgScope *PrevDbgScope = NULL; 1770 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(), 1771 RE = MIRanges.end(); RI != RE; ++RI) { 1772 const DbgRange &R = *RI; 1773 DbgScope *S = MI2ScopeMap.lookup(R.first); 1774 assert (S && "Lost DbgScope for a machine instruction!"); 1775 if (PrevDbgScope && !PrevDbgScope->dominates(S)) 1776 PrevDbgScope->closeInsnRange(S); 1777 S->openInsnRange(R.first); 1778 S->extendInsnRange(R.second); 1779 PrevDbgScope = S; 1780 } 1781 1782 if (PrevDbgScope) 1783 PrevDbgScope->closeInsnRange(); 1784 1785 identifyScopeMarkers(); 1786 1787 return !DbgScopeMap.empty(); 1788} 1789 1790/// identifyScopeMarkers() - 1791/// Each DbgScope has first instruction and last instruction to mark beginning 1792/// and end of a scope respectively. Create an inverse map that list scopes 1793/// starts (and ends) with an instruction. One instruction may start (or end) 1794/// multiple scopes. Ignore scopes that are not reachable. 1795void DwarfDebug::identifyScopeMarkers() { 1796 SmallVector<DbgScope *, 4> WorkList; 1797 WorkList.push_back(CurrentFnDbgScope); 1798 while (!WorkList.empty()) { 1799 DbgScope *S = WorkList.pop_back_val(); 1800 1801 const SmallVector<DbgScope *, 4> &Children = S->getScopes(); 1802 if (!Children.empty()) 1803 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(), 1804 SE = Children.end(); SI != SE; ++SI) 1805 WorkList.push_back(*SI); 1806 1807 if (S->isAbstractScope()) 1808 continue; 1809 1810 const SmallVector<DbgRange, 4> &Ranges = S->getRanges(); 1811 if (Ranges.empty()) 1812 continue; 1813 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(), 1814 RE = Ranges.end(); RI != RE; ++RI) { 1815 assert(RI->first && "DbgRange does not have first instruction!"); 1816 assert(RI->second && "DbgRange does not have second instruction!"); 1817 requestLabelBeforeInsn(RI->first); 1818 requestLabelAfterInsn(RI->second); 1819 } 1820 } 1821} 1822 1823/// getScopeNode - Get MDNode for DebugLoc's scope. 1824static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) { 1825 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx)) 1826 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx); 1827 return DL.getScope(Ctx); 1828} 1829 1830/// getFnDebugLoc - Walk up the scope chain of given debug loc and find 1831/// line number info for the function. 1832static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) { 1833 const MDNode *Scope = getScopeNode(DL, Ctx); 1834 DISubprogram SP = getDISubprogram(Scope); 1835 if (SP.Verify()) 1836 return DebugLoc::get(SP.getLineNumber(), 0, SP); 1837 return DebugLoc(); 1838} 1839 1840/// beginFunction - Gather pre-function debug information. Assumes being 1841/// emitted immediately after the function entry point. 1842void DwarfDebug::beginFunction(const MachineFunction *MF) { 1843 if (!MMI->hasDebugInfo()) return; 1844 if (!extractScopeInformation()) return; 1845 1846 FunctionBeginSym = Asm->GetTempSymbol("func_begin", 1847 Asm->getFunctionNumber()); 1848 // Assumes in correct section after the entry point. 1849 Asm->OutStreamer.EmitLabel(FunctionBeginSym); 1850 1851 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned"); 1852 1853 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 1854 /// LiveUserVar - Map physreg numbers to the MDNode they contain. 1855 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs()); 1856 1857 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 1858 I != E; ++I) { 1859 bool AtBlockEntry = true; 1860 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 1861 II != IE; ++II) { 1862 const MachineInstr *MI = II; 1863 1864 if (MI->isDebugValue()) { 1865 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!"); 1866 1867 // Keep track of user variables. 1868 const MDNode *Var = 1869 MI->getOperand(MI->getNumOperands() - 1).getMetadata(); 1870 1871 // Variable is in a register, we need to check for clobbers. 1872 if (isDbgValueInDefinedReg(MI)) 1873 LiveUserVar[MI->getOperand(0).getReg()] = Var; 1874 1875 // Check the history of this variable. 1876 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var]; 1877 if (History.empty()) { 1878 UserVariables.push_back(Var); 1879 // The first mention of a function argument gets the FunctionBeginSym 1880 // label, so arguments are visible when breaking at function entry. 1881 DIVariable DV(Var); 1882 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable && 1883 DISubprogram(getDISubprogram(DV.getContext())) 1884 .describes(MF->getFunction())) 1885 LabelsBeforeInsn[MI] = FunctionBeginSym; 1886 } else { 1887 // We have seen this variable before. Try to coalesce DBG_VALUEs. 1888 const MachineInstr *Prev = History.back(); 1889 if (Prev->isDebugValue()) { 1890 // Coalesce identical entries at the end of History. 1891 if (History.size() >= 2 && 1892 Prev->isIdenticalTo(History[History.size() - 2])) { 1893 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n" 1894 << "\t" << *Prev 1895 << "\t" << *History[History.size() - 2] << "\n"); 1896 History.pop_back(); 1897 } 1898 1899 // Terminate old register assignments that don't reach MI; 1900 MachineFunction::const_iterator PrevMBB = Prev->getParent(); 1901 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) && 1902 isDbgValueInDefinedReg(Prev)) { 1903 // Previous register assignment needs to terminate at the end of 1904 // its basic block. 1905 MachineBasicBlock::const_iterator LastMI = 1906 PrevMBB->getLastNonDebugInstr(); 1907 if (LastMI == PrevMBB->end()) { 1908 // Drop DBG_VALUE for empty range. 1909 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n" 1910 << "\t" << *Prev << "\n"); 1911 History.pop_back(); 1912 } 1913 else { 1914 // Terminate after LastMI. 1915 History.push_back(LastMI); 1916 } 1917 } 1918 } 1919 } 1920 History.push_back(MI); 1921 } else { 1922 // Not a DBG_VALUE instruction. 1923 if (!MI->isLabel()) 1924 AtBlockEntry = false; 1925 1926 // First known non DBG_VALUE location marks beginning of function 1927 // body. 1928 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()) 1929 PrologEndLoc = MI->getDebugLoc(); 1930 1931 // Check if the instruction clobbers any registers with debug vars. 1932 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(), 1933 MOE = MI->operands_end(); MOI != MOE; ++MOI) { 1934 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg()) 1935 continue; 1936 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg()); 1937 unsigned Reg = *AI; ++AI) { 1938 const MDNode *Var = LiveUserVar[Reg]; 1939 if (!Var) 1940 continue; 1941 // Reg is now clobbered. 1942 LiveUserVar[Reg] = 0; 1943 1944 // Was MD last defined by a DBG_VALUE referring to Reg? 1945 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var); 1946 if (HistI == DbgValues.end()) 1947 continue; 1948 SmallVectorImpl<const MachineInstr*> &History = HistI->second; 1949 if (History.empty()) 1950 continue; 1951 const MachineInstr *Prev = History.back(); 1952 // Sanity-check: Register assignments are terminated at the end of 1953 // their block. 1954 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent()) 1955 continue; 1956 // Is the variable still in Reg? 1957 if (!isDbgValueInDefinedReg(Prev) || 1958 Prev->getOperand(0).getReg() != Reg) 1959 continue; 1960 // Var is clobbered. Make sure the next instruction gets a label. 1961 History.push_back(MI); 1962 } 1963 } 1964 } 1965 } 1966 } 1967 1968 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end(); 1969 I != E; ++I) { 1970 SmallVectorImpl<const MachineInstr*> &History = I->second; 1971 if (History.empty()) 1972 continue; 1973 1974 // Make sure the final register assignments are terminated. 1975 const MachineInstr *Prev = History.back(); 1976 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) { 1977 const MachineBasicBlock *PrevMBB = Prev->getParent(); 1978 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr(); 1979 if (LastMI == PrevMBB->end()) 1980 // Drop DBG_VALUE for empty range. 1981 History.pop_back(); 1982 else { 1983 // Terminate after LastMI. 1984 History.push_back(LastMI); 1985 } 1986 } 1987 // Request labels for the full history. 1988 for (unsigned i = 0, e = History.size(); i != e; ++i) { 1989 const MachineInstr *MI = History[i]; 1990 if (MI->isDebugValue()) 1991 requestLabelBeforeInsn(MI); 1992 else 1993 requestLabelAfterInsn(MI); 1994 } 1995 } 1996 1997 PrevInstLoc = DebugLoc(); 1998 PrevLabel = FunctionBeginSym; 1999 2000 // Record beginning of function. 2001 if (!PrologEndLoc.isUnknown()) { 2002 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc, 2003 MF->getFunction()->getContext()); 2004 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(), 2005 FnStartDL.getScope(MF->getFunction()->getContext()), 2006 DWARF2_FLAG_IS_STMT); 2007 } 2008} 2009 2010/// endFunction - Gather and emit post-function debug information. 2011/// 2012void DwarfDebug::endFunction(const MachineFunction *MF) { 2013 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return; 2014 2015 if (CurrentFnDbgScope) { 2016 2017 // Define end label for subprogram. 2018 FunctionEndSym = Asm->GetTempSymbol("func_end", 2019 Asm->getFunctionNumber()); 2020 // Assumes in correct section after the entry point. 2021 Asm->OutStreamer.EmitLabel(FunctionEndSym); 2022 2023 SmallPtrSet<const MDNode *, 16> ProcessedVars; 2024 collectVariableInfo(MF, ProcessedVars); 2025 2026 // Construct abstract scopes. 2027 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(), 2028 AE = AbstractScopesList.end(); AI != AE; ++AI) { 2029 DISubprogram SP((*AI)->getScopeNode()); 2030 if (SP.Verify()) { 2031 // Collect info for variables that were optimized out. 2032 StringRef FName = SP.getLinkageName(); 2033 if (FName.empty()) 2034 FName = SP.getName(); 2035 if (NamedMDNode *NMD = 2036 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) { 2037 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2038 DIVariable DV(cast<MDNode>(NMD->getOperand(i))); 2039 if (!DV || !ProcessedVars.insert(DV)) 2040 continue; 2041 DbgScope *Scope = AbstractScopes.lookup(DV.getContext()); 2042 if (Scope) 2043 Scope->addVariable(new DbgVariable(DV)); 2044 } 2045 } 2046 } 2047 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0) 2048 constructScopeDIE(*AI); 2049 } 2050 2051 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope); 2052 2053 if (!DisableFramePointerElim(*MF)) 2054 getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE, 2055 dwarf::DW_AT_APPLE_omit_frame_ptr, 2056 dwarf::DW_FORM_flag, 1); 2057 2058 2059 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(), 2060 MMI->getFrameMoves())); 2061 } 2062 2063 // Clear debug info 2064 CurrentFnDbgScope = NULL; 2065 DeleteContainerPointers(CurrentFnArguments); 2066 DbgVariableToFrameIndexMap.clear(); 2067 VarToAbstractVarMap.clear(); 2068 DbgVariableToDbgInstMap.clear(); 2069 InlinedDbgScopeMap.clear(); 2070 DeleteContainerSeconds(DbgScopeMap); 2071 UserVariables.clear(); 2072 DbgValues.clear(); 2073 DeleteContainerSeconds(AbstractScopes); 2074 AbstractScopesList.clear(); 2075 AbstractVariables.clear(); 2076 LabelsBeforeInsn.clear(); 2077 LabelsAfterInsn.clear(); 2078 PrevLabel = NULL; 2079} 2080 2081/// recordVariableFrameIndex - Record a variable's index. 2082void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) { 2083 assert (V && "Invalid DbgVariable!"); 2084 DbgVariableToFrameIndexMap[V] = Index; 2085} 2086 2087/// findVariableFrameIndex - Return true if frame index for the variable 2088/// is found. Update FI to hold value of the index. 2089bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) { 2090 assert (V && "Invalid DbgVariable!"); 2091 DenseMap<const DbgVariable *, int>::iterator I = 2092 DbgVariableToFrameIndexMap.find(V); 2093 if (I == DbgVariableToFrameIndexMap.end()) 2094 return false; 2095 *FI = I->second; 2096 return true; 2097} 2098 2099/// findDbgScope - Find DbgScope for the debug loc. 2100DbgScope *DwarfDebug::findDbgScope(DebugLoc DL) { 2101 if (DL.isUnknown()) 2102 return NULL; 2103 2104 DbgScope *Scope = NULL; 2105 LLVMContext &Ctx = Asm->MF->getFunction()->getContext(); 2106 if (MDNode *IA = DL.getInlinedAt(Ctx)) 2107 Scope = InlinedDbgScopeMap.lookup(DebugLoc::getFromDILocation(IA)); 2108 else 2109 Scope = DbgScopeMap.lookup(DL.getScope(Ctx)); 2110 return Scope; 2111} 2112 2113 2114/// recordSourceLine - Register a source line with debug info. Returns the 2115/// unique label that was emitted and which provides correspondence to 2116/// the source line list. 2117void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S, 2118 unsigned Flags) { 2119 StringRef Fn; 2120 StringRef Dir; 2121 unsigned Src = 1; 2122 if (S) { 2123 DIDescriptor Scope(S); 2124 2125 if (Scope.isCompileUnit()) { 2126 DICompileUnit CU(S); 2127 Fn = CU.getFilename(); 2128 Dir = CU.getDirectory(); 2129 } else if (Scope.isFile()) { 2130 DIFile F(S); 2131 Fn = F.getFilename(); 2132 Dir = F.getDirectory(); 2133 } else if (Scope.isSubprogram()) { 2134 DISubprogram SP(S); 2135 Fn = SP.getFilename(); 2136 Dir = SP.getDirectory(); 2137 } else if (Scope.isLexicalBlock()) { 2138 DILexicalBlock DB(S); 2139 Fn = DB.getFilename(); 2140 Dir = DB.getDirectory(); 2141 } else 2142 assert(0 && "Unexpected scope info"); 2143 2144 Src = GetOrCreateSourceID(Fn, Dir); 2145 } 2146 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 2147 0, 0, Fn); 2148} 2149 2150//===----------------------------------------------------------------------===// 2151// Emit Methods 2152//===----------------------------------------------------------------------===// 2153 2154/// computeSizeAndOffset - Compute the size and offset of a DIE. 2155/// 2156unsigned 2157DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) { 2158 // Get the children. 2159 const std::vector<DIE *> &Children = Die->getChildren(); 2160 2161 // If not last sibling and has children then add sibling offset attribute. 2162 if (!Last && !Children.empty()) 2163 Die->addSiblingOffset(DIEValueAllocator); 2164 2165 // Record the abbreviation. 2166 assignAbbrevNumber(Die->getAbbrev()); 2167 2168 // Get the abbreviation for this DIE. 2169 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2170 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2171 2172 // Set DIE offset 2173 Die->setOffset(Offset); 2174 2175 // Start the size with the size of abbreviation code. 2176 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 2177 2178 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2179 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2180 2181 // Size the DIE attribute values. 2182 for (unsigned i = 0, N = Values.size(); i < N; ++i) 2183 // Size attribute value. 2184 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm()); 2185 2186 // Size the DIE children if any. 2187 if (!Children.empty()) { 2188 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 2189 "Children flag not set"); 2190 2191 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2192 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M); 2193 2194 // End of children marker. 2195 Offset += sizeof(int8_t); 2196 } 2197 2198 Die->setSize(Offset - Die->getOffset()); 2199 return Offset; 2200} 2201 2202/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. 2203/// 2204void DwarfDebug::computeSizeAndOffsets() { 2205 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2206 E = CUMap.end(); I != E; ++I) { 2207 // Compute size of compile unit header. 2208 unsigned Offset = 2209 sizeof(int32_t) + // Length of Compilation Unit Info 2210 sizeof(int16_t) + // DWARF version number 2211 sizeof(int32_t) + // Offset Into Abbrev. Section 2212 sizeof(int8_t); // Pointer Size (in bytes) 2213 computeSizeAndOffset(I->second->getCUDie(), Offset, true); 2214 } 2215} 2216 2217/// EmitSectionSym - Switch to the specified MCSection and emit an assembler 2218/// temporary label to it if SymbolStem is specified. 2219static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section, 2220 const char *SymbolStem = 0) { 2221 Asm->OutStreamer.SwitchSection(Section); 2222 if (!SymbolStem) return 0; 2223 2224 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem); 2225 Asm->OutStreamer.EmitLabel(TmpSym); 2226 return TmpSym; 2227} 2228 2229/// EmitSectionLabels - Emit initial Dwarf sections with a label at 2230/// the start of each one. 2231void DwarfDebug::EmitSectionLabels() { 2232 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 2233 2234 // Dwarf sections base addresses. 2235 DwarfInfoSectionSym = 2236 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info"); 2237 DwarfAbbrevSectionSym = 2238 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev"); 2239 EmitSectionSym(Asm, TLOF.getDwarfARangesSection()); 2240 2241 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection()) 2242 EmitSectionSym(Asm, MacroInfo); 2243 2244 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line"); 2245 EmitSectionSym(Asm, TLOF.getDwarfLocSection()); 2246 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection()); 2247 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection()); 2248 DwarfStrSectionSym = 2249 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str"); 2250 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(), 2251 "debug_range"); 2252 2253 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(), 2254 "section_debug_loc"); 2255 2256 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin"); 2257 EmitSectionSym(Asm, TLOF.getDataSection()); 2258} 2259 2260/// emitDIE - Recusively Emits a debug information entry. 2261/// 2262void DwarfDebug::emitDIE(DIE *Die) { 2263 // Get the abbreviation for this DIE. 2264 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2265 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; 2266 2267 // Emit the code (index) for the abbreviation. 2268 if (Asm->isVerbose()) 2269 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 2270 Twine::utohexstr(Die->getOffset()) + ":0x" + 2271 Twine::utohexstr(Die->getSize()) + " " + 2272 dwarf::TagString(Abbrev->getTag())); 2273 Asm->EmitULEB128(AbbrevNumber); 2274 2275 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 2276 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 2277 2278 // Emit the DIE attribute values. 2279 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 2280 unsigned Attr = AbbrevData[i].getAttribute(); 2281 unsigned Form = AbbrevData[i].getForm(); 2282 assert(Form && "Too many attributes for DIE (check abbreviation)"); 2283 2284 if (Asm->isVerbose()) 2285 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 2286 2287 switch (Attr) { 2288 case dwarf::DW_AT_sibling: 2289 Asm->EmitInt32(Die->getSiblingOffset()); 2290 break; 2291 case dwarf::DW_AT_abstract_origin: { 2292 DIEEntry *E = cast<DIEEntry>(Values[i]); 2293 DIE *Origin = E->getEntry(); 2294 unsigned Addr = Origin->getOffset(); 2295 Asm->EmitInt32(Addr); 2296 break; 2297 } 2298 case dwarf::DW_AT_ranges: { 2299 // DW_AT_range Value encodes offset in debug_range section. 2300 DIEInteger *V = cast<DIEInteger>(Values[i]); 2301 2302 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) { 2303 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym, 2304 V->getValue(), 2305 4); 2306 } else { 2307 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym, 2308 V->getValue(), 2309 DwarfDebugRangeSectionSym, 2310 4); 2311 } 2312 break; 2313 } 2314 case dwarf::DW_AT_location: { 2315 if (UseDotDebugLocEntry.count(Die) != 0) { 2316 DIELabel *L = cast<DIELabel>(Values[i]); 2317 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4); 2318 } else 2319 Values[i]->EmitValue(Asm, Form); 2320 break; 2321 } 2322 case dwarf::DW_AT_accessibility: { 2323 if (Asm->isVerbose()) { 2324 DIEInteger *V = cast<DIEInteger>(Values[i]); 2325 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue())); 2326 } 2327 Values[i]->EmitValue(Asm, Form); 2328 break; 2329 } 2330 default: 2331 // Emit an attribute using the defined form. 2332 Values[i]->EmitValue(Asm, Form); 2333 break; 2334 } 2335 } 2336 2337 // Emit the DIE children if any. 2338 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 2339 const std::vector<DIE *> &Children = Die->getChildren(); 2340 2341 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2342 emitDIE(Children[j]); 2343 2344 if (Asm->isVerbose()) 2345 Asm->OutStreamer.AddComment("End Of Children Mark"); 2346 Asm->EmitInt8(0); 2347 } 2348} 2349 2350/// emitDebugInfo - Emit the debug info section. 2351/// 2352void DwarfDebug::emitDebugInfo() { 2353 // Start debug info section. 2354 Asm->OutStreamer.SwitchSection( 2355 Asm->getObjFileLowering().getDwarfInfoSection()); 2356 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2357 E = CUMap.end(); I != E; ++I) { 2358 CompileUnit *TheCU = I->second; 2359 DIE *Die = TheCU->getCUDie(); 2360 2361 // Emit the compile units header. 2362 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin", 2363 TheCU->getID())); 2364 2365 // Emit size of content not including length itself 2366 unsigned ContentSize = Die->getSize() + 2367 sizeof(int16_t) + // DWARF version number 2368 sizeof(int32_t) + // Offset Into Abbrev. Section 2369 sizeof(int8_t); // Pointer Size (in bytes) 2370 2371 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 2372 Asm->EmitInt32(ContentSize); 2373 Asm->OutStreamer.AddComment("DWARF version number"); 2374 Asm->EmitInt16(dwarf::DWARF_VERSION); 2375 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 2376 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"), 2377 DwarfAbbrevSectionSym); 2378 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 2379 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 2380 2381 emitDIE(Die); 2382 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID())); 2383 } 2384} 2385 2386/// emitAbbreviations - Emit the abbreviation section. 2387/// 2388void DwarfDebug::emitAbbreviations() const { 2389 // Check to see if it is worth the effort. 2390 if (!Abbreviations.empty()) { 2391 // Start the debug abbrev section. 2392 Asm->OutStreamer.SwitchSection( 2393 Asm->getObjFileLowering().getDwarfAbbrevSection()); 2394 2395 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin")); 2396 2397 // For each abbrevation. 2398 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { 2399 // Get abbreviation data 2400 const DIEAbbrev *Abbrev = Abbreviations[i]; 2401 2402 // Emit the abbrevations code (base 1 index.) 2403 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 2404 2405 // Emit the abbreviations data. 2406 Abbrev->Emit(Asm); 2407 } 2408 2409 // Mark end of abbreviations. 2410 Asm->EmitULEB128(0, "EOM(3)"); 2411 2412 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end")); 2413 } 2414} 2415 2416/// emitEndOfLineMatrix - Emit the last address of the section and the end of 2417/// the line matrix. 2418/// 2419void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 2420 // Define last address of section. 2421 Asm->OutStreamer.AddComment("Extended Op"); 2422 Asm->EmitInt8(0); 2423 2424 Asm->OutStreamer.AddComment("Op size"); 2425 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1); 2426 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 2427 Asm->EmitInt8(dwarf::DW_LNE_set_address); 2428 2429 Asm->OutStreamer.AddComment("Section end label"); 2430 2431 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd), 2432 Asm->getTargetData().getPointerSize(), 2433 0/*AddrSpace*/); 2434 2435 // Mark end of matrix. 2436 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 2437 Asm->EmitInt8(0); 2438 Asm->EmitInt8(1); 2439 Asm->EmitInt8(1); 2440} 2441 2442/// emitDebugPubNames - Emit visible names into a debug pubnames section. 2443/// 2444void DwarfDebug::emitDebugPubNames() { 2445 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2446 E = CUMap.end(); I != E; ++I) { 2447 CompileUnit *TheCU = I->second; 2448 // Start the dwarf pubnames section. 2449 Asm->OutStreamer.SwitchSection( 2450 Asm->getObjFileLowering().getDwarfPubNamesSection()); 2451 2452 Asm->OutStreamer.AddComment("Length of Public Names Info"); 2453 Asm->EmitLabelDifference( 2454 Asm->GetTempSymbol("pubnames_end", TheCU->getID()), 2455 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4); 2456 2457 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", 2458 TheCU->getID())); 2459 2460 Asm->OutStreamer.AddComment("DWARF Version"); 2461 Asm->EmitInt16(dwarf::DWARF_VERSION); 2462 2463 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2464 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 2465 DwarfInfoSectionSym); 2466 2467 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2468 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 2469 Asm->GetTempSymbol("info_begin", TheCU->getID()), 2470 4); 2471 2472 const StringMap<DIE*> &Globals = TheCU->getGlobals(); 2473 for (StringMap<DIE*>::const_iterator 2474 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2475 const char *Name = GI->getKeyData(); 2476 DIE *Entity = GI->second; 2477 2478 Asm->OutStreamer.AddComment("DIE offset"); 2479 Asm->EmitInt32(Entity->getOffset()); 2480 2481 if (Asm->isVerbose()) 2482 Asm->OutStreamer.AddComment("External Name"); 2483 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0); 2484 } 2485 2486 Asm->OutStreamer.AddComment("End Mark"); 2487 Asm->EmitInt32(0); 2488 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", 2489 TheCU->getID())); 2490 } 2491} 2492 2493void DwarfDebug::emitDebugPubTypes() { 2494 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2495 E = CUMap.end(); I != E; ++I) { 2496 CompileUnit *TheCU = I->second; 2497 // Start the dwarf pubnames section. 2498 Asm->OutStreamer.SwitchSection( 2499 Asm->getObjFileLowering().getDwarfPubTypesSection()); 2500 Asm->OutStreamer.AddComment("Length of Public Types Info"); 2501 Asm->EmitLabelDifference( 2502 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()), 2503 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4); 2504 2505 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin", 2506 TheCU->getID())); 2507 2508 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version"); 2509 Asm->EmitInt16(dwarf::DWARF_VERSION); 2510 2511 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2512 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()), 2513 DwarfInfoSectionSym); 2514 2515 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2516 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()), 2517 Asm->GetTempSymbol("info_begin", TheCU->getID()), 2518 4); 2519 2520 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes(); 2521 for (StringMap<DIE*>::const_iterator 2522 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2523 const char *Name = GI->getKeyData(); 2524 DIE * Entity = GI->second; 2525 2526 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 2527 Asm->EmitInt32(Entity->getOffset()); 2528 2529 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name"); 2530 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0); 2531 } 2532 2533 Asm->OutStreamer.AddComment("End Mark"); 2534 Asm->EmitInt32(0); 2535 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end", 2536 TheCU->getID())); 2537 } 2538} 2539 2540/// emitDebugStr - Emit visible names into a debug str section. 2541/// 2542void DwarfDebug::emitDebugStr() { 2543 // Check to see if it is worth the effort. 2544 if (StringPool.empty()) return; 2545 2546 // Start the dwarf str section. 2547 Asm->OutStreamer.SwitchSection( 2548 Asm->getObjFileLowering().getDwarfStrSection()); 2549 2550 // Get all of the string pool entries and put them in an array by their ID so 2551 // we can sort them. 2552 SmallVector<std::pair<unsigned, 2553 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 2554 2555 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 2556 I = StringPool.begin(), E = StringPool.end(); I != E; ++I) 2557 Entries.push_back(std::make_pair(I->second.second, &*I)); 2558 2559 array_pod_sort(Entries.begin(), Entries.end()); 2560 2561 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2562 // Emit a label for reference from debug information entries. 2563 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 2564 2565 // Emit the string itself. 2566 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/); 2567 } 2568} 2569 2570/// emitDebugLoc - Emit visible names into a debug loc section. 2571/// 2572void DwarfDebug::emitDebugLoc() { 2573 if (DotDebugLocEntries.empty()) 2574 return; 2575 2576 for (SmallVector<DotDebugLocEntry, 4>::iterator 2577 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 2578 I != E; ++I) { 2579 DotDebugLocEntry &Entry = *I; 2580 if (I + 1 != DotDebugLocEntries.end()) 2581 Entry.Merge(I+1); 2582 } 2583 2584 // Start the dwarf loc section. 2585 Asm->OutStreamer.SwitchSection( 2586 Asm->getObjFileLowering().getDwarfLocSection()); 2587 unsigned char Size = Asm->getTargetData().getPointerSize(); 2588 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0)); 2589 unsigned index = 1; 2590 for (SmallVector<DotDebugLocEntry, 4>::iterator 2591 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 2592 I != E; ++I, ++index) { 2593 DotDebugLocEntry &Entry = *I; 2594 if (Entry.isMerged()) continue; 2595 if (Entry.isEmpty()) { 2596 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 2597 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 2598 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index)); 2599 } else { 2600 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0); 2601 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0); 2602 DIVariable DV(Entry.Variable); 2603 Asm->OutStreamer.AddComment("Loc expr size"); 2604 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol(); 2605 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol(); 2606 Asm->EmitLabelDifference(end, begin, 2); 2607 Asm->OutStreamer.EmitLabel(begin); 2608 if (Entry.isInt()) { 2609 DIBasicType BTy(DV.getType()); 2610 if (BTy.Verify() && 2611 (BTy.getEncoding() == dwarf::DW_ATE_signed 2612 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) { 2613 Asm->OutStreamer.AddComment("DW_OP_consts"); 2614 Asm->EmitInt8(dwarf::DW_OP_consts); 2615 Asm->EmitSLEB128(Entry.getInt()); 2616 } else { 2617 Asm->OutStreamer.AddComment("DW_OP_constu"); 2618 Asm->EmitInt8(dwarf::DW_OP_constu); 2619 Asm->EmitULEB128(Entry.getInt()); 2620 } 2621 } else if (Entry.isLocation()) { 2622 if (!DV.hasComplexAddress()) 2623 // Regular entry. 2624 Asm->EmitDwarfRegOp(Entry.Loc); 2625 else { 2626 // Complex address entry. 2627 unsigned N = DV.getNumAddrElements(); 2628 unsigned i = 0; 2629 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) { 2630 if (Entry.Loc.getOffset()) { 2631 i = 2; 2632 Asm->EmitDwarfRegOp(Entry.Loc); 2633 Asm->OutStreamer.AddComment("DW_OP_deref"); 2634 Asm->EmitInt8(dwarf::DW_OP_deref); 2635 Asm->OutStreamer.AddComment("DW_OP_plus_uconst"); 2636 Asm->EmitInt8(dwarf::DW_OP_plus_uconst); 2637 Asm->EmitSLEB128(DV.getAddrElement(1)); 2638 } else { 2639 // If first address element is OpPlus then emit 2640 // DW_OP_breg + Offset instead of DW_OP_reg + Offset. 2641 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1)); 2642 Asm->EmitDwarfRegOp(Loc); 2643 i = 2; 2644 } 2645 } else { 2646 Asm->EmitDwarfRegOp(Entry.Loc); 2647 } 2648 2649 // Emit remaining complex address elements. 2650 for (; i < N; ++i) { 2651 uint64_t Element = DV.getAddrElement(i); 2652 if (Element == DIBuilder::OpPlus) { 2653 Asm->EmitInt8(dwarf::DW_OP_plus_uconst); 2654 Asm->EmitULEB128(DV.getAddrElement(++i)); 2655 } else if (Element == DIBuilder::OpDeref) 2656 Asm->EmitInt8(dwarf::DW_OP_deref); 2657 else llvm_unreachable("unknown Opcode found in complex address"); 2658 } 2659 } 2660 } 2661 // else ... ignore constant fp. There is not any good way to 2662 // to represent them here in dwarf. 2663 Asm->OutStreamer.EmitLabel(end); 2664 } 2665 } 2666} 2667 2668/// EmitDebugARanges - Emit visible names into a debug aranges section. 2669/// 2670void DwarfDebug::EmitDebugARanges() { 2671 // Start the dwarf aranges section. 2672 Asm->OutStreamer.SwitchSection( 2673 Asm->getObjFileLowering().getDwarfARangesSection()); 2674} 2675 2676/// emitDebugRanges - Emit visible names into a debug ranges section. 2677/// 2678void DwarfDebug::emitDebugRanges() { 2679 // Start the dwarf ranges section. 2680 Asm->OutStreamer.SwitchSection( 2681 Asm->getObjFileLowering().getDwarfRangesSection()); 2682 unsigned char Size = Asm->getTargetData().getPointerSize(); 2683 for (SmallVector<const MCSymbol *, 8>::iterator 2684 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end(); 2685 I != E; ++I) { 2686 if (*I) 2687 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0); 2688 else 2689 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0); 2690 } 2691} 2692 2693/// emitDebugMacInfo - Emit visible names into a debug macinfo section. 2694/// 2695void DwarfDebug::emitDebugMacInfo() { 2696 if (const MCSection *LineInfo = 2697 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 2698 // Start the dwarf macinfo section. 2699 Asm->OutStreamer.SwitchSection(LineInfo); 2700 } 2701} 2702 2703/// emitDebugInlineInfo - Emit inline info using following format. 2704/// Section Header: 2705/// 1. length of section 2706/// 2. Dwarf version number 2707/// 3. address size. 2708/// 2709/// Entries (one "entry" for each function that was inlined): 2710/// 2711/// 1. offset into __debug_str section for MIPS linkage name, if exists; 2712/// otherwise offset into __debug_str for regular function name. 2713/// 2. offset into __debug_str section for regular function name. 2714/// 3. an unsigned LEB128 number indicating the number of distinct inlining 2715/// instances for the function. 2716/// 2717/// The rest of the entry consists of a {die_offset, low_pc} pair for each 2718/// inlined instance; the die_offset points to the inlined_subroutine die in the 2719/// __debug_info section, and the low_pc is the starting address for the 2720/// inlining instance. 2721void DwarfDebug::emitDebugInlineInfo() { 2722 if (!Asm->MAI->doesDwarfUsesInlineInfoSection()) 2723 return; 2724 2725 if (!FirstCU) 2726 return; 2727 2728 Asm->OutStreamer.SwitchSection( 2729 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 2730 2731 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry"); 2732 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1), 2733 Asm->GetTempSymbol("debug_inlined_begin", 1), 4); 2734 2735 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1)); 2736 2737 Asm->OutStreamer.AddComment("Dwarf Version"); 2738 Asm->EmitInt16(dwarf::DWARF_VERSION); 2739 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 2740 Asm->EmitInt8(Asm->getTargetData().getPointerSize()); 2741 2742 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(), 2743 E = InlinedSPNodes.end(); I != E; ++I) { 2744 2745 const MDNode *Node = *I; 2746 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II 2747 = InlineInfo.find(Node); 2748 SmallVector<InlineInfoLabels, 4> &Labels = II->second; 2749 DISubprogram SP(Node); 2750 StringRef LName = SP.getLinkageName(); 2751 StringRef Name = SP.getName(); 2752 2753 Asm->OutStreamer.AddComment("MIPS linkage name"); 2754 if (LName.empty()) { 2755 Asm->OutStreamer.EmitBytes(Name, 0); 2756 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator. 2757 } else 2758 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)), 2759 DwarfStrSectionSym); 2760 2761 Asm->OutStreamer.AddComment("Function name"); 2762 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym); 2763 Asm->EmitULEB128(Labels.size(), "Inline count"); 2764 2765 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(), 2766 LE = Labels.end(); LI != LE; ++LI) { 2767 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 2768 Asm->EmitInt32(LI->second->getOffset()); 2769 2770 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc"); 2771 Asm->OutStreamer.EmitSymbolValue(LI->first, 2772 Asm->getTargetData().getPointerSize(),0); 2773 } 2774 } 2775 2776 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1)); 2777} 2778