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