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