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