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