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