DwarfDebug.cpp revision 18eb245a2e5ec41b5da1367d5f7e7619532f7ceb
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 "DIEHash.h" 18#include "DwarfAccelTable.h" 19#include "DwarfCompileUnit.h" 20#include "llvm/ADT/STLExtras.h" 21#include "llvm/ADT/Statistic.h" 22#include "llvm/ADT/StringExtras.h" 23#include "llvm/ADT/Triple.h" 24#include "llvm/CodeGen/MachineFunction.h" 25#include "llvm/CodeGen/MachineModuleInfo.h" 26#include "llvm/DIBuilder.h" 27#include "llvm/DebugInfo.h" 28#include "llvm/IR/Constants.h" 29#include "llvm/IR/DataLayout.h" 30#include "llvm/IR/Instructions.h" 31#include "llvm/IR/Module.h" 32#include "llvm/MC/MCAsmInfo.h" 33#include "llvm/MC/MCSection.h" 34#include "llvm/MC/MCStreamer.h" 35#include "llvm/MC/MCSymbol.h" 36#include "llvm/Support/CommandLine.h" 37#include "llvm/Support/Debug.h" 38#include "llvm/Support/Dwarf.h" 39#include "llvm/Support/ErrorHandling.h" 40#include "llvm/Support/FormattedStream.h" 41#include "llvm/Support/MD5.h" 42#include "llvm/Support/Path.h" 43#include "llvm/Support/Timer.h" 44#include "llvm/Support/ValueHandle.h" 45#include "llvm/Target/TargetFrameLowering.h" 46#include "llvm/Target/TargetLoweringObjectFile.h" 47#include "llvm/Target/TargetMachine.h" 48#include "llvm/Target/TargetOptions.h" 49#include "llvm/Target/TargetRegisterInfo.h" 50using namespace llvm; 51 52static cl::opt<bool> 53DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden, 54 cl::desc("Disable debug info printing")); 55 56static cl::opt<bool> UnknownLocations( 57 "use-unknown-locations", cl::Hidden, 58 cl::desc("Make an absence of debug location information explicit."), 59 cl::init(false)); 60 61static cl::opt<bool> 62GenerateODRHash("generate-odr-hash", cl::Hidden, 63 cl::desc("Add an ODR hash to external type DIEs."), 64 cl::init(false)); 65 66static cl::opt<bool> 67GenerateCUHash("generate-cu-hash", cl::Hidden, 68 cl::desc("Add the CU hash as the dwo_id."), 69 cl::init(false)); 70 71namespace { 72enum DefaultOnOff { 73 Default, 74 Enable, 75 Disable 76}; 77} 78 79static cl::opt<DefaultOnOff> 80DwarfAccelTables("dwarf-accel-tables", cl::Hidden, 81 cl::desc("Output prototype dwarf accelerator tables."), 82 cl::values(clEnumVal(Default, "Default for platform"), 83 clEnumVal(Enable, "Enabled"), 84 clEnumVal(Disable, "Disabled"), clEnumValEnd), 85 cl::init(Default)); 86 87static cl::opt<DefaultOnOff> 88SplitDwarf("split-dwarf", cl::Hidden, 89 cl::desc("Output prototype dwarf split debug info."), 90 cl::values(clEnumVal(Default, "Default for platform"), 91 clEnumVal(Enable, "Enabled"), 92 clEnumVal(Disable, "Disabled"), clEnumValEnd), 93 cl::init(Default)); 94 95static cl::opt<DefaultOnOff> 96DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden, 97 cl::desc("Generate DWARF pubnames and pubtypes sections"), 98 cl::values(clEnumVal(Default, "Default for platform"), 99 clEnumVal(Enable, "Enabled"), 100 clEnumVal(Disable, "Disabled"), clEnumValEnd), 101 cl::init(Default)); 102 103static const char *const DWARFGroupName = "DWARF Emission"; 104static const char *const DbgTimerName = "DWARF Debug Writer"; 105 106//===----------------------------------------------------------------------===// 107 108// Configuration values for initial hash set sizes (log2). 109// 110static const unsigned InitAbbreviationsSetSize = 9; // log2(512) 111 112namespace llvm { 113 114DIType DbgVariable::getType() const { 115 DIType Ty = Var.getType(); 116 // FIXME: isBlockByrefVariable should be reformulated in terms of complex 117 // addresses instead. 118 if (Var.isBlockByrefVariable()) { 119 /* Byref variables, in Blocks, are declared by the programmer as 120 "SomeType VarName;", but the compiler creates a 121 __Block_byref_x_VarName struct, and gives the variable VarName 122 either the struct, or a pointer to the struct, as its type. This 123 is necessary for various behind-the-scenes things the compiler 124 needs to do with by-reference variables in blocks. 125 126 However, as far as the original *programmer* is concerned, the 127 variable should still have type 'SomeType', as originally declared. 128 129 The following function dives into the __Block_byref_x_VarName 130 struct to find the original type of the variable. This will be 131 passed back to the code generating the type for the Debug 132 Information Entry for the variable 'VarName'. 'VarName' will then 133 have the original type 'SomeType' in its debug information. 134 135 The original type 'SomeType' will be the type of the field named 136 'VarName' inside the __Block_byref_x_VarName struct. 137 138 NOTE: In order for this to not completely fail on the debugger 139 side, the Debug Information Entry for the variable VarName needs to 140 have a DW_AT_location that tells the debugger how to unwind through 141 the pointers and __Block_byref_x_VarName struct to find the actual 142 value of the variable. The function addBlockByrefType does this. */ 143 DIType subType = Ty; 144 uint16_t tag = Ty.getTag(); 145 146 if (tag == dwarf::DW_TAG_pointer_type) 147 subType = DIDerivedType(Ty).getTypeDerivedFrom(); 148 149 DIArray Elements = DICompositeType(subType).getTypeArray(); 150 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 151 DIDerivedType DT = DIDerivedType(Elements.getElement(i)); 152 if (getName() == DT.getName()) 153 return (DT.getTypeDerivedFrom()); 154 } 155 } 156 return Ty; 157} 158 159} // end llvm namespace 160 161/// Return Dwarf Version by checking module flags. 162static unsigned getDwarfVersionFromModule(const Module *M) { 163 Value *Val = M->getModuleFlag("Dwarf Version"); 164 if (!Val) 165 return dwarf::DWARF_VERSION; 166 return cast<ConstantInt>(Val)->getZExtValue(); 167} 168 169DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M) 170 : Asm(A), MMI(Asm->MMI), FirstCU(0), 171 AbbreviationsSet(InitAbbreviationsSetSize), 172 SourceIdMap(DIEValueAllocator), 173 PrevLabel(NULL), GlobalCUIndexCount(0), 174 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string", 175 DIEValueAllocator), 176 SkeletonAbbrevSet(InitAbbreviationsSetSize), 177 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string", 178 DIEValueAllocator) { 179 180 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0; 181 DwarfStrSectionSym = TextSectionSym = 0; 182 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0; 183 DwarfAddrSectionSym = 0; 184 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0; 185 FunctionBeginSym = FunctionEndSym = 0; 186 187 // Turn on accelerator tables and older gdb compatibility 188 // for Darwin by default, pubnames by default for non-Darwin, 189 // and handle split dwarf. 190 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin(); 191 192 if (DwarfAccelTables == Default) 193 HasDwarfAccelTables = IsDarwin; 194 else 195 HasDwarfAccelTables = DwarfAccelTables == Enable; 196 197 if (SplitDwarf == Default) 198 HasSplitDwarf = false; 199 else 200 HasSplitDwarf = SplitDwarf == Enable; 201 202 if (DwarfPubSections == Default) 203 HasDwarfPubSections = !IsDarwin; 204 else 205 HasDwarfPubSections = DwarfPubSections == Enable; 206 207 DwarfVersion = getDwarfVersionFromModule(MMI->getModule()); 208 209 { 210 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled); 211 beginModule(); 212 } 213} 214DwarfDebug::~DwarfDebug() { 215} 216 217// Switch to the specified MCSection and emit an assembler 218// temporary label to it if SymbolStem is specified. 219static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section, 220 const char *SymbolStem = 0) { 221 Asm->OutStreamer.SwitchSection(Section); 222 if (!SymbolStem) return 0; 223 224 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem); 225 Asm->OutStreamer.EmitLabel(TmpSym); 226 return TmpSym; 227} 228 229MCSymbol *DwarfUnits::getStringPoolSym() { 230 return Asm->GetTempSymbol(StringPref); 231} 232 233MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) { 234 std::pair<MCSymbol*, unsigned> &Entry = 235 StringPool.GetOrCreateValue(Str).getValue(); 236 if (Entry.first) return Entry.first; 237 238 Entry.second = NextStringPoolNumber++; 239 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second); 240} 241 242unsigned DwarfUnits::getStringPoolIndex(StringRef Str) { 243 std::pair<MCSymbol*, unsigned> &Entry = 244 StringPool.GetOrCreateValue(Str).getValue(); 245 if (Entry.first) return Entry.second; 246 247 Entry.second = NextStringPoolNumber++; 248 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second); 249 return Entry.second; 250} 251 252unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) { 253 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext)); 254} 255 256unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) { 257 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P = 258 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber)); 259 if (P.second) 260 ++NextAddrPoolNumber; 261 return P.first->second; 262} 263 264// Define a unique number for the abbreviation. 265// 266void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) { 267 // Check the set for priors. 268 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev); 269 270 // If it's newly added. 271 if (InSet == &Abbrev) { 272 // Add to abbreviation list. 273 Abbreviations->push_back(&Abbrev); 274 275 // Assign the vector position + 1 as its number. 276 Abbrev.setNumber(Abbreviations->size()); 277 } else { 278 // Assign existing abbreviation number. 279 Abbrev.setNumber(InSet->getNumber()); 280 } 281} 282 283static bool isObjCClass(StringRef Name) { 284 return Name.startswith("+") || Name.startswith("-"); 285} 286 287static bool hasObjCCategory(StringRef Name) { 288 if (!isObjCClass(Name)) return false; 289 290 return Name.find(") ") != StringRef::npos; 291} 292 293static void getObjCClassCategory(StringRef In, StringRef &Class, 294 StringRef &Category) { 295 if (!hasObjCCategory(In)) { 296 Class = In.slice(In.find('[') + 1, In.find(' ')); 297 Category = ""; 298 return; 299 } 300 301 Class = In.slice(In.find('[') + 1, In.find('(')); 302 Category = In.slice(In.find('[') + 1, In.find(' ')); 303 return; 304} 305 306static StringRef getObjCMethodName(StringRef In) { 307 return In.slice(In.find(' ') + 1, In.find(']')); 308} 309 310// Add the various names to the Dwarf accelerator table names. 311static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP, 312 DIE* Die) { 313 if (!SP.isDefinition()) return; 314 315 TheCU->addAccelName(SP.getName(), Die); 316 317 // If the linkage name is different than the name, go ahead and output 318 // that as well into the name table. 319 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName()) 320 TheCU->addAccelName(SP.getLinkageName(), Die); 321 322 // If this is an Objective-C selector name add it to the ObjC accelerator 323 // too. 324 if (isObjCClass(SP.getName())) { 325 StringRef Class, Category; 326 getObjCClassCategory(SP.getName(), Class, Category); 327 TheCU->addAccelObjC(Class, Die); 328 if (Category != "") 329 TheCU->addAccelObjC(Category, Die); 330 // Also add the base method name to the name table. 331 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die); 332 } 333} 334 335/// isSubprogramContext - Return true if Context is either a subprogram 336/// or another context nested inside a subprogram. 337bool DwarfDebug::isSubprogramContext(const MDNode *Context) { 338 if (!Context) 339 return false; 340 DIDescriptor D(Context); 341 if (D.isSubprogram()) 342 return true; 343 if (D.isType()) 344 return isSubprogramContext(DIType(Context).getContext()); 345 return false; 346} 347 348// Find DIE for the given subprogram and attach appropriate DW_AT_low_pc 349// and DW_AT_high_pc attributes. If there are global variables in this 350// scope then create and insert DIEs for these variables. 351DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU, 352 const MDNode *SPNode) { 353 DIE *SPDie = SPCU->getDIE(SPNode); 354 355 assert(SPDie && "Unable to find subprogram DIE!"); 356 DISubprogram SP(SPNode); 357 358 // If we're updating an abstract DIE, then we will be adding the children and 359 // object pointer later on. But what we don't want to do is process the 360 // concrete DIE twice. 361 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode); 362 if (AbsSPDIE) { 363 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie()); 364 // Pick up abstract subprogram DIE. 365 SPDie = new DIE(dwarf::DW_TAG_subprogram); 366 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of 367 // DW_FORM_ref4. 368 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, 369 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr, 370 AbsSPDIE); 371 SPCU->addDie(SPDie); 372 } else { 373 DISubprogram SPDecl = SP.getFunctionDeclaration(); 374 if (!SPDecl.isSubprogram()) { 375 // There is not any need to generate specification DIE for a function 376 // defined at compile unit level. If a function is defined inside another 377 // function then gdb prefers the definition at top level and but does not 378 // expect specification DIE in parent function. So avoid creating 379 // specification DIE for a function defined inside a function. 380 if (SP.isDefinition() && !SP.getContext().isCompileUnit() && 381 !SP.getContext().isFile() && 382 !isSubprogramContext(SP.getContext())) { 383 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration); 384 385 // Add arguments. 386 DICompositeType SPTy = SP.getType(); 387 DIArray Args = SPTy.getTypeArray(); 388 uint16_t SPTag = SPTy.getTag(); 389 if (SPTag == dwarf::DW_TAG_subroutine_type) 390 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 391 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 392 DIType ATy = DIType(Args.getElement(i)); 393 SPCU->addType(Arg, ATy); 394 if (ATy.isArtificial()) 395 SPCU->addFlag(Arg, dwarf::DW_AT_artificial); 396 if (ATy.isObjectPointer()) 397 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, 398 dwarf::DW_FORM_ref4, Arg); 399 SPDie->addChild(Arg); 400 } 401 DIE *SPDeclDie = SPDie; 402 SPDie = new DIE(dwarf::DW_TAG_subprogram); 403 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, 404 dwarf::DW_FORM_ref4, SPDeclDie); 405 SPCU->addDie(SPDie); 406 } 407 } 408 } 409 410 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, 411 Asm->GetTempSymbol("func_begin", 412 Asm->getFunctionNumber())); 413 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, 414 Asm->GetTempSymbol("func_end", 415 Asm->getFunctionNumber())); 416 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 417 MachineLocation Location(RI->getFrameRegister(*Asm->MF)); 418 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location); 419 420 // Add name to the name table, we do this here because we're guaranteed 421 // to have concrete versions of our DW_TAG_subprogram nodes. 422 addSubprogramNames(SPCU, SP, SPDie); 423 424 return SPDie; 425} 426 427// Construct new DW_TAG_lexical_block for this scope and attach 428// DW_AT_low_pc/DW_AT_high_pc labels. 429DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU, 430 LexicalScope *Scope) { 431 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block); 432 if (Scope->isAbstractScope()) 433 return ScopeDIE; 434 435 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges(); 436 if (Ranges.empty()) 437 return 0; 438 439 // If we have multiple ranges, emit them into the range section. 440 if (Ranges.size() > 1) { 441 // .debug_range section has not been laid out yet. Emit offset in 442 // .debug_range as a uint, size 4, for now. emitDIE will handle 443 // DW_AT_ranges appropriately. 444 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4, 445 DebugRangeSymbols.size() 446 * Asm->getDataLayout().getPointerSize()); 447 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(), 448 RE = Ranges.end(); RI != RE; ++RI) { 449 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first)); 450 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second)); 451 } 452 453 // Terminate the range list. 454 DebugRangeSymbols.push_back(NULL); 455 DebugRangeSymbols.push_back(NULL); 456 return ScopeDIE; 457 } 458 459 // Construct the address range for this DIE. 460 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(); 461 MCSymbol *Start = getLabelBeforeInsn(RI->first); 462 MCSymbol *End = getLabelAfterInsn(RI->second); 463 464 if (End == 0) return 0; 465 466 assert(Start->isDefined() && "Invalid starting label for an inlined scope!"); 467 assert(End->isDefined() && "Invalid end label for an inlined scope!"); 468 469 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start); 470 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End); 471 472 return ScopeDIE; 473} 474 475// This scope represents inlined body of a function. Construct DIE to 476// represent this concrete inlined copy of the function. 477DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU, 478 LexicalScope *Scope) { 479 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges(); 480 assert(Ranges.empty() == false && 481 "LexicalScope does not have instruction markers!"); 482 483 if (!Scope->getScopeNode()) 484 return NULL; 485 DIScope DS(Scope->getScopeNode()); 486 DISubprogram InlinedSP = getDISubprogram(DS); 487 DIE *OriginDIE = TheCU->getDIE(InlinedSP); 488 if (!OriginDIE) { 489 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram."); 490 return NULL; 491 } 492 493 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine); 494 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, 495 dwarf::DW_FORM_ref4, OriginDIE); 496 497 if (Ranges.size() > 1) { 498 // .debug_range section has not been laid out yet. Emit offset in 499 // .debug_range as a uint, size 4, for now. emitDIE will handle 500 // DW_AT_ranges appropriately. 501 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4, 502 DebugRangeSymbols.size() 503 * Asm->getDataLayout().getPointerSize()); 504 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(), 505 RE = Ranges.end(); RI != RE; ++RI) { 506 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first)); 507 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second)); 508 } 509 DebugRangeSymbols.push_back(NULL); 510 DebugRangeSymbols.push_back(NULL); 511 } else { 512 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(); 513 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first); 514 MCSymbol *EndLabel = getLabelAfterInsn(RI->second); 515 516 if (StartLabel == 0 || EndLabel == 0) 517 llvm_unreachable("Unexpected Start and End labels for an inlined scope!"); 518 519 assert(StartLabel->isDefined() && 520 "Invalid starting label for an inlined scope!"); 521 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!"); 522 523 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel); 524 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel); 525 } 526 527 InlinedSubprogramDIEs.insert(OriginDIE); 528 529 // Add the call site information to the DIE. 530 DILocation DL(Scope->getInlinedAt()); 531 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, 532 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(), 533 TheCU->getUniqueID())); 534 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber()); 535 536 // Add name to the name table, we do this here because we're guaranteed 537 // to have concrete versions of our DW_TAG_inlined_subprogram nodes. 538 addSubprogramNames(TheCU, InlinedSP, ScopeDIE); 539 540 return ScopeDIE; 541} 542 543// Construct a DIE for this scope. 544DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) { 545 if (!Scope || !Scope->getScopeNode()) 546 return NULL; 547 548 DIScope DS(Scope->getScopeNode()); 549 // Early return to avoid creating dangling variable|scope DIEs. 550 if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() && 551 !TheCU->getDIE(DS)) 552 return NULL; 553 554 SmallVector<DIE *, 8> Children; 555 DIE *ObjectPointer = NULL; 556 557 // Collect arguments for current function. 558 if (LScopes.isCurrentFunctionScope(Scope)) 559 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i) 560 if (DbgVariable *ArgDV = CurrentFnArguments[i]) 561 if (DIE *Arg = 562 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) { 563 Children.push_back(Arg); 564 if (ArgDV->isObjectPointer()) ObjectPointer = Arg; 565 } 566 567 // Collect lexical scope children first. 568 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope); 569 for (unsigned i = 0, N = Variables.size(); i < N; ++i) 570 if (DIE *Variable = 571 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) { 572 Children.push_back(Variable); 573 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable; 574 } 575 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren(); 576 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) 577 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j])) 578 Children.push_back(Nested); 579 DIE *ScopeDIE = NULL; 580 if (Scope->getInlinedAt()) 581 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope); 582 else if (DS.isSubprogram()) { 583 ProcessedSPNodes.insert(DS); 584 if (Scope->isAbstractScope()) { 585 ScopeDIE = TheCU->getDIE(DS); 586 // Note down abstract DIE. 587 if (ScopeDIE) 588 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE)); 589 } 590 else 591 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS); 592 } 593 else { 594 // There is no need to emit empty lexical block DIE. 595 std::pair<ImportedEntityMap::const_iterator, 596 ImportedEntityMap::const_iterator> Range = std::equal_range( 597 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(), 598 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0), 599 less_first()); 600 if (Children.empty() && Range.first == Range.second) 601 return NULL; 602 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope); 603 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second; 604 ++i) 605 constructImportedEntityDIE(TheCU, i->second, ScopeDIE); 606 } 607 608 if (!ScopeDIE) { 609 std::for_each(Children.begin(), Children.end(), deleter<DIE>); 610 return NULL; 611 } 612 613 // Add children 614 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(), 615 E = Children.end(); I != E; ++I) 616 ScopeDIE->addChild(*I); 617 618 if (DS.isSubprogram() && ObjectPointer != NULL) 619 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, 620 dwarf::DW_FORM_ref4, ObjectPointer); 621 622 if (DS.isSubprogram()) 623 TheCU->addPubTypes(DISubprogram(DS)); 624 625 return ScopeDIE; 626} 627 628// Look up the source id with the given directory and source file names. 629// If none currently exists, create a new id and insert it in the 630// SourceIds map. This can update DirectoryNames and SourceFileNames maps 631// as well. 632unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, 633 StringRef DirName, unsigned CUID) { 634 // If we use .loc in assembly, we can't separate .file entries according to 635 // compile units. Thus all files will belong to the default compile unit. 636 if (Asm->TM.hasMCUseLoc() && 637 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) 638 CUID = 0; 639 640 // If FE did not provide a file name, then assume stdin. 641 if (FileName.empty()) 642 return getOrCreateSourceID("<stdin>", StringRef(), CUID); 643 644 // TODO: this might not belong here. See if we can factor this better. 645 if (DirName == CompilationDir) 646 DirName = ""; 647 648 // FileIDCUMap stores the current ID for the given compile unit. 649 unsigned SrcId = FileIDCUMap[CUID] + 1; 650 651 // We look up the CUID/file/dir by concatenating them with a zero byte. 652 SmallString<128> NamePair; 653 NamePair += utostr(CUID); 654 NamePair += '\0'; 655 NamePair += DirName; 656 NamePair += '\0'; // Zero bytes are not allowed in paths. 657 NamePair += FileName; 658 659 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId); 660 if (Ent.getValue() != SrcId) 661 return Ent.getValue(); 662 663 FileIDCUMap[CUID] = SrcId; 664 // Print out a .file directive to specify files for .loc directives. 665 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID); 666 667 return SrcId; 668} 669 670// Create new CompileUnit for the given metadata node with tag 671// DW_TAG_compile_unit. 672CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) { 673 DICompileUnit DIUnit(N); 674 StringRef FN = DIUnit.getFilename(); 675 CompilationDir = DIUnit.getDirectory(); 676 677 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 678 CompileUnit *NewCU = 679 new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &InfoHolder); 680 681 FileIDCUMap[NewCU->getUniqueID()] = 0; 682 // Call this to emit a .file directive if it wasn't emitted for the source 683 // file this CU comes from yet. 684 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID()); 685 686 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer()); 687 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2, 688 DIUnit.getLanguage()); 689 NewCU->addString(Die, dwarf::DW_AT_name, FN); 690 691 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point 692 // into an entity. We're using 0 (or a NULL label) for this. For 693 // split dwarf it's in the skeleton CU so omit it here. 694 if (!useSplitDwarf()) 695 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL); 696 697 // Define start line table label for each Compile Unit. 698 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start", 699 NewCU->getUniqueID()); 700 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym, 701 NewCU->getUniqueID()); 702 703 // Use a single line table if we are using .loc and generating assembly. 704 bool UseTheFirstCU = 705 (Asm->TM.hasMCUseLoc() && 706 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) || 707 (NewCU->getUniqueID() == 0); 708 709 // DW_AT_stmt_list is a offset of line number information for this 710 // compile unit in debug_line section. For split dwarf this is 711 // left in the skeleton CU and so not included. 712 // The line table entries are not always emitted in assembly, so it 713 // is not okay to use line_table_start here. 714 if (!useSplitDwarf()) { 715 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 716 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 717 UseTheFirstCU ? 718 Asm->GetTempSymbol("section_line") : LineTableStartSym); 719 else if (UseTheFirstCU) 720 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0); 721 else 722 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 723 LineTableStartSym, DwarfLineSectionSym); 724 } 725 726 // If we're using split dwarf the compilation dir is going to be in the 727 // skeleton CU and so we don't need to duplicate it here. 728 if (!useSplitDwarf() && !CompilationDir.empty()) 729 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir); 730 if (DIUnit.isOptimized()) 731 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized); 732 733 StringRef Flags = DIUnit.getFlags(); 734 if (!Flags.empty()) 735 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags); 736 737 if (unsigned RVer = DIUnit.getRunTimeVersion()) 738 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers, 739 dwarf::DW_FORM_data1, RVer); 740 741 if (!FirstCU) 742 FirstCU = NewCU; 743 744 InfoHolder.addUnit(NewCU); 745 746 CUMap.insert(std::make_pair(N, NewCU)); 747 return NewCU; 748} 749 750// Construct subprogram DIE. 751void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU, 752 const MDNode *N) { 753 CompileUnit *&CURef = SPMap[N]; 754 if (CURef) 755 return; 756 CURef = TheCU; 757 758 DISubprogram SP(N); 759 if (!SP.isDefinition()) 760 // This is a method declaration which will be handled while constructing 761 // class type. 762 return; 763 764 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP); 765 766 // Add to map. 767 TheCU->insertDIE(N, SubprogramDie); 768 769 // Add to context owner. 770 TheCU->addToContextOwner(SubprogramDie, SP.getContext()); 771 772 // Expose as global, if requested. 773 if (HasDwarfPubSections) 774 TheCU->addGlobalName(SP.getName(), SubprogramDie); 775} 776 777void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, 778 const MDNode *N) { 779 DIImportedEntity Module(N); 780 if (!Module.Verify()) 781 return; 782 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext())) 783 constructImportedEntityDIE(TheCU, Module, D); 784} 785 786void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N, 787 DIE *Context) { 788 DIImportedEntity Module(N); 789 if (!Module.Verify()) 790 return; 791 return constructImportedEntityDIE(TheCU, Module, Context); 792} 793 794void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, 795 const DIImportedEntity &Module, 796 DIE *Context) { 797 assert(Module.Verify() && 798 "Use one of the MDNode * overloads to handle invalid metadata"); 799 assert(Context && "Should always have a context for an imported_module"); 800 DIE *IMDie = new DIE(Module.getTag()); 801 TheCU->insertDIE(Module, IMDie); 802 DIE *EntityDie; 803 DIDescriptor Entity = Module.getEntity(); 804 if (Entity.isNameSpace()) 805 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity)); 806 else if (Entity.isSubprogram()) 807 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity)); 808 else if (Entity.isType()) 809 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity)); 810 else 811 EntityDie = TheCU->getDIE(Entity); 812 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(), 813 Module.getContext().getDirectory(), 814 TheCU->getUniqueID()); 815 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID); 816 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber()); 817 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4, 818 EntityDie); 819 StringRef Name = Module.getName(); 820 if (!Name.empty()) 821 TheCU->addString(IMDie, dwarf::DW_AT_name, Name); 822 Context->addChild(IMDie); 823} 824 825// Emit all Dwarf sections that should come prior to the content. Create 826// global DIEs and emit initial debug info sections. This is invoked by 827// the target AsmPrinter. 828void DwarfDebug::beginModule() { 829 if (DisableDebugInfoPrinting) 830 return; 831 832 const Module *M = MMI->getModule(); 833 834 // If module has named metadata anchors then use them, otherwise scan the 835 // module using debug info finder to collect debug info. 836 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu"); 837 if (!CU_Nodes) 838 return; 839 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes); 840 841 // Emit initial sections so we can reference labels later. 842 emitSectionLabels(); 843 844 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { 845 DICompileUnit CUNode(CU_Nodes->getOperand(i)); 846 CompileUnit *CU = constructCompileUnit(CUNode); 847 DIArray ImportedEntities = CUNode.getImportedEntities(); 848 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i) 849 ScopesWithImportedEntities.push_back(std::make_pair( 850 DIImportedEntity(ImportedEntities.getElement(i)).getContext(), 851 ImportedEntities.getElement(i))); 852 std::sort(ScopesWithImportedEntities.begin(), 853 ScopesWithImportedEntities.end(), less_first()); 854 DIArray GVs = CUNode.getGlobalVariables(); 855 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) 856 CU->createGlobalVariableDIE(GVs.getElement(i)); 857 DIArray SPs = CUNode.getSubprograms(); 858 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) 859 constructSubprogramDIE(CU, SPs.getElement(i)); 860 DIArray EnumTypes = CUNode.getEnumTypes(); 861 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i) 862 CU->getOrCreateTypeDIE(EnumTypes.getElement(i)); 863 DIArray RetainedTypes = CUNode.getRetainedTypes(); 864 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) 865 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i)); 866 // Emit imported_modules last so that the relevant context is already 867 // available. 868 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i) 869 constructImportedEntityDIE(CU, ImportedEntities.getElement(i)); 870 } 871 872 // Tell MMI that we have debug info. 873 MMI->setDebugInfoAvailability(true); 874 875 // Prime section data. 876 SectionMap.insert(Asm->getObjFileLowering().getTextSection()); 877} 878 879// Attach DW_AT_inline attribute with inlined subprogram DIEs. 880void DwarfDebug::computeInlinedDIEs() { 881 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 882 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(), 883 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) { 884 DIE *ISP = *AI; 885 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 886 } 887 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(), 888 AE = AbstractSPDies.end(); AI != AE; ++AI) { 889 DIE *ISP = AI->second; 890 if (InlinedSubprogramDIEs.count(ISP)) 891 continue; 892 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 893 } 894} 895 896// Collect info for variables that were optimized out. 897void DwarfDebug::collectDeadVariables() { 898 const Module *M = MMI->getModule(); 899 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap; 900 901 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) { 902 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { 903 DICompileUnit TheCU(CU_Nodes->getOperand(i)); 904 DIArray Subprograms = TheCU.getSubprograms(); 905 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) { 906 DISubprogram SP(Subprograms.getElement(i)); 907 if (ProcessedSPNodes.count(SP) != 0) continue; 908 if (!SP.isSubprogram()) continue; 909 if (!SP.isDefinition()) continue; 910 DIArray Variables = SP.getVariables(); 911 if (Variables.getNumElements() == 0) continue; 912 913 LexicalScope *Scope = 914 new LexicalScope(NULL, DIDescriptor(SP), NULL, false); 915 DeadFnScopeMap[SP] = Scope; 916 917 // Construct subprogram DIE and add variables DIEs. 918 CompileUnit *SPCU = CUMap.lookup(TheCU); 919 assert(SPCU && "Unable to find Compile Unit!"); 920 constructSubprogramDIE(SPCU, SP); 921 DIE *ScopeDIE = SPCU->getDIE(SP); 922 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) { 923 DIVariable DV(Variables.getElement(vi)); 924 if (!DV.isVariable()) continue; 925 DbgVariable NewVar(DV, NULL); 926 if (DIE *VariableDIE = 927 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope())) 928 ScopeDIE->addChild(VariableDIE); 929 } 930 } 931 } 932 } 933 DeleteContainerSeconds(DeadFnScopeMap); 934} 935 936// Type Signature [7.27] and ODR Hash code. 937 938/// \brief Grabs the string in whichever attribute is passed in and returns 939/// a reference to it. Returns "" if the attribute doesn't exist. 940static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) { 941 DIEValue *V = Die->findAttribute(Attr); 942 943 if (DIEString *S = dyn_cast_or_null<DIEString>(V)) 944 return S->getString(); 945 946 return StringRef(""); 947} 948 949/// Return true if the current DIE is contained within an anonymous namespace. 950static bool isContainedInAnonNamespace(DIE *Die) { 951 DIE *Parent = Die->getParent(); 952 953 while (Parent) { 954 if (Parent->getTag() == dwarf::DW_TAG_namespace && 955 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "") 956 return true; 957 Parent = Parent->getParent(); 958 } 959 960 return false; 961} 962 963/// Test if the current CU language is C++ and that we have 964/// a named type that is not contained in an anonymous namespace. 965static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) { 966 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus && 967 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" && 968 !isContainedInAnonNamespace(Die); 969} 970 971void DwarfDebug::finalizeModuleInfo() { 972 // Collect info for variables that were optimized out. 973 collectDeadVariables(); 974 975 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 976 computeInlinedDIEs(); 977 978 // Split out type units and conditionally add an ODR tag to the split 979 // out type. 980 // FIXME: Do type splitting. 981 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) { 982 DIE *Die = TypeUnits[i]; 983 DIEHash Hash; 984 // If we've requested ODR hashes and it's applicable for an ODR hash then 985 // add the ODR signature now. 986 // FIXME: This should be added onto the type unit, not the type, but this 987 // works as an intermediate stage. 988 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die)) 989 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature, 990 dwarf::DW_FORM_data8, 991 Hash.computeDIEODRSignature(Die)); 992 } 993 994 // Handle anything that needs to be done on a per-cu basis. 995 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(), 996 CUE = CUMap.end(); 997 CUI != CUE; ++CUI) { 998 CompileUnit *TheCU = CUI->second; 999 // Emit DW_AT_containing_type attribute to connect types with their 1000 // vtable holding type. 1001 TheCU->constructContainingTypeDIEs(); 1002 1003 // If we're splitting the dwarf out now that we've got the entire 1004 // CU then construct a skeleton CU based upon it. 1005 if (useSplitDwarf()) { 1006 uint64_t ID = 0; 1007 if (GenerateCUHash) { 1008 DIEHash CUHash; 1009 ID = CUHash.computeCUSignature(TheCU->getCUDie()); 1010 } 1011 // This should be a unique identifier when we want to build .dwp files. 1012 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id, 1013 dwarf::DW_FORM_data8, ID); 1014 // Now construct the skeleton CU associated. 1015 CompileUnit *SkCU = constructSkeletonCU(TheCU); 1016 // This should be a unique identifier when we want to build .dwp files. 1017 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id, 1018 dwarf::DW_FORM_data8, ID); 1019 } 1020 } 1021 1022 // Compute DIE offsets and sizes. 1023 InfoHolder.computeSizeAndOffsets(); 1024 if (useSplitDwarf()) 1025 SkeletonHolder.computeSizeAndOffsets(); 1026} 1027 1028void DwarfDebug::endSections() { 1029 // Standard sections final addresses. 1030 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 1031 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end")); 1032 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 1033 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end")); 1034 1035 // End text sections. 1036 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) { 1037 Asm->OutStreamer.SwitchSection(SectionMap[I]); 1038 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1)); 1039 } 1040} 1041 1042// Emit all Dwarf sections that should come after the content. 1043void DwarfDebug::endModule() { 1044 1045 if (!FirstCU) return; 1046 1047 // End any existing sections. 1048 // TODO: Does this need to happen? 1049 endSections(); 1050 1051 // Finalize the debug info for the module. 1052 finalizeModuleInfo(); 1053 1054 if (!useSplitDwarf()) { 1055 // Emit all the DIEs into a debug info section. 1056 emitDebugInfo(); 1057 1058 // Corresponding abbreviations into a abbrev section. 1059 emitAbbreviations(); 1060 1061 // Emit info into a debug loc section. 1062 emitDebugLoc(); 1063 1064 // Emit info into a debug aranges section. 1065 emitDebugARanges(); 1066 1067 // Emit info into a debug ranges section. 1068 emitDebugRanges(); 1069 1070 // Emit info into a debug macinfo section. 1071 emitDebugMacInfo(); 1072 1073 } else { 1074 // TODO: Fill this in for separated debug sections and separate 1075 // out information into new sections. 1076 1077 // Emit the debug info section and compile units. 1078 emitDebugInfo(); 1079 emitDebugInfoDWO(); 1080 1081 // Corresponding abbreviations into a abbrev section. 1082 emitAbbreviations(); 1083 emitDebugAbbrevDWO(); 1084 1085 // Emit info into a debug loc section. 1086 emitDebugLoc(); 1087 1088 // Emit info into a debug aranges section. 1089 emitDebugARanges(); 1090 1091 // Emit info into a debug ranges section. 1092 emitDebugRanges(); 1093 1094 // Emit info into a debug macinfo section. 1095 emitDebugMacInfo(); 1096 1097 // Emit DWO addresses. 1098 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection()); 1099 1100 } 1101 1102 // Emit info into the dwarf accelerator table sections. 1103 if (useDwarfAccelTables()) { 1104 emitAccelNames(); 1105 emitAccelObjC(); 1106 emitAccelNamespaces(); 1107 emitAccelTypes(); 1108 } 1109 1110 // Emit the pubnames and pubtypes sections if requested. 1111 if (HasDwarfPubSections) { 1112 emitDebugPubnames(); 1113 emitDebugPubTypes(); 1114 } 1115 1116 // Finally emit string information into a string table. 1117 emitDebugStr(); 1118 if (useSplitDwarf()) 1119 emitDebugStrDWO(); 1120 1121 // clean up. 1122 SPMap.clear(); 1123 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 1124 E = CUMap.end(); I != E; ++I) 1125 delete I->second; 1126 1127 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(), 1128 E = SkeletonCUs.end(); I != E; ++I) 1129 delete *I; 1130 1131 // Reset these for the next Module if we have one. 1132 FirstCU = NULL; 1133} 1134 1135// Find abstract variable, if any, associated with Var. 1136DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV, 1137 DebugLoc ScopeLoc) { 1138 LLVMContext &Ctx = DV->getContext(); 1139 // More then one inlined variable corresponds to one abstract variable. 1140 DIVariable Var = cleanseInlinedVariable(DV, Ctx); 1141 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var); 1142 if (AbsDbgVariable) 1143 return AbsDbgVariable; 1144 1145 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx)); 1146 if (!Scope) 1147 return NULL; 1148 1149 AbsDbgVariable = new DbgVariable(Var, NULL); 1150 addScopeVariable(Scope, AbsDbgVariable); 1151 AbstractVariables[Var] = AbsDbgVariable; 1152 return AbsDbgVariable; 1153} 1154 1155// If Var is a current function argument then add it to CurrentFnArguments list. 1156bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF, 1157 DbgVariable *Var, LexicalScope *Scope) { 1158 if (!LScopes.isCurrentFunctionScope(Scope)) 1159 return false; 1160 DIVariable DV = Var->getVariable(); 1161 if (DV.getTag() != dwarf::DW_TAG_arg_variable) 1162 return false; 1163 unsigned ArgNo = DV.getArgNumber(); 1164 if (ArgNo == 0) 1165 return false; 1166 1167 size_t Size = CurrentFnArguments.size(); 1168 if (Size == 0) 1169 CurrentFnArguments.resize(MF->getFunction()->arg_size()); 1170 // llvm::Function argument size is not good indicator of how many 1171 // arguments does the function have at source level. 1172 if (ArgNo > Size) 1173 CurrentFnArguments.resize(ArgNo * 2); 1174 CurrentFnArguments[ArgNo - 1] = Var; 1175 return true; 1176} 1177 1178// Collect variable information from side table maintained by MMI. 1179void 1180DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF, 1181 SmallPtrSet<const MDNode *, 16> &Processed) { 1182 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 1183 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 1184 VE = VMap.end(); VI != VE; ++VI) { 1185 const MDNode *Var = VI->first; 1186 if (!Var) continue; 1187 Processed.insert(Var); 1188 DIVariable DV(Var); 1189 const std::pair<unsigned, DebugLoc> &VP = VI->second; 1190 1191 LexicalScope *Scope = LScopes.findLexicalScope(VP.second); 1192 1193 // If variable scope is not found then skip this variable. 1194 if (Scope == 0) 1195 continue; 1196 1197 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second); 1198 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable); 1199 RegVar->setFrameIndex(VP.first); 1200 if (!addCurrentFnArgument(MF, RegVar, Scope)) 1201 addScopeVariable(Scope, RegVar); 1202 if (AbsDbgVariable) 1203 AbsDbgVariable->setFrameIndex(VP.first); 1204 } 1205} 1206 1207// Return true if debug value, encoded by DBG_VALUE instruction, is in a 1208// defined reg. 1209static bool isDbgValueInDefinedReg(const MachineInstr *MI) { 1210 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 1211 return MI->getNumOperands() == 3 && 1212 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() && 1213 (MI->getOperand(1).isImm() || 1214 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U)); 1215} 1216 1217// Get .debug_loc entry for the instruction range starting at MI. 1218static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm, 1219 const MCSymbol *FLabel, 1220 const MCSymbol *SLabel, 1221 const MachineInstr *MI) { 1222 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata(); 1223 1224 assert(MI->getNumOperands() == 3); 1225 if (MI->getOperand(0).isReg()) { 1226 MachineLocation MLoc; 1227 // If the second operand is an immediate, this is a 1228 // register-indirect address. 1229 if (!MI->getOperand(1).isImm()) 1230 MLoc.set(MI->getOperand(0).getReg()); 1231 else 1232 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm()); 1233 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var); 1234 } 1235 if (MI->getOperand(0).isImm()) 1236 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm()); 1237 if (MI->getOperand(0).isFPImm()) 1238 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm()); 1239 if (MI->getOperand(0).isCImm()) 1240 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm()); 1241 1242 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!"); 1243} 1244 1245// Find variables for each lexical scope. 1246void 1247DwarfDebug::collectVariableInfo(const MachineFunction *MF, 1248 SmallPtrSet<const MDNode *, 16> &Processed) { 1249 1250 // Grab the variable info that was squirreled away in the MMI side-table. 1251 collectVariableInfoFromMMITable(MF, Processed); 1252 1253 for (SmallVectorImpl<const MDNode*>::const_iterator 1254 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE; 1255 ++UVI) { 1256 const MDNode *Var = *UVI; 1257 if (Processed.count(Var)) 1258 continue; 1259 1260 // History contains relevant DBG_VALUE instructions for Var and instructions 1261 // clobbering it. 1262 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var]; 1263 if (History.empty()) 1264 continue; 1265 const MachineInstr *MInsn = History.front(); 1266 1267 DIVariable DV(Var); 1268 LexicalScope *Scope = NULL; 1269 if (DV.getTag() == dwarf::DW_TAG_arg_variable && 1270 DISubprogram(DV.getContext()).describes(MF->getFunction())) 1271 Scope = LScopes.getCurrentFunctionScope(); 1272 else if (MDNode *IA = DV.getInlinedAt()) 1273 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA)); 1274 else 1275 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1))); 1276 // If variable scope is not found then skip this variable. 1277 if (!Scope) 1278 continue; 1279 1280 Processed.insert(DV); 1281 assert(MInsn->isDebugValue() && "History must begin with debug value"); 1282 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc()); 1283 DbgVariable *RegVar = new DbgVariable(DV, AbsVar); 1284 if (!addCurrentFnArgument(MF, RegVar, Scope)) 1285 addScopeVariable(Scope, RegVar); 1286 if (AbsVar) 1287 AbsVar->setMInsn(MInsn); 1288 1289 // Simplify ranges that are fully coalesced. 1290 if (History.size() <= 1 || (History.size() == 2 && 1291 MInsn->isIdenticalTo(History.back()))) { 1292 RegVar->setMInsn(MInsn); 1293 continue; 1294 } 1295 1296 // Handle multiple DBG_VALUE instructions describing one variable. 1297 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size()); 1298 1299 for (SmallVectorImpl<const MachineInstr*>::const_iterator 1300 HI = History.begin(), HE = History.end(); HI != HE; ++HI) { 1301 const MachineInstr *Begin = *HI; 1302 assert(Begin->isDebugValue() && "Invalid History entry"); 1303 1304 // Check if DBG_VALUE is truncating a range. 1305 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() 1306 && !Begin->getOperand(0).getReg()) 1307 continue; 1308 1309 // Compute the range for a register location. 1310 const MCSymbol *FLabel = getLabelBeforeInsn(Begin); 1311 const MCSymbol *SLabel = 0; 1312 1313 if (HI + 1 == HE) 1314 // If Begin is the last instruction in History then its value is valid 1315 // until the end of the function. 1316 SLabel = FunctionEndSym; 1317 else { 1318 const MachineInstr *End = HI[1]; 1319 DEBUG(dbgs() << "DotDebugLoc Pair:\n" 1320 << "\t" << *Begin << "\t" << *End << "\n"); 1321 if (End->isDebugValue()) 1322 SLabel = getLabelBeforeInsn(End); 1323 else { 1324 // End is a normal instruction clobbering the range. 1325 SLabel = getLabelAfterInsn(End); 1326 assert(SLabel && "Forgot label after clobber instruction"); 1327 ++HI; 1328 } 1329 } 1330 1331 // The value is valid until the next DBG_VALUE or clobber. 1332 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, 1333 Begin)); 1334 } 1335 DotDebugLocEntries.push_back(DotDebugLocEntry()); 1336 } 1337 1338 // Collect info for variables that were optimized out. 1339 LexicalScope *FnScope = LScopes.getCurrentFunctionScope(); 1340 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables(); 1341 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) { 1342 DIVariable DV(Variables.getElement(i)); 1343 if (!DV || !DV.isVariable() || !Processed.insert(DV)) 1344 continue; 1345 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext())) 1346 addScopeVariable(Scope, new DbgVariable(DV, NULL)); 1347 } 1348} 1349 1350// Return Label preceding the instruction. 1351MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) { 1352 MCSymbol *Label = LabelsBeforeInsn.lookup(MI); 1353 assert(Label && "Didn't insert label before instruction"); 1354 return Label; 1355} 1356 1357// Return Label immediately following the instruction. 1358MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) { 1359 return LabelsAfterInsn.lookup(MI); 1360} 1361 1362// Process beginning of an instruction. 1363void DwarfDebug::beginInstruction(const MachineInstr *MI) { 1364 // Check if source location changes, but ignore DBG_VALUE locations. 1365 if (!MI->isDebugValue()) { 1366 DebugLoc DL = MI->getDebugLoc(); 1367 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) { 1368 unsigned Flags = 0; 1369 PrevInstLoc = DL; 1370 if (DL == PrologEndLoc) { 1371 Flags |= DWARF2_FLAG_PROLOGUE_END; 1372 PrologEndLoc = DebugLoc(); 1373 } 1374 if (PrologEndLoc.isUnknown()) 1375 Flags |= DWARF2_FLAG_IS_STMT; 1376 1377 if (!DL.isUnknown()) { 1378 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext()); 1379 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags); 1380 } else 1381 recordSourceLine(0, 0, 0, 0); 1382 } 1383 } 1384 1385 // Insert labels where requested. 1386 DenseMap<const MachineInstr*, MCSymbol*>::iterator I = 1387 LabelsBeforeInsn.find(MI); 1388 1389 // No label needed. 1390 if (I == LabelsBeforeInsn.end()) 1391 return; 1392 1393 // Label already assigned. 1394 if (I->second) 1395 return; 1396 1397 if (!PrevLabel) { 1398 PrevLabel = MMI->getContext().CreateTempSymbol(); 1399 Asm->OutStreamer.EmitLabel(PrevLabel); 1400 } 1401 I->second = PrevLabel; 1402} 1403 1404// Process end of an instruction. 1405void DwarfDebug::endInstruction(const MachineInstr *MI) { 1406 // Don't create a new label after DBG_VALUE instructions. 1407 // They don't generate code. 1408 if (!MI->isDebugValue()) 1409 PrevLabel = 0; 1410 1411 DenseMap<const MachineInstr*, MCSymbol*>::iterator I = 1412 LabelsAfterInsn.find(MI); 1413 1414 // No label needed. 1415 if (I == LabelsAfterInsn.end()) 1416 return; 1417 1418 // Label already assigned. 1419 if (I->second) 1420 return; 1421 1422 // We need a label after this instruction. 1423 if (!PrevLabel) { 1424 PrevLabel = MMI->getContext().CreateTempSymbol(); 1425 Asm->OutStreamer.EmitLabel(PrevLabel); 1426 } 1427 I->second = PrevLabel; 1428} 1429 1430// Each LexicalScope has first instruction and last instruction to mark 1431// beginning and end of a scope respectively. Create an inverse map that list 1432// scopes starts (and ends) with an instruction. One instruction may start (or 1433// end) multiple scopes. Ignore scopes that are not reachable. 1434void DwarfDebug::identifyScopeMarkers() { 1435 SmallVector<LexicalScope *, 4> WorkList; 1436 WorkList.push_back(LScopes.getCurrentFunctionScope()); 1437 while (!WorkList.empty()) { 1438 LexicalScope *S = WorkList.pop_back_val(); 1439 1440 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren(); 1441 if (!Children.empty()) 1442 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(), 1443 SE = Children.end(); SI != SE; ++SI) 1444 WorkList.push_back(*SI); 1445 1446 if (S->isAbstractScope()) 1447 continue; 1448 1449 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges(); 1450 if (Ranges.empty()) 1451 continue; 1452 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(), 1453 RE = Ranges.end(); RI != RE; ++RI) { 1454 assert(RI->first && "InsnRange does not have first instruction!"); 1455 assert(RI->second && "InsnRange does not have second instruction!"); 1456 requestLabelBeforeInsn(RI->first); 1457 requestLabelAfterInsn(RI->second); 1458 } 1459 } 1460} 1461 1462// Get MDNode for DebugLoc's scope. 1463static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) { 1464 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx)) 1465 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx); 1466 return DL.getScope(Ctx); 1467} 1468 1469// Walk up the scope chain of given debug loc and find line number info 1470// for the function. 1471static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) { 1472 const MDNode *Scope = getScopeNode(DL, Ctx); 1473 DISubprogram SP = getDISubprogram(Scope); 1474 if (SP.isSubprogram()) { 1475 // Check for number of operands since the compatibility is 1476 // cheap here. 1477 if (SP->getNumOperands() > 19) 1478 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP); 1479 else 1480 return DebugLoc::get(SP.getLineNumber(), 0, SP); 1481 } 1482 1483 return DebugLoc(); 1484} 1485 1486// Gather pre-function debug information. Assumes being called immediately 1487// after the function entry point has been emitted. 1488void DwarfDebug::beginFunction(const MachineFunction *MF) { 1489 if (!MMI->hasDebugInfo()) return; 1490 LScopes.initialize(*MF); 1491 if (LScopes.empty()) return; 1492 identifyScopeMarkers(); 1493 1494 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function 1495 // belongs to. 1496 LexicalScope *FnScope = LScopes.getCurrentFunctionScope(); 1497 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode()); 1498 assert(TheCU && "Unable to find compile unit!"); 1499 if (Asm->TM.hasMCUseLoc() && 1500 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) 1501 // Use a single line table if we are using .loc and generating assembly. 1502 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0); 1503 else 1504 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID()); 1505 1506 FunctionBeginSym = Asm->GetTempSymbol("func_begin", 1507 Asm->getFunctionNumber()); 1508 // Assumes in correct section after the entry point. 1509 Asm->OutStreamer.EmitLabel(FunctionBeginSym); 1510 1511 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned"); 1512 1513 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 1514 // LiveUserVar - Map physreg numbers to the MDNode they contain. 1515 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs()); 1516 1517 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 1518 I != E; ++I) { 1519 bool AtBlockEntry = true; 1520 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 1521 II != IE; ++II) { 1522 const MachineInstr *MI = II; 1523 1524 if (MI->isDebugValue()) { 1525 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!"); 1526 1527 // Keep track of user variables. 1528 const MDNode *Var = 1529 MI->getOperand(MI->getNumOperands() - 1).getMetadata(); 1530 1531 // Variable is in a register, we need to check for clobbers. 1532 if (isDbgValueInDefinedReg(MI)) 1533 LiveUserVar[MI->getOperand(0).getReg()] = Var; 1534 1535 // Check the history of this variable. 1536 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var]; 1537 if (History.empty()) { 1538 UserVariables.push_back(Var); 1539 // The first mention of a function argument gets the FunctionBeginSym 1540 // label, so arguments are visible when breaking at function entry. 1541 DIVariable DV(Var); 1542 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable && 1543 DISubprogram(getDISubprogram(DV.getContext())) 1544 .describes(MF->getFunction())) 1545 LabelsBeforeInsn[MI] = FunctionBeginSym; 1546 } else { 1547 // We have seen this variable before. Try to coalesce DBG_VALUEs. 1548 const MachineInstr *Prev = History.back(); 1549 if (Prev->isDebugValue()) { 1550 // Coalesce identical entries at the end of History. 1551 if (History.size() >= 2 && 1552 Prev->isIdenticalTo(History[History.size() - 2])) { 1553 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n" 1554 << "\t" << *Prev 1555 << "\t" << *History[History.size() - 2] << "\n"); 1556 History.pop_back(); 1557 } 1558 1559 // Terminate old register assignments that don't reach MI; 1560 MachineFunction::const_iterator PrevMBB = Prev->getParent(); 1561 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) && 1562 isDbgValueInDefinedReg(Prev)) { 1563 // Previous register assignment needs to terminate at the end of 1564 // its basic block. 1565 MachineBasicBlock::const_iterator LastMI = 1566 PrevMBB->getLastNonDebugInstr(); 1567 if (LastMI == PrevMBB->end()) { 1568 // Drop DBG_VALUE for empty range. 1569 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n" 1570 << "\t" << *Prev << "\n"); 1571 History.pop_back(); 1572 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end()) 1573 // Terminate after LastMI. 1574 History.push_back(LastMI); 1575 } 1576 } 1577 } 1578 History.push_back(MI); 1579 } else { 1580 // Not a DBG_VALUE instruction. 1581 if (!MI->isLabel()) 1582 AtBlockEntry = false; 1583 1584 // First known non-DBG_VALUE and non-frame setup location marks 1585 // the beginning of the function body. 1586 if (!MI->getFlag(MachineInstr::FrameSetup) && 1587 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())) 1588 PrologEndLoc = MI->getDebugLoc(); 1589 1590 // Check if the instruction clobbers any registers with debug vars. 1591 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(), 1592 MOE = MI->operands_end(); MOI != MOE; ++MOI) { 1593 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg()) 1594 continue; 1595 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); 1596 AI.isValid(); ++AI) { 1597 unsigned Reg = *AI; 1598 const MDNode *Var = LiveUserVar[Reg]; 1599 if (!Var) 1600 continue; 1601 // Reg is now clobbered. 1602 LiveUserVar[Reg] = 0; 1603 1604 // Was MD last defined by a DBG_VALUE referring to Reg? 1605 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var); 1606 if (HistI == DbgValues.end()) 1607 continue; 1608 SmallVectorImpl<const MachineInstr*> &History = HistI->second; 1609 if (History.empty()) 1610 continue; 1611 const MachineInstr *Prev = History.back(); 1612 // Sanity-check: Register assignments are terminated at the end of 1613 // their block. 1614 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent()) 1615 continue; 1616 // Is the variable still in Reg? 1617 if (!isDbgValueInDefinedReg(Prev) || 1618 Prev->getOperand(0).getReg() != Reg) 1619 continue; 1620 // Var is clobbered. Make sure the next instruction gets a label. 1621 History.push_back(MI); 1622 } 1623 } 1624 } 1625 } 1626 } 1627 1628 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end(); 1629 I != E; ++I) { 1630 SmallVectorImpl<const MachineInstr*> &History = I->second; 1631 if (History.empty()) 1632 continue; 1633 1634 // Make sure the final register assignments are terminated. 1635 const MachineInstr *Prev = History.back(); 1636 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) { 1637 const MachineBasicBlock *PrevMBB = Prev->getParent(); 1638 MachineBasicBlock::const_iterator LastMI = 1639 PrevMBB->getLastNonDebugInstr(); 1640 if (LastMI == PrevMBB->end()) 1641 // Drop DBG_VALUE for empty range. 1642 History.pop_back(); 1643 else if (PrevMBB != &PrevMBB->getParent()->back()) { 1644 // Terminate after LastMI. 1645 History.push_back(LastMI); 1646 } 1647 } 1648 // Request labels for the full history. 1649 for (unsigned i = 0, e = History.size(); i != e; ++i) { 1650 const MachineInstr *MI = History[i]; 1651 if (MI->isDebugValue()) 1652 requestLabelBeforeInsn(MI); 1653 else 1654 requestLabelAfterInsn(MI); 1655 } 1656 } 1657 1658 PrevInstLoc = DebugLoc(); 1659 PrevLabel = FunctionBeginSym; 1660 1661 // Record beginning of function. 1662 if (!PrologEndLoc.isUnknown()) { 1663 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc, 1664 MF->getFunction()->getContext()); 1665 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(), 1666 FnStartDL.getScope(MF->getFunction()->getContext()), 1667 // We'd like to list the prologue as "not statements" but GDB behaves 1668 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing. 1669 DWARF2_FLAG_IS_STMT); 1670 } 1671} 1672 1673void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) { 1674 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS]; 1675 DIVariable DV = Var->getVariable(); 1676 // Variables with positive arg numbers are parameters. 1677 if (unsigned ArgNum = DV.getArgNumber()) { 1678 // Keep all parameters in order at the start of the variable list to ensure 1679 // function types are correct (no out-of-order parameters) 1680 // 1681 // This could be improved by only doing it for optimized builds (unoptimized 1682 // builds have the right order to begin with), searching from the back (this 1683 // would catch the unoptimized case quickly), or doing a binary search 1684 // rather than linear search. 1685 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin(); 1686 while (I != Vars.end()) { 1687 unsigned CurNum = (*I)->getVariable().getArgNumber(); 1688 // A local (non-parameter) variable has been found, insert immediately 1689 // before it. 1690 if (CurNum == 0) 1691 break; 1692 // A later indexed parameter has been found, insert immediately before it. 1693 if (CurNum > ArgNum) 1694 break; 1695 ++I; 1696 } 1697 Vars.insert(I, Var); 1698 return; 1699 } 1700 1701 Vars.push_back(Var); 1702} 1703 1704// Gather and emit post-function debug information. 1705void DwarfDebug::endFunction(const MachineFunction *MF) { 1706 if (!MMI->hasDebugInfo() || LScopes.empty()) return; 1707 1708 // Define end label for subprogram. 1709 FunctionEndSym = Asm->GetTempSymbol("func_end", 1710 Asm->getFunctionNumber()); 1711 // Assumes in correct section after the entry point. 1712 Asm->OutStreamer.EmitLabel(FunctionEndSym); 1713 // Set DwarfCompileUnitID in MCContext to default value. 1714 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0); 1715 1716 SmallPtrSet<const MDNode *, 16> ProcessedVars; 1717 collectVariableInfo(MF, ProcessedVars); 1718 1719 LexicalScope *FnScope = LScopes.getCurrentFunctionScope(); 1720 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode()); 1721 assert(TheCU && "Unable to find compile unit!"); 1722 1723 // Construct abstract scopes. 1724 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList(); 1725 for (unsigned i = 0, e = AList.size(); i != e; ++i) { 1726 LexicalScope *AScope = AList[i]; 1727 DISubprogram SP(AScope->getScopeNode()); 1728 if (SP.isSubprogram()) { 1729 // Collect info for variables that were optimized out. 1730 DIArray Variables = SP.getVariables(); 1731 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) { 1732 DIVariable DV(Variables.getElement(i)); 1733 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV)) 1734 continue; 1735 // Check that DbgVariable for DV wasn't created earlier, when 1736 // findAbstractVariable() was called for inlined instance of DV. 1737 LLVMContext &Ctx = DV->getContext(); 1738 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx); 1739 if (AbstractVariables.lookup(CleanDV)) 1740 continue; 1741 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext())) 1742 addScopeVariable(Scope, new DbgVariable(DV, NULL)); 1743 } 1744 } 1745 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0) 1746 constructScopeDIE(TheCU, AScope); 1747 } 1748 1749 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope); 1750 1751 if (!MF->getTarget().Options.DisableFramePointerElim(*MF)) 1752 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr); 1753 1754 // Clear debug info 1755 for (ScopeVariablesMap::iterator 1756 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I) 1757 DeleteContainerPointers(I->second); 1758 ScopeVariables.clear(); 1759 DeleteContainerPointers(CurrentFnArguments); 1760 UserVariables.clear(); 1761 DbgValues.clear(); 1762 AbstractVariables.clear(); 1763 LabelsBeforeInsn.clear(); 1764 LabelsAfterInsn.clear(); 1765 PrevLabel = NULL; 1766} 1767 1768// Register a source line with debug info. Returns the unique label that was 1769// emitted and which provides correspondence to the source line list. 1770void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S, 1771 unsigned Flags) { 1772 StringRef Fn; 1773 StringRef Dir; 1774 unsigned Src = 1; 1775 if (S) { 1776 DIDescriptor Scope(S); 1777 1778 if (Scope.isCompileUnit()) { 1779 DICompileUnit CU(S); 1780 Fn = CU.getFilename(); 1781 Dir = CU.getDirectory(); 1782 } else if (Scope.isFile()) { 1783 DIFile F(S); 1784 Fn = F.getFilename(); 1785 Dir = F.getDirectory(); 1786 } else if (Scope.isSubprogram()) { 1787 DISubprogram SP(S); 1788 Fn = SP.getFilename(); 1789 Dir = SP.getDirectory(); 1790 } else if (Scope.isLexicalBlockFile()) { 1791 DILexicalBlockFile DBF(S); 1792 Fn = DBF.getFilename(); 1793 Dir = DBF.getDirectory(); 1794 } else if (Scope.isLexicalBlock()) { 1795 DILexicalBlock DB(S); 1796 Fn = DB.getFilename(); 1797 Dir = DB.getDirectory(); 1798 } else 1799 llvm_unreachable("Unexpected scope info"); 1800 1801 Src = getOrCreateSourceID(Fn, Dir, 1802 Asm->OutStreamer.getContext().getDwarfCompileUnitID()); 1803 } 1804 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn); 1805} 1806 1807//===----------------------------------------------------------------------===// 1808// Emit Methods 1809//===----------------------------------------------------------------------===// 1810 1811// Compute the size and offset of a DIE. 1812unsigned 1813DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) { 1814 // Get the children. 1815 const std::vector<DIE *> &Children = Die->getChildren(); 1816 1817 // Record the abbreviation. 1818 assignAbbrevNumber(Die->getAbbrev()); 1819 1820 // Get the abbreviation for this DIE. 1821 unsigned AbbrevNumber = Die->getAbbrevNumber(); 1822 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1); 1823 1824 // Set DIE offset 1825 Die->setOffset(Offset); 1826 1827 // Start the size with the size of abbreviation code. 1828 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 1829 1830 const SmallVectorImpl<DIEValue*> &Values = Die->getValues(); 1831 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData(); 1832 1833 // Size the DIE attribute values. 1834 for (unsigned i = 0, N = Values.size(); i < N; ++i) 1835 // Size attribute value. 1836 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm()); 1837 1838 // Size the DIE children if any. 1839 if (!Children.empty()) { 1840 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 1841 "Children flag not set"); 1842 1843 for (unsigned j = 0, M = Children.size(); j < M; ++j) 1844 Offset = computeSizeAndOffset(Children[j], Offset); 1845 1846 // End of children marker. 1847 Offset += sizeof(int8_t); 1848 } 1849 1850 Die->setSize(Offset - Die->getOffset()); 1851 return Offset; 1852} 1853 1854// Compute the size and offset of all the DIEs. 1855void DwarfUnits::computeSizeAndOffsets() { 1856 // Offset from the beginning of debug info section. 1857 unsigned SecOffset = 0; 1858 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), 1859 E = CUs.end(); I != E; ++I) { 1860 (*I)->setDebugInfoOffset(SecOffset); 1861 unsigned Offset = 1862 sizeof(int32_t) + // Length of Compilation Unit Info 1863 sizeof(int16_t) + // DWARF version number 1864 sizeof(int32_t) + // Offset Into Abbrev. Section 1865 sizeof(int8_t); // Pointer Size (in bytes) 1866 1867 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset); 1868 SecOffset += EndOffset; 1869 } 1870} 1871 1872// Emit initial Dwarf sections with a label at the start of each one. 1873void DwarfDebug::emitSectionLabels() { 1874 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 1875 1876 // Dwarf sections base addresses. 1877 DwarfInfoSectionSym = 1878 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info"); 1879 DwarfAbbrevSectionSym = 1880 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev"); 1881 if (useSplitDwarf()) 1882 DwarfAbbrevDWOSectionSym = 1883 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(), 1884 "section_abbrev_dwo"); 1885 emitSectionSym(Asm, TLOF.getDwarfARangesSection()); 1886 1887 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection()) 1888 emitSectionSym(Asm, MacroInfo); 1889 1890 DwarfLineSectionSym = 1891 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line"); 1892 emitSectionSym(Asm, TLOF.getDwarfLocSection()); 1893 if (HasDwarfPubSections) { 1894 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection()); 1895 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection()); 1896 } 1897 DwarfStrSectionSym = 1898 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string"); 1899 if (useSplitDwarf()) { 1900 DwarfStrDWOSectionSym = 1901 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string"); 1902 DwarfAddrSectionSym = 1903 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec"); 1904 } 1905 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(), 1906 "debug_range"); 1907 1908 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(), 1909 "section_debug_loc"); 1910 1911 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin"); 1912 emitSectionSym(Asm, TLOF.getDataSection()); 1913} 1914 1915// Recursively emits a debug information entry. 1916void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) { 1917 // Get the abbreviation for this DIE. 1918 unsigned AbbrevNumber = Die->getAbbrevNumber(); 1919 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1); 1920 1921 // Emit the code (index) for the abbreviation. 1922 if (Asm->isVerbose()) 1923 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 1924 Twine::utohexstr(Die->getOffset()) + ":0x" + 1925 Twine::utohexstr(Die->getSize()) + " " + 1926 dwarf::TagString(Abbrev->getTag())); 1927 Asm->EmitULEB128(AbbrevNumber); 1928 1929 const SmallVectorImpl<DIEValue*> &Values = Die->getValues(); 1930 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData(); 1931 1932 // Emit the DIE attribute values. 1933 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 1934 unsigned Attr = AbbrevData[i].getAttribute(); 1935 unsigned Form = AbbrevData[i].getForm(); 1936 assert(Form && "Too many attributes for DIE (check abbreviation)"); 1937 1938 if (Asm->isVerbose()) 1939 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 1940 1941 switch (Attr) { 1942 case dwarf::DW_AT_abstract_origin: { 1943 DIEEntry *E = cast<DIEEntry>(Values[i]); 1944 DIE *Origin = E->getEntry(); 1945 unsigned Addr = Origin->getOffset(); 1946 if (Form == dwarf::DW_FORM_ref_addr) { 1947 // For DW_FORM_ref_addr, output the offset from beginning of debug info 1948 // section. Origin->getOffset() returns the offset from start of the 1949 // compile unit. 1950 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; 1951 Addr += Holder.getCUOffset(Origin->getCompileUnit()); 1952 } 1953 Asm->OutStreamer.EmitIntValue(Addr, 1954 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4); 1955 break; 1956 } 1957 case dwarf::DW_AT_ranges: { 1958 // DW_AT_range Value encodes offset in debug_range section. 1959 DIEInteger *V = cast<DIEInteger>(Values[i]); 1960 1961 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) { 1962 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym, 1963 V->getValue(), 1964 4); 1965 } else { 1966 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym, 1967 V->getValue(), 1968 DwarfDebugRangeSectionSym, 1969 4); 1970 } 1971 break; 1972 } 1973 case dwarf::DW_AT_location: { 1974 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) { 1975 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 1976 Asm->EmitLabelReference(L->getValue(), 4); 1977 else 1978 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4); 1979 } else { 1980 Values[i]->EmitValue(Asm, Form); 1981 } 1982 break; 1983 } 1984 case dwarf::DW_AT_accessibility: { 1985 if (Asm->isVerbose()) { 1986 DIEInteger *V = cast<DIEInteger>(Values[i]); 1987 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue())); 1988 } 1989 Values[i]->EmitValue(Asm, Form); 1990 break; 1991 } 1992 default: 1993 // Emit an attribute using the defined form. 1994 Values[i]->EmitValue(Asm, Form); 1995 break; 1996 } 1997 } 1998 1999 // Emit the DIE children if any. 2000 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 2001 const std::vector<DIE *> &Children = Die->getChildren(); 2002 2003 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2004 emitDIE(Children[j], Abbrevs); 2005 2006 if (Asm->isVerbose()) 2007 Asm->OutStreamer.AddComment("End Of Children Mark"); 2008 Asm->EmitInt8(0); 2009 } 2010} 2011 2012// Emit the various dwarf units to the unit section USection with 2013// the abbreviations going into ASection. 2014void DwarfUnits::emitUnits(DwarfDebug *DD, 2015 const MCSection *USection, 2016 const MCSection *ASection, 2017 const MCSymbol *ASectionSym) { 2018 Asm->OutStreamer.SwitchSection(USection); 2019 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), 2020 E = CUs.end(); I != E; ++I) { 2021 CompileUnit *TheCU = *I; 2022 DIE *Die = TheCU->getCUDie(); 2023 2024 // Emit the compile units header. 2025 Asm->OutStreamer 2026 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(), 2027 TheCU->getUniqueID())); 2028 2029 // Emit size of content not including length itself 2030 unsigned ContentSize = Die->getSize() + 2031 sizeof(int16_t) + // DWARF version number 2032 sizeof(int32_t) + // Offset Into Abbrev. Section 2033 sizeof(int8_t); // Pointer Size (in bytes) 2034 2035 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 2036 Asm->EmitInt32(ContentSize); 2037 Asm->OutStreamer.AddComment("DWARF version number"); 2038 Asm->EmitInt16(DD->getDwarfVersion()); 2039 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 2040 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()), 2041 ASectionSym); 2042 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 2043 Asm->EmitInt8(Asm->getDataLayout().getPointerSize()); 2044 2045 DD->emitDIE(Die, Abbreviations); 2046 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(), 2047 TheCU->getUniqueID())); 2048 } 2049} 2050 2051/// For a given compile unit DIE, returns offset from beginning of debug info. 2052unsigned DwarfUnits::getCUOffset(DIE *Die) { 2053 assert(Die->getTag() == dwarf::DW_TAG_compile_unit && 2054 "Input DIE should be compile unit in getCUOffset."); 2055 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end(); 2056 I != E; ++I) { 2057 CompileUnit *TheCU = *I; 2058 if (TheCU->getCUDie() == Die) 2059 return TheCU->getDebugInfoOffset(); 2060 } 2061 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits."); 2062} 2063 2064// Emit the debug info section. 2065void DwarfDebug::emitDebugInfo() { 2066 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; 2067 2068 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(), 2069 Asm->getObjFileLowering().getDwarfAbbrevSection(), 2070 DwarfAbbrevSectionSym); 2071} 2072 2073// Emit the abbreviation section. 2074void DwarfDebug::emitAbbreviations() { 2075 if (!useSplitDwarf()) 2076 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(), 2077 &Abbreviations); 2078 else 2079 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection()); 2080} 2081 2082void DwarfDebug::emitAbbrevs(const MCSection *Section, 2083 std::vector<DIEAbbrev *> *Abbrevs) { 2084 // Check to see if it is worth the effort. 2085 if (!Abbrevs->empty()) { 2086 // Start the debug abbrev section. 2087 Asm->OutStreamer.SwitchSection(Section); 2088 2089 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName()); 2090 Asm->OutStreamer.EmitLabel(Begin); 2091 2092 // For each abbrevation. 2093 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) { 2094 // Get abbreviation data 2095 const DIEAbbrev *Abbrev = Abbrevs->at(i); 2096 2097 // Emit the abbrevations code (base 1 index.) 2098 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 2099 2100 // Emit the abbreviations data. 2101 Abbrev->Emit(Asm); 2102 } 2103 2104 // Mark end of abbreviations. 2105 Asm->EmitULEB128(0, "EOM(3)"); 2106 2107 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName()); 2108 Asm->OutStreamer.EmitLabel(End); 2109 } 2110} 2111 2112// Emit the last address of the section and the end of the line matrix. 2113void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 2114 // Define last address of section. 2115 Asm->OutStreamer.AddComment("Extended Op"); 2116 Asm->EmitInt8(0); 2117 2118 Asm->OutStreamer.AddComment("Op size"); 2119 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1); 2120 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 2121 Asm->EmitInt8(dwarf::DW_LNE_set_address); 2122 2123 Asm->OutStreamer.AddComment("Section end label"); 2124 2125 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd), 2126 Asm->getDataLayout().getPointerSize()); 2127 2128 // Mark end of matrix. 2129 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 2130 Asm->EmitInt8(0); 2131 Asm->EmitInt8(1); 2132 Asm->EmitInt8(1); 2133} 2134 2135// Emit visible names into a hashed accelerator table section. 2136void DwarfDebug::emitAccelNames() { 2137 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, 2138 dwarf::DW_FORM_data4)); 2139 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2140 E = CUMap.end(); I != E; ++I) { 2141 CompileUnit *TheCU = I->second; 2142 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames(); 2143 for (StringMap<std::vector<DIE*> >::const_iterator 2144 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2145 StringRef Name = GI->getKey(); 2146 const std::vector<DIE *> &Entities = GI->second; 2147 for (std::vector<DIE *>::const_iterator DI = Entities.begin(), 2148 DE = Entities.end(); DI != DE; ++DI) 2149 AT.AddName(Name, (*DI)); 2150 } 2151 } 2152 2153 AT.FinalizeTable(Asm, "Names"); 2154 Asm->OutStreamer.SwitchSection( 2155 Asm->getObjFileLowering().getDwarfAccelNamesSection()); 2156 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin"); 2157 Asm->OutStreamer.EmitLabel(SectionBegin); 2158 2159 // Emit the full data. 2160 AT.Emit(Asm, SectionBegin, &InfoHolder); 2161} 2162 2163// Emit objective C classes and categories into a hashed accelerator table 2164// section. 2165void DwarfDebug::emitAccelObjC() { 2166 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, 2167 dwarf::DW_FORM_data4)); 2168 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2169 E = CUMap.end(); I != E; ++I) { 2170 CompileUnit *TheCU = I->second; 2171 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC(); 2172 for (StringMap<std::vector<DIE*> >::const_iterator 2173 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2174 StringRef Name = GI->getKey(); 2175 const std::vector<DIE *> &Entities = GI->second; 2176 for (std::vector<DIE *>::const_iterator DI = Entities.begin(), 2177 DE = Entities.end(); DI != DE; ++DI) 2178 AT.AddName(Name, (*DI)); 2179 } 2180 } 2181 2182 AT.FinalizeTable(Asm, "ObjC"); 2183 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering() 2184 .getDwarfAccelObjCSection()); 2185 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin"); 2186 Asm->OutStreamer.EmitLabel(SectionBegin); 2187 2188 // Emit the full data. 2189 AT.Emit(Asm, SectionBegin, &InfoHolder); 2190} 2191 2192// Emit namespace dies into a hashed accelerator table. 2193void DwarfDebug::emitAccelNamespaces() { 2194 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, 2195 dwarf::DW_FORM_data4)); 2196 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2197 E = CUMap.end(); I != E; ++I) { 2198 CompileUnit *TheCU = I->second; 2199 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace(); 2200 for (StringMap<std::vector<DIE*> >::const_iterator 2201 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2202 StringRef Name = GI->getKey(); 2203 const std::vector<DIE *> &Entities = GI->second; 2204 for (std::vector<DIE *>::const_iterator DI = Entities.begin(), 2205 DE = Entities.end(); DI != DE; ++DI) 2206 AT.AddName(Name, (*DI)); 2207 } 2208 } 2209 2210 AT.FinalizeTable(Asm, "namespac"); 2211 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering() 2212 .getDwarfAccelNamespaceSection()); 2213 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin"); 2214 Asm->OutStreamer.EmitLabel(SectionBegin); 2215 2216 // Emit the full data. 2217 AT.Emit(Asm, SectionBegin, &InfoHolder); 2218} 2219 2220// Emit type dies into a hashed accelerator table. 2221void DwarfDebug::emitAccelTypes() { 2222 std::vector<DwarfAccelTable::Atom> Atoms; 2223 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, 2224 dwarf::DW_FORM_data4)); 2225 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, 2226 dwarf::DW_FORM_data2)); 2227 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, 2228 dwarf::DW_FORM_data1)); 2229 DwarfAccelTable AT(Atoms); 2230 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2231 E = CUMap.end(); I != E; ++I) { 2232 CompileUnit *TheCU = I->second; 2233 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names 2234 = TheCU->getAccelTypes(); 2235 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator 2236 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2237 StringRef Name = GI->getKey(); 2238 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second; 2239 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI 2240 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI) 2241 AT.AddName(Name, (*DI).first, (*DI).second); 2242 } 2243 } 2244 2245 AT.FinalizeTable(Asm, "types"); 2246 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering() 2247 .getDwarfAccelTypesSection()); 2248 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin"); 2249 Asm->OutStreamer.EmitLabel(SectionBegin); 2250 2251 // Emit the full data. 2252 AT.Emit(Asm, SectionBegin, &InfoHolder); 2253} 2254 2255/// emitDebugPubnames - Emit visible names into a debug pubnames section. 2256/// 2257void DwarfDebug::emitDebugPubnames() { 2258 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection(); 2259 2260 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType; 2261 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) { 2262 CompileUnit *TheCU = I->second; 2263 unsigned ID = TheCU->getUniqueID(); 2264 2265 if (TheCU->getGlobalNames().empty()) 2266 continue; 2267 2268 // Start the dwarf pubnames section. 2269 Asm->OutStreamer 2270 .SwitchSection(Asm->getObjFileLowering().getDwarfPubNamesSection()); 2271 2272 Asm->OutStreamer.AddComment("Length of Public Names Info"); 2273 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID), 2274 Asm->GetTempSymbol("pubnames_begin", ID), 4); 2275 2276 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID)); 2277 2278 Asm->OutStreamer.AddComment("DWARF Version"); 2279 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION); 2280 2281 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2282 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID), 2283 DwarfInfoSectionSym); 2284 2285 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2286 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID), 2287 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID), 2288 4); 2289 2290 const StringMap<DIE*> &Globals = TheCU->getGlobalNames(); 2291 for (StringMap<DIE*>::const_iterator 2292 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2293 const char *Name = GI->getKeyData(); 2294 const DIE *Entity = GI->second; 2295 2296 Asm->OutStreamer.AddComment("DIE offset"); 2297 Asm->EmitInt32(Entity->getOffset()); 2298 2299 if (Asm->isVerbose()) 2300 Asm->OutStreamer.AddComment("External Name"); 2301 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1)); 2302 } 2303 2304 Asm->OutStreamer.AddComment("End Mark"); 2305 Asm->EmitInt32(0); 2306 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID)); 2307 } 2308} 2309 2310void DwarfDebug::emitDebugPubTypes() { 2311 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2312 E = CUMap.end(); I != E; ++I) { 2313 CompileUnit *TheCU = I->second; 2314 // Start the dwarf pubtypes section. 2315 Asm->OutStreamer.SwitchSection( 2316 Asm->getObjFileLowering().getDwarfPubTypesSection()); 2317 Asm->OutStreamer.AddComment("Length of Public Types Info"); 2318 Asm->EmitLabelDifference( 2319 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()), 2320 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4); 2321 2322 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin", 2323 TheCU->getUniqueID())); 2324 2325 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version"); 2326 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION); 2327 2328 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2329 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection(); 2330 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), 2331 TheCU->getUniqueID()), 2332 DwarfInfoSectionSym); 2333 2334 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2335 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), 2336 TheCU->getUniqueID()), 2337 Asm->GetTempSymbol(ISec->getLabelBeginName(), 2338 TheCU->getUniqueID()), 2339 4); 2340 2341 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes(); 2342 for (StringMap<DIE*>::const_iterator 2343 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2344 const char *Name = GI->getKeyData(); 2345 DIE *Entity = GI->second; 2346 2347 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 2348 Asm->EmitInt32(Entity->getOffset()); 2349 2350 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name"); 2351 // Emit the name with a terminating null byte. 2352 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1)); 2353 } 2354 2355 Asm->OutStreamer.AddComment("End Mark"); 2356 Asm->EmitInt32(0); 2357 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end", 2358 TheCU->getUniqueID())); 2359 } 2360} 2361 2362// Emit strings into a string section. 2363void DwarfUnits::emitStrings(const MCSection *StrSection, 2364 const MCSection *OffsetSection = NULL, 2365 const MCSymbol *StrSecSym = NULL) { 2366 2367 if (StringPool.empty()) return; 2368 2369 // Start the dwarf str section. 2370 Asm->OutStreamer.SwitchSection(StrSection); 2371 2372 // Get all of the string pool entries and put them in an array by their ID so 2373 // we can sort them. 2374 SmallVector<std::pair<unsigned, 2375 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 2376 2377 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 2378 I = StringPool.begin(), E = StringPool.end(); 2379 I != E; ++I) 2380 Entries.push_back(std::make_pair(I->second.second, &*I)); 2381 2382 array_pod_sort(Entries.begin(), Entries.end()); 2383 2384 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2385 // Emit a label for reference from debug information entries. 2386 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 2387 2388 // Emit the string itself with a terminating null byte. 2389 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(), 2390 Entries[i].second->getKeyLength()+1)); 2391 } 2392 2393 // If we've got an offset section go ahead and emit that now as well. 2394 if (OffsetSection) { 2395 Asm->OutStreamer.SwitchSection(OffsetSection); 2396 unsigned offset = 0; 2397 unsigned size = 4; // FIXME: DWARF64 is 8. 2398 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2399 Asm->OutStreamer.EmitIntValue(offset, size); 2400 offset += Entries[i].second->getKeyLength() + 1; 2401 } 2402 } 2403} 2404 2405// Emit strings into a string section. 2406void DwarfUnits::emitAddresses(const MCSection *AddrSection) { 2407 2408 if (AddressPool.empty()) return; 2409 2410 // Start the dwarf addr section. 2411 Asm->OutStreamer.SwitchSection(AddrSection); 2412 2413 // Order the address pool entries by ID 2414 SmallVector<const MCExpr *, 64> Entries(AddressPool.size()); 2415 2416 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(), 2417 E = AddressPool.end(); 2418 I != E; ++I) 2419 Entries[I->second] = I->first; 2420 2421 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2422 // Emit an expression for reference from debug information entries. 2423 if (const MCExpr *Expr = Entries[i]) 2424 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize()); 2425 else 2426 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize()); 2427 } 2428 2429} 2430 2431// Emit visible names into a debug str section. 2432void DwarfDebug::emitDebugStr() { 2433 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; 2434 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection()); 2435} 2436 2437// Emit locations into the debug loc section. 2438void DwarfDebug::emitDebugLoc() { 2439 if (DotDebugLocEntries.empty()) 2440 return; 2441 2442 for (SmallVectorImpl<DotDebugLocEntry>::iterator 2443 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 2444 I != E; ++I) { 2445 DotDebugLocEntry &Entry = *I; 2446 if (I + 1 != DotDebugLocEntries.end()) 2447 Entry.Merge(I+1); 2448 } 2449 2450 // Start the dwarf loc section. 2451 Asm->OutStreamer.SwitchSection( 2452 Asm->getObjFileLowering().getDwarfLocSection()); 2453 unsigned char Size = Asm->getDataLayout().getPointerSize(); 2454 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0)); 2455 unsigned index = 1; 2456 for (SmallVectorImpl<DotDebugLocEntry>::iterator 2457 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 2458 I != E; ++I, ++index) { 2459 DotDebugLocEntry &Entry = *I; 2460 if (Entry.isMerged()) continue; 2461 if (Entry.isEmpty()) { 2462 Asm->OutStreamer.EmitIntValue(0, Size); 2463 Asm->OutStreamer.EmitIntValue(0, Size); 2464 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index)); 2465 } else { 2466 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size); 2467 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size); 2468 DIVariable DV(Entry.getVariable()); 2469 Asm->OutStreamer.AddComment("Loc expr size"); 2470 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol(); 2471 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol(); 2472 Asm->EmitLabelDifference(end, begin, 2); 2473 Asm->OutStreamer.EmitLabel(begin); 2474 if (Entry.isInt()) { 2475 DIBasicType BTy(DV.getType()); 2476 if (BTy.Verify() && 2477 (BTy.getEncoding() == dwarf::DW_ATE_signed 2478 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) { 2479 Asm->OutStreamer.AddComment("DW_OP_consts"); 2480 Asm->EmitInt8(dwarf::DW_OP_consts); 2481 Asm->EmitSLEB128(Entry.getInt()); 2482 } else { 2483 Asm->OutStreamer.AddComment("DW_OP_constu"); 2484 Asm->EmitInt8(dwarf::DW_OP_constu); 2485 Asm->EmitULEB128(Entry.getInt()); 2486 } 2487 } else if (Entry.isLocation()) { 2488 MachineLocation Loc = Entry.getLoc(); 2489 if (!DV.hasComplexAddress()) 2490 // Regular entry. 2491 Asm->EmitDwarfRegOp(Loc, DV.isIndirect()); 2492 else { 2493 // Complex address entry. 2494 unsigned N = DV.getNumAddrElements(); 2495 unsigned i = 0; 2496 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) { 2497 if (Loc.getOffset()) { 2498 i = 2; 2499 Asm->EmitDwarfRegOp(Loc, DV.isIndirect()); 2500 Asm->OutStreamer.AddComment("DW_OP_deref"); 2501 Asm->EmitInt8(dwarf::DW_OP_deref); 2502 Asm->OutStreamer.AddComment("DW_OP_plus_uconst"); 2503 Asm->EmitInt8(dwarf::DW_OP_plus_uconst); 2504 Asm->EmitSLEB128(DV.getAddrElement(1)); 2505 } else { 2506 // If first address element is OpPlus then emit 2507 // DW_OP_breg + Offset instead of DW_OP_reg + Offset. 2508 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1)); 2509 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect()); 2510 i = 2; 2511 } 2512 } else { 2513 Asm->EmitDwarfRegOp(Loc, DV.isIndirect()); 2514 } 2515 2516 // Emit remaining complex address elements. 2517 for (; i < N; ++i) { 2518 uint64_t Element = DV.getAddrElement(i); 2519 if (Element == DIBuilder::OpPlus) { 2520 Asm->EmitInt8(dwarf::DW_OP_plus_uconst); 2521 Asm->EmitULEB128(DV.getAddrElement(++i)); 2522 } else if (Element == DIBuilder::OpDeref) { 2523 if (!Loc.isReg()) 2524 Asm->EmitInt8(dwarf::DW_OP_deref); 2525 } else 2526 llvm_unreachable("unknown Opcode found in complex address"); 2527 } 2528 } 2529 } 2530 // else ... ignore constant fp. There is not any good way to 2531 // to represent them here in dwarf. 2532 Asm->OutStreamer.EmitLabel(end); 2533 } 2534 } 2535} 2536 2537// Emit visible names into a debug aranges section. 2538void DwarfDebug::emitDebugARanges() { 2539 // Start the dwarf aranges section. 2540 Asm->OutStreamer 2541 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection()); 2542} 2543 2544// Emit visible names into a debug ranges section. 2545void DwarfDebug::emitDebugRanges() { 2546 // Start the dwarf ranges section. 2547 Asm->OutStreamer 2548 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection()); 2549 unsigned char Size = Asm->getDataLayout().getPointerSize(); 2550 for (SmallVectorImpl<const MCSymbol *>::iterator 2551 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end(); 2552 I != E; ++I) { 2553 if (*I) 2554 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size); 2555 else 2556 Asm->OutStreamer.EmitIntValue(0, Size); 2557 } 2558} 2559 2560// Emit visible names into a debug macinfo section. 2561void DwarfDebug::emitDebugMacInfo() { 2562 if (const MCSection *LineInfo = 2563 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 2564 // Start the dwarf macinfo section. 2565 Asm->OutStreamer.SwitchSection(LineInfo); 2566 } 2567} 2568 2569// DWARF5 Experimental Separate Dwarf emitters. 2570 2571// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list, 2572// DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id, 2573// DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present, 2574// DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa. 2575CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) { 2576 2577 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 2578 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(), 2579 Asm, this, &SkeletonHolder); 2580 2581 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name, 2582 DICompileUnit(CU->getNode()).getSplitDebugFilename()); 2583 2584 // Relocate to the beginning of the addr_base section, else 0 for the 2585 // beginning of the one for this compile unit. 2586 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 2587 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset, 2588 DwarfAddrSectionSym); 2589 else 2590 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base, 2591 dwarf::DW_FORM_sec_offset, 0); 2592 2593 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point 2594 // into an entity. We're using 0, or a NULL label for this. 2595 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0); 2596 2597 // DW_AT_stmt_list is a offset of line number information for this 2598 // compile unit in debug_line section. 2599 // FIXME: Should handle multiple compile units. 2600 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 2601 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 2602 DwarfLineSectionSym); 2603 else 2604 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0); 2605 2606 if (!CompilationDir.empty()) 2607 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir); 2608 2609 SkeletonHolder.addUnit(NewCU); 2610 SkeletonCUs.push_back(NewCU); 2611 2612 return NewCU; 2613} 2614 2615void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) { 2616 assert(useSplitDwarf() && "No split dwarf debug info?"); 2617 emitAbbrevs(Section, &SkeletonAbbrevs); 2618} 2619 2620// Emit the .debug_info.dwo section for separated dwarf. This contains the 2621// compile units that would normally be in debug_info. 2622void DwarfDebug::emitDebugInfoDWO() { 2623 assert(useSplitDwarf() && "No split dwarf debug info?"); 2624 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(), 2625 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(), 2626 DwarfAbbrevDWOSectionSym); 2627} 2628 2629// Emit the .debug_abbrev.dwo section for separated dwarf. This contains the 2630// abbreviations for the .debug_info.dwo section. 2631void DwarfDebug::emitDebugAbbrevDWO() { 2632 assert(useSplitDwarf() && "No split dwarf?"); 2633 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(), 2634 &Abbreviations); 2635} 2636 2637// Emit the .debug_str.dwo section for separated dwarf. This contains the 2638// string section and is identical in format to traditional .debug_str 2639// sections. 2640void DwarfDebug::emitDebugStrDWO() { 2641 assert(useSplitDwarf() && "No split dwarf?"); 2642 const MCSection *OffSec = Asm->getObjFileLowering() 2643 .getDwarfStrOffDWOSection(); 2644 const MCSymbol *StrSym = DwarfStrSectionSym; 2645 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(), 2646 OffSec, StrSym); 2647} 2648 2649/// Find the MDNode for the given scope reference. 2650DIScope DwarfDebug::resolve(DIScopeRef SRef) const { 2651 return SRef.resolve(TypeIdentifierMap); 2652} 2653 2654// If the current node has a parent scope then return that, 2655// else return an empty scope. 2656DIScope DwarfDebug::getScopeContext(DIScope S) const { 2657 2658 if (S.isType()) 2659 return DIType(S).getContext(); 2660 2661 if (S.isSubprogram()) 2662 return DISubprogram(S).getContext(); 2663 2664 if (S.isLexicalBlock()) 2665 return DILexicalBlock(S).getContext(); 2666 2667 if (S.isLexicalBlockFile()) 2668 return DILexicalBlockFile(S).getContext(); 2669 2670 if (S.isNameSpace()) 2671 return DINameSpace(S).getContext(); 2672 2673 assert((S.isFile() || S.isCompileUnit()) && "Unhandled type of scope."); 2674 return DIScope(); 2675} 2676