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