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